| durin42 |
| hg-reviewers |
We have had these methods on both contexts and dirstate for a long
time now.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | contrib/synthrepo.py (2 lines) | |||
| M | hgext/histedit.py (12 lines) | |||
| M | hgext/largefiles/lfcommands.py (4 lines) | |||
| M | hgext/largefiles/lfutil.py (4 lines) | |||
| M | hgext/shelve.py (4 lines) | |||
| M | hgext/strip.py (2 lines) | |||
| M | hgext/uncommit.py (2 lines) | |||
| M | mercurial/commands.py (4 lines) | |||
| M | mercurial/hgweb/webcommands.py (2 lines) | |||
| M | mercurial/revset.py (6 lines) | |||
| M | mercurial/sparse.py (2 lines) | |||
| M | mercurial/templatekw.py (2 lines) | |||
| M | tests/test-context.py (2 lines) |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz |
| _synthesizing = _('synthesizing') | _synthesizing = _('synthesizing') | ||||
| _files = _('initial files') | _files = _('initial files') | ||||
| _changesets = _('changesets') | _changesets = _('changesets') | ||||
| # Synthesize a single initial revision adding files to the repo according | # Synthesize a single initial revision adding files to the repo according | ||||
| # to the modeled directory structure. | # to the modeled directory structure. | ||||
| initcount = int(opts['initfiles']) | initcount = int(opts['initfiles']) | ||||
| if initcount and initdirs: | if initcount and initdirs: | ||||
| pctx = repo[None].parents()[0] | pctx = repo[None].p1() | ||||
| dirs = set(pctx.dirs()) | dirs = set(pctx.dirs()) | ||||
| files = {} | files = {} | ||||
| def validpath(path): | def validpath(path): | ||||
| # Don't pick filenames which are already directory names. | # Don't pick filenames which are already directory names. | ||||
| if path in dirs: | if path in dirs: | ||||
| return False | return False | ||||
| # Don't pick directories which were used as file names. | # Don't pick directories which were used as file names. | ||||
| extra = kwargs.get(r'extra', {}).copy() | extra = kwargs.get(r'extra', {}).copy() | ||||
| extra['histedit_source'] = src.hex() | extra['histedit_source'] = src.hex() | ||||
| kwargs[r'extra'] = extra | kwargs[r'extra'] = extra | ||||
| return repo.commit(**kwargs) | return repo.commit(**kwargs) | ||||
| return commitfunc | return commitfunc | ||||
| def applychanges(ui, repo, ctx, opts): | def applychanges(ui, repo, ctx, opts): | ||||
| """Merge changeset from ctx (only) in the current working directory""" | """Merge changeset from ctx (only) in the current working directory""" | ||||
| wcpar = repo.dirstate.parents()[0] | wcpar = repo.dirstate.p1() | ||||
| if ctx.p1().node() == wcpar: | if ctx.p1().node() == wcpar: | ||||
| # edits are "in place" we do not need to make any merge, | # edits are "in place" we do not need to make any merge, | ||||
| # just applies changes on parent for editing | # just applies changes on parent for editing | ||||
| cmdutil.revert(ui, repo, ctx, (wcpar, node.nullid), all=True) | cmdutil.revert(ui, repo, ctx, (wcpar, node.nullid), all=True) | ||||
| stats = mergemod.updateresult(0, 0, 0, 0) | stats = mergemod.updateresult(0, 0, 0, 0) | ||||
| else: | else: | ||||
| try: | try: | ||||
| # ui.forcemerge is an internal variable, do not document | # ui.forcemerge is an internal variable, do not document | ||||
| This function works in memory.""" | This function works in memory.""" | ||||
| ctxs = list(repo.set('%d::%d', firstctx.rev(), lastctx.rev())) | ctxs = list(repo.set('%d::%d', firstctx.rev(), lastctx.rev())) | ||||
| if not ctxs: | if not ctxs: | ||||
| return None | return None | ||||
| for c in ctxs: | for c in ctxs: | ||||
| if not c.mutable(): | if not c.mutable(): | ||||
| raise error.ParseError( | raise error.ParseError( | ||||
| _("cannot fold into public change %s") % node.short(c.node())) | _("cannot fold into public change %s") % node.short(c.node())) | ||||
| base = firstctx.parents()[0] | base = firstctx.p1() | ||||
| # commit a new version of the old changeset, including the update | # commit a new version of the old changeset, including the update | ||||
| # collect all files which might be affected | # collect all files which might be affected | ||||
| files = set() | files = set() | ||||
| for ctx in ctxs: | for ctx in ctxs: | ||||
| files.update(ctx.files()) | files.update(ctx.files()) | ||||
| # Recompute copies (avoid recording a -> b -> a) | # Recompute copies (avoid recording a -> b -> a) | ||||
| return wrap | return wrap | ||||
| @action(['pick', 'p'], | @action(['pick', 'p'], | ||||
| _('use commit'), | _('use commit'), | ||||
| priority=True) | priority=True) | ||||
| class pick(histeditaction): | class pick(histeditaction): | ||||
| def run(self): | def run(self): | ||||
| rulectx = self.repo[self.node] | rulectx = self.repo[self.node] | ||||
| if rulectx.parents()[0].node() == self.state.parentctxnode: | if rulectx.p1().node() == self.state.parentctxnode: | ||||
| self.repo.ui.debug('node %s unchanged\n' % node.short(self.node)) | self.repo.ui.debug('node %s unchanged\n' % node.short(self.node)) | ||||
| return rulectx, [] | return rulectx, [] | ||||
| return super(pick, self).run() | return super(pick, self).run() | ||||
| @action(['edit', 'e'], | @action(['edit', 'e'], | ||||
| _('use commit, but stop for amending'), | _('use commit, but stop for amending'), | ||||
| priority=True) | priority=True) | ||||
| @action(['fold', 'f'], | @action(['fold', 'f'], | ||||
| _('use commit, but combine it with the one above')) | _('use commit, but combine it with the one above')) | ||||
| class fold(histeditaction): | class fold(histeditaction): | ||||
| def verify(self, prev, expected, seen): | def verify(self, prev, expected, seen): | ||||
| """ Verifies semantic correctness of the fold rule""" | """ Verifies semantic correctness of the fold rule""" | ||||
| super(fold, self).verify(prev, expected, seen) | super(fold, self).verify(prev, expected, seen) | ||||
| repo = self.repo | repo = self.repo | ||||
| if not prev: | if not prev: | ||||
| c = repo[self.node].parents()[0] | c = repo[self.node].p1() | ||||
| elif not prev.verb in ('pick', 'base'): | elif not prev.verb in ('pick', 'base'): | ||||
| return | return | ||||
| else: | else: | ||||
| c = repo[prev.node] | c = repo[prev.node] | ||||
| if not c.mutable(): | if not c.mutable(): | ||||
| raise error.ParseError( | raise error.ParseError( | ||||
| _("cannot fold into public change %s") % node.short(c.node())) | _("cannot fold into public change %s") % node.short(c.node())) | ||||
| change. | change. | ||||
| This exists mainly so that 'rollup' rules can be a subclass of | This exists mainly so that 'rollup' rules can be a subclass of | ||||
| 'fold'. | 'fold'. | ||||
| """ | """ | ||||
| return False | return False | ||||
| def finishfold(self, ui, repo, ctx, oldctx, newnode, internalchanges): | def finishfold(self, ui, repo, ctx, oldctx, newnode, internalchanges): | ||||
| parent = ctx.parents()[0].node() | parent = ctx.p1().node() | ||||
| hg.updaterepo(repo, parent, overwrite=False) | hg.updaterepo(repo, parent, overwrite=False) | ||||
| ### prepare new commit data | ### prepare new commit data | ||||
| commitopts = {} | commitopts = {} | ||||
| commitopts['user'] = ctx.user() | commitopts['user'] = ctx.user() | ||||
| # commit message | # commit message | ||||
| if not self.mergedescs(): | if not self.mergedescs(): | ||||
| newmessage = ctx.description() | newmessage = ctx.description() | ||||
| else: | else: | ||||
| comment = geteditcomment(ui, node.short(root), node.short(topmost)) | comment = geteditcomment(ui, node.short(root), node.short(topmost)) | ||||
| actions = [pick(state, r) for r in revs] | actions = [pick(state, r) for r in revs] | ||||
| rules = ruleeditor(repo, ui, actions, comment) | rules = ruleeditor(repo, ui, actions, comment) | ||||
| else: | else: | ||||
| rules = _readfile(ui, rules) | rules = _readfile(ui, rules) | ||||
| actions = parserules(rules, state) | actions = parserules(rules, state) | ||||
| warnverifyactions(ui, repo, actions, state, ctxs) | warnverifyactions(ui, repo, actions, state, ctxs) | ||||
| parentctxnode = repo[root].parents()[0].node() | parentctxnode = repo[root].p1().node() | ||||
| state.parentctxnode = parentctxnode | state.parentctxnode = parentctxnode | ||||
| state.actions = actions | state.actions = actions | ||||
| state.topmost = topmost | state.topmost = topmost | ||||
| state.replacements = [] | state.replacements = [] | ||||
| ui.log("histedit", "%d actions to histedit\n", len(actions), | ui.log("histedit", "%d actions to histedit\n", len(actions), | ||||
| histedit_num_actions=len(actions)) | histedit_num_actions=len(actions)) | ||||
| rdst.setparents(ret) | rdst.setparents(ret) | ||||
| revmap[ctx.node()] = rdst.changelog.tip() | revmap[ctx.node()] = rdst.changelog.tip() | ||||
| # Generate list of changed files | # Generate list of changed files | ||||
| def _getchangedfiles(ctx, parents): | def _getchangedfiles(ctx, parents): | ||||
| files = set(ctx.files()) | files = set(ctx.files()) | ||||
| if node.nullid not in parents: | if node.nullid not in parents: | ||||
| mc = ctx.manifest() | mc = ctx.manifest() | ||||
| mp1 = ctx.parents()[0].manifest() | mp1 = ctx.p1().manifest() | ||||
| mp2 = ctx.parents()[1].manifest() | mp2 = ctx.p2().manifest() | ||||
| files |= (set(mp1) | set(mp2)) - set(mc) | files |= (set(mp1) | set(mp2)) - set(mc) | ||||
| for f in mc: | for f in mc: | ||||
| if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None): | if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None): | ||||
| files.add(f) | files.add(f) | ||||
| return files | return files | ||||
| # Convert src parents to dst parents | # Convert src parents to dst parents | ||||
| def _convertparents(ctx, revmap): | def _convertparents(ctx, revmap): | ||||
| try: | try: | ||||
| ctx = repo[n] | ctx = repo[n] | ||||
| finally: | finally: | ||||
| repo.lfstatus = oldlfstatus | repo.lfstatus = oldlfstatus | ||||
| files = set(ctx.files()) | files = set(ctx.files()) | ||||
| if len(parents) == 2: | if len(parents) == 2: | ||||
| mc = ctx.manifest() | mc = ctx.manifest() | ||||
| mp1 = ctx.parents()[0].manifest() | mp1 = ctx.p1().manifest() | ||||
| mp2 = ctx.parents()[1].manifest() | mp2 = ctx.p2().manifest() | ||||
| for f in mp1: | for f in mp1: | ||||
| if f not in mc: | if f not in mc: | ||||
| files.add(f) | files.add(f) | ||||
| for f in mp2: | for f in mp2: | ||||
| if f not in mc: | if f not in mc: | ||||
| files.add(f) | files.add(f) | ||||
| for f in mc: | for f in mc: | ||||
| if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None): | if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None): | ||||
| def mergefiles(ui, repo, wctx, shelvectx): | def mergefiles(ui, repo, wctx, shelvectx): | ||||
| """updates to wctx and merges the changes from shelvectx into the | """updates to wctx and merges the changes from shelvectx into the | ||||
| dirstate.""" | dirstate.""" | ||||
| with ui.configoverride({('ui', 'quiet'): True}): | with ui.configoverride({('ui', 'quiet'): True}): | ||||
| hg.update(repo, wctx.node()) | hg.update(repo, wctx.node()) | ||||
| files = [] | files = [] | ||||
| files.extend(shelvectx.files()) | files.extend(shelvectx.files()) | ||||
| files.extend(shelvectx.parents()[0].files()) | files.extend(shelvectx.p1().files()) | ||||
| # revert will overwrite unknown files, so move them out of the way | # revert will overwrite unknown files, so move them out of the way | ||||
| for file in repo.status(unknown=True).unknown: | for file in repo.status(unknown=True).unknown: | ||||
| if file in files: | if file in files: | ||||
| util.rename(file, scmutil.origpath(ui, repo, file)) | util.rename(file, scmutil.origpath(ui, repo, file)) | ||||
| ui.pushbuffer(True) | ui.pushbuffer(True) | ||||
| cmdutil.revert(ui, repo, shelvectx, repo.dirstate.parents(), | cmdutil.revert(ui, repo, shelvectx, repo.dirstate.parents(), | ||||
| *pathtofiles(repo, files), | *pathtofiles(repo, files), | ||||
| return repo, shelvectx | return repo, shelvectx | ||||
| def _rebaserestoredcommit(ui, repo, opts, tr, oldtiprev, basename, pctx, | def _rebaserestoredcommit(ui, repo, opts, tr, oldtiprev, basename, pctx, | ||||
| tmpwctx, shelvectx, branchtorestore, | tmpwctx, shelvectx, branchtorestore, | ||||
| activebookmark): | activebookmark): | ||||
| """Rebase restored commit from its original location to a destination""" | """Rebase restored commit from its original location to a destination""" | ||||
| # If the shelve is not immediately on top of the commit | # If the shelve is not immediately on top of the commit | ||||
| # we'll be merging with, rebase it to be on top. | # we'll be merging with, rebase it to be on top. | ||||
| if tmpwctx.node() == shelvectx.parents()[0].node(): | if tmpwctx.node() == shelvectx.p1().node(): | ||||
| return shelvectx | return shelvectx | ||||
| overrides = { | overrides = { | ||||
| ('ui', 'forcemerge'): opts.get('tool', ''), | ('ui', 'forcemerge'): opts.get('tool', ''), | ||||
| ('phases', 'new-commit'): phases.secret, | ('phases', 'new-commit'): phases.secret, | ||||
| } | } | ||||
| with repo.ui.configoverride(overrides, 'unshelve'): | with repo.ui.configoverride(overrides, 'unshelve'): | ||||
| ui.status(_('rebasing shelved changes\n')) | ui.status(_('rebasing shelved changes\n')) | ||||
| def checksubstate(repo, baserev=None): | def checksubstate(repo, baserev=None): | ||||
| '''return list of subrepos at a different revision than substate. | '''return list of subrepos at a different revision than substate. | ||||
| Abort if any subrepos have uncommitted changes.''' | Abort if any subrepos have uncommitted changes.''' | ||||
| inclsubs = [] | inclsubs = [] | ||||
| wctx = repo[None] | wctx = repo[None] | ||||
| if baserev: | if baserev: | ||||
| bctx = repo[baserev] | bctx = repo[baserev] | ||||
| else: | else: | ||||
| bctx = wctx.parents()[0] | bctx = wctx.p1() | ||||
| for s in sorted(wctx.substate): | for s in sorted(wctx.substate): | ||||
| wctx.sub(s).bailifchanged(True) | wctx.sub(s).bailifchanged(True) | ||||
| if s not in bctx.substate or bctx.sub(s).dirty(): | if s not in bctx.substate or bctx.sub(s).dirty(): | ||||
| inclsubs.append(s) | inclsubs.append(s) | ||||
| return inclsubs | return inclsubs | ||||
| def checklocalchanges(repo, force=False, excsuffix=''): | def checklocalchanges(repo, force=False, excsuffix=''): | ||||
| cmdutil.checkunfinished(repo) | cmdutil.checkunfinished(repo) | ||||
| # No files matched commit, so nothing excluded | # No files matched commit, so nothing excluded | ||||
| if not exclude: | if not exclude: | ||||
| return None | return None | ||||
| files = (initialfiles - exclude) | files = (initialfiles - exclude) | ||||
| # return the p1 so that we don't create an obsmarker later | # return the p1 so that we don't create an obsmarker later | ||||
| if not keepcommit: | if not keepcommit: | ||||
| return ctx.parents()[0].node() | return ctx.p1().node() | ||||
| # Filter copies | # Filter copies | ||||
| copied = copiesmod.pathcopies(base, ctx) | copied = copiesmod.pathcopies(base, ctx) | ||||
| copied = dict((dst, src) for dst, src in copied.iteritems() | copied = dict((dst, src) for dst, src in copied.iteritems() | ||||
| if dst in files) | if dst in files) | ||||
| def filectxfn(repo, memctx, path, contentctx=ctx, redirect=()): | def filectxfn(repo, memctx, path, contentctx=ctx, redirect=()): | ||||
| if path not in contentctx: | if path not in contentctx: | ||||
| return None | return None | ||||
| extra = {} | extra = {} | ||||
| if opts.get('close_branch'): | if opts.get('close_branch'): | ||||
| extra['close'] = '1' | extra['close'] = '1' | ||||
| if not bheads: | if not bheads: | ||||
| raise error.Abort(_('can only close branch heads')) | raise error.Abort(_('can only close branch heads')) | ||||
| elif opts.get('amend'): | elif opts.get('amend'): | ||||
| if repo[None].parents()[0].p1().branch() != branch and \ | if repo[None].p1().p1().branch() != branch and \ | ||||
| repo[None].parents()[0].p2().branch() != branch: | repo[None].p1().p2().branch() != branch: | ||||
| raise error.Abort(_('can only close branch heads')) | raise error.Abort(_('can only close branch heads')) | ||||
| if opts.get('amend'): | if opts.get('amend'): | ||||
| if ui.configbool('ui', 'commitsubrepos'): | if ui.configbool('ui', 'commitsubrepos'): | ||||
| raise error.Abort(_('cannot amend with ui.commitsubrepos enabled')) | raise error.Abort(_('cannot amend with ui.commitsubrepos enabled')) | ||||
| old = repo['.'] | old = repo['.'] | ||||
| rewriteutil.precheck(repo, [old.rev()], 'amend') | rewriteutil.precheck(repo, [old.rev()], 'amend') | ||||
| rightlines = filelines(fctx) | rightlines = filelines(fctx) | ||||
| if path not in parent: | if path not in parent: | ||||
| leftlines = () | leftlines = () | ||||
| else: | else: | ||||
| pfctx = parent[path] | pfctx = parent[path] | ||||
| leftlines = filelines(pfctx) | leftlines = filelines(pfctx) | ||||
| else: | else: | ||||
| rightlines = () | rightlines = () | ||||
| pfctx = ctx.parents()[0][path] | pfctx = ctx.p1()[path] | ||||
| leftlines = filelines(pfctx) | leftlines = filelines(pfctx) | ||||
| comparison = webutil.compare(context, leftlines, rightlines) | comparison = webutil.compare(context, leftlines, rightlines) | ||||
| if fctx is not None: | if fctx is not None: | ||||
| rename = webutil.renamelink(fctx) | rename = webutil.renamelink(fctx) | ||||
| ctx = fctx | ctx = fctx | ||||
| else: | else: | ||||
| rename = templateutil.mappinglist([]) | rename = templateutil.mappinglist([]) | ||||
| return _childrenspec(repo, subset, x, -n, order) | return _childrenspec(repo, subset, x, -n, order) | ||||
| ps = set() | ps = set() | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| for r in getset(repo, fullreposet(repo), x): | for r in getset(repo, fullreposet(repo), x): | ||||
| for i in range(n): | for i in range(n): | ||||
| try: | try: | ||||
| r = cl.parentrevs(r)[0] | r = cl.parentrevs(r)[0] | ||||
| except error.WdirUnsupported: | except error.WdirUnsupported: | ||||
| r = repo[r].parents()[0].rev() | r = repo[r].p1().rev() | ||||
| ps.add(r) | ps.add(r) | ||||
| return subset & ps | return subset & ps | ||||
| @predicate('author(string)', safe=True, weight=10) | @predicate('author(string)', safe=True, weight=10) | ||||
| def author(repo, subset, x): | def author(repo, subset, x): | ||||
| """Alias for ``user(string)``. | """Alias for ``user(string)``. | ||||
| """ | """ | ||||
| # i18n: "author" is a keyword | # i18n: "author" is a keyword | ||||
| return baseset() | return baseset() | ||||
| ps = set() | ps = set() | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| for r in getset(repo, fullreposet(repo), x): | for r in getset(repo, fullreposet(repo), x): | ||||
| try: | try: | ||||
| ps.add(cl.parentrevs(r)[0]) | ps.add(cl.parentrevs(r)[0]) | ||||
| except error.WdirUnsupported: | except error.WdirUnsupported: | ||||
| ps.add(repo[r].parents()[0].rev()) | ps.add(repo[r].p1().rev()) | ||||
| ps -= {node.nullrev} | ps -= {node.nullrev} | ||||
| # XXX we should turn this into a baseset instead of a set, smartset may do | # XXX we should turn this into a baseset instead of a set, smartset may do | ||||
| # some optimizations from the fact this is a baseset. | # some optimizations from the fact this is a baseset. | ||||
| return subset & ps | return subset & ps | ||||
| @predicate('p2([set])', safe=True) | @predicate('p2([set])', safe=True) | ||||
| def p2(repo, subset, x): | def p2(repo, subset, x): | ||||
| """Second parent of changesets in set, or the working directory. | """Second parent of changesets in set, or the working directory. | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| for r in getset(repo, fullreposet(repo), x): | for r in getset(repo, fullreposet(repo), x): | ||||
| if n == 0: | if n == 0: | ||||
| ps.add(r) | ps.add(r) | ||||
| elif n == 1: | elif n == 1: | ||||
| try: | try: | ||||
| ps.add(cl.parentrevs(r)[0]) | ps.add(cl.parentrevs(r)[0]) | ||||
| except error.WdirUnsupported: | except error.WdirUnsupported: | ||||
| ps.add(repo[r].parents()[0].rev()) | ps.add(repo[r].p1().rev()) | ||||
| else: | else: | ||||
| try: | try: | ||||
| parents = cl.parentrevs(r) | parents = cl.parentrevs(r) | ||||
| if parents[1] != node.nullrev: | if parents[1] != node.nullrev: | ||||
| ps.add(parents[1]) | ps.add(parents[1]) | ||||
| except error.WdirUnsupported: | except error.WdirUnsupported: | ||||
| parents = repo[r].parents() | parents = repo[r].parents() | ||||
| if len(parents) == 2: | if len(parents) == 2: | ||||
| return actions | return actions | ||||
| files = set() | files = set() | ||||
| prunedactions = {} | prunedactions = {} | ||||
| if branchmerge: | if branchmerge: | ||||
| # If we're merging, use the wctx filter, since we're merging into | # If we're merging, use the wctx filter, since we're merging into | ||||
| # the wctx. | # the wctx. | ||||
| sparsematch = matcher(repo, [wctx.parents()[0].rev()]) | sparsematch = matcher(repo, [wctx.p1().rev()]) | ||||
| else: | else: | ||||
| # If we're updating, use the target context's filter, since we're | # If we're updating, use the target context's filter, since we're | ||||
| # moving to the target context. | # moving to the target context. | ||||
| sparsematch = matcher(repo, [mctx.rev()]) | sparsematch = matcher(repo, [mctx.rev()]) | ||||
| temporaryfiles = [] | temporaryfiles = [] | ||||
| for file, action in actions.iteritems(): | for file, action in actions.iteritems(): | ||||
| type, args, msg = action | type, args, msg = action | ||||
| @templatekeyword('subrepos', requires={'ctx'}) | @templatekeyword('subrepos', requires={'ctx'}) | ||||
| def showsubrepos(context, mapping): | def showsubrepos(context, mapping): | ||||
| """List of strings. Updated subrepositories in the changeset.""" | """List of strings. Updated subrepositories in the changeset.""" | ||||
| ctx = context.resource(mapping, 'ctx') | ctx = context.resource(mapping, 'ctx') | ||||
| substate = ctx.substate | substate = ctx.substate | ||||
| if not substate: | if not substate: | ||||
| return compatlist(context, mapping, 'subrepo', []) | return compatlist(context, mapping, 'subrepo', []) | ||||
| psubstate = ctx.parents()[0].substate or {} | psubstate = ctx.p1().substate or {} | ||||
| subrepos = [] | subrepos = [] | ||||
| for sub in substate: | for sub in substate: | ||||
| if sub not in psubstate or substate[sub] != psubstate[sub]: | if sub not in psubstate or substate[sub] != psubstate[sub]: | ||||
| subrepos.append(sub) # modified or newly added in ctx | subrepos.append(sub) # modified or newly added in ctx | ||||
| for sub in psubstate: | for sub in psubstate: | ||||
| if sub not in substate: | if sub not in substate: | ||||
| subrepos.append(sub) # removed in ctx | subrepos.append(sub) # removed in ctx | ||||
| return compatlist(context, mapping, 'subrepo', sorted(subrepos)) | return compatlist(context, mapping, 'subrepo', sorted(subrepos)) | ||||
| ctx.commit() | ctx.commit() | ||||
| for enc in "ASCII", "Latin-1", "UTF-8": | for enc in "ASCII", "Latin-1", "UTF-8": | ||||
| encoding.encoding = enc | encoding.encoding = enc | ||||
| printb(b"%-8s: %s" % (enc.encode('ascii'), repo[b"tip"].description())) | printb(b"%-8s: %s" % (enc.encode('ascii'), repo[b"tip"].description())) | ||||
| # test performing a status | # test performing a status | ||||
| def getfilectx(repo, memctx, f): | def getfilectx(repo, memctx, f): | ||||
| fctx = memctx.parents()[0][f] | fctx = memctx.p1()[f] | ||||
| data, flags = fctx.data(), fctx.flags() | data, flags = fctx.data(), fctx.flags() | ||||
| if f == b'foo': | if f == b'foo': | ||||
| data += b'bar\n' | data += b'bar\n' | ||||
| return context.memfilectx( | return context.memfilectx( | ||||
| repo, memctx, f, data, b'l' in flags, b'x' in flags) | repo, memctx, f, data, b'l' in flags, b'x' in flags) | ||||
| ctxa = repo[0] | ctxa = repo[0] | ||||
| ctxb = context.memctx(repo, [ctxa.node(), None], b"test diff", [b"foo"], | ctxb = context.memctx(repo, [ctxa.node(), None], b"test diff", [b"foo"], | ||||