| #!/usr/bin/env python |
| # |
| # Hacked together by ESR, October 2009. New BSD license applies. |
| # The Subversion project is explicitly granted permission to redistribute |
| # under the prevailing license of their project. |
| |
| """ |
| svncutter - clique-squash, range-selection, property mutations, and skeletonization on SVN dump files |
| general usage: svncutter [-q] [-r SELECTION] SUBCOMMAND |
| |
| In all commands, the -r (or --range) option limits the selection of revisions |
| over which an operation will be performed. A selection consists of |
| one or more comma-separated ranges. A range may consist of an integer |
| revision number or the special name HEAD for the head revision. Or it |
| may be a colon-separated pair of integers, or an integer followed by a |
| colon followed by HEAD. |
| |
| Normally, each subcommand produces a progress spinner on standard |
| error; each turn means another revision has been filtered. The -q (or |
| --quiet) option suppresses this. |
| |
| Type 'svncutter help <subcommand>' for help on a specific subcommand. |
| |
| Available subcommands: |
| squash |
| select |
| propdel |
| propset |
| proprename |
| log |
| setlog |
| skeleton |
| expunge |
| renumber |
| """ |
| |
| oneliners = { |
| "squash": "Squashing revisions", |
| "select": "Selecting revisions", |
| "propdel": "Deleting revision properties", |
| "propset": "Setting revision properties", |
| "proprename": "Renaming revision properties", |
| "log": "Extracting log entries", |
| "setlog": "Mutating log entries", |
| "skeleton": "Replace content with unique cookies, preserving structure", |
| "expunge": "Expunge operations by Node-path header", |
| "renumber": "Renumber revisions so they're contiguous", |
| } |
| |
| helpdict = { |
| "squash": """\ |
| squash: usage: svncutter [-q] [-r SELECTION] [-m mapfile] [-f] [-c] squash |
| |
| The 'squash' subcommand merges adjacent commits that have the same |
| author and log text and were made within 5 minutes of each other. |
| This can be helpful in cleaning up after migrations from file-oriented |
| revision control systems, or if a developer has been using a pre-2006 |
| version of Emacs VC. |
| |
| With the -m (or --mapfile) option, squash emits a map to the named |
| file showing how old revision numbers map into new ones. |
| |
| With the -e (or --excise) option, the specified set of revisions in |
| unconditionally removed. The tool will exit with an error if an |
| excised remove is part of a clique eligible for squashing. Note that |
| svncutter does not perform any checks on whether the repository |
| history is afterwards valid; if you delete a node using this option, |
| you won't find out you have a problem until you attempt to load the |
| resulting dumpfile. |
| |
| svncutter attempts to fix up references to Subversion revisions in log |
| entries so they will still be correct after squashing. It considers |
| anything that looks like the regular expression \\br[0-9]+\\b to be |
| a comment reference (this is the same format that Subversion uses |
| in log headers). |
| |
| Every revision in the file after the first omitted one gets the property |
| 'svncutter:original' set to the revision number it had before the |
| squash operation. |
| |
| The option --f (or --flagrefs) causes svncutter to wrap its revision-reference |
| substitutions in curly braces ({}). By doing this, then grepping for 'r{' |
| in the output of 'svncutter log', you can check for false conversions. |
| |
| The -c (or --compressmap) option changes the mapfile format to one |
| that is easier for human browsing, though less well suited for |
| interpretation by other programs. |
| """, |
| "select": """\ |
| select: usage: svncutter [-q] [-r SELECTION] select |
| |
| The 'select' subcommand selects a range and permits only revisions in |
| that range to pass to standard output. A range beginning with 0 |
| includes the dumpfile header. |
| """, |
| "propdel": """\ |
| propdel: usage: svncutter [-r SELECTION] propdel PROPNAME... |
| |
| Delete the property PROPNAME. May be restricted by a revision |
| selection. You may specify multiple properties to be deleted. |
| |
| """, |
| "propset": """\ |
| propset: usage: svncutter [-r SELECTION] propset PROPNAME=PROPVAL... |
| |
| Set the property PROPNAME to PROPVAL. May be restricted by a revision |
| selection. You may specify multiple property settings. |
| """, |
| "proprename": """\ |
| proprename: usage: svncutter [-r SELECTION] proprename OLDNAME->NEWNAME... |
| |
| Rename the property OLDNAME to NEWNAME. May be restricted by a |
| revision selection. You may specify multiple properties to be renamed. |
| """, |
| "log": """\ |
| log: usage: svncutter [-r SELECTION] log |
| |
| Generate a log report, same format as the output of svn log on a |
| repository, to standard output. |
| """, |
| "setlog": """\ |
| setlog: usage: svncutter [-r SELECTION] --logentries=LOGFILE setlog |
| |
| Replace the log entries in the input dumpfile with the corresponding entries |
| in the LOGFILE, which should be in the format of an svn log output. |
| Replacements may be restricted to a specified range. |
| """, |
| "skeleton": """\ |
| skeleton: usage: svncutter [-r SELECTION] skeleton |
| |
| Replace content with unique generated cookies. Useful |
| when you need to examine a particularly complex node structure. |
| """, |
| "expunge": """\ |
| expunge: usage: svncutter [-r SELECTION ] expunge PATTERN... |
| |
| Delete all operations with Node-path headers matching the specified |
| Python regular expressions. Any revision left with no Node records |
| after this filtering has its Revision record removed as well |
| """, |
| "renumber": """\ |
| renumber: usage: svncutter renumber |
| |
| Renumber all revisions, patching Node-copyfrom headers as required. |
| Any selection option is ignored. Takes no arguments. |
| """, |
| } |
| |
| import os, sys, calendar, time, getopt, re |
| |
| class Baton: |
| "Ship progress indications to stderr." |
| def __init__(self, prompt, endmsg=None): |
| self.stream = sys.stderr |
| self.stream.write(prompt + "...") |
| if os.isatty(self.stream.fileno()): |
| self.stream.write(" \010") |
| self.stream.flush() |
| self.count = 0 |
| self.endmsg = endmsg |
| self.time = time.time() |
| return |
| |
| def twirl(self, ch=None): |
| if self.stream is None: |
| return |
| if os.isatty(self.stream.fileno()): |
| if ch: |
| self.stream.write(ch) |
| else: |
| self.stream.write("-/|\\"[self.count % 4]) |
| self.stream.write("\010") |
| self.stream.flush() |
| self.count = self.count + 1 |
| return |
| |
| def end(self, msg=None): |
| if msg == None: |
| msg = self.endmsg |
| if self.stream: |
| self.stream.write(("...(%2.2f sec) %s." % (time.time() - self.time, msg)) + os.linesep) |
| return |
| |
| class LineBufferedSource: |
| "Generic class for line-buffered input with pushback." |
| def __init__(self, infile): |
| self.linebuffer = None |
| self.file = infile |
| self.linenumber = 0 |
| def readline(self): |
| "Line-buffered readline." |
| if self.linebuffer: |
| line = self.linebuffer |
| self.linebuffer = None |
| else: |
| line = self.file.readline() |
| self.linenumber += 1 |
| return line |
| def require(self, prefix): |
| "Read a line, require it to have a specified prefix." |
| line = self.readline() |
| if not line: |
| sys.stderr.write("svncutter: unexpected end of input while requiring '%s' input." % prefix + os.linesep) |
| sys.exit(1) |
| assert line.startswith(prefix) |
| return line |
| def read(self, len): |
| "Straight read from underlying file, no buffering." |
| assert(self.linebuffer is None) |
| text = self.file.read(len) |
| self.linenumber += text.count(os.linesep[0]) |
| return text |
| def peek(self): |
| "Peek at the next line in the source." |
| assert(self.linebuffer is None) |
| self.linebuffer = self.file.readline() |
| return self.linebuffer |
| def flush(self): |
| "Get the contents of the line buffer, clearing it." |
| assert(self.linebuffer is not None) |
| line = self.linebuffer |
| self.linebuffer = None |
| return line |
| def push(self, line): |
| "Push a line back to the line buffer." |
| assert(self.linebuffer is None) |
| self.linebuffer = line |
| def has_line_buffered(self): |
| return self.linebuffer is not None |
| |
| class Properties: |
| def __init__(self, source): |
| self.properties = {} |
| self.propkeys = [] |
| while not source.peek().startswith("PROPS-END"): |
| source.require("K") |
| keyhd = source.readline() |
| key = keyhd.strip() |
| valhd = source.require("V") |
| vlen = int(valhd.split()[1]) |
| value = source.read(vlen) |
| source.require(os.linesep) |
| self.properties[key] = value |
| self.propkeys.append(key) |
| source.flush() |
| def __str__(self): |
| st = "" |
| for key in self.propkeys: |
| if key in self.properties: |
| st += "K %d%s" % (len(key), os.linesep) |
| st += "%s%s" % (key, os.linesep) |
| st += "V %d%s" % (len(self.properties[key]), os.linesep) |
| st += "%s%s" % (self.properties[key], os.linesep) |
| st += "PROPS-END\n" |
| return st |
| |
| class DumpfileSource(LineBufferedSource): |
| "This class knows about dumpfile format." |
| def __init__(self, infile, baton=None): |
| LineBufferedSource.__init__(self, infile) |
| self.baton = baton |
| self.revision = None |
| @staticmethod |
| def set_length(header, line, val): |
| return re.sub("(?<=" + header + "-length: )[0-9]+", str(val), line) |
| def read_revision_header(self, property_hook=None): |
| "Read a revision header, parsing its properties." |
| stash = self.require("Revision-number:") |
| self.revision = int(stash.split()[1]) |
| stash += self.require("Prop-content-length:") |
| stash += self.require("Content-length:") |
| stash += self.require(os.linesep) |
| props = Properties(self) |
| if property_hook: |
| (props.propkeys, props.properties) = property_hook(props.propkeys, props.properties) |
| stash = DumpfileSource.set_length("Prop-content", stash, len(str(props))) |
| stash = DumpfileSource.set_length("Content", stash, len(str(props))) |
| stash += str(props) |
| while self.peek() == '\n': |
| stash += self.readline() |
| if self.baton: |
| self.baton.twirl() |
| return (stash, props.properties) |
| def read_node(self, property_hook=None): |
| "Read a node header and body." |
| #print "READ NODE BEGINS" |
| header = self.require("Node-path:") |
| while True: |
| line = self.readline() |
| #print "I see header line", repr(line) |
| if not line: |
| sys.stderr.write('unexpected EOF in node header' + os.linesep) |
| sys.exit(1) |
| header += line |
| if line == '\n': |
| break |
| properties = "" |
| if "Prop-content-length" in header: |
| props = Properties(self) |
| if property_hook: |
| (props.propkeys, props.properties) = property_hook(props.propkeys, props.properties) |
| properties = str(props) |
| content = "" |
| if "Text-content-length" in header: |
| while True: |
| line = self.readline() |
| #print "I see contents line", repr(line) |
| if not line: |
| break |
| if line.startswith("Node-path:") or line.startswith("Revision-number"): |
| self.push(line) |
| break |
| content += line |
| #print "READ NODE ENDS" |
| if property_hook: |
| header = DumpfileSource.set_length("Prop-content", header, |
| len(properties)) |
| header = DumpfileSource.set_length("Content", header, |
| len(properties) + len(content)) |
| return (header, properties, content) |
| def read_until_next(self, prefix, revmap=None): |
| "Accumulate lines until the next matches a specified prefix." |
| stash = "" |
| while True: |
| line = self.readline() |
| if not line: |
| return stash |
| elif line.startswith(prefix): |
| self.push(line) |
| return stash |
| else: |
| # Hack the revision levels in copy-from headers. |
| # We're actually modifying the dumpfile contents |
| # (rather than selectively omitting parts of it). |
| # Note: this will break on a dumpfile that has dumpfiles |
| # in its nodes! |
| if revmap and line.startswith("Node-copyfrom-rev:"): |
| oldrev = line.split()[1] |
| line = line.replace(oldrev, `revmap[int(oldrev)]`) |
| stash += line |
| def report(self, selection, nodehook, prophook=None): |
| "Report a filtered portion of content." |
| emit = 0 in selection |
| stash = self.read_until_next("Revision-number:") |
| if emit: |
| sys.stdout.write(stash) |
| if not self.has_line_buffered(): |
| return |
| while True: |
| nodecount = 0 |
| (stash, properties) = self.read_revision_header(prophook) |
| if self.revision in selection: |
| pass |
| elif self.revision == selection.upperbound()+1: |
| return |
| else: |
| self.read_until_next("Revision-number:") |
| continue |
| while True: |
| line = self.readline() |
| if not line: |
| return |
| elif line == '\n': |
| sys.stdout.write(line) |
| continue |
| elif line.startswith("Revision-number:"): |
| self.push(line) |
| if stash and nodecount == 0: |
| sys.stdout.write(stash) |
| break |
| elif line.startswith("Node-path:"): |
| nodecount += 1 |
| self.push(line) |
| (header, properties, content) = self.read_node(prophook) |
| emit = nodehook(header, properties, content) |
| if emit and stash: |
| emit = stash + emit |
| stash = "" |
| sys.stdout.write(emit) |
| continue |
| else: |
| sys.stderr.write("svncutter: parse at %s doesn't look right (%s), aborting!\n" % (self.revision, repr(line))) |
| sys.exit(1) |
| |
| def __del__(self): |
| if self.baton: |
| self.baton.end() |
| |
| class SubversionRange: |
| def __init__(self, txt): |
| self.txt = txt |
| self.intervals = [] |
| for (i, item) in enumerate(txt.split(",")): |
| if ':' in item: |
| (lower, upper) = item.split(':') |
| else: |
| lower = upper = item |
| if lower.isdigit(): |
| lower = int(lower) |
| if upper.isdigit(): |
| upper = int(upper) |
| self.intervals.append((lower, upper)) |
| def __contains__(self, rev): |
| for (lower, upper) in self.intervals: |
| if lower == "HEAD": |
| sys.stderr.write("svncutter: can't accept HEAD as lower bound of a range.\n") |
| sys.exit(1) |
| elif upper == "HEAD": |
| upper = sys.maxint-1 |
| if rev >= lower and rev <= upper: |
| return True |
| return False |
| def upperbound(self): |
| "What is the uppermost revision in the spec?" |
| if self.intervals[-1][1] == "HEAD": |
| return sys.maxint |
| else: |
| return self.intervals[-1][1] |
| def __repr__(self): |
| return self.txt |
| |
| class Logfile: |
| "Represent the state of a logfile" |
| def __init__(self, readable, restriction=None): |
| self.comments = {} |
| self.source = LineBufferedSource(readable) |
| state = 'awaiting_header' |
| author = date = None |
| logentry = "" |
| lineno = 0 |
| while True: |
| lineno += 1 |
| line = readable.readline() |
| if state == 'in_logentry': |
| if not line or line.startswith("-----------"): |
| if rev: |
| logentry = logentry.strip() |
| if restriction is None or rev in restriction: |
| self.comments[rev] = (author, date, logentry) |
| rev = None |
| logentry = "" |
| if line: |
| state = 'awaiting_header' |
| else: |
| break |
| else: |
| logentry += line |
| elif state == 'awaiting_header': |
| if not line: |
| break |
| elif line.startswith("-----------"): |
| continue |
| else: |
| m = re.match("r[0-9]+", line) |
| if not m: |
| sys.stderr.write('"%s", line %d: svncutter did not see a comment header where one was expected\n' % (readable.name, lineno)) |
| sys.exit(1) |
| else: |
| fields = line.split("|") |
| (rev, author, date, linecount) = map(lambda x: x.strip(), fields) |
| rev = rev[1:] # strip off leaing 'r' |
| state = 'in_logentry' |
| |
| def __contains__(self, key): |
| return str(key) in self.comments |
| def __getitem__(self, key): |
| "Emulate dictionary, for new-style interface." |
| return self.comments[str(key)] |
| |
| def isotime(s): |
| "ISO 8601 to local clock time." |
| if s[-1] == "Z": |
| s = s[:-1] |
| if "." in s: |
| (date, msec) = s.split(".") |
| else: |
| date = s |
| msec = "0" |
| # Note: no leap-second correction! |
| return calendar.timegm(time.strptime(date, "%Y-%m-%dT%H:%M:%S")) + float("0." + msec) |
| |
| def reference_mapper(value, mutator, flagrefs=False): |
| "Apply a mutator function to revision references." |
| revrefs = [] |
| for matchobj in re.finditer(r'\br([0-9]+)\b', value): |
| revrefs.append(matchobj) |
| if revrefs: |
| revrefs.reverse() |
| for m in revrefs: |
| new = mutator(m.group(1)) |
| if flagrefs: |
| new = "{" + new + "}" |
| if new != m.group(1): |
| value = value[:m.start(1)] + new + value[m.end(1):] |
| return value |
| |
| # Generic machinery ends here, actual command implementations begin |
| |
| def squash(source, timefuzz, |
| mapto=None, selection=None, excise=None, |
| flagrefs=False, compressmap=False): |
| "Coalesce adjacent commits with same author+log and close timestamps." |
| dupes = [] |
| # The tricky bit is rewriting the revision numbers in node headers |
| # associated with copy actions. |
| clique_map = {} # Map revisions to the base reves of their cliques |
| squash_map = {} # Map clique bases revs to their squashed numbers |
| skipcount = numbered = clique_base = 0 |
| outmap = [] |
| def hacklog(propkeys, propdict, revision): |
| # Hack references to revision levels in comments. |
| for (key, value) in propdict.items(): |
| if key == "svn:log": |
| propdict[key] = reference_mapper(value, lambda old: str(squash_map[clique_map[int(old)]]), flagrefs) |
| return (propkeys, propdict) |
| prevprops = {"svn:log":"", "svn:author":"", "svn:date":0} |
| omit = excise is not None and 0 in excise |
| while True: |
| stash = source.read_until_next("Revision-number:", clique_map) |
| if not omit: |
| sys.stdout.write(stash) |
| if not source.has_line_buffered(): |
| if excise is not None and dupes and dupes[0] in excise: |
| outmap.append((None, dupes)) |
| elif numbered >= 1: |
| outmap.append((numbered-1, dupes)) |
| break |
| else: |
| (stash, properties) = source.read_revision_header(hacklog) |
| # We have all properties of this revision. |
| # Compute whether to merge it with the previous one. |
| skip = "svn:log" in properties and "svn:author" in properties \ |
| and properties["svn:log"] == prevprops.get("svn:log") \ |
| and properties["svn:author"] == prevprops.get("svn:author") \ |
| and (selection is None or source.revision in selection) \ |
| and abs(isotime(properties["svn:date"]) - isotime(prevprops.get("svn:date"))) < timefuzz |
| # Did user request an unconditional omission? |
| omit = excise is not None and source.revision in excise |
| if skip and omit: |
| sys.stderr.write("squash: can't omit a revision about to be squashed.\n") |
| sys.exit(1) |
| # Treat spans of omitted commits as cliques for reporting |
| if omit and excise is not None and source.revision-1 in excise: |
| skip = True |
| # The magic moment |
| if skip: |
| skipcount += 1 |
| clique_map[source.revision] = clique_base |
| else: |
| clique_base = source.revision |
| clique_map[clique_base] = clique_base |
| squash_map[clique_base] = source.revision - skipcount |
| if excise is not None and dupes and dupes[0] in excise: |
| outmap.append((None, dupes)) |
| elif numbered >= 1: |
| outmap.append((numbered-1, dupes)) |
| dupes = [] |
| if omit: |
| skipcount += 1 |
| else: |
| sys.stdout.write(stash) |
| prevprops = properties |
| numbered += 1 |
| dupes.append(source.revision) |
| # Go back around to copying to the next revision header. |
| if mapto: |
| mapto.write(("%% %d out of %d original revisions squashed, leaving %d" \ |
| % (skipcount, source.revision, numbered-1)) + os.linesep) |
| if not compressmap: |
| for (numbered, dupes) in outmap: |
| if numbered is None: |
| mapto.write(" None <- " + " ".join(map(str, dupes))+os.linesep) |
| else: |
| mapto.write(("%6d <- " % numbered) + " ".join(map(str, dupes))+os.linesep) |
| else: |
| compressed = [] |
| force_new_range = True |
| last_n = -1 |
| last_oldrevs = [] |
| # Process the raw outmap into a form that compressees ranges. |
| # Squash cliques are left alone. Ranger between |
| # them map to either |
| # (1) None followed by a singleton list (single deleted rev) |
| # (2) None followed by a two-element list (range of deletions) |
| # (3) Single number followed by singleton list = 1-element range) |
| # (4) Two-element list followed by two-element list = |
| # multiple elements, old range to new range. |
| for (n, oldrevs) in outmap: |
| #print >>sys.stderr, "I see:", (n, oldrevs) |
| cliquebase = oldrevs[0] |
| if len(oldrevs) > 1: |
| compressed.append((n, oldrevs)) |
| force_new_range = True |
| else: |
| if (n is None) != (last_n is None): |
| #print >>sys.stderr, "Forcing range break" |
| force_new_range = True |
| if force_new_range: |
| compressed.append((n, oldrevs)) |
| else: |
| #print >>sys.stderr, "Adding to range" |
| if len(last_oldrevs) == 1: |
| oldrevs = last_oldrevs + oldrevs |
| else: |
| oldrevs = last_oldrevs[:1] + oldrevs |
| lowerbound = compressed[-1][0] |
| if (last_n is None) and (n is None): |
| compressed[-1] = [None, oldrevs] |
| elif type(lowerbound) == type(0): |
| compressed[-1] = [[lowerbound, n], oldrevs] |
| else: |
| compressed[-1] = [lowerbound[:1] + [n], oldrevs] |
| force_new_range = False |
| last_n = n |
| last_oldrevs = oldrevs |
| #print >>sys.stderr, "Compressed:", compressed |
| for (a, b) in compressed: |
| if a is None: |
| if len(b) == 1: |
| print >>mapto, " None <- %d" % b[0] |
| continue |
| else: |
| print >>mapto, " None <- %d..%d" % (b[0], b[-1]) |
| continue |
| else: |
| if type(a) == type(0) and len(b) == 1: |
| print >>mapto, "%6d <- %d" % (a, b[0]) |
| continue |
| elif type(a) == type(0) and type(b) == type([]): |
| print >>mapto, "%6d <- %d..%d" % (a, b[0], b[-1]) |
| continue |
| elif type(a) == type([]) and len(a)==2 and len(b)==2: |
| print >>mapto, "%6d..%-6d <- %d..%d" % (a[0], a[1], b[0], b[1]) |
| continue |
| sys.stderr.write("svncutter: Internal error on %s\n" % ((a, b),)) |
| sys.exit(1) |
| |
| def select(source, selection): |
| "Select a portion of the dump file defined by a revision selection." |
| emit = 0 in selection |
| while True: |
| stash = source.read_until_next("Revision-number:") |
| if emit: |
| sys.stdout.write(stash) |
| if not source.has_line_buffered(): |
| return |
| else: |
| revision = int(source.linebuffer.split()[1]) |
| emit = revision in selection |
| if emit: |
| sys.stdout.write(source.flush()) |
| elif revision == selection.upperbound()+1: |
| return |
| else: |
| source.flush() |
| |
| def propdel(source, properties, selection): |
| "Delete properties." |
| def __revhook(propkeys, propdict): |
| for propname in properties: |
| if propname in propdict: |
| del propdict[propname] |
| return (propkeys, propdict) |
| def __nodehook(header, properties, content): |
| return header + properties + content |
| source.report(selection, __nodehook, __revhook) |
| |
| def propset(source, properties, selection): |
| "Set properties." |
| def __revhook(propkeys, propdict): |
| for prop in properties: |
| (propname, propval) = prop.split("=") |
| if propname in propdict: |
| propdict[propname] = propval |
| return (propkeys, propdict) |
| def __nodehook(header, properties, content): |
| return header + properties + content |
| source.report(selection, __nodehook, __revhook) |
| |
| def proprename(source, properties, selection): |
| "Rename properties." |
| def __revhook(propkeys, propdict): |
| for prop in properties: |
| (oldname, newname) = prop.split("->") |
| if oldname in propdict: |
| propdict[newname] = propdict[oldname] |
| del propdict[oldname] |
| propkeys[propkeys.index(oldname)] = newname |
| return (propkeys, propdict) |
| def __nodehook(header, properties, content): |
| return header + properties + content |
| source.report(selection, __nodehook, __revhook) |
| |
| def log(source, selection): |
| "Extract log entries." |
| while True: |
| source.read_until_next("Revision-number:") |
| if not source.has_line_buffered(): |
| return |
| else: |
| (stash, props) = source.read_revision_header() |
| logentry = props.get("svn:log") |
| if logentry: |
| print "-" * 72 |
| author = props.get("svn:author", "(no author)") |
| date = props["svn:date"].split(".")[0] |
| date = time.strptime(date, "%Y-%m-%dT%H:%M:%S") |
| date = time.strftime("%Y-%m-%d %H:%M:%S +0000 (%a, %d %b %Y)", date) |
| print "r%s | %s | %s | %d lines" % (source.revision, |
| author, |
| date, |
| logentry.count(os.linesep)) |
| sys.stdout.write("\n" + logentry + "\n") |
| |
| def setlog(source, logpatch, selection): |
| "Mutate log entries." |
| logpatch = Logfile(file(logpatch), selection) |
| def loghook(propkeys, propdict): |
| if "svn:log" in propkeys and revision in logpatch: |
| (author, date, logentry) = logpatch[source.revision] |
| if author != propdict.get("svn:author", "(no author)"): |
| sys.stderr.write("svncutter: author of revision %s doesn't look right, aborting!\n" % source.revision) |
| sys.exit(1) |
| propdict["svn:log"] = logentry |
| return (propkeys, propdict) |
| source.apply_property_hook(selection, loghook) |
| |
| def skeletonize(source, selection): |
| "Skeletonize a portion of the dump file defined by a revision selection." |
| def __skeletonize(header, properties, content): |
| def get_header(hd, name): |
| m = re.search(name + ": (.*)", hd) |
| return m and m.group(1) |
| def set_length(hd, name, val): |
| return re.sub("(?<=%s: )[0-9]+" % name, str(val), hd) |
| if content: |
| tell = "Revision is %s, file path is %s.\n\n\n" % \ |
| (source.revision, get_header(header, "Node-path"),) |
| # Avoid replacing symlinks, a reposurgeon sanity check barfs. |
| if content.startswith("link "): |
| content = content + tell |
| else: |
| content = tell |
| header = set_length(header, |
| "Text-content-length", len(content)-2) |
| header = set_length(header, |
| "Content-length", len(properties)+len(content)-2) |
| header = re.sub("Text-content-md5:.*\n", "", header) |
| header = re.sub("Text-content-sha1:.*\n", "", header) |
| header = re.sub("Text-copy-source-md5:.*\n", "", header) |
| header = re.sub("Text-copy-source-sha1:.*\n", "", header) |
| return header + properties + content |
| source.report(selection, __skeletonize) |
| |
| def expunge(source, selection, patterns): |
| "Strip out ops defined by a revision selection and a path regexp." |
| def __expunge(header, properties, content): |
| for pattern in patterns: |
| if re.search("Node-path: " + pattern, header): |
| return "" |
| else: |
| return header + properties + content |
| source.report(selection, __expunge) |
| |
| def renumber(source): |
| "Renumber all revisions." |
| renumbering = {} |
| counter = 0 |
| while True: |
| line = source.readline() |
| if not line: |
| break |
| elif line.startswith("Revision-number: "): |
| oldrev = line.split(":")[1].strip() |
| sys.stdout.write("Revision-number: %d\n" % counter) |
| renumbering[oldrev] = counter |
| counter += 1 |
| elif line.startswith("Node-copyfrom-rev:"): |
| oldrev = line.split(":")[1].strip() |
| sys.stdout.write("Node-copyfrom-rev: %s\n" % renumbering[oldrev]) |
| else: |
| sys.stdout.write(line) |
| |
| if __name__ == '__main__': |
| try: |
| (options, arguments) = getopt.getopt(sys.argv[1:], "ce:fl:m:p:qr:s", |
| ["excise", "flagrefs", "revprop=", |
| "logpatch=", "map=", |
| "quiet", "range="]) |
| selection = SubversionRange("0:HEAD") |
| timefuzz = 300 # 5 minute fuzz |
| compressmap = False |
| excise = None |
| revprops = [] |
| progress = True |
| flagrefs = False |
| logpatch = None |
| mapto = None |
| for (switch, val) in options: |
| if switch in ('-c', '--compressmap'): |
| compressmap = True |
| elif switch in ('-e', '--excise'): |
| excise = SubversionRange(val) |
| elif switch in ('-f', '--flagrefs'): |
| flagrefs = True |
| elif switch in ('-l', '--logentries'): |
| logpatch = val |
| elif switch in ('-m', '--map'): |
| mapto = open(val, "w") |
| elif switch in ('-p', '--revprop'): |
| revprops.append(val) |
| elif switch in ('-q', '--quiet'): |
| progress = False |
| elif switch in ('-r', '--range'): |
| selection = SubversionRange(val) |
| if len(arguments) == 0: |
| sys.stderr.write("Type 'svncutter help' for usage." + os.linesep) |
| sys.exit(1) |
| baton = None |
| if arguments[0] != 'help': |
| if progress: |
| baton = Baton(oneliners[arguments[0]], "done") |
| else: |
| baton = None |
| if arguments[0] == "squash": |
| squash(DumpfileSource(sys.stdin, baton), |
| timefuzz, mapto, selection, excise, flagrefs, compressmap) |
| elif arguments[0] == "propdel": |
| propdel(DumpfileSource(sys.stdin, baton), revprops + arguments[1:], selection) |
| elif arguments[0] == "propset": |
| propset(DumpfileSource(sys.stdin, baton), revprops + arguments[1:], selection) |
| elif arguments[0] == "proprename": |
| proprename(DumpfileSource(sys.stdin, baton), revprops + arguments[1:], selection) |
| elif arguments[0] == "select": |
| select(DumpfileSource(sys.stdin, baton), selection) |
| elif arguments[0] == "log": |
| log(DumpfileSource(sys.stdin, baton), selection) |
| elif arguments[0] == "setlog": |
| if not logpatch: |
| sys.stderr.write("svncutter: setlog requires a log entries file.\n") |
| setlog(DumpfileSource(sys.stdin, baton), logpatch, selection) |
| elif arguments[0] == "skeleton": |
| skeletonize(DumpfileSource(sys.stdin, baton), selection) |
| elif arguments[0] == "expunge": |
| expunge(DumpfileSource(sys.stdin, baton), selection, arguments) |
| elif arguments[0] == "renumber": |
| renumber(DumpfileSource(sys.stdin, baton)) |
| elif arguments[0] == "help": |
| if len(arguments) == 1: |
| sys.stdout.write(__doc__) |
| else: |
| sys.stdout.write(helpdict.get(arguments[1], arguments[1] + ": no such subcommand.\n")) |
| else: |
| sys.stderr.write(('"%s": unknown subcommand\n' % arguments[0])+os.linesep) |
| sys.exit(1) |
| except KeyboardInterrupt: |
| pass |
| |
| # script ends here |
