Python context.memctx函数代码示例

 def test_push_two_revs_different_local_branch(self):
     def filectxfn(repo, memctx, path):
         return context.memfilectx(path=path,
                                   data=path,
                                   islink=False,
                                   isexec=False,
                                   copied=False)
     oldtiphash = self.repo['default'].node()
     ctx = context.memctx(self.repo,
                          (self.repo[0].node(), revlog.nullid, ),
                          'automated test',
                          ['gamma', ],
                          filectxfn,
                          'testy',
                          '2008-12-21 16:32:00 -0500',
                          {'branch': 'localbranch', })
     newhash = self.repo.commitctx(ctx)
     ctx = context.memctx(self.repo,
                          (newhash, revlog.nullid),
                          'automated test2',
                          ['delta', ],
                          filectxfn,
                          'testy',
                          '2008-12-21 16:32:00 -0500',
                          {'branch': 'localbranch', })
     newhash = self.repo.commitctx(ctx)
     repo = self.repo
     hg.update(repo, newhash)
     commands.push(repo.ui, repo)
     self.assertEqual(self.repo['tip'].parents()[0].parents()[0].node(), oldtiphash)
     self.assertEqual(self.repo['tip'].files(), ['delta', ])
     self.assertEqual(self.repo['tip'].manifest().keys(),
                      ['alpha', 'beta', 'gamma', 'delta'])

    def test_push_single_dir_renamed_branch(self, stupid=False):
        # Tests pulling and pushing with a renamed branch
        # Based on test_push_single_dir
        test_util.load_svndump_fixture(self.repo_path,
                                       'branch_from_tag.svndump')
        cmd = ['clone', '--layout=single', '--branch=flaf']
        if stupid:
            cmd.append('--stupid')
        cmd += [test_util.fileurl(self.repo_path), self.wc_path]
        dispatch.dispatch(cmd)

        def file_callback(repo, memctx, path):
            if path == 'adding_file':
                return context.memfilectx(path=path,
                                          data='foo',
                                          islink=False,
                                          isexec=False,
                                          copied=False)
            raise IOError(errno.EINVAL, 'Invalid operation: ' + path)
        ctx = context.memctx(self.repo,
                             (self.repo['tip'].node(), node.nullid),
                             'automated test',
                             ['adding_file'],
                             file_callback,
                             'an_author',
                             '2009-10-19 18:49:30 -0500',
                             {'branch': 'default',})
        self.repo.commitctx(ctx)
        hg.update(self.repo, self.repo['tip'].node())
        self.pushrevisions()
        self.assertTrue('adding_file' in self.svnls(''))

        self.assertEquals(set(['flaf']),
                          set(self.repo[i].branch() for i in self.repo))

 def test_push_to_default(self, commit=True):
     repo = self.repo
     old_tip = repo['tip'].node()
     expected_parent = repo['default'].node()
     def file_callback(repo, memctx, path):
         if path == 'adding_file':
             return context.memfilectx(path=path,
                                       data='foo',
                                       islink=False,
                                       isexec=False,
                                       copied=False)
         raise IOError(errno.EINVAL, 'Invalid operation: ' + path)
     ctx = context.memctx(repo,
                          (repo['default'].node(), node.nullid),
                          'automated test',
                          ['adding_file'],
                          file_callback,
                          'an_author',
                          '2008-10-07 20:59:48 -0500',
                          {'branch': 'default',})
     new_hash = repo.commitctx(ctx)
     if not commit:
         return # some tests use this test as an extended setup.
     hg.update(repo, repo['tip'].node())
     self.pushrevisions()
     tip = self.repo['tip']
     self.assertNotEqual(tip.node(), old_tip)
     self.assertEqual(node.hex(tip.parents()[0].node()),
                      node.hex(expected_parent))
     self.assertEqual(tip['adding_file'].data(), 'foo')
     self.assertEqual(tip.branch(), 'default')

 def test_push_single_dir_one_incoming_and_two_outgoing(self):
     # Tests simple pushing from default branch to a single dir repo
     # Pushes two outgoing over one incoming svn rev
     # (used to cause an "unknown revision")
     # This can happen if someone committed to svn since our last pull (race).
     repo = self._load_fixture_and_fetch('branch_from_tag.svndump',
                                         stupid=False,
                                         layout='single',
                                         subdir='trunk')
     self._add_svn_rev({'trunk/alpha': 'Changed'})
     def file_callback(repo, memctx, path):
         return context.memfilectx(path=path,
                                   data='data of %s' % path,
                                   islink=False,
                                   isexec=False,
                                   copied=False)
     for fn in ['one', 'two']:
         ctx = context.memctx(repo,
                              (repo['tip'].node(), node.nullid),
                              'automated test',
                              [fn],
                              file_callback,
                              'an_author',
                              '2009-10-19 18:49:30 -0500',
                              {'branch': 'default',})
         repo.commitctx(ctx)
     hg.update(repo, repo['tip'].node())
     self.pushrevisions(expected_extra_back=1)
     self.assertTrue('trunk/one' in self.svnls(''))
     self.assertTrue('trunk/two' in self.svnls(''))

 def test_push_single_dir_at_subdir(self):
     repo = self._load_fixture_and_fetch('branch_from_tag.svndump',
                                         stupid=False,
                                         layout='single',
                                         subdir='trunk')
     def filectxfn(repo, memctx, path):
         return context.memfilectx(path=path,
                                   data='contents of %s' % path,
                                   islink=False,
                                   isexec=False,
                                   copied=False)
     ctx = context.memctx(repo,
                          (repo['tip'].node(), node.nullid),
                          'automated test',
                          ['bogus'],
                          filectxfn,
                          'an_author',
                          '2009-10-19 18:49:30 -0500',
                          {'branch': 'localhacking',})
     n = repo.commitctx(ctx)
     self.assertEqual(self.repo['tip']['bogus'].data(),
                      'contents of bogus')
     before = repo['tip'].hex()
     hg.update(repo, self.repo['tip'].hex())
     self.pushrevisions()
     self.assertNotEqual(before, self.repo['tip'].hex())
     self.assertEqual(self.repo['tip']['bogus'].data(),
                      'contents of bogus')

    def putcommit(self, files, modes, copies, commit):

        def getfilectx(repo, memctx, name):
            fileid = files[name]
            if fileid is None:  # deleted file
                raise IOError
            data = self.getblob(fileid)
            ctx = context.memfilectx(name, data, 'l' in modes,
                                     'x' in modes, copies.get(name))
            return ctx

        parents = list(set(commit.parents))
        nparents = len(parents)

        if len(parents) < 2:
            parents.append(nullid)
        if len(parents) < 2:
            parents.append(nullid)
        p2 = parents.pop(0)

        text = commit.desc
        extra = commit.extra.copy()
        if self.branchnames and commit.branch:
            extra['branch'] = commit.branch

        while parents:
            p1 = p2
            p2 = parents.pop(0)
            ctx = context.memctx(self.repo, (p1, p2), text, files.keys(),
                                 getfilectx, commit.author, commit.date, extra)
            self.repo.commitctx(ctx)
            text = "(octopus merge fixup)\n"
            p2 = hex(self.repo.changelog.tip())

        return p2

 def test_push_to_branch(self, push=True):
     repo = self.repo
     def file_callback(repo, memctx, path):
         if path == 'adding_file':
             return context.memfilectx(path=path,
                                       data='foo',
                                       islink=False,
                                       isexec=False,
                                       copied=False)
         raise IOError(errno.EINVAL, 'Invalid operation: ' + path)
     ctx = context.memctx(repo,
                          (repo['the_branch'].node(), node.nullid),
                          'automated test',
                          ['adding_file'],
                          file_callback,
                          'an_author',
                          '2008-10-07 20:59:48 -0500',
                          {'branch': 'the_branch',})
     new_hash = repo.commitctx(ctx)
     hg.update(repo, repo['tip'].node())
     if push:
         self.pushrevisions()
         tip = self.repo['tip']
         self.assertNotEqual(tip.node(), new_hash)
         self.assertEqual(tip['adding_file'].data(), 'foo')
         self.assertEqual(tip.branch(), 'the_branch')

 def test_push_symlink_file(self):
     self.test_push_to_default(commit=True)
     repo = self.repo
     def file_callback(repo, memctx, path):
         if path == 'gamma':
             return context.memfilectx(path=path,
                                       data='foo',
                                       islink=True,
                                       isexec=False,
                                       copied=False)
         raise IOError(errno.EINVAL, 'Invalid operation: ' + path)
     ctx = context.memctx(repo,
                          (repo['tip'].node(), node.nullid),
                          'message',
                          ['gamma', ],
                          file_callback,
                          'author',
                          '2008-10-29 21:26:00 -0500',
                          {'branch': 'default', })
     new_hash = repo.commitctx(ctx)
     hg.update(repo, repo['tip'].node())
     self.pushrevisions()
     tip = self.repo['tip']
     self.assertNotEqual(tip.node(), new_hash)
     self.assertEqual(tip['gamma'].flags(), 'l')
     self.assertEqual(tip['gamma'].data(), 'foo')
     self.assertEqual([x for x in tip.manifest().keys() if 'l' not in
                       tip[x].flags()], ['alpha', 'beta', 'adding_file', ])

 def test_outgoing_output(self):
     self._load_fixture_and_fetch('two_heads.svndump')
     u = self.ui()
     parents = (self.repo['the_branch'].node(), revlog.nullid, )
     def filectxfn(repo, memctx, path):
         return context.memfilectx(path=path,
                                   data='added',
                                   islink=False,
                                   isexec=False,
                                   copied=False)
     ctx = context.memctx(self.repo,
                          parents,
                          'automated test',
                          ['added_bogus_file', 'other_added_file', ],
                          filectxfn,
                          'testy',
                          '2008-12-21 16:32:00 -0500',
                          {'branch': 'localbranch', })
     new = self.repo.commitctx(ctx)
     hg.update(self.repo, new)
     u.pushbuffer()
     commands.outgoing(u, self.repo, self.repourl)
     actual = u.popbuffer()
     self.assertTrue(node.hex(self.repo['localbranch'].node())[:8] in actual)
     self.assertEqual(actual.strip(), '5:6de15430fa20')
     hg.update(self.repo, 'default')
     u.pushbuffer()
     commands.outgoing(u, self.repo, self.repourl)
     actual = u.popbuffer()
     self.assertEqual(actual, '')

 def test_push_single_dir(self):
     # Tests simple pushing from default branch to a single dir repo
     repo = self._load_fixture_and_fetch('branch_from_tag.svndump',
                                         stupid=False,
                                         layout='single',
                                         subdir='')
     def file_callback(repo, memctx, path):
         if path == 'adding_file':
             return context.memfilectx(path=path,
                                       data='foo',
                                       islink=False,
                                       isexec=False,
                                       copied=False)
         raise IOError(errno.EINVAL, 'Invalid operation: ' + path)
     ctx = context.memctx(repo,
                          (repo['tip'].node(), node.nullid),
                          'automated test',
                          ['adding_file'],
                          file_callback,
                          'an_author',
                          '2009-10-19 18:49:30 -0500',
                          {'branch': 'default',})
     repo.commitctx(ctx)
     hg.update(repo, repo['tip'].node())
     self.pushrevisions()
     self.assertTrue('adding_file' in self.svnls(''))

 def test_rebase(self):
     self._load_fixture_and_fetch('two_revs.svndump')
     parents = (self.repo[0].node(), revlog.nullid, )
     def filectxfn(repo, memctx, path):
         return context.memfilectx(path=path,
                                   data='added',
                                   islink=False,
                                   isexec=False,
                                   copied=False)
     ctx = context.memctx(self.repo,
                          parents,
                          'automated test',
                          ['added_bogus_file', 'other_added_file', ],
                          filectxfn,
                          'testy',
                          '2008-12-21 16:32:00 -0500',
                          {'branch': 'localbranch', })
     self.repo.commitctx(ctx)
     self.assertEqual(self.repo['tip'].branch(), 'localbranch')
     beforerebasehash = self.repo['tip'].node()
     hg.update(self.repo, 'tip')
     wrappers.rebase(rebase.rebase, self.ui(), self.repo, svn=True)
     self.assertEqual(self.repo['tip'].branch(), 'localbranch')
     self.assertEqual(self.repo['tip'].parents()[0].parents()[0], self.repo[0])
     self.assertNotEqual(beforerebasehash, self.repo['tip'].node())

    def puttags(self, tags):
        try:
            parentctx = self.repo[self.tagsbranch]
            tagparent = parentctx.node()
        except error.RepoError:
            parentctx = None
            tagparent = nullid

        try:
            oldlines = sorted(parentctx['.hgtags'].data().splitlines(True))
        except:
            oldlines = []

        newlines = sorted([("%s %s\n" % (tags[tag], tag)) for tag in tags])
        if newlines == oldlines:
            return None, None
        data = "".join(newlines)
        def getfilectx(repo, memctx, f):
            return context.memfilectx(f, data, False, False, None)

        self.ui.status(_("updating tags\n"))
        date = "%s 0" % int(time.mktime(time.gmtime()))
        extra = {'branch': self.tagsbranch}
        ctx = context.memctx(self.repo, (tagparent, None), "update tags",
                             [".hgtags"], getfilectx, "convert-repo", date,
                             extra)
        self.repo.commitctx(ctx)
        return hex(self.repo.changelog.tip()), hex(tagparent)

 def test_cant_push_with_changes(self):
     repo = self.repo
     def file_callback(repo, memctx, path):
         return compathacks.makememfilectx(repo,
                                           path=path,
                                           data='foo',
                                           islink=False,
                                           isexec=False,
                                           copied=False)
     ctx = context.memctx(repo,
                          (repo['default'].node(), node.nullid),
                          'automated test',
                          ['adding_file'],
                          file_callback,
                          'an_author',
                          '2008-10-07 20:59:48 -0500',
                          {'branch': 'default', })
     new_hash = repo.commitctx(ctx)
     hg.update(repo, repo['tip'].node())
     # Touch an existing file
     repo.wwrite('beta', 'something else', '')
     try:
         self.pushrevisions()
     except hgutil.Abort:
         pass
     tip = self.repo['tip']
     self.assertEqual(new_hash, tip.node())

def _commitcontext(rdst, parents, ctx, dstfiles, getfilectx, revmap):
    mctx = context.memctx(rdst, parents, ctx.description(), dstfiles,
                          getfilectx, ctx.user(), ctx.date(), ctx.extra())
    ret = rdst.commitctx(mctx)
    lfutil.copyalltostore(rdst, ret)
    rdst.setparents(ret)
    revmap[ctx.node()] = rdst.changelog.tip()

    def commit(self, items):
        def file_callback(repo, memctx, path):
            return context.memfilectx(
                path=path,
                data=items[path],
                islink=False,
                isexec=False,
                copied=False,
                )
        local_repo = self._local_repo
        remote_repo = self._remote_repo

        lock = local_repo.lock()
        try:
            if remote_repo:
                local_repo.pull(self._remote_repo)

            ctx = context.memctx(
                repo=local_repo,
                parents=('tip', None),
                text=revision.message,
                files=items.keys(),
                filectxfn=file_callback,
                user=str(revision.user.id),
                )
            version = node.hex(local_repo.commitctx(ctx))
            # TODO: if we want the working copy of the repository to be updated as well add logic to enable this.
            # hg.update(local_repo, local_repo['tip'].node())
            if remote_repo:
                local_repo.push(remote_repo)

            return version
        finally:
            lock.release()