def annotate(web, req, tmpl): """ /annotate/{revision}/{path} --------------------------- Show changeset information for each line in a file. The ``fileannotate`` template is rendered. """ fctx = webutil.filectx(web.repo, req) f = fctx.path() parity = paritygen(web.stripecount) diffopts = patch.difffeatureopts(web.repo.ui, untrusted=True, section='annotate', whitespace=True) def annotate(**map): last = None if util.binary(fctx.data()): mt = (mimetypes.guess_type(fctx.path())[0] or 'application/octet-stream') lines = enumerate([((fctx.filectx(fctx.filerev()), 1), '(binary:%s)' % mt)]) else: lines = enumerate(fctx.annotate(follow=True, linenumber=True, diffopts=diffopts)) for lineno, ((f, targetline), l) in lines: fnode = f.filenode() if last != fnode: last = fnode yield {"parity": parity.next(), "node": f.hex(), "rev": f.rev(), "author": f.user(), "desc": f.description(), "extra": f.extra(), "file": f.path(), "targetline": targetline, "line": l, "lineno": lineno + 1, "lineid": "l%d" % (lineno + 1), "linenumber": "% 6d" % (lineno + 1), "revdate": f.date()} return tmpl("fileannotate", file=f, annotate=annotate, path=webutil.up(f), rev=fctx.rev(), node=fctx.hex(), author=fctx.user(), date=fctx.date(), desc=fctx.description(), extra=fctx.extra(), rename=webutil.renamelink(fctx), branch=webutil.nodebranchnodefault(fctx), parent=webutil.parents(fctx), child=webutil.children(fctx), permissions=fctx.manifest().flags(f))
def autodiff(ui, repo, *pats, **opts): diffopts = patch.difffeatureopts(ui, opts) git = opts.get('git', 'no') brokenfiles = set() losedatafn = None if git in ('yes', 'no'): diffopts.git = git == 'yes' diffopts.upgrade = False elif git == 'auto': diffopts.git = False diffopts.upgrade = True elif git == 'warn': diffopts.git = False diffopts.upgrade = True def losedatafn(fn=None, **kwargs): brokenfiles.add(fn) return True elif git == 'abort': diffopts.git = False diffopts.upgrade = True def losedatafn(fn=None, **kwargs): raise error.Abort('losing data for %s' % fn) else: raise error.Abort('--git must be yes, no or auto') node1, node2 = scmutil.revpair(repo, []) m = scmutil.match(repo[node2], pats, opts) it = patch.diff(repo, node1, node2, match=m, opts=diffopts, losedatafn=losedatafn) for chunk in it: ui.write(chunk) for fn in sorted(brokenfiles): ui.write(('data lost for: %s\n' % fn))
def recordfunc(ui, repo, message, match, opts): """This is generic record driver. Its job is to interactively filter local changes, and accordingly prepare working directory into a state in which the job can be delegated to a non-interactive commit command such as 'commit' or 'qrefresh'. After the actual job is done by non-interactive command, the working directory is restored to its original state. In the end we'll record interesting changes, and everything else will be left in place, so the user can continue working. """ cmdutil.checkunfinished(repo, commit=True) merge = len(repo[None].parents()) > 1 if merge: raise util.Abort(_('cannot partially commit a merge ' '(use "hg commit" instead)')) status = repo.status(match=match) diffopts = patch.difffeatureopts(ui, opts=opts, whitespace=True) diffopts.nodates = True diffopts.git = True chunks = patch.diff(repo, changes=status, opts=diffopts) fp = cStringIO.StringIO() fp.write(''.join(chunks)) fp.seek(0) # 1. filter patch, so we have intending-to apply subset of it try: chunks = filterpatch(ui, parsepatch(fp)) except patch.PatchError, err: raise util.Abort(_('error parsing patch: %s') % err)
def difftree(ui, repo, node1=None, node2=None, *files, **opts): """diff trees from two commits""" def __difftree(repo, node1, node2, files=[]): assert node2 is not None mmap = repo[node1].manifest() mmap2 = repo[node2].manifest() m = scmutil.match(repo[node1], files) modified, added, removed = repo.status(node1, node2, m)[:3] empty = short(nullid) for f in modified: # TODO get file permissions ui.write(":100664 100664 %s %s M\t%s\t%s\n" % (short(mmap[f]), short(mmap2[f]), f, f)) for f in added: ui.write(":000000 100664 %s %s N\t%s\t%s\n" % (empty, short(mmap2[f]), f, f)) for f in removed: ui.write(":100664 000000 %s %s D\t%s\t%s\n" % (short(mmap[f]), empty, f, f)) ## while True: if opts['stdin']: try: line = raw_input().split(' ') node1 = line[0] if len(line) > 1: node2 = line[1] else: node2 = None except EOFError: break node1 = repo.lookup(node1) if node2: node2 = repo.lookup(node2) else: node2 = node1 node1 = repo.changelog.parents(node1)[0] if opts['patch']: if opts['pretty']: catcommit(ui, repo, node2, "") m = scmutil.match(repo[node1], files) diffopts = patch.difffeatureopts(ui) diffopts.git = True chunks = patch.diff(repo, node1, node2, match=m, opts=diffopts) for chunk in chunks: ui.write(chunk) else: __difftree(repo, node1, node2, files=files) if not opts['stdin']: break
def _getpatches(repo, revs, **opts): """return a list of patches for a list of revisions Each patch in the list is itself a list of lines. """ ui = repo.ui prev = repo['.'].rev() for r in revs: if r == prev and (repo[None].files() or repo[None].deleted()): ui.warn(_('warning: working directory has ' 'uncommitted changes\n')) output = cStringIO.StringIO() cmdutil.export(repo, [r], fp=output, opts=patch.difffeatureopts(ui, opts, git=True)) yield output.getvalue().split('\n')
def _getpatches(repo, revs, **opts): """return a list of patches for a list of revisions Each patch in the list is itself a list of lines. """ ui = repo.ui prev = repo['.'].rev() for r in scmutil.revrange(repo, revs): if r == prev and (repo[None].files() or repo[None].deleted()): ui.warn( _('warning: working directory has ' 'uncommitted changes\n')) output = cStringIO.StringIO() cmdutil.export(repo, [r], fp=output, opts=patch.difffeatureopts(ui, opts, git=True)) yield output.getvalue().split('\n')
def autodiff(ui, repo, *pats, **opts): opts = pycompat.byteskwargs(opts) diffopts = patch.difffeatureopts(ui, opts) git = opts.get(b'git', b'no') brokenfiles = set() losedatafn = None if git in (b'yes', b'no'): diffopts.git = git == b'yes' diffopts.upgrade = False elif git == b'auto': diffopts.git = False diffopts.upgrade = True elif git == b'warn': diffopts.git = False diffopts.upgrade = True def losedatafn(fn=None, **kwargs): brokenfiles.add(fn) return True elif git == b'abort': diffopts.git = False diffopts.upgrade = True def losedatafn(fn=None, **kwargs): raise error.Abort(b'losing data for %s' % fn) else: raise error.Abort(b'--git must be yes, no or auto') ctx1, ctx2 = scmutil.revpair(repo, []) m = scmutil.match(ctx2, pats, opts) it = patch.diff(repo, ctx1.node(), ctx2.node(), match=m, opts=diffopts, losedatafn=losedatafn) for chunk in it: ui.write(chunk) for fn in sorted(brokenfiles): ui.write((b'data lost for: %s\n' % fn))
def autodiff(ui, repo, *pats, **opts): diffopts = patch.difffeatureopts(ui, opts) git = opts.get('git', 'no') brokenfiles = set() losedatafn = None if git in ('yes', 'no'): diffopts.git = git == 'yes' diffopts.upgrade = False elif git == 'auto': diffopts.git = False diffopts.upgrade = True elif git == 'warn': diffopts.git = False diffopts.upgrade = True def losedatafn(fn=None, **kwargs): brokenfiles.add(fn) return True elif git == 'abort': diffopts.git = False diffopts.upgrade = True def losedatafn(fn=None, **kwargs): raise util.Abort('losing data for %s' % fn) else: raise util.Abort('--git must be yes, no or auto') node1, node2 = scmutil.revpair(repo, []) m = scmutil.match(repo[node2], pats, opts) it = patch.diff(repo, node1, node2, match=m, opts=diffopts, losedatafn=losedatafn) for chunk in it: ui.write(chunk) for fn in sorted(brokenfiles): ui.write(('data lost for: %s\n' % fn))
def recordfunc(ui, repo, message, match, opts): """This is generic record driver. Its job is to interactively filter local changes, and accordingly prepare working directory into a state in which the job can be delegated to a non-interactive commit command such as 'commit' or 'qrefresh'. After the actual job is done by non-interactive command, the working directory is restored to its original state. In the end we'll record interesting changes, and everything else will be left in place, so the user can continue working. """ cmdutil.checkunfinished(repo, commit=True) merge = len(repo[None].parents()) > 1 if merge: raise util.Abort( _('cannot partially commit a merge ' '(use "hg commit" instead)')) status = repo.status(match=match) diffopts = patch.difffeatureopts(ui, opts=opts, whitespace=True) diffopts.nodates = True diffopts.git = True chunks = patch.diff(repo, changes=status, opts=diffopts) fp = cStringIO.StringIO() fp.write(''.join(chunks)) fp.seek(0) # 1. filter patch, so we have intending-to apply subset of it try: chunks = filterpatch(ui, parsepatch(fp)) except patch.PatchError, err: raise util.Abort(_('error parsing patch: %s') % err)
def apply(self, repo, source, revmap, merges, opts={}): '''apply the revisions in revmap one by one in revision order''' revs = sorted(revmap) p1, p2 = repo.dirstate.parents() pulls = [] diffopts = patch.difffeatureopts(self.ui, opts) diffopts.git = True lock = wlock = tr = None try: wlock = repo.wlock() lock = repo.lock() tr = repo.transaction('transplant') for rev in revs: node = revmap[rev] revstr = '%s:%s' % (rev, short(node)) if self.applied(repo, node, p1): self.ui.warn( _('skipping already applied revision %s\n') % revstr) continue parents = source.changelog.parents(node) if not (opts.get('filter') or opts.get('log')): # If the changeset parent is the same as the # wdir's parent, just pull it. if parents[0] == p1: pulls.append(node) p1 = node continue if pulls: if source != repo: exchange.pull(repo, source.peer(), heads=pulls) merge.update(repo, pulls[-1], False, False, None) p1, p2 = repo.dirstate.parents() pulls = [] domerge = False if node in merges: # pulling all the merge revs at once would mean we # couldn't transplant after the latest even if # transplants before them fail. domerge = True if not hasnode(repo, node): exchange.pull(repo, source.peer(), heads=[node]) skipmerge = False if parents[1] != revlog.nullid: if not opts.get('parent'): self.ui.note( _('skipping merge changeset %s:%s\n') % (rev, short(node))) skipmerge = True else: parent = source.lookup(opts['parent']) if parent not in parents: raise util.Abort( _('%s is not a parent of %s') % (short(parent), short(node))) else: parent = parents[0] if skipmerge: patchfile = None else: fd, patchfile = tempfile.mkstemp(prefix='hg-transplant-') fp = os.fdopen(fd, 'w') gen = patch.diff(source, parent, node, opts=diffopts) for chunk in gen: fp.write(chunk) fp.close() del revmap[rev] if patchfile or domerge: try: try: n = self.applyone(repo, node, source.changelog.read(node), patchfile, merge=domerge, log=opts.get('log'), filter=opts.get('filter')) except TransplantError: # Do not rollback, it is up to the user to # fix the merge or cancel everything tr.close() raise if n and domerge: self.ui.status( _('%s merged at %s\n') % (revstr, short(n))) elif n: self.ui.status( _('%s transplanted to %s\n') % (short(node), short(n))) finally: if patchfile: os.unlink(patchfile) tr.close() if pulls: exchange.pull(repo, source.peer(), heads=pulls) merge.update(repo, pulls[-1], False, False, None) finally: self.saveseries(revmap, merges) self.transplants.write() if tr: tr.release() lock.release() wlock.release()
def annotate(web, req, tmpl): """ /annotate/{revision}/{path} --------------------------- Show changeset information for each line in a file. The ``fileannotate`` template is rendered. """ fctx = webutil.filectx(web.repo, req) f = fctx.path() parity = paritygen(web.stripecount) diffopts = patch.difffeatureopts(web.repo.ui, untrusted=True, section='annotate', whitespace=True) def annotate(**map): last = None if util.binary(fctx.data()): mt = (mimetypes.guess_type(fctx.path())[0] or 'application/octet-stream') lines = enumerate([((fctx.filectx(fctx.filerev()), 1), '(binary:%s)' % mt)]) else: lines = enumerate( fctx.annotate(follow=True, linenumber=True, diffopts=diffopts)) for lineno, ((f, targetline), l) in lines: fnode = f.filenode() if last != fnode: last = fnode yield { "parity": parity.next(), "node": f.hex(), "rev": f.rev(), "author": f.user(), "desc": f.description(), "extra": f.extra(), "file": f.path(), "targetline": targetline, "line": l, "lineno": lineno + 1, "lineid": "l%d" % (lineno + 1), "linenumber": "% 6d" % (lineno + 1), "revdate": f.date() } return tmpl("fileannotate", file=f, annotate=annotate, path=webutil.up(f), rev=fctx.rev(), symrev=webutil.symrevorshortnode(req, fctx), node=fctx.hex(), author=fctx.user(), date=fctx.date(), desc=fctx.description(), extra=fctx.extra(), rename=webutil.renamelink(fctx), branch=webutil.nodebranchnodefault(fctx), parent=webutil.parents(fctx), child=webutil.children(fctx), tags=webutil.nodetagsdict(web.repo, fctx.node()), bookmarks=webutil.nodebookmarksdict(web.repo, fctx.node()), permissions=fctx.manifest().flags(f))
def apply(self, repo, source, revmap, merges, opts=None): '''apply the revisions in revmap one by one in revision order''' if opts is None: opts = {} revs = sorted(revmap) p1, p2 = repo.dirstate.parents() pulls = [] diffopts = patch.difffeatureopts(self.ui, opts) diffopts.git = True lock = tr = None try: lock = repo.lock() tr = repo.transaction('transplant') for rev in revs: node = revmap[rev] revstr = '%s:%s' % (rev, nodemod.short(node)) if self.applied(repo, node, p1): self.ui.warn(_('skipping already applied revision %s\n') % revstr) continue parents = source.changelog.parents(node) if not (opts.get('filter') or opts.get('log')): # If the changeset parent is the same as the # wdir's parent, just pull it. if parents[0] == p1: pulls.append(node) p1 = node continue if pulls: if source != repo: exchange.pull(repo, source.peer(), heads=pulls) merge.update(repo, pulls[-1], False, False) p1, p2 = repo.dirstate.parents() pulls = [] domerge = False if node in merges: # pulling all the merge revs at once would mean we # couldn't transplant after the latest even if # transplants before them fail. domerge = True if not hasnode(repo, node): exchange.pull(repo, source.peer(), heads=[node]) skipmerge = False if parents[1] != revlog.nullid: if not opts.get('parent'): self.ui.note(_('skipping merge changeset %s:%s\n') % (rev, nodemod.short(node))) skipmerge = True else: parent = source.lookup(opts['parent']) if parent not in parents: raise error.Abort(_('%s is not a parent of %s') % (nodemod.short(parent), nodemod.short(node))) else: parent = parents[0] if skipmerge: patchfile = None else: fd, patchfile = tempfile.mkstemp(prefix='hg-transplant-') fp = os.fdopen(fd, 'w') gen = patch.diff(source, parent, node, opts=diffopts) for chunk in gen: fp.write(chunk) fp.close() del revmap[rev] if patchfile or domerge: try: try: n = self.applyone(repo, node, source.changelog.read(node), patchfile, merge=domerge, log=opts.get('log'), filter=opts.get('filter')) except TransplantError: # Do not rollback, it is up to the user to # fix the merge or cancel everything tr.close() raise if n and domerge: self.ui.status(_('%s merged at %s\n') % (revstr, nodemod.short(n))) elif n: self.ui.status(_('%s transplanted to %s\n') % (nodemod.short(node), nodemod.short(n))) finally: if patchfile: os.unlink(patchfile) tr.close() if pulls: exchange.pull(repo, source.peer(), heads=pulls) merge.update(repo, pulls[-1], False, False) finally: self.saveseries(revmap, merges) self.transplants.write() if tr: tr.release() if lock: lock.release()
def _hgwebannotate(orig, fctx, ui): diffopts = patch.difffeatureopts( ui, untrusted=True, section=b'annotate', whitespace=True ) return _doannotate(fctx, diffopts=diffopts)
def recordfunc(ui, repo, message, match, opts): """This is generic record driver. Its job is to interactively filter local changes, and accordingly prepare working dir into a state, where the job can be delegated to non-interactive commit command such as 'commit' or 'qrefresh'. After the actual job is done by non-interactive command, working dir state is restored to original. In the end we'll record interesting changes, and everything else will be left in place, so the user can continue his work. """ merge = len(repo[None].parents()) > 1 if merge: raise util.Abort(_('cannot partially commit a merge ' '(use hg commit instead)')) # status gives back # modified, added, removed, deleted, unknown, ignored, clean # we take only the first 3 of these changes = repo.status(match=match)[:3] modified, added, removed = changes try: # Mercurial >= 3.3 allow disabling format-changing diffopts diffopts = patch.difffeatureopts(ui, opts=opts, section='crecord', whitespace=True) except AttributeError: diffopts = patch.diffopts(ui, opts=opts, section='crecord') diffopts.nodates = True diffopts.git = True chunks = patch.diff(repo, changes=changes, opts=diffopts) fp = cStringIO.StringIO() fp.write(''.join(chunks)) fp.seek(0) # 1. filter patch, so we have intending-to apply subset of it chunks = crpatch.filterpatch(opts, crpatch.parsepatch(changes, fp), chunk_selector.chunkselector, ui) del fp contenders = set() for h in chunks: try: contenders.update(set(h.files())) except AttributeError: pass changed = changes[0] + changes[1] + changes[2] newfiles = [f for f in changed if f in contenders] if not newfiles: ui.status(_('no changes to record\n')) return 0 # 2. backup changed files, so we can restore them in the end backups = {} newly_added_backups = {} backupdir = repo.join('record-backups') try: os.mkdir(backupdir) except OSError, err: if err.errno != errno.EEXIST: raise
def fastannotate(ui, repo, *pats, **opts): """show changeset information by line for each file List changes in files, showing the revision id responsible for each line. This command is useful for discovering when a change was made and by whom. By default this command prints revision numbers. If you include --file, --user, or --date, the revision number is suppressed unless you also include --number. The default format can also be customized by setting fastannotate.defaultformat. Returns 0 on success. .. container:: verbose This command uses an implementation different from the vanilla annotate command, which may produce slightly different (while still reasonable) outputs for some cases. Unlike the vanilla anootate, fastannotate follows rename regardless of the existence of --file. For the best performance when running on a full repo, use -c, -l, avoid -u, -d, -n. Use --linear and --no-content to make it even faster. For the best performance when running on a shallow (remotefilelog) repo, avoid --linear, --no-follow, or any diff options. As the server won't be able to populate annotate cache when non-default options affecting results are used. """ if not pats: raise error.Abort(_('at least one filename or pattern is required')) # performance hack: filtered repo can be slow. unfilter by default. if ui.configbool('fastannotate', 'unfilteredrepo', True): repo = repo.unfiltered() rev = opts.get('rev', '.') rebuild = opts.get('rebuild', False) diffopts = patch.difffeatureopts(ui, opts, section='annotate', whitespace=True) aopts = facontext.annotateopts( diffopts=diffopts, followmerge=not opts.get('linear', False), followrename=not opts.get('no_follow', False)) if not any(opts.get(s) for s in ['user', 'date', 'file', 'number', 'changeset']): # default 'number' for compatibility. but fastannotate is more # efficient with "changeset", "line-number" and "no-content". for name in ui.configlist('fastannotate', 'defaultformat', ['number']): opts[name] = True ui.pager('fastannotate') template = opts.get('template') if template == 'json': formatter = faformatter.jsonformatter(ui, repo, opts) else: formatter = faformatter.defaultformatter(ui, repo, opts) showdeleted = opts.get('deleted', False) showlines = not bool(opts.get('no_content')) showpath = opts.get('file', False) # find the head of the main (master) branch master = ui.config('fastannotate', 'mainbranch') or rev # paths will be used for prefetching and the real annotating paths = list(_matchpaths(repo, rev, pats, opts, aopts)) # for client, prefetch from the server if util.safehasattr(repo, 'prefetchfastannotate'): repo.prefetchfastannotate(paths) for path in paths: result = lines = existinglines = None while True: try: with facontext.annotatecontext(repo, path, aopts, rebuild) as a: result = a.annotate(rev, master=master, showpath=showpath, showlines=(showlines and not showdeleted)) if showdeleted: existinglines = set((l[0], l[1]) for l in result) result = a.annotatealllines( rev, showpath=showpath, showlines=showlines) break except (faerror.CannotReuseError, faerror.CorruptedFileError): # happens if master moves backwards, or the file was deleted # and readded, or renamed to an existing name, or corrupted. if rebuild: # give up since we have tried rebuild already raise else: # try a second time rebuilding the cache (slow) rebuild = True continue if showlines: result, lines = result formatter.write(result, lines, existinglines=existinglines) formatter.end()
def fastannotate(ui, repo, *pats, **opts): """show changeset information by line for each file List changes in files, showing the revision id responsible for each line. This command is useful for discovering when a change was made and by whom. By default this command prints revision numbers. If you include --file, --user, or --date, the revision number is suppressed unless you also include --number. The default format can also be customized by setting fastannotate.defaultformat. Returns 0 on success. .. container:: verbose This command uses an implementation different from the vanilla annotate command, which may produce slightly different (while still reasonable) outputs for some cases. Unlike the vanilla anootate, fastannotate follows rename regardless of the existence of --file. For the best performance when running on a full repo, use -c, -l, avoid -u, -d, -n. Use --linear and --no-content to make it even faster. For the best performance when running on a shallow (remotefilelog) repo, avoid --linear, --no-follow, or any diff options. As the server won't be able to populate annotate cache when non-default options affecting results are used. """ if not pats: raise error.Abort(_(b'at least one filename or pattern is required')) # performance hack: filtered repo can be slow. unfilter by default. if ui.configbool(b'fastannotate', b'unfilteredrepo'): repo = repo.unfiltered() opts = pycompat.byteskwargs(opts) rev = opts.get(b'rev', b'.') rebuild = opts.get(b'rebuild', False) diffopts = patch.difffeatureopts(ui, opts, section=b'annotate', whitespace=True) aopts = facontext.annotateopts( diffopts=diffopts, followmerge=not opts.get(b'linear', False), followrename=not opts.get(b'no_follow', False), ) if not any( opts.get(s) for s in [b'user', b'date', b'file', b'number', b'changeset']): # default 'number' for compatibility. but fastannotate is more # efficient with "changeset", "line-number" and "no-content". for name in ui.configlist(b'fastannotate', b'defaultformat', [b'number']): opts[name] = True ui.pager(b'fastannotate') template = opts.get(b'template') if template == b'json': formatter = faformatter.jsonformatter(ui, repo, opts) else: formatter = faformatter.defaultformatter(ui, repo, opts) showdeleted = opts.get(b'deleted', False) showlines = not bool(opts.get(b'no_content')) showpath = opts.get(b'file', False) # find the head of the main (master) branch master = ui.config(b'fastannotate', b'mainbranch') or rev # paths will be used for prefetching and the real annotating paths = list(_matchpaths(repo, rev, pats, opts, aopts)) # for client, prefetch from the server if util.safehasattr(repo, 'prefetchfastannotate'): repo.prefetchfastannotate(paths) for path in paths: result = lines = existinglines = None while True: try: with facontext.annotatecontext(repo, path, aopts, rebuild) as a: result = a.annotate( rev, master=master, showpath=showpath, showlines=(showlines and not showdeleted), ) if showdeleted: existinglines = {(l[0], l[1]) for l in result} result = a.annotatealllines(rev, showpath=showpath, showlines=showlines) break except (faerror.CannotReuseError, faerror.CorruptedFileError): # happens if master moves backwards, or the file was deleted # and readded, or renamed to an existing name, or corrupted. if rebuild: # give up since we have tried rebuild already raise else: # try a second time rebuilding the cache (slow) rebuild = True continue if showlines: result, lines = result formatter.write(result, lines, existinglines=existinglines) formatter.end()
def _hgwebannotate(orig, fctx, ui): diffopts = patch.difffeatureopts(ui, untrusted=True, section='annotate', whitespace=True) return _doannotate(fctx, diffopts=diffopts)
def recordfunc(ui, repo, message, match, opts): """This is generic record driver. Its job is to interactively filter local changes, and accordingly prepare working dir into a state, where the job can be delegated to non-interactive commit command such as 'commit' or 'qrefresh'. After the actual job is done by non-interactive command, working dir state is restored to original. In the end we'll record interesting changes, and everything else will be left in place, so the user can continue his work. """ merge = len(repo[None].parents()) > 1 if merge: raise util.Abort( _('cannot partially commit a merge ' '(use hg commit instead)')) # status gives back # modified, added, removed, deleted, unknown, ignored, clean # we take only the first 3 of these changes = repo.status(match=match)[:3] modified, added, removed = changes try: # Mercurial >= 3.3 allow disabling format-changing diffopts diffopts = patch.difffeatureopts(ui, opts=opts, section='crecord', whitespace=True) except AttributeError: diffopts = patch.diffopts(ui, opts=opts, section='crecord') diffopts.nodates = True diffopts.git = True chunks = patch.diff(repo, changes=changes, opts=diffopts) fp = cStringIO.StringIO() fp.write(''.join(chunks)) fp.seek(0) # 1. filter patch, so we have intending-to apply subset of it chunks = crpatch.filterpatch(opts, crpatch.parsepatch(changes, fp), chunk_selector.chunkselector, ui) del fp contenders = set() for h in chunks: try: contenders.update(set(h.files())) except AttributeError: pass changed = changes[0] + changes[1] + changes[2] newfiles = [f for f in changed if f in contenders] if not newfiles: ui.status(_('no changes to record\n')) return 0 # 2. backup changed files, so we can restore them in the end backups = {} newly_added_backups = {} backupdir = repo.join('record-backups') try: os.mkdir(backupdir) except OSError, err: if err.errno != errno.EEXIST: raise