# -*- coding: utf-8 -*-

"""

    vcs

    ~~~

    Various version Control System (vcs) management abstraction layer for

    Python.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

__version__ = '.'.join((str(each) for each in VERSION[:4]))

__all__ = [

    'get_version', 'get_repo', 'get_backend',

    'VCSError', 'RepositoryError', 'ChangesetError']

import sys

from rhodecode.lib.vcs.backends import get_repo, get_backend

from rhodecode.lib.vcs.exceptions import VCSError, RepositoryError, ChangesetError

def get_version():

    """

    Returns shorter version (digit parts only) as string.

    """

    return '.'.join((str(each) for each in VERSION[:3]))

def main(argv=None):

    if argv is None:

        argv = sys.argv

    from rhodecode.lib.vcs.cli import ExecutionManager

    manager = ExecutionManager(argv)

    manager.execute()

import re

from itertools import chain

from dulwich import objects

from subprocess import Popen, PIPE

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.exceptions import ChangesetError

from rhodecode.lib.vcs.exceptions import NodeDoesNotExistError

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.exceptions import ImproperArchiveTypeError

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

from rhodecode.lib.vcs.nodes import FileNode, DirNode, NodeKind, RootNode, \

    RemovedFileNode, SubModuleNode

from rhodecode.lib.vcs.utils import safe_unicode

from rhodecode.lib.vcs.utils import date_fromtimestamp

from rhodecode.lib.vcs.utils.lazy import LazyProperty

class GitChangeset(BaseChangeset):

    """

    Represents state of the repository at single revision.

    """

    def __init__(self, repository, revision):

        self._stat_modes = {}

        self.repository = repository

        try:

            commit = self.repository._repo.get_object(revision)

                revision = 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 = revision

        self.id = self.raw_id

        self.short_id = self.raw_id[:12]

        self._commit = commit

        self._tree_id = commit.tree

        self._commiter_property = 'committer'

        self._date_property = 'commit_time'

        self._date_tz_property = 'commit_timezone'

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

        self.message = safe_unicode(commit.message)

        #self.branch = None

        self.tags = []

        self.nodes = {}

        self._paths = {}

    @LazyProperty

    def author(self):

        return safe_unicode(getattr(self._commit, self._commiter_property))

import os

import posixpath

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

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import  ChangesetDoesNotExistError, \

    ChangesetError, ImproperArchiveTypeError, NodeDoesNotExistError, VCSError

from rhodecode.lib.vcs.nodes import AddedFileNodesGenerator, \

    ChangedFileNodesGenerator, DirNode, FileNode, NodeKind, \

    RemovedFileNodesGenerator, RootNode, SubModuleNode

from rhodecode.lib.vcs.utils import safe_str, safe_unicode, date_fromtimestamp

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.utils.paths import get_dirs_for_path

class MercurialChangeset(BaseChangeset):

    """

    Represents state of the repository at the single revision.

    """

    def __init__(self, repository, revision):

        self.repository = repository

        self.raw_id = revision

        self._ctx = repository._repo[revision]

        self.revision = self._ctx._rev

        self.nodes = {}

    @LazyProperty

    def tags(self):

        return map(safe_unicode, self._ctx.tags())

    @LazyProperty

    def branch(self):

        return  safe_unicode(self._ctx.branch())

    @LazyProperty

    def bookmarks(self):

import datetime

import errno

from rhodecode.lib.vcs.backends.base import BaseInMemoryChangeset

from rhodecode.lib.vcs.exceptions import RepositoryError

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

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

        :param message: message of the commit

        :param author: full username, i.e. "Joe Doe <joe.doe@example.com>"

        :param parents: single parent or sequence of parents from which commit

          would be derieved

        :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

        """

        self.check_integrity(parents)

import os

import time

import datetime

import urllib

import urllib2

from rhodecode.lib.vcs.backends.base import BaseRepository

from .workdir import MercurialWorkdir

from .changeset import MercurialChangeset

from .inmemory import MercurialInMemoryChangeset

from rhodecode.lib.vcs.exceptions import BranchDoesNotExistError, \

    ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, \

    VCSError, TagAlreadyExistError, TagDoesNotExistError

from rhodecode.lib.vcs.utils import author_email, author_name, date_fromtimestamp, \

    makedate, safe_unicode

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.utils.ordered_dict import OrderedDict

from rhodecode.lib.vcs.utils.paths import abspath

    get_contact, pull, localrepository, RepoLookupError, Abort, RepoError, hex

class MercurialRepository(BaseRepository):

    """

    Mercurial repository backend

    """

    DEFAULT_BRANCH_NAME = 'default'

    scm = 'hg'

    def __init__(self, repo_path, create=False, baseui=None, src_url=None,

                 update_after_clone=False):

        """

        Raises RepositoryError if repository could not be find at the given

        ``repo_path``.

        :param repo_path: local path of the repository

        :param create=False: if set to True, would try to create repository if

           it does not exist rather than raising exception

        :param baseui=None: user data

        :param src_url=None: would try to clone repository from given location

        :param update_after_clone=False: sets update of working copy after

          making a clone

        """

from rhodecode.lib.vcs.backends.base import BaseWorkdir

from rhodecode.lib.vcs.exceptions import BranchDoesNotExistError

class MercurialWorkdir(BaseWorkdir):

    def get_branch(self):

        return self.repository._repo.dirstate.branch()

    def get_changeset(self):

        return self.repository.get_changeset()

    def checkout_branch(self, branch=None):

        if branch is None:

            branch = self.repository.DEFAULT_BRANCH_NAME

        if branch not in self.repository.branches:

            raise BranchDoesNotExistError

        hg_merge.update(self.repository._repo, branch, False, False, None)

# -*- coding: utf-8 -*-

"""

    vcs.nodes

    ~~~~~~~~~

    Module holding everything related to vcs nodes.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import os

import stat

import posixpath

import mimetypes

from pygments import lexers

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.exceptions import NodeError

from rhodecode.lib.vcs.exceptions import RemovedFileNodeError

from rhodecode.lib.vcs.backends.base import EmptyChangeset

class NodeKind:

    SUBMODULE = -1

    DIR = 1

    FILE = 2

class NodeState:

    ADDED = u'added'

    CHANGED = u'changed'

    NOT_CHANGED = u'not changed'

    REMOVED = u'removed'

class NodeGeneratorBase(object):

    """

    Base class for removed added and changed filenodes, it's a lazy generator

    class that will create filenodes only on iteration or call

    The len method doesn't need to create filenodes at all

        )

        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)

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

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