load_rcextensions(root_path=config['here'])

    config['base_path'] = repos_path

    set_app_settings(config)

                hgrepo = other_repo._repo

            ancestors = [hgrepo[ancestor].hex() for ancestor in

            if ancestors:

                log.debug("shortcut found: %s is already an ancestor of %s", other_rev, org_rev)

            else:

                log.debug("no shortcut found: %s is not an ancestor of %s", other_rev, org_rev)

                ancestors = [hgrepo[ancestor].hex() for ancestor in

                                     other_rev, org_rev, org_rev)

                                   org_rev, other_rev, other_rev)

        elif alias == 'git':

            if org_repo != other_repo:

            # including branches of children could be nice too

            peerbranches = set()

            for i in repo._repo.revs(

                branch_rev, branch_rev

            ):

                for abranch in repo.get_changeset(i).branches:

    context = context or 3

    submodules = [o for o in [filenode_new, filenode_old] if isinstance(o, SubModuleNode)]

    if submodules:

    for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

                                     ignore_whitespace=ignore_whitespace, context=context)

    except MemoryError:

        h.flash('MemoryError: Diff is too big', category='error')

NEW_FILENODE = 1

    mentioned in the diff together with a dict of meta information that

    can be used to render it in a HTML template.

    """

    def __init__(self, diff, vcs='hg', diff_limit=None, inline_diff=True):

        """

    return _escape_re.sub(substitute, safe_unicode(string))

    ^diff[ ]--git[ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

    (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

       ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

""", re.VERBOSE | re.MULTILINE)

    ^diff[ ]--git[ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

    (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

       ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

    rest = diff_chunk[match.end():]

    if rest and _header_next_check.match(rest):

        raise Exception('cannot parse %s diff header: %r followed by %r' % (vcs, diff_chunk[:match.end()], rest[:1000]))

    return meta_info, diff_lines

    cahes! The function should perhaps be renamed.

    """

    _h = binascii.hexlify

    process_pushed_raw_ids(revs)

    return 0

            if push_ref['old_rev'] == EmptyChangeset().raw_id:

                # update the symbolic ref if we push new repo

                if scm_repo.is_empty():

                # build exclude list without the ref

                cmd = ['for-each-ref', '--format=%(refname)', 'refs/heads/*']

    except TypeError:

        raise SshKeyParseError(_("Incorrect SSH key - failed to decode base64 part %r") % keyvalue)

    return keytype, decoded, comment

    sa = meta.Session()

    for ui_ in sa.query(Ui).all():

        if ui_.ui_active:

            log.debug('config from db: [%s] %s=%r', ui_.ui_section,

                      ui_.ui_key, ui_val)

            baseui.setconfig(safe_str(ui_.ui_section), safe_str(ui_.ui_key),

                             ui_val)

    # force set push_ssl requirement to False, Kallithea handles that

    # prevent interactive questions for ssh password / passphrase

    # push / pull hooks

    if repo_path is not None:

        hgrc_path = os.path.join(repo_path, '.hg', 'hgrc')

        # Only used to feed diffstat

        rev1 = self.parents[0] if self.parents else self.repository.EMPTY_CHANGESET

        rev2 = self

                                    ignore_whitespace=ignore_whitespace,

                                    context=context))

                obj_path = name

            if objects.S_ISGITLINK(stat):

                root_tree = self.repository._repo[self._tree_id]

                url = cf.get(('submodule', obj_path), 'url')

                dirnodes.append(SubModuleNode(obj_path, url=url, changeset=id,

                                              alias=als))

            _GL = lambda m: m and objects.S_ISGITLINK(m)

            if _GL(self._stat_modes.get(path)):

                tree = self.repository._repo[self._tree_id]

                url = cf.get(('submodule', path), 'url')

                node = SubModuleNode(path, url=url, changeset=id_,

                                     alias=self.repository.alias)

        repo = self.repository._repo

        object_store = repo.object_store

        # Create tree and populates it with blobs

        commit_tree = self.parents[0] and repo[self.parents[0]._commit.tree] or \

        for node in self.added + self.changed:

            # Compute subdirs if needed

            dirpath, nodename = posixpath.split(node.path)

            parent = commit_tree

            ancestors = [('', parent)]

            for tree in new_trees:

                object_store.add_object(tree)

        for node in self.removed:

            tree = commit_tree

            trees = [tree]

            # Traverse deep into the forest...

        object_store.add_object(commit)

        repo.refs[ref] = commit.id

        self.repository.revisions.append(commit.id)

        # invalidate parsed refs after commit

        self.repository._parsed_refs = self.repository._get_parsed_refs()

            raise RepositoryError(msg)

        try:

        finally:

            p.close()

        # TODO: introduce option to make commands fail if they have any stderr output?

        handlers = []

        url_obj = hg_url(url)

        test_uri, authinfo = url_obj.authinfo()

        if not test_uri.endswith('info/refs'):

            test_uri = test_uri.rstrip('/') + '/info/refs'

        if authinfo:

            # create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

    def _get_all_revisions2(self):

        # alternate implementation using dulwich

        includes = [x[1][0] for x in self._parsed_refs.iteritems()

        return [c.commit.id for c in self._repo.get_walker(include=includes)]

    def _get_revision(self, revision):

            # get by branch/tag name

            _ref_revision = self._parsed_refs.get(revision)

                return _ref_revision[0]

            if revision in self.revisions:

    @LazyProperty

    def description(self):

    @LazyProperty

    def contact(self):

            return {}

        sortkey = lambda ctx: ctx[0]

        _branches = [(x[0], x[1][0])

        return OrderedDict(sorted(_branches, key=sortkey, reverse=False))

    @LazyProperty

        sortkey = lambda ctx: ctx[0]

        _tags = [(x[0], x[1][0])

        return OrderedDict(sorted(_tags, key=sortkey, reverse=True))

    def tag(self, name, user, revision=None, message=None, date=None,

        changeset = self.get_changeset(revision)

        message = message or "Added tag %s for commit %s" % (name,

            changeset.raw_id)

        self._parsed_refs = self._get_parsed_refs()

        self.tags = self._get_tags()

        # cache the property

        _repo = self._repo

        refs = _repo.get_refs()

        _refs = {}

        for ref, sha in refs.iteritems():

            for k, type_ in keys:

                if ref.startswith(k):

                    _key = ref[len(k):]

                        obj = _repo.get_object(sha)

                        if isinstance(obj, Tag):

                            sha = _repo.get_object(sha).object[1]

        heads = {}

        for key, val in refs.items():

                if key.startswith(ref_key):

                    n = key[len(ref_key):]

                        heads[n] = val

        return heads if reverse else dict((y, x) for x, y in heads.iteritems())

        # If we used 'show' command, strip first few lines (until actual diff

        # starts)

        if rev1 == self.EMPTY_CHANGESET:

            if len(parts) > 1:

        return stdout

    @LazyProperty

class GitWorkdir(BaseWorkdir):

    def get_branch(self):

        try:

            content = open(headpath).read()

            match = re.match(r'^ref: refs/heads/(?P<branch>.+)\n$', content)

            raise RepositoryError("Couldn't compute workdir's branch")

    def get_changeset(self):

        return self.repository.get_changeset(wk_dir_id)

    def checkout_branch(self, branch=None):

    def diff(self):

        # Only used to feed diffstat

    def _fix_path(self, path):

        """

        Returns stat mode of the file at the given ``path``.

        """

        fctx = self._get_filectx(path)

            return 0o100755

        else:

            return 0o100644

        if branch is None:

            branch = MercurialRepository.DEFAULT_BRANCH_NAME

        def filectxfn(_repo, memctx, path):

            """

        commit_ctx = memctx(repo=self.repository._repo,

            parents=parents,

            files=self.get_paths(),

            filectxfn=filectxfn,

            user=author,

        ))

    def _get_all_revisions(self):

    def get_diff(self, rev1, rev2, path='', ignore_whitespace=False,

                  context=3):

        else:

            file_filter = None

                          opts=diffopts(git=True,

                                        showfunc=True,

                                        ignorews=ignore_whitespace,

        when the return code is non 200

        """

        # check first if it's not an local url

            return True

            # in case of invalid uri or authentication issues, sshpeer will

            # throw an exception.

            return True

        url_prefix = None

        handlers = []

        url_obj = hg_url(url)

        test_uri, authinfo = url_obj.authinfo()

        cleaned_uri = str(url_obj)

        if authinfo:

        if not url_prefix: # skip svn+http://... (and git+... too)

            # now check if it's a proper hg repo

            try:

            except Exception as e:

                raise urllib2.URLError(

                    "url [%s] does not look like an hg repo org_exc: %s"

    @LazyProperty

    def description(self):

    @LazyProperty

    def contact(self):

        return safe_unicode(get_contact(self._repo.ui.config)

    @LazyProperty

    def last_change(self):

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, None]:

        elif isinstance(revision, unicode):

            revision = safe_bytes(revision)

        return self._get_revision(revision)

    def _get_archives(self, archive_name='tip'):

                                         untrusted=True)

                                                           untrusted=True):

    def _get_url(self, url):

        """

        # filter branches

        filter_ = []

        if branch_name:

        if start_date:

        if end_date:

        if filter_ or max_revisions:

            if filter_:

            else:

            if max_revisions:

            revisions = scmutil.revrange(self._repo, [revspec])

        else:

            revisions = self.revisions

        # Note: we want a repo with config based on .hg/hgrc and can thus not use self.db_repo.scm_instance._repo.ui

        baseui = make_ui(repo_path=self.db_repo.repo_full_path)

        if not self.allow_push:

        repo = hg.repository(baseui, safe_str(self.db_repo.repo_full_path))

        log.debug("Starting Mercurial sshserver for %s", self.db_repo.repo_full_path)

            and returncode != 0

        ): # and it failed

            bg_out.stop()

            bg_err.stop()

            ):

                # hack inspired by https://github.com/schacon/grack/pull/7

                bg_out = iter([out])

        if self.org_repo.scm_instance.alias == 'git':

            # create a ref under refs/pull/ so that commits don't get garbage-collected

        # reset state to under-review

        from kallithea.model.changeset_status import ChangesetStatusModel

        if not os.path.isdir(loc):

            os.makedirs(loc)

        tmpl_post += pkg_resources.resource_string(

            'kallithea', os.path.join('config', 'post_receive_tmpl.py')

        )

        tmpl_pre += pkg_resources.resource_string(

            'kallithea', os.path.join('config', 'pre_receive_tmpl.py')

        )

                log.debug('writing %s hook file !', h_type)

                try:

                    with open(_hook_file, 'wb') as f:

                        f.write(tmpl)

                    os.chmod(_hook_file, 0o755)

                except IOError as e:

            "revisions": self.TEST_PR_REVISIONS,

        }

        self._compare_ok(random_id, expected,

    def test_api_close_pullrequest(self):

        pull_request_id = fixture.create_pullrequest(self, self.REPO, self.TEST_PR_SRC, self.TEST_PR_DST, u'close test')

                                  'password': password,

                                  '_session_csrf_secret_token': self.session_csrf_secret_token()})

            pytest.fail('could not login using %s %s' % (username, password))

        assert response.status == '302 Found'

def failing_test_hook(ui, repo, **kwargs):

    return 1

def passing_test_hook(ui, repo, **kwargs):

    return 0

            url=url(controller='admin/my_account', action='my_account'),

            extra_environ={'REMOTE_USER': 'john'},

        )

    def test_crowd_save_settings(self):

        self.log_user()

        gist = _create_gist('gist-show-me', content='GIST CONTENT')

        response = self.app.get(url('formatted_gist',

                                    gist_id=gist.gist_access_id, format='raw'))

    def test_show_as_raw_individual_file(self):

        gist = _create_gist('gist-show-me-raw', content='GIST BODY')

        response = self.app.get(url('formatted_gist_file',

                                    gist_id=gist.gist_access_id, format='raw',

                                    revision='tip', f_path='gist-show-me-raw'))

    def test_edit(self):

        response = self.app.get(url('edit_gist', gist_id=1))

    def test_changeset10(self):

        chset10 = self.repo.get_changeset(self.repo.revisions[9])

VCS

===

    def test_paths_slow_traversing(self):

        cs = self.repo.get_changeset()

    def test_paths_fast_traversing(self):

        cs = self.repo.get_changeset()

    def test_workdir_get_branch(self):

        self.repo.run_git_command(['checkout', '-b', 'production'])

    def test_changeset10(self):

        chset10 = self.repo.get_changeset(10)

VCS

===

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

        assert isinstance(changeset.get_node('foo'), DirNode)

        assert isinstance(changeset.get_node('foo/bar'), DirNode)

        # commit some more files again

        to_add = [

        ]

        self.imc.add(*to_add)

        changeset = self.imc.commit(u'Another', u'joe.doe@example.com')

    def test_add_non_ascii_files(self):

        rev_count = len(self.repo.revisions)

        newtip = self.repo.get_changeset()

        assert tip != newtip

        assert tip.id != newtip.id

    def test_change_non_ascii(self):

        to_add = [

        assert tip != newtip

        assert tip.id != newtip.id

    def test_change_raise_empty_repository(self):

        node = FileNode('foobar')

        tar_node = FileNode('test.tar.gz')

        my_node2 = FileNode('myfile2')

        my_node3 = FileNode('myfile3')

        assert py_node.mimetype == mimetypes.guess_type(py_node.name)[0]

        assert py_node.get_mimetype() == mimetypes.guess_type(py_node.name)

    def test_initial_commit_diff(self):

        initial_rev = self.repo.revisions[0]

new file mode 100644

index 0000000000000000000000000000000000000000..f6ea0495187600e7b2288c8ac19c5886383a4632

--- /dev/null

    def test_second_changeset_diff(self):

        revs = self.repo.revisions

index f6ea0495187600e7b2288c8ac19c5886383a4632..389865bb681b358c9b102d79abd8d5f941e96551 100644

--- a/foobar

+++ b/foobar

    def test_third_changeset_diff(self):

        revs = self.repo.revisions