class AnnotateHtmlFormatter(HtmlFormatter):

    def __init__(self, filenode, annotate_from_changeset_func,

            order=None, **options):

        """

        ``annotate_from_changeset_func`` must be a function

        which returns string from the given changeset. For example, we may pass

        following function as ``annotate_from_changeset_func``::

            def changeset_to_anchor(changeset):

                return '<a href="/changesets/%s/">%s</a>\n' % \

        :param annotate_from_changeset_func: see above

        :param order: (default: ``['ls', 'annotate', 'code']``); order of

          columns;

        :param options: standard pygment's HtmlFormatter options, there is

          extra option tough, ``headers``. For instance we can pass::

             formatter = AnnotateHtmlFormatter(filenode, headers={

                'ls': '#',

                'annotate': 'Annotate',

                'code': 'Code',

             })

        raise NotImplementedError

class BaseChangeset(object):

    """

    Each backend should implement it's changeset representation.

    **Attributes**

        ``repository``

            repository object within which changeset exists

        ``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

        Returns list of parents changesets.

        """

        raise NotImplementedError

    @LazyProperty

    def children(self):

        """

        Returns list of children changesets.

        """

        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.

        """

    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.

        """

            'revision', 'date', 'message'])

        data['author'] = {'name': self.author_name, 'email': self.author_email}

        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 __init__(self, repository, revision):

        self._stat_modes = {}

        self.repository = repository

        revision = safe_str(revision)

        try:

            commit = self.repository._repo[ascii_bytes(revision)]

            if isinstance(commit, objects.Tag):

                revision = safe_str(commit.object[1])

                commit = self.repository._repo.get_object(commit.object[1])

        except KeyError:

            raise RepositoryError("Cannot get object with id %s" % revision)

        self.raw_id = ascii_str(commit.id)

        self.short_id = self.raw_id[:12]

        self._commit = commit  # a Dulwich Commmit with .id

        self._tree_id = commit.tree

        self._committer_property = 'committer'

        self._author_property = 'author'

        self._date_property = 'commit_time'

        self._date_tz_property = 'commit_timezone'

        self.revision = repository.revisions.index(self.raw_id)

        self.nodes = {}

        self._paths = {}

        return self.get_file_history(path, limit=1)[0]

    def get_file_history(self, path, limit=None):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        TODO: This function now uses os underlying 'git' and 'grep' commands

        which is generally not good. Should be replaced with algorithm

        iterating commits.

        """

        self._get_filectx(path)

        f_path = safe_str(path)

        if limit is not None:

            cmd = ['log', '-n', str(safe_int(limit, 0)),

        else:

            cmd = ['log',

        so = self.repository.run_git_command(cmd)

        ids = re.findall(r'[0-9a-fA-F]{40}', so)

        return [self.repository.get_changeset(sha) for sha in ids]

    def get_file_history_2(self, path):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        """

        self._get_filectx(path)

        from dulwich.walk import Walker

        walker = Walker(self.repository._repo.object_store, include,

                        paths=[path], max_entries=1)

        return [self.repository.get_changeset(ascii_str(x.commit.id.decode))

                for x in walker]

    def get_file_annotate(self, path):

        """

        Returns a generator of four element tuples with

            lineno, sha, changeset lazy loader and line

        """

        # TODO: This function now uses os underlying 'git' command which is

        # generally not good. Should be replaced with algorithm iterating

        # commits.

        # -l     ==> outputs long shas (and we need all 40 characters)

        # --root ==> doesn't put '^' character for boundaries

        # -r sha ==> blames for the given revision

        so = self.repository.run_git_command(cmd)

        for i, blame_line in enumerate(so.split('\n')[:-1]):

            sha, line = re.split(r' ', blame_line, 1)

            yield (i + 1, sha, lambda sha=sha: self.repository.get_changeset(sha), line)

    def fill_archive(self, stream=None, kind='tgz', prefix=None,

                     subrepos=False):

        """

    @LazyProperty

    def _dir_paths(self):

        p = list(set(get_dirs_for_path(*self._file_paths)))

        p.insert(0, '')

        return p

    @LazyProperty

    def _paths(self):

        return self._dir_paths + self._file_paths

    @LazyProperty

    def short_id(self):

        return self.raw_id[:12]

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        return [self.repository.get_changeset(parent.rev())

                for parent in self._ctx.parents() if parent.rev() >= 0]

    @LazyProperty

from kallithea.lib import vcs

from kallithea.lib.vcs.backends.base import BaseChangeset

from kallithea.lib.vcs.exceptions import BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError

from kallithea.lib.vcs.nodes import AddedFileNodesGenerator, ChangedFileNodesGenerator, FileNode, RemovedFileNodesGenerator

from kallithea.tests.vcs.base import _BackendTestMixin

class TestBaseChangeset(object):

    def test_as_dict(self):

        changeset = BaseChangeset()

        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 <joe.doe@example.com>'

        changeset.added = [FileNode('foo/bar/baz'), FileNode(u'foobar'), FileNode(u'blåbærgrød')]

        changeset.changed = []

        changeset.removed = []

        assert changeset.as_dict() == {

            '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': 'joe.doe@example.com',

            },

            'added': ['foo/bar/baz', 'foobar', u'bl\xe5b\xe6rgr\xf8d'],

            'changed': [],

            'removed': [],

    def test_change(self):

        self.imc.add(FileNode('foo/bar/baz', content='foo'))

        self.imc.add(FileNode('foo/fbar', content='foobar'))

        tip = self.imc.commit(u'Initial', u'joe.doe@example.com')

        # Change node's content

        node = FileNode('foo/bar/baz', content='My **changed** content')

        self.imc.change(node)

        self.imc.commit(u'Changed %s' % node.path, u'joe.doe@example.com')

        newtip = self.repo.get_changeset()

        assert tip != newtip

        assert newtip.get_node('foo/bar/baz').content == b'My **changed** content'

    def test_change_non_ascii(self):

        to_add = [

            FileNode('żółwik/zwierzątko', content='ćććć'),

            FileNode(u'żółwik/zwierzątko_uni', content=u'ćććć'),

        ]

        for node in to_add:

            self.imc.add(node)

        tip = self.imc.commit(u'Initial', u'joe.doe@example.com')

        node = FileNode('żółwik/zwierzątko', content='My **changed** content')

        self.imc.change(node)

        self.imc.commit(u'Changed %s' % safe_unicode(node.path),

                        u'joe.doe@example.com')

        node = FileNode(u'żółwik/zwierzątko_uni', content=u'My **changed** content')

        self.imc.change(node)

        self.imc.commit(u'Changed %s' % safe_unicode(node.path),

                        u'joe.doe@example.com')

        newtip = self.repo.get_changeset()

        assert tip != newtip

        assert newtip.get_node('żółwik/zwierzątko').content == b'My **changed** content'

        assert newtip.get_node('żółwik/zwierzątko_uni').content == b'My **changed** content'

    def test_change_raise_empty_repository(self):

        node = FileNode('foobar')

        with pytest.raises(EmptyRepositoryError):

            self.imc.change(node)

    def test_check_integrity_change_raise_node_does_not_exist(self):

        node = FileNode('foobar', content='baz')

        self.imc.add(node)

    def test_remove(self):

        self.test_add()  # Performs first commit

        tip = self.repo.get_changeset()

        node = self.nodes[0]

        assert node.content == tip.get_node(node.path).content

        self.imc.remove(node)

        self.imc.commit(message=u'Removed %s' % node.path, author=unicode(self))

        newtip = self.repo.get_changeset()

        assert tip != newtip

        with pytest.raises(NodeDoesNotExistError):

            newtip.get_node(node.path)

    def test_remove_last_file_from_directory(self):

        node = FileNode('omg/qwe/foo/bar', content='foobar')

        self.imc.add(node)

        self.imc.commit(u'added', u'joe doe')

        self.imc.remove(node)

        tip = self.imc.commit(u'removed', u'joe doe')

        with pytest.raises(NodeDoesNotExistError):

            tip.get_node('omg/qwe/foo/bar')