convert: move *** empty log message *** into commit class

hgext/convert/common.py

@@ -1,108 +1,110
 # common code for the convert extension
 
 class NoRepo(Exception): pass
 
 class commit(object):
     def __init__(self, **parts):
         for x in "author date desc parents".split():
             if not x in parts:
                 raise util.Abort("commit missing field %s" % x)
         self.__dict__.update(parts)
+        if not self.desc or self.desc.isspace():
+            self.desc = '*** empty log message ***'
 
 class converter_source(object):
     """Conversion source interface"""
 
     def __init__(self, ui, path, rev=None):
         """Initialize conversion source (or raise NoRepo("message")
         exception if path is not a valid repository)"""
         raise NotImplementedError()
 
     def getheads(self):
         """Return a list of this repository's heads"""
         raise NotImplementedError()
 
     def getfile(self, name, rev):
         """Return file contents as a string"""
         raise NotImplementedError()
 
     def getmode(self, name, rev):
         """Return file mode, eg. '', 'x', or 'l'"""
         raise NotImplementedError()
 
     def getchanges(self, version):
         """Return sorted list of (filename, id) tuples for all files changed in rev.
 
         id just tells us which revision to return in getfile(), e.g. in
         git it's an object hash."""
         raise NotImplementedError()
 
     def getcommit(self, version):
         """Return the commit object for version"""
         raise NotImplementedError()
 
     def gettags(self):
         """Return the tags as a dictionary of name: revision"""
         raise NotImplementedError()
 
     def recode(self, s, encoding=None):
         if not encoding:
             encoding = hasattr(self, 'encoding') and self.encoding or 'utf-8'
             
         try:
             return s.decode(encoding).encode("utf-8")
         except:
             try:
                 return s.decode("latin-1").encode("utf-8")
             except:
                 return s.decode(encoding, "replace").encode("utf-8")
 
 class converter_sink(object):
     """Conversion sink (target) interface"""
 
     def __init__(self, ui, path):
         """Initialize conversion sink (or raise NoRepo("message")
         exception if path is not a valid repository)"""
         raise NotImplementedError()
 
     def getheads(self):
         """Return a list of this repository's heads"""
         raise NotImplementedError()
 
     def mapfile(self):
         """Path to a file that will contain lines
         source_rev_id sink_rev_id
         mapping equivalent revision identifiers for each system."""
         raise NotImplementedError()
 
     def authorfile(self):
         """Path to a file that will contain lines
         srcauthor=dstauthor
         mapping equivalent authors identifiers for each system."""
         return None
 
     def putfile(self, f, e, data):
         """Put file for next putcommit().
         f: path to file
         e: '', 'x', or 'l' (regular file, executable, or symlink)
         data: file contents"""
         raise NotImplementedError()
 
     def delfile(self, f):
         """Delete file for next putcommit().
         f: path to file"""
         raise NotImplementedError()
 
     def putcommit(self, files, parents, commit):
         """Create a revision with all changed files listed in 'files'
         and having listed parents. 'commit' is a commit object containing
         at a minimum the author, date, and message for this changeset.
         Called after putfile() and delfile() calls. Note that the sink
         repository is not told to update itself to a particular revision
         (or even what that revision would be) before it receives the
         file data."""
         raise NotImplementedError()
 
     def puttags(self, tags):
         """Put tags into sink.
         tags: {tagname: sink_rev_id, ...}"""
         raise NotImplementedError()

hgext/convert/cvs.py

@@ -1,262 +1,260
 # CVS conversion code inspired by hg-cvs-import and git-cvsimport
 
 import os, locale, re, socket
 from mercurial import util
 
 from common import NoRepo, commit, converter_source
 
 class convert_cvs(converter_source):
     def __init__(self, ui, path, rev=None):
         self.path = path
         self.ui = ui
         self.rev = rev
         cvs = os.path.join(path, "CVS")
         if not os.path.exists(cvs):
             raise NoRepo("couldn't open CVS repo %s" % path)
 
         self.changeset = {}
         self.files = {}
         self.tags = {}
         self.lastbranch = {}
         self.parent = {}
         self.socket = None
         self.cvsroot = file(os.path.join(cvs, "Root")).read()[:-1]
         self.cvsrepo = file(os.path.join(cvs, "Repository")).read()[:-1]
         self.encoding = locale.getpreferredencoding()
         self._parse()
         self._connect()
 
     def _parse(self):
         if self.changeset:
             return
 
         maxrev = 0
         cmd = 'cvsps -A -u --cvs-direct -q'
         if self.rev:
             # TODO: handle tags
             try:
                 # patchset number?
                 maxrev = int(self.rev)
             except ValueError:
                 try:
                     # date
                     util.parsedate(self.rev, ['%Y/%m/%d %H:%M:%S'])
                     cmd = "%s -d '1970/01/01 00:00:01' -d '%s'" % (cmd, self.rev)
                 except util.Abort:
                     raise util.Abort('revision %s is not a patchset number or date' % self.rev)
 
         d = os.getcwd()
         try:
             os.chdir(self.path)
             id = None
             state = 0
             for l in os.popen(cmd):
                 if state == 0: # header
                     if l.startswith("PatchSet"):
                         id = l[9:-2]
                         if maxrev and int(id) > maxrev:
                             state = 3
                     elif l.startswith("Date"):
                         date = util.parsedate(l[6:-1], ["%Y/%m/%d %H:%M:%S"])
                         date = util.datestr(date)
                     elif l.startswith("Branch"):
                         branch = l[8:-1]
                         self.parent[id] = self.lastbranch.get(branch, 'bad')
                         self.lastbranch[branch] = id
                     elif l.startswith("Ancestor branch"):
                         ancestor = l[17:-1]
                         self.parent[id] = self.lastbranch[ancestor]
                     elif l.startswith("Author"):
                         author = self.recode(l[8:-1])
                     elif l.startswith("Tag:") or l.startswith("Tags:"):
                         t = l[l.index(':')+1:]
                         t = [ut.strip() for ut in t.split(',')]
                         if (len(t) > 1) or (t[0] and (t[0] != "(none)")):
                             self.tags.update(dict.fromkeys(t, id))
                     elif l.startswith("Log:"):
                         state = 1
                         log = ""
                 elif state == 1: # log
                     if l == "Members: \n":
                         files = {}
                         log = self.recode(log[:-1])
-                        if log.isspace():
-                            log = "*** empty log message ***\n"
                         state = 2
                     else:
                         log += l
                 elif state == 2:
                     if l == "\n": #
                         state = 0
                         p = [self.parent[id]]
                         if id == "1":
                             p = []
                         if branch == "HEAD":
                             branch = ""
                         c = commit(author=author, date=date, parents=p,
                                    desc=log, branch=branch)
                         self.changeset[id] = c
                         self.files[id] = files
                     else:
                         colon = l.rfind(':')
                         file = l[1:colon]
                         rev = l[colon+1:-2]
                         rev = rev.split("->")[1]
                         files[file] = rev
                 elif state == 3:
                     continue
 
             self.heads = self.lastbranch.values()
         finally:
             os.chdir(d)
 
     def _connect(self):
         root = self.cvsroot
         conntype = None
         user, host = None, None
         cmd = ['cvs', 'server']
 
         self.ui.status("connecting to %s\n" % root)
 
         if root.startswith(":pserver:"):
             root = root[9:]
             m = re.match(r'(?:(.*?)(?::(.*?))?@)?([^:\/]*)(?::(\d*))?(.*)',
                          root)
             if m:
                 conntype = "pserver"
                 user, passw, serv, port, root = m.groups()
                 if not user:
                     user = "anonymous"
                 rr = ":pserver:" + user + "@" + serv + ":" +  root
                 if port:
                     rr2, port = "-", int(port)
                 else:
                     rr2, port = rr, 2401
                 rr += str(port)
 
                 if not passw:
                     passw = "A"
                     pf = open(os.path.join(os.environ["HOME"], ".cvspass"))
                     for l in pf:
                         # :pserver:[e-mail]:/cvsroot/zmailer Ah<Z
                         m = re.match(r'(/\d+\s+/)?(.*)', l)
                         l = m.group(2)
                         w, p = l.split(' ', 1)
                         if w in [rr, rr2]:
                             passw = p
                             break
                     pf.close()
 
                 sck = socket.socket()
                 sck.connect((serv, port))
                 sck.send("\n".join(["BEGIN AUTH REQUEST", root, user, passw,
                                     "END AUTH REQUEST", ""]))
                 if sck.recv(128) != "I LOVE YOU\n":
                     raise NoRepo("CVS pserver authentication failed")
 
                 self.writep = self.readp = sck.makefile('r+')
 
         if not conntype and root.startswith(":local:"):
             conntype = "local"
             root = root[7:]
 
         if not conntype:
             # :ext:user@host/home/user/path/to/cvsroot
             if root.startswith(":ext:"):
                 root = root[5:]
             m = re.match(r'(?:([^@:/]+)@)?([^:/]+):?(.*)', root)
             if not m:
                 conntype = "local"
             else:
                 conntype = "rsh"
                 user, host, root = m.group(1), m.group(2), m.group(3)
 
         if conntype != "pserver":
             if conntype == "rsh":
                 rsh = os.environ.get("CVS_RSH" or "rsh")
                 if user:
                     cmd = [rsh, '-l', user, host] + cmd
                 else:
                     cmd = [rsh, host] + cmd
 
             self.writep, self.readp = os.popen2(cmd)
 
         self.realroot = root
 
         self.writep.write("Root %s\n" % root)
         self.writep.write("Valid-responses ok error Valid-requests Mode"
                           " M Mbinary E Checked-in Created Updated"
                           " Merged Removed\n")
         self.writep.write("valid-requests\n")
         self.writep.flush()
         r = self.readp.readline()
         if not r.startswith("Valid-requests"):
             raise util.Abort("server sucks")
         if "UseUnchanged" in r:
             self.writep.write("UseUnchanged\n")
             self.writep.flush()
             r = self.readp.readline()
 
     def getheads(self):
         return self.heads
 
     def _getfile(self, name, rev):
         if rev.endswith("(DEAD)"):
             raise IOError
 
         args = ("-N -P -kk -r %s --" % rev).split()
         args.append(os.path.join(self.cvsrepo, name))
         for x in args:
             self.writep.write("Argument %s\n" % x)
         self.writep.write("Directory .\n%s\nco\n" % self.realroot)
         self.writep.flush()
 
         data = ""
         while 1:
             line = self.readp.readline()
             if line.startswith("Created ") or line.startswith("Updated "):
                 self.readp.readline() # path
                 self.readp.readline() # entries
                 mode = self.readp.readline()[:-1]
                 count = int(self.readp.readline()[:-1])
                 data = self.readp.read(count)
             elif line.startswith(" "):
                 data += line[1:]
             elif line.startswith("M "):
                 pass
             elif line.startswith("Mbinary "):
                 count = int(self.readp.readline()[:-1])
                 data = self.readp.read(count)
             else:
                 if line == "ok\n":
                     return (data, "x" in mode and "x" or "")
                 elif line.startswith("E "):
                     self.ui.warn("cvs server: %s\n" % line[2:])
                 elif line.startswith("Remove"):
                     l = self.readp.readline()
                     l = self.readp.readline()
                     if l != "ok\n":
                         raise util.Abort("unknown CVS response: %s" % l)
                 else:
                     raise util.Abort("unknown CVS response: %s" % line)
 
     def getfile(self, file, rev):
         data, mode = self._getfile(file, rev)
         self.modecache[(file, rev)] = mode
         return data
 
     def getmode(self, file, rev):
         return self.modecache[(file, rev)]
 
     def getchanges(self, rev):
         self.modecache = {}
         files = self.files[rev]
         cl = files.items()
         cl.sort()
         return cl
 
     def getcommit(self, rev):
         return self.changeset[rev]
 
     def gettags(self):
         return self.tags