convert: added gnu arch (baz) tests

tests/test-convert-baz

@@ -0,0 +1,66 b''
+#!/bin/sh
+
+"$TESTDIR/hghave" baz || exit 80
+
+echo "[extensions]" >> $HGRCPATH
+echo "convert=" >> $HGRCPATH
+echo 'hgext.graphlog =' >> $HGRCPATH
+
+echo % create baz archive
+baz make-archive baz@mercurial--convert hg-test-convert-baz
+
+echo % initialize baz repo
+mkdir baz-repo
+cd baz-repo/
+baz init-tree baz@mercurial--convert/baz--test--0
+baz import
+
+echo % create initial files
+echo 'this is a file' > a
+baz add a
+mkdir src
+baz add src
+cd src
+dd count=1 if=/dev/zero of=b > /dev/null 2> /dev/null
+baz add b
+baz commit -s "added a file, src and src/b (binary)"
+
+echo % create link file and modify a
+ln -s ../a a-link
+baz add a-link
+echo 'this a modification to a' >> ../a
+baz commit -s "added link to a and modify a"
+
+echo % create second link and modify b
+ln -s ../a a-link-2
+baz add a-link-2
+dd count=1 seek=1 if=/dev/zero of=b > /dev/null 2> /dev/null
+baz commit -s "added second link and modify b"
+
+echo % b file to link and a-link-2 to regular file
+rm -f a-link-2
+echo 'this is now a regular file' > a-link-2
+ln -sf ../a b
+baz commit -s "file to link and link to file test"
+
+echo % move a-link-2 file and src directory
+cd ..
+baz mv src/a-link-2 c
+baz mv src test
+baz commit -s "move and rename a-link-2 file and src directory"
+
+cd ..
+
+echo % converting baz repo to Mercurial
+hg convert baz-repo baz-repo-hg
+
+baz register-archive -d baz@mercurial--convert
+
+glog()
+{
+    hg glog --template '#rev# "#desc|firstline#" files: #files#\n' "$@"
+}
+
+echo % show graph log
+glog -R baz-repo-hg
+hg -R baz-repo-hg manifest --debug

tests/test-convert-baz.out

@@ -0,0 +1,75 b''
+% create baz archive
+% initialize baz repo
+* creating version baz@mercurial--convert/baz--test--0
+* imported baz@mercurial--convert/baz--test--0
+% create initial files
+* build pristine tree for baz@mercurial--convert/baz--test--0--base-0
+* Scanning for full-tree revision: .
+* from import revision: baz@mercurial--convert/baz--test--0--base-0
+A/ .arch-ids
+A/ src
+A/ src/.arch-ids
+A  .arch-ids/a.id
+A  a
+A  src/.arch-ids/=id
+A  src/.arch-ids/b.id
+A  src/b
+* update pristine tree (baz@mercurial--convert/baz--test--0--base-0 => baz--test--0--patch-1)
+* committed baz@mercurial--convert/baz--test--0--patch-1
+% create link file and modify a
+A  src/.arch-ids/a-link.id
+A  src/a-link
+M  a
+* update pristine tree (baz@mercurial--convert/baz--test--0--patch-1 => baz--test--0--patch-2)
+* committed baz@mercurial--convert/baz--test--0--patch-2
+% create second link and modify b
+A  src/.arch-ids/a-link-2.id
+A  src/a-link-2
+Mb src/b
+* update pristine tree (baz@mercurial--convert/baz--test--0--patch-2 => baz--test--0--patch-3)
+* committed baz@mercurial--convert/baz--test--0--patch-3
+% b file to link and a-link-2 to regular file
+fl src/b
+lf src/a-link-2
+* update pristine tree (baz@mercurial--convert/baz--test--0--patch-3 => baz--test--0--patch-4)
+* committed baz@mercurial--convert/baz--test--0--patch-4
+% move a-link-2 file and src directory
+D/ src/.arch-ids
+A/ test/.arch-ids
+/> src	test
+=> src/.arch-ids/a-link-2.id	.arch-ids/c.id
+=> src/a-link-2	c
+=> src/.arch-ids/=id	test/.arch-ids/=id
+=> src/.arch-ids/a-link.id	test/.arch-ids/a-link.id
+=> src/.arch-ids/b.id	test/.arch-ids/b.id
+* update pristine tree (baz@mercurial--convert/baz--test--0--patch-4 => baz--test--0--patch-5)
+* committed baz@mercurial--convert/baz--test--0--patch-5
+% converting baz repo to Mercurial
+initializing destination baz-repo-hg repository
+analyzing tree version baz@mercurial--convert/baz--test--0...
+scanning source...
+sorting...
+converting...
+5 initial import
+4 added a file, src and src/b (binary)
+3 added link to a and modify a
+2 added second link and modify b
+1 file to link and link to file test
+0 move and rename a-link-2 file and src directory
+% show graph log
+o  5 "move and rename a-link-2 file and src directory" files: c src/a-link src/a-link-2 src/b test/a-link test/b
+|
+o  4 "file to link and link to file test" files: src/a-link-2 src/b
+|
+o  3 "added second link and modify b" files: src/a-link-2 src/b
+|
+o  2 "added link to a and modify a" files: a src/a-link
+|
+o  1 "added a file, src and src/b (binary)" files: a src/b
+|
+o  0 "initial import" files:
+
+c4072c4b72e1cabace081888efa148ee80ca3cbb 644   a
+e3207be798aaf87a444a62903621edab4ddc1fb6 644   c
+1f6b5bb93f1da278ef1fead1e4740a03d8802e9f 644 @ test/a-link
+1f6b5bb93f1da278ef1fead1e4740a03d8802e9f 644 @ test/b

hgext/convert/gnuarch.py

@@ -1,292 +1,292 b''
 # GNU Arch support for the convert extension
 
 from common import NoRepo, checktool, commandline, commit, converter_source
 from mercurial.i18n import _
 from mercurial import util
 import os, shutil, tempfile, stat
 
 class gnuarch_source(converter_source, commandline):
 
     class gnuarch_rev:
         def __init__(self, rev):
             self.rev = rev
             self.summary = ''
             self.date = None
             self.author = ''
             self.add_files = []
             self.mod_files = []
             self.del_files = []
             self.ren_files = {}
             self.ren_dirs = {}
 
     def __init__(self, ui, path, rev=None):
         super(gnuarch_source, self).__init__(ui, path, rev=rev)
 
         if not os.path.exists(os.path.join(path, '{arch}')):
-            raise NoRepo(_("couldn't open GNU Arch repo %s" % path))
+            raise NoRepo(_("%s does not look like a GNU Arch repo" % path))
 
         # Could use checktool, but we want to check for baz or tla.
         self.execmd = None
         if util.find_exe('tla'):
             self.execmd = 'tla'
         else:
             if util.find_exe('baz'):
                 self.execmd = 'baz'
             else:
                 raise util.Abort(_('cannot find a GNU Arch tool'))
 
         commandline.__init__(self, ui, self.execmd)
 
         self.path = os.path.realpath(path)
         self.tmppath = None
 
         self.treeversion = None
         self.lastrev = None
         self.changes = {}
         self.parents = {}
         self.tags = {}
         self.modecache = {}
 
     def before(self):
         if self.execmd == 'tla':
             output = self.run0('tree-version', self.path)
         else:
             output = self.run0('tree-version', '-d', self.path)
         self.treeversion = output.strip()
 
         self.ui.status(_('analyzing tree version %s...\n' % self.treeversion))
 
         # Get name of temporary directory
         version = self.treeversion.split('/')
         self.tmppath = os.path.join(tempfile.gettempdir(),
                                     'hg-%s' % version[1])
 
         # Generate parents dictionary
         child = []
         output, status = self.runlines('revisions', self.treeversion)
         self.checkexit(status, 'archive registered?')
         for l in output:
             rev = l.strip()
             self.changes[rev] = self.gnuarch_rev(rev)
 
             # Read author, date and summary
             catlog = self.runlines0('cat-log', '-d', self.path, rev)
             self._parsecatlog(catlog, rev)
 
             self.parents[rev] = child
             child = [rev]
             if rev == self.rev:
                 break
         self.parents[None] = child
 
     def after(self):
         self.ui.debug(_('cleaning up %s\n' % self.tmppath))
         shutil.rmtree(self.tmppath, ignore_errors=True)
 
     def getheads(self):
         return self.parents[None]
 
     def getfile(self, name, rev):
         if rev != self.lastrev:
             raise util.Abort(_('internal calling inconsistency'))
 
         # Raise IOError if necessary (i.e. deleted files).
         if not os.path.exists(os.path.join(self.tmppath, name)):
             raise IOError
 
         data, mode = self._getfile(name, rev)
         self.modecache[(name, rev)] = mode
 
         return data
 
     def getmode(self, name, rev):
         return self.modecache[(name, rev)]
 
     def getchanges(self, rev):
         self.modecache = {}
         self._update(rev)
         changes = []
         copies = {}
 
         for f in self.changes[rev].add_files:
             changes.append((f, rev))
 
         for f in self.changes[rev].mod_files:
             changes.append((f, rev))
 
         for f in self.changes[rev].del_files:
             changes.append((f, rev))
 
         for src in self.changes[rev].ren_files:
             to = self.changes[rev].ren_files[src]
             changes.append((src, rev))
             changes.append((to, rev))
             copies[src] = to
 
         for src in self.changes[rev].ren_dirs:
             to = self.changes[rev].ren_dirs[src]
             chgs, cps = self._rendirchanges(src, to);
             changes += [(f, rev) for f in chgs]
             for c in cps:
                 copies[c] = cps[c]
 
         changes.sort()
         self.lastrev = rev
 
         return changes, copies
 
     def getcommit(self, rev):
         changes = self.changes[rev]
         return commit(author = changes.author, date = changes.date,
                       desc = changes.summary, parents = self.parents[rev])
 
     def gettags(self):
         return self.tags
 
     def _execute(self, cmd, *args, **kwargs):
         cmdline = [self.execmd, cmd]
         cmdline += args
         cmdline = [util.shellquote(arg) for arg in cmdline]
         cmdline += ['>', util.nulldev, '2>', util.nulldev]
         cmdline = util.quotecommand(' '.join(cmdline))
         self.ui.debug(cmdline, '\n')
         return os.system(cmdline)
 
     def _update(self, rev):
         if rev == 'base-0':
             # Initialise 'base-0' revision
             self._obtainrevision(rev)
         else:
             self.ui.debug(_('applying revision %s...\n' % rev))
             revision = '%s--%s' % (self.treeversion, rev)
             changeset, status = self.runlines('replay', '-d', self.tmppath,
                                               revision)
             if status:
                 # Something went wrong while merging (baz or tla
                 # issue?), get latest revision and try from there
                 shutil.rmtree(self.tmppath, ignore_errors=True)
                 self._obtainrevision(rev)
             else:
                 old_rev = self.parents[rev][0]
                 self.ui.debug(_('computing changeset between %s and %s...\n' \
                                     % (old_rev, rev)))
                 rev_a = '%s--%s' % (self.treeversion, old_rev)
                 rev_b = '%s--%s' % (self.treeversion, rev)
                 self._parsechangeset(changeset, rev)
 
     def _getfile(self, name, rev):
         mode = os.lstat(os.path.join(self.tmppath, name)).st_mode
         if stat.S_ISLNK(mode):
             data = os.readlink(os.path.join(self.tmppath, name))
             mode = mode and 'l' or ''
         else:
             data = open(os.path.join(self.tmppath, name), 'rb').read()
             mode = (mode & 0111) and 'x' or ''
         return data, mode
 
     def _exclude(self, name):
         exclude = [ '{arch}', '.arch-ids', '.arch-inventory' ]
         for exc in exclude:
             if name.find(exc) != -1:
                 return True
         return False
 
     def _readcontents(self, path):
         files = []
         contents = os.listdir(path)
         while len(contents) > 0:
             c = contents.pop()
             p = os.path.join(path, c)
             # os.walk could be used, but here we avoid internal GNU
             # Arch files and directories, thus saving a lot time.
             if not self._exclude(p):
                 if os.path.isdir(p):
                     contents += [os.path.join(c, f) for f in os.listdir(p)]
                 else:
                     files.append(c)
         return files
 
     def _rendirchanges(self, src, dest):
         changes = []
         copies = {}
         files = self._readcontents(os.path.join(self.tmppath, dest))
         for f in files:
             s = os.path.join(src, f)
             d = os.path.join(dest, f)
             changes.append(s)
             changes.append(d)
             copies[s] = d
         return changes, copies
 
     def _obtainrevision(self, rev):
         self.ui.debug(_('obtaining revision %s...\n' % rev))
         revision = '%s--%s' % (self.treeversion, rev)
         output = self._execute('get', revision, self.tmppath)
         self.checkexit(output)
         self.ui.debug(_('analysing revision %s...\n' % rev))
         files = self._readcontents(self.tmppath)
         self.changes[rev].add_files += files
 
     def _parsecatlog(self, data, rev):
         summary = []
         for l in data:
             l = l.strip()
             if summary:
                 summary.append(l)
             elif l.startswith('Summary:'):
                 summary.append(l[len('Summary: '):])
             elif l.startswith('Standard-date:'):
                 date = l[len('Standard-date: '):]
                 strdate = util.strdate(date, '%Y-%m-%d %H:%M:%S')
                 self.changes[rev].date = util.datestr(strdate)
             elif l.startswith('Creator:'):
                 self.changes[rev].author = l[len('Creator: '):]
         self.changes[rev].summary = '\n'.join(summary)
 
     def _parsechangeset(self, data, rev):
         for l in data:
             l = l.strip()
             # Added file (ignore added directory)
             if l.startswith('A') and not l.startswith('A/'):
                 file = l[1:].strip()
                 if not self._exclude(file):
                     self.changes[rev].add_files.append(file)
             # Deleted file (ignore deleted directory)
             elif l.startswith('D') and not l.startswith('D/'):
                 file = l[1:].strip()
                 if not self._exclude(file):
                     self.changes[rev].del_files.append(file)
             # Modified binary file
             elif l.startswith('Mb'):
                 file = l[2:].strip()
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Modified link
             elif l.startswith('M->'):
                 file = l[3:].strip()
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Modified file
             elif l.startswith('M'):
                 file = l[1:].strip()
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Renamed file (or link)
             elif l.startswith('=>'):
                 files = l[2:].strip().split(' ')
                 if len(files) == 1:
                     files = l[2:].strip().split('\t')
                 if not self._exclude(files[0]) and not self._exclude(files[1]):
                     self.changes[rev].ren_files[files[0]] = files[1]
             # Conversion from file to link or from link to file (modified)
             elif l.startswith('ch'):
                 file = l[2:].strip()
                 if not self._exclude(file):
                     self.changes[rev].mod_files.append(file)
             # Renamed directory
             elif l.startswith('/>'):
                 dirs = l[2:].strip().split(' ')
                 if len(dirs) == 1:
                     dirs = l[2:].strip().split('\t')
                 if not self._exclude(dirs[0]) and not self._exclude(dirs[1]):
                     self.changes[rev].ren_dirs[dirs[0]] = dirs[1]

tests/hghave

@@ -1,165 +1,169 b''
 #!/usr/bin/env python
 """Test the running system for features availability. Exit with zero
 if all features are there, non-zero otherwise. If a feature name is
 prefixed with "no-", the absence of feature is tested.
 """
 import optparse
 import os
 import re
 import sys
 import tempfile
 
 tempprefix = 'hg-hghave-'
 
 def matchoutput(cmd, regexp, ignorestatus=False):
     """Return True if cmd executes successfully and its output
     is matched by the supplied regular expression.
     """
     r = re.compile(regexp)
     fh = os.popen(cmd)
     s = fh.read()
     ret = fh.close()
     return (ignorestatus or ret is None) and r.search(s)
 
+def has_baz():
+    return matchoutput('baz --version 2>&1', r'baz Bazaar version')
+
 def has_cvs():
     return matchoutput('cvs --version 2>&1', r'Concurrent Versions System')
 
 def has_cvsps():
     return matchoutput('cvsps -h -q 2>&1', r'cvsps version', True)
 
 def has_darcs():
     return matchoutput('darcs', 'darcs version', True)
 
 def has_eol_in_paths():
     try:
         fd, path = tempfile.mkstemp(prefix=tempprefix, suffix='\n\r')
         os.close(fd)
         os.remove(path)
         return True
     except:
         return False
 
 def has_executablebit():
     fd, path = tempfile.mkstemp(prefix=tempprefix)
     os.close(fd)
     try:
         s = os.lstat(path).st_mode
         os.chmod(path, s | 0100)
         return (os.lstat(path).st_mode & 0100 != 0)
     finally:
         os.remove(path)
 
 def has_fifo():
     return hasattr(os, "mkfifo")
 
 def has_hotshot():
     try:
         # hotshot.stats tests hotshot and many problematic dependencies
         # like profile.
         import hotshot.stats
         return True
     except ImportError:
         return False
 
 def has_lsprof():
     try:
         import _lsprof
         return True
     except ImportError:
         return False
 
 def has_git():
     return matchoutput('git --version 2>&1', r'^git version')
 
 def has_svn():
     return matchoutput('svn --version 2>&1', r'^svn, version') and \
         matchoutput('svnadmin --version 2>&1', r'^svnadmin, version')
 
 def has_svn_bindings():
     try:
         import svn.core
         return True
     except ImportError:
         return False
 
 def has_symlink():
     return hasattr(os, "symlink")
 
 def has_unix_permissions():
     d = tempfile.mkdtemp(prefix=tempprefix, dir=".")
     try:
         fname = os.path.join(d, 'foo')
         for umask in (077, 007, 022):
             os.umask(umask)
             f = open(fname, 'w')
             f.close()
             mode = os.stat(fname).st_mode
             os.unlink(fname)
             if mode & 0777 != ~umask & 0666:
                 return False
         return True
     finally:
         os.rmdir(d)
 
 checks = {
+    "baz": (has_baz, "GNU Arch baz client"),
     "cvs": (has_cvs, "cvs client"),
     "cvsps": (has_cvsps, "cvsps utility"),
     "darcs": (has_darcs, "darcs client"),
     "eol-in-paths": (has_eol_in_paths, "end-of-lines in paths"),
     "execbit": (has_executablebit, "executable bit"),
     "fifo": (has_fifo, "named pipes"),
     "git": (has_git, "git command line client"),
     "hotshot": (has_hotshot, "python hotshot module"),
     "lsprof": (has_lsprof, "python lsprof module"),
     "svn": (has_svn, "subversion client and admin tools"),
     "svn-bindings": (has_svn_bindings, "subversion python bindings"),
     "symlink": (has_symlink, "symbolic links"),
     "unix-permissions": (has_unix_permissions, "unix-style permissions"),
 }
 
 def list_features():
     for name, feature in checks.iteritems():
         desc = feature[1]
         print name + ':', desc
 
 parser = optparse.OptionParser("%prog [options] [features]")
 parser.add_option("--list-features", action="store_true",
                   help="list available features")
 parser.add_option("-q", "--quiet", action="store_true",
                   help="check features silently")
 
 if __name__ == '__main__':
     options, args = parser.parse_args()
     if options.list_features:
         list_features()
         sys.exit(0)
 
     quiet = options.quiet
 
     failures = 0
 
     def error(msg):
         global failures
         if not quiet:
             sys.stderr.write(msg + '\n')
         failures += 1
 
     for feature in args:
         negate = feature.startswith('no-')
         if negate:
             feature = feature[3:]
 
         if feature not in checks:
             error('skipped: unknown feature: ' + feature)
             continue
 
         check, desc = checks[feature]
         if not negate and not check():
             error('skipped: missing feature: ' + desc)
         elif negate and check():
             error('skipped: system supports %s' % desc)
 
     if failures != 0:
         sys.exit(1)