comparison hgext/convert/__init__.py @ 4589:451e91ed535e

convert extension: Add support for username mapping

Allows mapping usernames to new ones during conversion process.
 - Use -A option for first import
 - Then at the end of the conversion process and if the destination
   repo supports authorfile attribute, author map content is copied
   to the file pointed by the authorfile call.
 - On incremental conversions w/o any -A option specified, the
   destination authorfile, if any, gets read automatically.

EG: This allows mapping unix system usernames used in CVS accounts
    to a more typical "Firstname Lastname <[e-mail]>" pair.

4588:9855939d0c82

        self.ui = ui
        self.opts = opts
        self.commitcache = {}
        self.mapfile = mapfile
        self.mapfilefd = None

        self.map = {}
        try:
            origmapfile = open(self.mapfile, 'r')
            for l in origmapfile:
                sv, dv = l[:-1].split()
                self.map[sv] = dv
            origmapfile.close()
        except IOError:
            pass

    def walktree(self, heads):
        visit = heads
        known = {}
        parents = {}

                raise util.Abort("Could not open map file %s: %s, %s\n" % (self.mapfile, errno, strerror))
        self.map[src] = dst
        self.mapfilefd.write("%s %s\n" % (src, dst))
        self.mapfilefd.flush()

    def copy(self, rev):
        c = self.commitcache[rev]
        files = self.source.getchanges(rev)

        for f, v in files:

            for c in t:
                num -= 1
                desc = self.commitcache[c].desc
                if "\n" in desc:
                    desc = desc.splitlines()[0]
                self.ui.status("%d %s\n" % (num, desc))
                self.copy(c)

            tags = self.source.gettags()
            ctags = {}

                nrev = self.dest.puttags(ctags)
                # write another hash correspondence to override the previous
                # one so we don't end up with extra tag heads
                if nrev:
                    self.mapentry(c, nrev)
        finally:
            self.cleanup()

    def cleanup(self):
       if self.mapfilefd:

    be created. If <mapfile> isn't given, it will be put in a default
    location (<dest>/.hg/shamap by default)

    The <mapfile> is a simple text file that maps each source commit ID to
    the destination ID for that revision, like so:

    <source ID> <destination ID>

    If the file doesn't exist, it's automatically created.  It's updated
    on each commit copied, so convert-repo can be interrupted and can
    be run repeatedly to copy new commits.
    '''

    srcc = converter(ui, src)
    if not hasattr(srcc, "getcommit"):
        raise util.Abort("%s: can't read from this repo type" % src)

    c.convert()

cmdtable = {
    "convert":
        (_convert,
         [('', 'datesort', None, 'try to sort changesets by date')],
         'hg convert [OPTION]... SOURCE [DEST [MAPFILE]]'),
}

4589:451e91ed535e

        self.ui = ui
        self.opts = opts
        self.commitcache = {}
        self.mapfile = mapfile
        self.mapfilefd = None
        self.authors = {}
        self.writeauthors = False

        self.map = {}
        try:
            origmapfile = open(self.mapfile, 'r')
            for l in origmapfile:
                sv, dv = l[:-1].split()
                self.map[sv] = dv
            origmapfile.close()
        except IOError:
            pass

        # Read first the dst author map if any
        if  hasattr(self.dest, 'authorfile'):
            self.readauthormap(self.dest.authorfile())
        # Extend/Override with new author map if necessary
        if 'authors' in opts:
            self.readauthormap(opts.get('authors'))
            self.writeauthors = True

    def walktree(self, heads):
        visit = heads
        known = {}
        parents = {}

                raise util.Abort("Could not open map file %s: %s, %s\n" % (self.mapfile, errno, strerror))
        self.map[src] = dst
        self.mapfilefd.write("%s %s\n" % (src, dst))
        self.mapfilefd.flush()

    def writeauthormap(self):
        if self.writeauthors == True and len(self.authors) > 0 and hasattr(self.dest, 'authorfile'):
           authorfile = self.dest.authorfile()
           self.ui.status('Writing author map file %s\n' % authorfile)
           ofile = open(authorfile, 'w+')
           for author in self.authors:
               ofile.write("%s=%s\n" % (author, self.authors[author]))
           ofile.close()

    def readauthormap(self, authorfile):
        try:
            afile = open(authorfile, 'r')
            for line in afile:
                try:
                    srcauthor = line.split('=')[0].strip()
                    dstauthor = line.split('=')[1].strip()
                    if srcauthor in self.authors and dstauthor != self.authors[srcauthor]:
                        self.ui.status(
                            'Overriding mapping for author %s, was %s, will be %s\n'
                            % (srcauthor, self.authors[srcauthor], dstauthor))
                    else:
                        self.ui.debug('Mapping author %s to %s\n'
			    % (srcauthor, dstauthor))
                    self.authors[srcauthor] = dstauthor
		    
                except IndexError:
                    self.ui.warn(
                        'Ignoring bad line in author file map %s: %s\n'
                        % (authorfile, line))
            afile.close()
        except IOError:
            self.ui.warn('Error reading author file map %s.\n' % authorfile)

    def copy(self, rev):
        c = self.commitcache[rev]
        files = self.source.getchanges(rev)

        for f, v in files:

            for c in t:
                num -= 1
                desc = self.commitcache[c].desc
                if "\n" in desc:
                    desc = desc.splitlines()[0]
                author = self.commitcache[c].author
                author = self.authors.get(author, author)
                self.commitcache[c].author = author
                self.ui.status("%d %s\n" % (num, desc))
                self.copy(c)

            tags = self.source.gettags()
            ctags = {}

                nrev = self.dest.puttags(ctags)
                # write another hash correspondence to override the previous
                # one so we don't end up with extra tag heads
                if nrev:
                    self.mapentry(c, nrev)

            self.writeauthormap()
        finally:
            self.cleanup()

    def cleanup(self):
       if self.mapfilefd:

    be created. If <mapfile> isn't given, it will be put in a default
    location (<dest>/.hg/shamap by default)

    The <mapfile> is a simple text file that maps each source commit ID to
    the destination ID for that revision, like so:
    <source ID> <destination ID>

    If the file doesn't exist, it's automatically created.  It's updated
    on each commit copied, so convert-repo can be interrupted and can
    be run repeatedly to copy new commits.

    The [username mapping] file is a simple text file that maps each source
    commit author to a destination commit author. It is handy for source SCMs
    that use unix logins to identify authors (eg: CVS). One line per author
    mapping and the line format is:
    srcauthor=whatever string you want
    '''

    srcc = converter(ui, src)
    if not hasattr(srcc, "getcommit"):
        raise util.Abort("%s: can't read from this repo type" % src)

    c.convert()

cmdtable = {
    "convert":
        (_convert,
         [('A', 'authors', '', 'username mapping filename'),
          ('', 'datesort', None, 'try to sort changesets by date')],
         'hg convert [OPTION]... SOURCE [DEST [MAPFILE]]'),
}