api: wrap changeset file paths with safe_unicode

Fixes error in get_changesets if path contains non ascii character.

kallithea/lib/vcs/backends/base.py

@@ -1,1076 +1,1076 b''
 # -*- coding: utf-8 -*-
 """
     vcs.backends.base
     ~~~~~~~~~~~~~~~~~
 
     Base for all available scm backends
 
     :created_on: Apr 8, 2010
     :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.
 """
 
 import datetime
 import itertools
 
 from kallithea.lib.vcs.utils import author_name, author_email, safe_unicode
 from kallithea.lib.vcs.utils.lazy import LazyProperty
 from kallithea.lib.vcs.utils.helpers import get_dict_for_attrs
 from kallithea.lib.vcs.conf import settings
 
 from kallithea.lib.vcs.exceptions import (
     ChangesetError, EmptyRepositoryError, NodeAlreadyAddedError,
     NodeAlreadyChangedError, NodeAlreadyExistsError, NodeAlreadyRemovedError,
     NodeDoesNotExistError, NodeNotChangedError, RepositoryError
 )
 
 
 class BaseRepository(object):
     """
     Base Repository for final backends
 
     **Attributes**
 
         ``DEFAULT_BRANCH_NAME``
             name of default branch (i.e. "trunk" for svn, "master" for git etc.
 
         ``scm``
             alias of scm, i.e. *git* or *hg*
 
         ``repo``
             object from external api
 
         ``revisions``
             list of all available revisions' ids, in ascending order
 
         ``changesets``
             storage dict caching returned changesets
 
         ``path``
             absolute path to the repository
 
         ``branches``
             branches as list of changesets
 
         ``tags``
             tags as list of changesets
     """
     scm = None
     DEFAULT_BRANCH_NAME = None
     EMPTY_CHANGESET = '0' * 40
 
     def __init__(self, repo_path, create=False, **kwargs):
         """
         Initializes repository. Raises RepositoryError if repository could
         not be find at the given ``repo_path`` or directory at ``repo_path``
         exists and ``create`` is set to True.
 
         :param repo_path: local path of the repository
         :param create=False: if set to True, would try to create repository.
         :param src_url=None: if set, should be proper url from which repository
           would be cloned; requires ``create`` parameter to be set to True -
           raises RepositoryError if src_url is set and create evaluates to
           False
         """
         raise NotImplementedError
 
     def __str__(self):
         return '<%s at %s>' % (self.__class__.__name__, self.path)
 
     def __repr__(self):
         return self.__str__()
 
     def __len__(self):
         return self.count()
 
     def __eq__(self, other):
         same_instance = isinstance(other, self.__class__)
         return same_instance and getattr(other, 'path', None) == self.path
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     @LazyProperty
     def alias(self):
         for k, v in settings.BACKENDS.items():
             if v.split('.')[-1] == str(self.__class__.__name__):
                 return k
 
     @LazyProperty
     def name(self):
         """
         Return repository name (without group name)
         """
         raise NotImplementedError
 
     @property
     def name_unicode(self):
         return safe_unicode(self.name)
 
     @LazyProperty
     def owner(self):
         raise NotImplementedError
 
     @LazyProperty
     def description(self):
         raise NotImplementedError
 
     @LazyProperty
     def size(self):
         """
         Returns combined size in bytes for all repository files
         """
 
         size = 0
         try:
             tip = self.get_changeset()
             for topnode, dirs, files in tip.walk('/'):
                 for f in files:
                     size += tip.get_file_size(f.path)
 
         except RepositoryError as e:
             pass
         return size
 
     def is_valid(self):
         """
         Validates repository.
         """
         raise NotImplementedError
 
     def is_empty(self):
         return self._empty
 
     #==========================================================================
     # CHANGESETS
     #==========================================================================
 
     def get_changeset(self, revision=None):
         """
         Returns instance of ``Changeset`` class. If ``revision`` is None, most
         recent changeset is returned.
 
         :raises ``EmptyRepositoryError``: if there are no revisions
         """
         raise NotImplementedError
 
     def __iter__(self):
         """
         Allows Repository objects to be iterated.
 
         *Requires* implementation of ``__getitem__`` method.
         """
         for revision in self.revisions:
             yield self.get_changeset(revision)
 
     def get_changesets(self, start=None, end=None, start_date=None,
                        end_date=None, branch_name=None, reverse=False):
         """
         Returns iterator of ``BaseChangeset`` objects from start to end,
         both inclusive.
 
         :param start: None or str
         :param end: None or str
         :param start_date:
         :param end_date:
         :param branch_name:
         :param reversed:
         """
         raise NotImplementedError
 
     def __getslice__(self, i, j):
         """
         Returns a iterator of sliced repository
         """
         for rev in self.revisions[i:j]:
             yield self.get_changeset(rev)
 
     def __getitem__(self, key):
         return self.get_changeset(key)
 
     def count(self):
         return len(self.revisions)
 
     def tag(self, name, user, revision=None, message=None, date=None, **opts):
         """
         Creates and returns a tag for the given ``revision``.
 
         :param name: name for new tag
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param revision: changeset id for which new tag would be created
         :param message: message of the tag's commit
         :param date: date of tag's commit
 
         :raises TagAlreadyExistError: if tag with same name already exists
         """
         raise NotImplementedError
 
     def remove_tag(self, name, user, message=None, date=None):
         """
         Removes tag with the given ``name``.
 
         :param name: name of the tag to be removed
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param message: message of the tag's removal commit
         :param date: date of tag's removal commit
 
         :raises TagDoesNotExistError: if tag with given name does not exists
         """
         raise NotImplementedError
 
     def get_diff(self, rev1, rev2, path=None, ignore_whitespace=False,
             context=3):
         """
         Returns (git like) *diff*, as plain text. Shows changes introduced by
         ``rev2`` since ``rev1``.
 
         :param rev1: Entry point from which diff is shown. Can be
           ``self.EMPTY_CHANGESET`` - in this case, patch showing all
           the changes since empty state of the repository until ``rev2``
         :param rev2: Until which revision changes should be shown.
         :param ignore_whitespace: If set to ``True``, would not show whitespace
           changes. Defaults to ``False``.
         :param context: How many lines before/after changed lines should be
           shown. Defaults to ``3``.
         """
         raise NotImplementedError
 
     # ========== #
     # COMMIT API #
     # ========== #
 
     @LazyProperty
     def in_memory_changeset(self):
         """
         Returns ``InMemoryChangeset`` object for this repository.
         """
         raise NotImplementedError
 
     def add(self, filenode, **kwargs):
         """
         Commit api function that will add given ``FileNode`` into this
         repository.
 
         :raises ``NodeAlreadyExistsError``: if there is a file with same path
           already in repository
         :raises ``NodeAlreadyAddedError``: if given node is already marked as
           *added*
         """
         raise NotImplementedError
 
     def remove(self, filenode, **kwargs):
         """
         Commit api function that will remove given ``FileNode`` into this
         repository.
 
         :raises ``EmptyRepositoryError``: if there are no changesets yet
         :raises ``NodeDoesNotExistError``: if there is no file with given path
         """
         raise NotImplementedError
 
     def commit(self, message, **kwargs):
         """
         Persists current changes made on this repository and returns newly
         created changeset.
 
         :raises ``NothingChangedError``: if no changes has been made
         """
         raise NotImplementedError
 
     def get_state(self):
         """
         Returns dictionary with ``added``, ``changed`` and ``removed`` lists
         containing ``FileNode`` objects.
         """
         raise NotImplementedError
 
     def get_config_value(self, section, name, config_file=None):
         """
         Returns configuration value for a given [``section``] and ``name``.
 
         :param section: Section we want to retrieve value from
         :param name: Name of configuration we want to retrieve
         :param config_file: A path to file which should be used to retrieve
           configuration from (might also be a list of file paths)
         """
         raise NotImplementedError
 
     def get_user_name(self, config_file=None):
         """
         Returns user's name from global configuration file.
 
         :param config_file: A path to file which should be used to retrieve
           configuration from (might also be a list of file paths)
         """
         raise NotImplementedError
 
     def get_user_email(self, config_file=None):
         """
         Returns user's email from global configuration file.
 
         :param config_file: A path to file which should be used to retrieve
           configuration from (might also be a list of file paths)
         """
         raise NotImplementedError
 
     # =========== #
     # WORKDIR API #
     # =========== #
 
     @LazyProperty
     def workdir(self):
         """
         Returns ``Workdir`` instance for this repository.
         """
         raise NotImplementedError
 
 
 class BaseChangeset(object):
     """
     Each backend should implement it's changeset representation.
 
     **Attributes**
 
         ``repository``
             repository object within which changeset exists
 
         ``id``
             may be ``raw_id`` or i.e. for mercurial's tip just ``tip``
 
         ``raw_id``
             raw changeset representation (i.e. full 40 length sha for git
             backend)
 
         ``short_id``
             shortened (if apply) version of ``raw_id``; it would be simple
             shortcut for ``raw_id[:12]`` for git/mercurial backends or same
             as ``raw_id`` for subversion
 
         ``revision``
             revision number as integer
 
         ``files``
             list of ``FileNode`` (``Node`` with NodeKind.FILE) objects
 
         ``dirs``
             list of ``DirNode`` (``Node`` with NodeKind.DIR) objects
 
         ``nodes``
             combined list of ``Node`` objects
 
         ``author``
             author of the changeset, as unicode
 
         ``message``
             message of the changeset, as unicode
 
         ``parents``
             list of parent changesets
 
         ``last``
             ``True`` if this is last changeset in repository, ``False``
             otherwise; trying to access this attribute while there is no
             changesets would raise ``EmptyRepositoryError``
     """
     def __str__(self):
         return '<%s at %s:%s>' % (self.__class__.__name__, self.revision,
             self.short_id)
 
     def __repr__(self):
         return self.__str__()
 
     def __unicode__(self):
         return u'%s:%s' % (self.revision, self.short_id)
 
     def __eq__(self, other):
         return self.raw_id == other.raw_id
 
     def __json__(self, with_file_list=False):
         if with_file_list:
             return dict(
                 short_id=self.short_id,
                 raw_id=self.raw_id,
                 revision=self.revision,
                 message=self.message,
                 date=self.date,
                 author=self.author,
-                added=[el.path for el in self.added],
-                changed=[el.path for el in self.changed],
-                removed=[el.path for el in self.removed],
+                added=[safe_unicode(el.path) for el in self.added],
+                changed=[safe_unicode(el.path) for el in self.changed],
+                removed=[safe_unicode(el.path) for el in self.removed],
             )
         else:
             return dict(
                 short_id=self.short_id,
                 raw_id=self.raw_id,
                 revision=self.revision,
                 message=self.message,
                 date=self.date,
                 author=self.author,
             )
 
     @LazyProperty
     def last(self):
         if self.repository is None:
             raise ChangesetError("Cannot check if it's most recent revision")
         return self.raw_id == self.repository.revisions[-1]
 
     @LazyProperty
     def parents(self):
         """
         Returns list of parents changesets.
         """
         raise NotImplementedError
 
     @LazyProperty
     def children(self):
         """
         Returns list of children changesets.
         """
         raise NotImplementedError
 
     @LazyProperty
     def id(self):
         """
         Returns string identifying this changeset.
         """
         raise NotImplementedError
 
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifying this changeset.
         """
         raise NotImplementedError
 
     @LazyProperty
     def short_id(self):
         """
         Returns shortened version of ``raw_id`` attribute, as string,
         identifying this changeset, useful for web representation.
         """
         raise NotImplementedError
 
     @LazyProperty
     def revision(self):
         """
         Returns integer identifying this changeset.
 
         """
         raise NotImplementedError
 
     @LazyProperty
     def committer(self):
         """
         Returns Committer for given commit
         """
 
         raise NotImplementedError
 
     @LazyProperty
     def committer_name(self):
         """
         Returns Author name for given commit
         """
 
         return author_name(self.committer)
 
     @LazyProperty
     def committer_email(self):
         """
         Returns Author email address for given commit
         """
 
         return author_email(self.committer)
 
     @LazyProperty
     def author(self):
         """
         Returns Author for given commit
         """
 
         raise NotImplementedError
 
     @LazyProperty
     def author_name(self):
         """
         Returns Author name for given commit
         """
 
         return author_name(self.author)
 
     @LazyProperty
     def author_email(self):
         """
         Returns Author email address for given commit
         """
 
         return author_email(self.author)
 
     def get_file_mode(self, path):
         """
         Returns stat mode of the file at the given ``path``.
         """
         raise NotImplementedError
 
     def get_file_content(self, path):
         """
         Returns content of the file at the given ``path``.
         """
         raise NotImplementedError
 
     def get_file_size(self, path):
         """
         Returns size of the file at the given ``path``.
         """
         raise NotImplementedError
 
     def get_file_changeset(self, path):
         """
         Returns last commit of the file at the given ``path``.
         """
         raise NotImplementedError
 
     def get_file_history(self, path):
         """
         Returns history of file as reversed list of ``Changeset`` objects for
         which file at given ``path`` has been modified.
         """
         raise NotImplementedError
 
     def get_nodes(self, path):
         """
         Returns combined ``DirNode`` and ``FileNode`` objects list representing
         state of changeset at the given ``path``.
 
         :raises ``ChangesetError``: if node at the given ``path`` is not
           instance of ``DirNode``
         """
         raise NotImplementedError
 
     def get_node(self, path):
         """
         Returns ``Node`` object from the given ``path``.
 
         :raises ``NodeDoesNotExistError``: if there is no node at the given
           ``path``
         """
         raise NotImplementedError
 
     def fill_archive(self, stream=None, kind='tgz', prefix=None):
         """
         Fills up given stream.
 
         :param stream: file like object.
         :param kind: one of following: ``zip``, ``tar``, ``tgz``
             or ``tbz2``. Default: ``tgz``.
         :param prefix: name of root directory in archive.
             Default is repository name and changeset's raw_id joined with dash.
 
             repo-tip.<kind>
         """
 
         raise NotImplementedError
 
     def get_chunked_archive(self, **kwargs):
         """
         Returns iterable archive. Tiny wrapper around ``fill_archive`` method.
 
         :param chunk_size: extra parameter which controls size of returned
             chunks. Default:8k.
         """
 
         chunk_size = kwargs.pop('chunk_size', 8192)
         stream = kwargs.get('stream')
         self.fill_archive(**kwargs)
         while True:
             data = stream.read(chunk_size)
             if not data:
                 break
             yield data
 
     @LazyProperty
     def root(self):
         """
         Returns ``RootNode`` object for this changeset.
         """
         return self.get_node('')
 
     def next(self, branch=None):
         """
         Returns next changeset from current, if branch is gives it will return
         next changeset belonging to this branch
 
         :param branch: show changesets within the given named branch
         """
         raise NotImplementedError
 
     def prev(self, branch=None):
         """
         Returns previous changeset from current, if branch is gives it will
         return previous changeset belonging to this branch
 
         :param branch: show changesets within the given named branch
         """
         raise NotImplementedError
 
     @LazyProperty
     def added(self):
         """
         Returns list of added ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def changed(self):
         """
         Returns list of modified ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def removed(self):
         """
         Returns list of removed ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def size(self):
         """
         Returns total number of bytes from contents of all filenodes.
         """
         return sum((node.size for node in self.get_filenodes_generator()))
 
     def walk(self, topurl=''):
         """
         Similar to os.walk method. Instead of filesystem it walks through
         changeset starting at given ``topurl``.  Returns generator of tuples
         (topnode, dirnodes, filenodes).
         """
         topnode = self.get_node(topurl)
         yield (topnode, topnode.dirs, topnode.files)
         for dirnode in topnode.dirs:
             for tup in self.walk(dirnode.path):
                 yield tup
 
     def get_filenodes_generator(self):
         """
         Returns generator that yields *all* file nodes.
         """
         for topnode, dirs, files in self.walk():
             for node in files:
                 yield node
 
     def as_dict(self):
         """
         Returns dictionary with changeset's attributes and their values.
         """
         data = get_dict_for_attrs(self, ['id', 'raw_id', 'short_id',
             'revision', 'date', 'message'])
         data['author'] = {'name': self.author_name, 'email': self.author_email}
-        data['added'] = [node.path for node in self.added]
-        data['changed'] = [node.path for node in self.changed]
-        data['removed'] = [node.path for node in self.removed]
+        data['added'] = [safe_unicode(node.path) for node in self.added]
+        data['changed'] = [safe_unicode(node.path) for node in self.changed]
+        data['removed'] = [safe_unicode(node.path) for node in self.removed]
         return data
 
     @LazyProperty
     def closesbranch(self):
         return False
 
     @LazyProperty
     def obsolete(self):
         return False
 
     @LazyProperty
     def bumped(self):
         return False
 
     @LazyProperty
     def divergent(self):
         return False
 
     @LazyProperty
     def extinct(self):
         return False
 
     @LazyProperty
     def unstable(self):
         return False
 
     @LazyProperty
     def phase(self):
         return ''
 
 
 class BaseWorkdir(object):
     """
     Working directory representation of single repository.
 
     :attribute: repository: repository object of working directory
     """
 
     def __init__(self, repository):
         self.repository = repository
 
     def get_branch(self):
         """
         Returns name of current branch.
         """
         raise NotImplementedError
 
     def get_changeset(self):
         """
         Returns current changeset.
         """
         raise NotImplementedError
 
     def get_added(self):
         """
         Returns list of ``FileNode`` objects marked as *new* in working
         directory.
         """
         raise NotImplementedError
 
     def get_changed(self):
         """
         Returns list of ``FileNode`` objects *changed* in working directory.
         """
         raise NotImplementedError
 
     def get_removed(self):
         """
         Returns list of ``RemovedFileNode`` objects marked as *removed* in
         working directory.
         """
         raise NotImplementedError
 
     def get_untracked(self):
         """
         Returns list of ``FileNode`` objects which are present within working
         directory however are not tracked by repository.
         """
         raise NotImplementedError
 
     def get_status(self):
         """
         Returns dict with ``added``, ``changed``, ``removed`` and ``untracked``
         lists.
         """
         raise NotImplementedError
 
     def commit(self, message, **kwargs):
         """
         Commits local (from working directory) changes and returns newly
         created
         ``Changeset``. Updates repository's ``revisions`` list.
 
         :raises ``CommitError``: if any error occurs while committing
         """
         raise NotImplementedError
 
     def update(self, revision=None):
         """
         Fetches content of the given revision and populates it within working
         directory.
         """
         raise NotImplementedError
 
     def checkout_branch(self, branch=None):
         """
         Checks out ``branch`` or the backend's default branch.
 
         Raises ``BranchDoesNotExistError`` if the branch does not exist.
         """
         raise NotImplementedError
 
 
 class BaseInMemoryChangeset(object):
     """
     Represents differences between repository's state (most recent head) and
     changes made *in place*.
 
     **Attributes**
 
         ``repository``
             repository object for this in-memory-changeset
 
         ``added``
             list of ``FileNode`` objects marked as *added*
 
         ``changed``
             list of ``FileNode`` objects marked as *changed*
 
         ``removed``
             list of ``FileNode`` or ``RemovedFileNode`` objects marked to be
             *removed*
 
         ``parents``
             list of ``Changeset`` representing parents of in-memory changeset.
             Should always be 2-element sequence.
 
     """
 
     def __init__(self, repository):
         self.repository = repository
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
 
     def add(self, *filenodes):
         """
         Marks given ``FileNode`` objects as *to be committed*.
 
         :raises ``NodeAlreadyExistsError``: if node with same path exists at
           latest changeset
         :raises ``NodeAlreadyAddedError``: if node with same path is already
           marked as *added*
         """
         # Check if not already marked as *added* first
         for node in filenodes:
             if node.path in (n.path for n in self.added):
                 raise NodeAlreadyAddedError("Such FileNode %s is already "
                     "marked for addition" % node.path)
         for node in filenodes:
             self.added.append(node)
 
     def change(self, *filenodes):
         """
         Marks given ``FileNode`` objects to be *changed* in next commit.
 
         :raises ``EmptyRepositoryError``: if there are no changesets yet
         :raises ``NodeAlreadyExistsError``: if node with same path is already
           marked to be *changed*
         :raises ``NodeAlreadyRemovedError``: if node with same path is already
           marked to be *removed*
         :raises ``NodeDoesNotExistError``: if node doesn't exist in latest
           changeset
         :raises ``NodeNotChangedError``: if node hasn't really be changed
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError("Node at %s is already marked "
                     "as removed" % node.path)
         try:
             self.repository.get_changeset()
         except EmptyRepositoryError:
             raise EmptyRepositoryError("Nothing to change - try to *add* new "
                 "nodes rather than changing them")
         for node in filenodes:
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError("Node at '%s' is already "
                     "marked as changed" % node.path)
             self.changed.append(node)
 
     def remove(self, *filenodes):
         """
         Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be
         *removed* in next commit.
 
         :raises ``NodeAlreadyRemovedError``: if node has been already marked to
           be *removed*
         :raises ``NodeAlreadyChangedError``: if node has been already marked to
           be *changed*
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError("Node is already marked to "
                     "for removal at %s" % node.path)
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError("Node is already marked to "
                     "be changed at %s" % node.path)
             # We only mark node as *removed* - real removal is done by
             # commit method
             self.removed.append(node)
 
     def reset(self):
         """
         Resets this instance to initial state (cleans ``added``, ``changed``
         and ``removed`` lists).
         """
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
 
     def get_ipaths(self):
         """
         Returns generator of paths from nodes marked as added, changed or
         removed.
         """
         for node in itertools.chain(self.added, self.changed, self.removed):
             yield node.path
 
     def get_paths(self):
         """
         Returns list of paths from nodes marked as added, changed or removed.
         """
         return list(self.get_ipaths())
 
     def check_integrity(self, parents=None):
         """
         Checks in-memory changeset's integrity. Also, sets parents if not
         already set.
 
         :raises CommitError: if any error occurs (i.e.
           ``NodeDoesNotExistError``).
         """
         if not self.parents:
             parents = parents or []
             if len(parents) == 0:
                 try:
                     parents = [self.repository.get_changeset(), None]
                 except EmptyRepositoryError:
                     parents = [None, None]
             elif len(parents) == 1:
                 parents += [None]
             self.parents = parents
 
         # Local parents, only if not None
         parents = [p for p in self.parents if p]
 
         # Check nodes marked as added
         for p in parents:
             for node in self.added:
                 try:
                     p.get_node(node.path)
                 except NodeDoesNotExistError:
                     pass
                 else:
                     raise NodeAlreadyExistsError("Node at %s already exists "
                         "at %s" % (node.path, p))
 
         # Check nodes marked as changed
         missing = set(self.changed)
         not_changed = set(self.changed)
         if self.changed and not parents:
             raise NodeDoesNotExistError(str(self.changed[0].path))
         for p in parents:
             for node in self.changed:
                 try:
                     old = p.get_node(node.path)
                     missing.remove(node)
                     # if content actually changed, remove node from unchanged
                     if old.content != node.content:
                         not_changed.remove(node)
                 except NodeDoesNotExistError:
                     pass
         if self.changed and missing:
             raise NodeDoesNotExistError("Node at %s is missing "
                 "(parents: %s)" % (node.path, parents))
 
         if self.changed and not_changed:
             raise NodeNotChangedError("Node at %s wasn't actually changed "
                 "since parents' changesets: %s" % (not_changed.pop().path,
                     parents)
             )
 
         # Check nodes marked as removed
         if self.removed and not parents:
             raise NodeDoesNotExistError("Cannot remove node at %s as there "
                 "were no parents specified" % self.removed[0].path)
         really_removed = set()
         for p in parents:
             for node in self.removed:
                 try:
                     p.get_node(node.path)
                     really_removed.add(node)
                 except ChangesetError:
                     pass
         not_removed = set(self.removed) - really_removed
         if not_removed:
             raise NodeDoesNotExistError("Cannot remove node at %s from "
                 "following parents: %s" % (not_removed[0], parents))
 
     def commit(self, message, author, parents=None, branch=None, date=None,
             **kwargs):
         """
         Performs in-memory commit (doesn't check workdir in any way) and
         returns newly created ``Changeset``. Updates repository's
         ``revisions``.
 
         .. note::
             While overriding this method each backend's should call
             ``self.check_integrity(parents)`` in the first place.
 
         :param message: message of the commit
         :param author: full username, i.e. "Joe Doe <[e-mail]>"
         :param parents: single parent or sequence of parents from which commit
           would be derived
         :param date: ``datetime.datetime`` instance. Defaults to
           ``datetime.datetime.now()``.
         :param branch: branch name, as string. If none given, default backend's
           branch would be used.
 
         :raises ``CommitError``: if any error occurs while committing
         """
         raise NotImplementedError
 
 
 class EmptyChangeset(BaseChangeset):
     """
     An dummy empty changeset. It's possible to pass hash when creating
     an EmptyChangeset
     """
 
     def __init__(self, cs='0' * 40, repo=None, requested_revision=None,
                  alias=None, revision=-1, message='', author='', date=None):
         self._empty_cs = cs
         self.revision = revision
         self.message = message
         self.author = author
         self.date = date or datetime.datetime.fromtimestamp(0)
         self.repository = repo
         self.requested_revision = requested_revision
         self.alias = alias
 
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifying this changeset, useful for web
         representation.
         """
 
         return self._empty_cs
 
     @LazyProperty
     def branch(self):
         from kallithea.lib.vcs.backends import get_backend
         return get_backend(self.alias).DEFAULT_BRANCH_NAME
 
     @LazyProperty
     def short_id(self):
         return self.raw_id[:12]
 
     def get_file_changeset(self, path):
         return self
 
     def get_file_content(self, path):
         return u''
 
     def get_file_size(self, path):
         return 0
 
 
 class CollectionGenerator(object):
 
     def __init__(self, repo, revs):
         self.repo = repo
         self.revs = revs
 
     def __len__(self):
         return len(self.revs)
 
     def __iter__(self):
         for rev in self.revs:
             yield self.repo.get_changeset(rev)
 
     def __getitem__(self, what):
         """Return either a single element by index, or a sliced collection."""
         if isinstance(what, slice):
             return CollectionGenerator(self.repo, self.revs[what])
         else:
             # single item
             return self.repo.get_changeset(self.revs[what])
 
     def __repr__(self):
         return '<CollectionGenerator[len:%s]>' % (len(self))

kallithea/tests/vcs/test_changesets.py

@@ -1,392 +1,394 b''
 # encoding: utf8
 
 import time
 import datetime
 from kallithea.lib import vcs
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS
 
 from kallithea.lib.vcs.backends.base import BaseChangeset
 from kallithea.lib.vcs.nodes import (
     FileNode, AddedFileNodesGenerator,
     ChangedFileNodesGenerator, RemovedFileNodesGenerator
 )
 from kallithea.lib.vcs.exceptions import (
     BranchDoesNotExistError, ChangesetDoesNotExistError,
     RepositoryError, EmptyRepositoryError
 )
 from kallithea.lib.vcs.utils.compat import unittest
 from kallithea.tests.vcs.conf import get_new_dir
 
 
 class TestBaseChangeset(unittest.TestCase):
 
     def test_as_dict(self):
         changeset = BaseChangeset()
         changeset.id = 'ID'
         changeset.raw_id = 'RAW_ID'
         changeset.short_id = 'SHORT_ID'
         changeset.revision = 1009
         changeset.date = datetime.datetime(2011, 1, 30, 1, 45)
         changeset.message = 'Message of a commit'
         changeset.author = 'Joe Doe <[e-mail]>'
-        changeset.added = [FileNode('foo/bar/baz'), FileNode('foobar')]
+        changeset.added = [FileNode('foo/bar/baz'), FileNode(u'foobar'), FileNode(u'blåbærgrød')]
         changeset.changed = []
         changeset.removed = []
         self.assertEqual(changeset.as_dict(), {
             'id': 'ID',
             'raw_id': 'RAW_ID',
             'short_id': 'SHORT_ID',
             'revision': 1009,
             'date': datetime.datetime(2011, 1, 30, 1, 45),
             'message': 'Message of a commit',
             'author': {
                 'name': 'Joe Doe',
                 'email': '[e-mail]',
             },
-            'added': ['foo/bar/baz', 'foobar'],
+            'added': ['foo/bar/baz', 'foobar', u'bl\xe5b\xe6rgr\xf8d'],
             'changed': [],
             'removed': [],
         })
 
 
 class _ChangesetsWithCommitsTestCaseixin(_BackendTestMixin):
     recreate_repo_per_test = True
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': 'Commit %d' % x,
                 'author': 'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
             }
 
     def test_new_branch(self):
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
         )
         self.assertTrue('foobar' in self.repo.branches)
         self.assertEqual(foobar_tip.branch, 'foobar')
         # 'foobar' should be the only branch that contains the new commit
         self.assertNotEqual(*self.repo.branches.values())
 
     def test_new_head_in_default_branch(self):
         tip = self.repo.get_changeset()
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
             parents=[tip],
         )
         self.imc.change(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\nand more...\n'))
         newtip = self.imc.commit(
             message=u'At default branch',
             author=u'joe',
             branch=foobar_tip.branch,
             parents=[foobar_tip],
         )
 
         newest_tip = self.imc.commit(
             message=u'Merged with %s' % foobar_tip.raw_id,
             author=u'joe',
             branch=self.backend_class.DEFAULT_BRANCH_NAME,
             parents=[newtip, foobar_tip],
         )
 
         self.assertEqual(newest_tip.branch,
             self.backend_class.DEFAULT_BRANCH_NAME)
 
     def test_get_changesets_respects_branch_name(self):
         tip = self.repo.get_changeset()
         self.imc.add(vcs.nodes.FileNode('docs/index.txt',
             content='Documentation\n'))
         doc_changeset = self.imc.commit(
             message=u'New branch: docs',
             author=u'joe',
             branch='docs',
         )
         self.imc.add(vcs.nodes.FileNode('newfile', content=''))
         self.imc.commit(
             message=u'Back in default branch',
             author=u'joe',
             parents=[tip],
         )
         default_branch_changesets = self.repo.get_changesets(
             branch_name=self.repo.DEFAULT_BRANCH_NAME)
         self.assertNotIn(doc_changeset, default_branch_changesets)
 
     def test_get_changeset_by_branch(self):
         for branch, sha in self.repo.branches.iteritems():
             self.assertEqual(sha, self.repo.get_changeset(branch).raw_id)
 
     def test_get_changeset_by_tag(self):
         for tag, sha in self.repo.tags.iteritems():
             self.assertEqual(sha, self.repo.get_changeset(tag).raw_id)
 
     def test_get_changeset_parents(self):
         for test_rev in [1, 2, 3]:
             sha = self.repo.get_changeset(test_rev-1)
             self.assertEqual([sha], self.repo.get_changeset(test_rev).parents)
 
     def test_get_changeset_children(self):
         for test_rev in [1, 2, 3]:
             sha = self.repo.get_changeset(test_rev+1)
             self.assertEqual([sha], self.repo.get_changeset(test_rev).children)
 
 
 class _ChangesetsTestCaseMixin(_BackendTestMixin):
     recreate_repo_per_test = False
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': u'Commit %d' % x,
                 'author': u'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
             }
 
     def test_simple(self):
         tip = self.repo.get_changeset()
         self.assertEqual(tip.date, datetime.datetime(2010, 1, 3, 20))
 
     def test_get_changesets_is_ordered_by_date(self):
         changesets = list(self.repo.get_changesets())
         ordered_by_date = sorted(changesets,
             key=lambda cs: cs.date)
         self.assertItemsEqual(changesets, ordered_by_date)
 
     def test_get_changesets_respects_start(self):
         second_id = self.repo.revisions[1]
         changesets = list(self.repo.get_changesets(start=second_id))
         self.assertEqual(len(changesets), 4)
 
     def test_get_changesets_numerical_id_respects_start(self):
         second_id = 1
         changesets = list(self.repo.get_changesets(start=second_id))
         self.assertEqual(len(changesets), 4)
 
     def test_get_changesets_includes_start_changeset(self):
         second_id = self.repo.revisions[1]
         changesets = list(self.repo.get_changesets(start=second_id))
         self.assertEqual(changesets[0].raw_id, second_id)
 
     def test_get_changesets_respects_end(self):
         second_id = self.repo.revisions[1]
         changesets = list(self.repo.get_changesets(end=second_id))
         self.assertEqual(changesets[-1].raw_id, second_id)
         self.assertEqual(len(changesets), 2)
 
     def test_get_changesets_numerical_id_respects_end(self):
         second_id = 1
         changesets = list(self.repo.get_changesets(end=second_id))
         self.assertEqual(changesets.index(changesets[-1]), second_id)
         self.assertEqual(len(changesets), 2)
 
     def test_get_changesets_respects_both_start_and_end(self):
         second_id = self.repo.revisions[1]
         third_id = self.repo.revisions[2]
         changesets = list(self.repo.get_changesets(start=second_id,
             end=third_id))
         self.assertEqual(len(changesets), 2)
 
     def test_get_changesets_numerical_id_respects_both_start_and_end(self):
         changesets = list(self.repo.get_changesets(start=2, end=3))
         self.assertEqual(len(changesets), 2)
 
     def test_get_changesets_on_empty_repo_raises_EmptyRepository_error(self):
         Backend = self.get_backend()
         repo_path = get_new_dir(str(time.time()))
         repo = Backend(repo_path, create=True)
 
         with self.assertRaises(EmptyRepositoryError):
             list(repo.get_changesets(start='foobar'))
 
     def test_get_changesets_includes_end_changeset(self):
         second_id = self.repo.revisions[1]
         changesets = list(self.repo.get_changesets(end=second_id))
         self.assertEqual(changesets[-1].raw_id, second_id)
 
     def test_get_changesets_respects_start_date(self):
         start_date = datetime.datetime(2010, 2, 1)
         for cs in self.repo.get_changesets(start_date=start_date):
             self.assertGreaterEqual(cs.date, start_date)
 
     def test_get_changesets_respects_end_date(self):
         start_date = datetime.datetime(2010, 1, 1)
         end_date = datetime.datetime(2010, 2, 1)
         for cs in self.repo.get_changesets(start_date=start_date,
                                            end_date=end_date):
             self.assertGreaterEqual(cs.date, start_date)
             self.assertLessEqual(cs.date, end_date)
 
     def test_get_changesets_respects_start_date_and_end_date(self):
         end_date = datetime.datetime(2010, 2, 1)
         for cs in self.repo.get_changesets(end_date=end_date):
             self.assertLessEqual(cs.date, end_date)
 
     def test_get_changesets_respects_reverse(self):
         changesets_id_list = [cs.raw_id for cs in
             self.repo.get_changesets(reverse=True)]
         self.assertItemsEqual(changesets_id_list, reversed(self.repo.revisions))
 
     def test_get_filenodes_generator(self):
         tip = self.repo.get_changeset()
         filepaths = [node.path for node in tip.get_filenodes_generator()]
         self.assertItemsEqual(filepaths, ['file_%d.txt' % x for x in xrange(5)])
 
     def test_size(self):
         tip = self.repo.get_changeset()
         size = 5 * len('Foobar N') # Size of 5 files
         self.assertEqual(tip.size, size)
 
     def test_author(self):
         tip = self.repo.get_changeset()
         self.assertEqual(tip.author, u'Joe Doe <[e-mail]>')
 
     def test_author_name(self):
         tip = self.repo.get_changeset()
         self.assertEqual(tip.author_name, u'Joe Doe')
 
     def test_author_email(self):
         tip = self.repo.get_changeset()
         self.assertEqual(tip.author_email, u'[e-mail]')
 
     def test_get_changesets_raise_changesetdoesnotexist_for_wrong_start(self):
         with self.assertRaises(ChangesetDoesNotExistError):
             list(self.repo.get_changesets(start='foobar'))
 
     def test_get_changesets_raise_changesetdoesnotexist_for_wrong_end(self):
         with self.assertRaises(ChangesetDoesNotExistError):
             list(self.repo.get_changesets(end='foobar'))
 
     def test_get_changesets_raise_branchdoesnotexist_for_wrong_branch_name(self):
         with self.assertRaises(BranchDoesNotExistError):
             list(self.repo.get_changesets(branch_name='foobar'))
 
     def test_get_changesets_raise_repositoryerror_for_wrong_start_end(self):
         start = self.repo.revisions[-1]
         end = self.repo.revisions[0]
         with self.assertRaises(RepositoryError):
             list(self.repo.get_changesets(start=start, end=end))
 
     def test_get_changesets_numerical_id_reversed(self):
         with self.assertRaises(RepositoryError):
             [x for x in self.repo.get_changesets(start=3, end=2)]
 
     def test_get_changesets_numerical_id_respects_both_start_and_end_last(self):
         with self.assertRaises(RepositoryError):
             last = len(self.repo.revisions)
             list(self.repo.get_changesets(start=last-1, end=last-2))
 
     def test_get_changesets_numerical_id_last_zero_error(self):
         with self.assertRaises(RepositoryError):
             last = len(self.repo.revisions)
             list(self.repo.get_changesets(start=last-1, end=0))
 
 
 class _ChangesetsChangesTestCaseMixin(_BackendTestMixin):
     recreate_repo_per_test = False
 
     @classmethod
     def _get_commits(cls):
         return [
             {
                 'message': u'Initial',
                 'author': u'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foo/bar', content='foo'),
                     FileNode('foo/bał', content='foo'),
                     FileNode('foobar', content='foo'),
                     FileNode('qwe', content='foo'),
                 ],
             },
             {
                 'message': u'Massive changes',
                 'author': u'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'added': [FileNode('fallout', content='War never changes')],
                 'changed': [
                     FileNode('foo/bar', content='baz'),
                     FileNode('foobar', content='baz'),
                 ],
                 'removed': [FileNode('qwe')],
             },
         ]
 
     def test_initial_commit(self):
         changeset = self.repo.get_changeset(0)
         self.assertItemsEqual(changeset.added, [
             changeset.get_node('foo/bar'),
             changeset.get_node('foo/bał'),
             changeset.get_node('foobar'),
             changeset.get_node('qwe'),
         ])
         self.assertItemsEqual(changeset.changed, [])
         self.assertItemsEqual(changeset.removed, [])
+        assert u'foo/ba\u0142' in changeset.as_dict()['added']
+        assert u'foo/ba\u0142' in changeset.__json__(with_file_list=True)['added']
 
     def test_head_added(self):
         changeset = self.repo.get_changeset()
         self.assertTrue(isinstance(changeset.added, AddedFileNodesGenerator))
         self.assertItemsEqual(changeset.added, [
             changeset.get_node('fallout'),
         ])
         self.assertTrue(isinstance(changeset.changed, ChangedFileNodesGenerator))
         self.assertItemsEqual(changeset.changed, [
             changeset.get_node('foo/bar'),
             changeset.get_node('foobar'),
         ])
         self.assertTrue(isinstance(changeset.removed, RemovedFileNodesGenerator))
         self.assertEqual(len(changeset.removed), 1)
         self.assertEqual(list(changeset.removed)[0].path, 'qwe')
 
     def test_get_filemode(self):
         changeset = self.repo.get_changeset()
         self.assertEqual(33188, changeset.get_file_mode('foo/bar'))
 
     def test_get_filemode_non_ascii(self):
         changeset = self.repo.get_changeset()
         self.assertEqual(33188, changeset.get_file_mode('foo/bał'))
         self.assertEqual(33188, changeset.get_file_mode(u'foo/bał'))
 
 
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
     # tests with additional commits
-    cls_name = ''.join(('%s changesets with commits test' % alias).title().split())
+    cls_name = alias.title() + 'ChangesetsWithCommitsTest'
     bases = (_ChangesetsWithCommitsTestCaseixin, unittest.TestCase)
     globals()[cls_name] = type(cls_name, bases, attrs)
 
     # tests without additional commits
-    cls_name = ''.join(('%s changesets test' % alias).title().split())
+    cls_name = alias.title() + 'ChangesetsTest'
     bases = (_ChangesetsTestCaseMixin, unittest.TestCase)
     globals()[cls_name] = type(cls_name, bases, attrs)
 
     # tests changes
-    cls_name = ''.join(('%s changesets changes test' % alias).title().split())
+    cls_name = alias.title() + 'ChangesetsChangesTest'
     bases = (_ChangesetsChangesTestCaseMixin, unittest.TestCase)
     globals()[cls_name] = type(cls_name, bases, attrs)
 
 
 if __name__ == '__main__':
     unittest.main()