**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):

        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

    def get_last_change(self):

        self.get_changesets()

    #==========================================================================

    # 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 ``MercurialChangeset`` objects from start to end

        not inclusive This should behave just like a list, ie. end is not

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

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

        :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,

        hex = '2a13f185e4525f9d4b59882791a2d397b90d5ddc'

        chset = self.repo.get_changeset(hex)

        root = chset.root

        docs = root.get_node('docs')

        self.assertTrue(docs is chset.get_node('docs'))

        api = docs.get_node('api')

        self.assertTrue(api is chset.get_node('docs/api'))

        index = api.get_node('index.rst')

        self.assertTrue(index is chset.get_node('docs/api/index.rst'))

        self.assertTrue(index is chset.get_node('docs')\

            .get_node('api')\

            .get_node('index.rst'))

    def test_branch_and_tags(self):

        """

        rev0 = self.repo.revisions[0]

        chset0 = self.repo.get_changeset(rev0)

        self.assertEqual(chset0.branch, 'master')

        self.assertEqual(chset0.tags, [])

        rev10 = self.repo.revisions[10]

        chset10 = self.repo.get_changeset(rev10)

        self.assertEqual(chset10.branch, 'master')

        self.assertEqual(chset10.tags, [])

        rev44 = self.repo.revisions[44]

        chset44 = self.repo.get_changeset(rev44)

        self.assertEqual(chset44.branch, 'web-branch')

        tip = self.repo.get_changeset('tip')

        self.assertTrue('tip' in tip.tags)

        """

        # Those tests would fail - branches are now going

        # to be changed at main API in order to support git backend

        pass

    def _test_slices(self, limit, offset):

        count = self.repo.count()

        changesets = self.repo.get_changesets(limit=limit, offset=offset)

        idx = 0

        for changeset in changesets:

            rev = offset + idx

            idx += 1

            rev_id = self.repo.revisions[rev]

            if idx > limit:

                self.fail("Exceeded limit already (getting revision %s, "

                    "there are %s total revisions, offset=%s, limit=%s)"

                    % (rev_id, count, offset, limit))

            self.assertEqual(changeset, self.repo.get_changeset(rev_id))

        result = list(self.repo.get_changesets(limit=limit, offset=offset))

        start = offset

        end = limit and offset + limit or None

        sliced = list(self.repo[start:end])

        self.failUnlessEqual(result, sliced,

            msg="Comparison failed for limit=%s, offset=%s"

            "(get_changeset returned: %s and sliced: %s"

            % (limit, offset, result, sliced))

    def _test_file_size(self, revision, path, size):

        node = self.repo.get_changeset(revision).get_node(path)

        self.assertTrue(node.is_file())

        self.assertEqual(node.size, size)

    def test_file_size(self):

        to_check = (

            ('c1214f7e79e02fc37156ff215cd71275450cffc3',

                'vcs/backends/BaseRepository.py', 502),

            ('d7e0d30fbcae12c90680eb095a4f5f02505ce501',

                'vcs/backends/hg.py', 854),

            ('6e125e7c890379446e98980d8ed60fba87d0f6d1',

                'setup.py', 1068),

            ('d955cd312c17b02143c04fa1099a352b04368118',

                'vcs/backends/base.py', 2921),

            ('ca1eb7957a54bce53b12d1a51b13452f95bc7c7e',

                'vcs/backends/base.py', 3936),

            ('f50f42baeed5af6518ef4b0cb2f1423f3851a941',

                'vcs/backends/base.py', 6189),

        )

        for revision, path, size in to_check:

            self._test_file_size(revision, path, size)

    def _test_dir_size(self, revision, path, size):

        node = self.repo.get_changeset(revision).get_node(path)

        self.assertEqual(node.size, size)

    def test_dir_size(self):

        to_check = (

            ('5f2c6ee195929b0be80749243c18121c9864a3b3', '/', 674076),

            ('7ab37bc680b4aa72c34d07b230c866c28e9fc204', '/', 674049),

            ('6892503fb8f2a552cef5f4d4cc2cdbd13ae1cd2f', '/', 671830),

        )

        for revision, path, size in to_check:

            self._test_dir_size(revision, path, size)

    def test_repo_size(self):

    def test_file_history(self):

        # we can only check if those revisions are present in the history

        # as we cannot update this test every time file is changed

        files = {

            'setup.py': [

                '54386793436c938cff89326944d4c2702340037d',

                '51d254f0ecf5df2ce50c0b115741f4cf13985dab',

                '998ed409c795fec2012b1c0ca054d99888b22090',

                '5e0eb4c47f56564395f76333f319d26c79e2fb09',

                '0115510b70c7229dbc5dc49036b32e7d91d23acd',

                '7cb3fd1b6d8c20ba89e2264f1c8baebc8a52d36e',

                '2a13f185e4525f9d4b59882791a2d397b90d5ddc',

                '191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',

                'ff7ca51e58c505fec0dd2491de52c622bb7a806b',

            ],

            'vcs/nodes.py': [

                '33fa3223355104431402a888fa77a4e9956feb3e',

                'fa014c12c26d10ba682fadb78f2a11c24c8118e1',

                'e686b958768ee96af8029fe19c6050b1a8dd3b2b',

                'ab5721ca0a081f26bf43d9051e615af2cc99952f',

                'c877b68d18e792a66b7f4c529ea02c8f80801542',

                '4313566d2e417cb382948f8d9d7c765330356054',

                '6c2303a793671e807d1cfc70134c9ca0767d98c2',

                '54386793436c938cff89326944d4c2702340037d',

                '54000345d2e78b03a99d561399e8e548de3f3203',

                '1c6b3677b37ea064cb4b51714d8f7498f93f4b2b',

                '2d03ca750a44440fb5ea8b751176d1f36f8e8f46',

                '2a08b128c206db48c2f0b8f70df060e6db0ae4f8',

                '30c26513ff1eb8e5ce0e1c6b477ee5dc50e2f34b',

                'ac71e9503c2ca95542839af0ce7b64011b72ea7c',

                '12669288fd13adba2a9b7dd5b870cc23ffab92d2',

                '5a0c84f3e6fe3473e4c8427199d5a6fc71a9b382',

                '12f2f5e2b38e6ff3fbdb5d722efed9aa72ecb0d5',

                '5eab1222a7cd4bfcbabc218ca6d04276d4e27378',

                'f50f42baeed5af6518ef4b0cb2f1423f3851a941',

                'd7e390a45f6aa96f04f5e7f583ad4f867431aa25',

                'f15c21f97864b4f071cddfbf2750ec2e23859414',

                'e906ef056cf539a4e4e5fc8003eaf7cf14dd8ade',

                'ea2b108b48aa8f8c9c4a941f66c1a03315ca1c3b',

                '84dec09632a4458f79f50ddbbd155506c460b4f9',

                '0115510b70c7229dbc5dc49036b32e7d91d23acd',

                '2a13f185e4525f9d4b59882791a2d397b90d5ddc',

                '3bf1c5868e570e39569d094f922d33ced2fa3b2b',

                'b8d04012574729d2c29886e53b1a43ef16dd00a1',

                '6970b057cffe4aab0a792aa634c89f4bebf01441',

                'dd80b0f6cf5052f17cc738c2951c4f2070200d7f',

                'ff7ca51e58c505fec0dd2491de52c622bb7a806b',

            ],

            'vcs/backends/git.py': [

                '4cf116ad5a457530381135e2f4c453e68a1b0105',

                '9a751d84d8e9408e736329767387f41b36935153',

                'cb681fb539c3faaedbcdf5ca71ca413425c18f01',

                '428f81bb652bcba8d631bce926e8834ff49bdcc6',

                '180ab15aebf26f98f714d8c68715e0f05fa6e1c7',

                '2b8e07312a2e89e92b90426ab97f349f4bce2a3a',

                '50e08c506174d8645a4bb517dd122ac946a0f3bf',

                '54000345d2e78b03a99d561399e8e548de3f3203',

            ],

        }

        for path, revs in files.items():

            node = self.repo.get_changeset(revs[0]).get_node(path)

            node_revs = [chset.raw_id for chset in node.history]

            self.assertTrue(set(revs).issubset(set(node_revs)),

                "We assumed that %s is subset of revisions for which file %s "

                "has been changed, and history of that node returned: %s"

                % (revs, path, node_revs))

    def test_file_annotate(self):

        files = {

            'vcs/backends/__init__.py': {

                'c1214f7e79e02fc37156ff215cd71275450cffc3': {

                    'lines_no': 1,

                    'changesets': [

                        'c1214f7e79e02fc37156ff215cd71275450cffc3',

                    ],

                },

                '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647': {

                    'lines_no': 21,

                    'changesets': [

                        '49d3fd156b6f7db46313fac355dca1a0b94a0017',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

        self.assertEqual(tip, self.repo.get_changeset(revision=None))

        self.assertEqual(tip, list(self.repo[-1:])[0])

    def test_root_node(self):

        tip = self.repo.get_changeset('tip')

        self.assertTrue(tip.root is tip.get_node(''))

    def test_lazy_fetch(self):

        """

        Test if changeset's nodes expands and are cached as we walk through

        the revision. This test is somewhat hard to write as order of tests

        is a key here. Written by running command after command in a shell.

        """

        self.setUp()

        chset = self.repo.get_changeset(45)

        self.assertTrue(len(chset.nodes) == 0)

        root = chset.root

        self.assertTrue(len(chset.nodes) == 1)

        self.assertTrue(len(root.nodes) == 8)

        # accessing root.nodes updates chset.nodes

        self.assertTrue(len(chset.nodes) == 9)

        docs = root.get_node('docs')

        # we haven't yet accessed anything new as docs dir was already cached

        self.assertTrue(len(chset.nodes) == 9)

        self.assertTrue(len(docs.nodes) == 8)

        # accessing docs.nodes updates chset.nodes

        self.assertTrue(len(chset.nodes) == 17)

        self.assertTrue(docs is chset.get_node('docs'))

        self.assertTrue(docs is root.nodes[0])

        self.assertTrue(docs is root.dirs[0])

        self.assertTrue(docs is chset.get_node('docs'))

    def test_nodes_with_changeset(self):

        self.setUp()

        chset = self.repo.get_changeset(45)

        root = chset.root

        docs = root.get_node('docs')

        self.assertTrue(docs is chset.get_node('docs'))

        api = docs.get_node('api')

        self.assertTrue(api is chset.get_node('docs/api'))

        index = api.get_node('index.rst')

        self.assertTrue(index is chset.get_node('docs/api/index.rst'))

        self.assertTrue(index is chset.get_node('docs')\

            .get_node('api')\

            .get_node('index.rst'))

    def test_branch_and_tags(self):

        chset0 = self.repo.get_changeset(0)

        self.assertEqual(chset0.branch, 'default')

        self.assertEqual(chset0.tags, [])

        chset10 = self.repo.get_changeset(10)

        self.assertEqual(chset10.branch, 'default')

        self.assertEqual(chset10.tags, [])

        chset44 = self.repo.get_changeset(44)

        self.assertEqual(chset44.branch, 'web')

        tip = self.repo.get_changeset('tip')

        self.assertTrue('tip' in tip.tags)

    def _test_file_size(self, revision, path, size):

        node = self.repo.get_changeset(revision).get_node(path)

        self.assertTrue(node.is_file())

        self.assertEqual(node.size, size)

    def test_file_size(self):

        to_check = (

            (10, 'setup.py', 1068),

            (20, 'setup.py', 1106),

            (60, 'setup.py', 1074),

            (10, 'vcs/backends/base.py', 2921),

            (20, 'vcs/backends/base.py', 3936),

            (60, 'vcs/backends/base.py', 6189),

        )

        for revision, path, size in to_check:

            self._test_file_size(revision, path, size)

    def _test_dir_size(self, revision, path, size):

        node = self.repo.get_changeset(revision).get_node(path)

        self.assertFalse(node.is_file())

        self.assertEqual(node.size, size)

    def test_dir_size(self):

        to_check = (

            ('96507bd11ecc', '/', 682421),

            ('a53d9201d4bc', '/', 682410),

            ('90243de06161', '/', 682006),

        )

        for revision, path, size in to_check:

            self._test_dir_size(revision, path, size)

    def test_repo_size(self):

    def test_file_history(self):

        # we can only check if those revisions are present in the history

        # as we cannot update this test every time file is changed

        files = {

            'setup.py': [7, 18, 45, 46, 47, 69, 77],

            'vcs/nodes.py': [7, 8, 24, 26, 30, 45, 47, 49, 56, 57, 58, 59, 60,

                61, 73, 76],

            'vcs/backends/hg.py': [4, 5, 6, 11, 12, 13, 14, 15, 16, 21, 22, 23,

                26, 27, 28, 30, 31, 33, 35, 36, 37, 38, 39, 40, 41, 44, 45, 47,

                48, 49, 53, 54, 55, 58, 60, 61, 67, 68, 69, 70, 73, 77, 78, 79,

                82],

        }

        for path, revs in files.items():

            tip = self.repo.get_changeset(revs[-1])

            node = tip.get_node(path)

            node_revs = [chset.revision for chset in node.history]

            self.assertTrue(set(revs).issubset(set(node_revs)),

                "We assumed that %s is subset of revisions for which file %s "

                "has been changed, and history of that node returned: %s"

                % (revs, path, node_revs))

    def test_file_annotate(self):

        files = {

                 'vcs/backends/__init__.py':

                  {89: {'lines_no': 31,

                        'changesets': [32, 32, 61, 32, 32, 37, 32, 32, 32, 44,

                                       37, 37, 37, 37, 45, 37, 44, 37, 37, 37,

                                       32, 32, 32, 32, 37, 32, 37, 37, 32,

                                       32, 32]},

                   20: {'lines_no': 1,

                        'changesets': [4]},

                   55: {'lines_no': 31,

                        'changesets': [32, 32, 45, 32, 32, 37, 32, 32, 32, 44,

                                       37, 37, 37, 37, 45, 37, 44, 37, 37, 37,

                                       32, 32, 32, 32, 37, 32, 37, 37, 32,

                                       32, 32]}},

                 'vcs/exceptions.py':

                 {89: {'lines_no': 18,

                       'changesets': [16, 16, 16, 16, 16, 16, 16, 16, 16, 16,

                                      16, 16, 17, 16, 16, 18, 18, 18]},

                  20: {'lines_no': 18,

                       'changesets': [16, 16, 16, 16, 16, 16, 16, 16, 16, 16,

                                      16, 16, 17, 16, 16, 18, 18, 18]},

                  55: {'lines_no': 18, 'changesets': [16, 16, 16, 16, 16, 16,

                                                      16, 16, 16, 16, 16, 16,

                                                      17, 16, 16, 18, 18, 18]}},

                 'MANIFEST.in': {89: {'lines_no': 5,

                                      'changesets': [7, 7, 7, 71, 71]},

                                 20: {'lines_no': 3,

                                      'changesets': [7, 7, 7]},

                                 55: {'lines_no': 3,

                                     'changesets': [7, 7, 7]}}}

        for fname, revision_dict in files.items():

            for rev, data in revision_dict.items():

                cs = self.repo.get_changeset(rev)

                l1_1 = [x[1] for x in cs.get_file_annotate(fname)]

                l1_2 = [x[2]().raw_id for x in cs.get_file_annotate(fname)]

                self.assertEqual(l1_1, l1_2)

                l1 = l1_2 = [x[2]().revision for x in cs.get_file_annotate(fname)]

                l2 = files[fname][rev]['changesets']

                self.assertTrue(l1 == l2 , "The lists of revision for %s@rev%s"

                                "from annotation list should match each other,"

                                "got \n%s \nvs \n%s " % (fname, rev, l1, l2))

    def test_changeset_state(self):

        """

        Tests which files have been added/changed/removed at particular revision

        """

        # rev 46ad32a4f974:

        # hg st --rev 46ad32a4f974

        #    changed: 13

        #    added:   20

        #    removed: 1

        changed = set(['.hgignore'

            , 'README.rst' , 'docs/conf.py' , 'docs/index.rst' , 'setup.py'

            , 'tests/test_hg.py' , 'tests/test_nodes.py' , 'vcs/__init__.py'

            , 'vcs/backends/__init__.py' , 'vcs/backends/base.py'

            , 'vcs/backends/hg.py' , 'vcs/nodes.py' , 'vcs/utils/__init__.py'])

        added = set(['docs/api/backends/hg.rst'

            , 'docs/api/backends/index.rst' , 'docs/api/index.rst'

            , 'docs/api/nodes.rst' , 'docs/api/web/index.rst'

            , 'docs/api/web/simplevcs.rst' , 'docs/installation.rst'

            , 'docs/quickstart.rst' , 'setup.cfg' , 'vcs/utils/baseui_config.py'

            , 'vcs/utils/web.py' , 'vcs/web/__init__.py' , 'vcs/web/exceptions.py'

            , 'vcs/web/simplevcs/__init__.py' , 'vcs/web/simplevcs/exceptions.py'

            , 'vcs/web/simplevcs/middleware.py' , 'vcs/web/simplevcs/models.py'

            , 'vcs/web/simplevcs/settings.py' , 'vcs/web/simplevcs/utils.py'

            , 'vcs/web/simplevcs/views.py'])

        removed = set(['docs/api.rst'])

        chset64 = self.repo.get_changeset('46ad32a4f974')