Typo in comment

[rcs-fast-export] / rcs-fast-export.rb

#!/usr/bin/ruby

=begin
RCS fast export: run the script with the `--help` option for further
information.

No installation needed: you can run it from anywhere, including the git
checkout directory. For extra comfort, symlink it to some directory in
your PATH. I myself have this symlink:

        ~/bin/rcs-fast-export -> ~/src/rcs-fast-export/rcs-fast-export.rb

allowing me to run `rcs-fast-export` from anywhere.
=end

=begin
TODO
        * Refactor commit coalescing
        * Add --strict-symbol-check to only coalesce commits if their symbol lists are equal
        * Add support for commitid for coalescing commits
        * Further coalescing options? (e.g. small logfile differences)
        * Proper branching support in multi-file export
        * Optimize memory usage by discarding unneeded text
=end

require 'pp'
require 'set'

class NoBranchSupport < NotImplementedError ; end

# Integer#odd? was introduced in Ruby 1.8.7, backport it to
# older versions
unless 2.respond_to? :odd?
        class Integer
                def odd?
                        self % 2 == 1
                end
        end
end

# Set standard output to binary mode: git fast-import doesn't like Windows
# line-endings, and this ensures that the line termination will be a simple 0x0a
# on Windows too (it expands to 0x0D 0x0A otherwise).
STDOUT.binmode

=begin
RCS fast-export version: set to `git` in the repository, but can be overridden
by packagers, e.g. based on the latest tag, git description, custom packager
patches or whatever.

When the version is set to `git`, we make a little effort to find more information
about which commit we are at.
=end

RFE_VERSION="git"

def version
        if RFE_VERSION == "git"
                nolinkfile = File.readlink(__FILE__) rescue __FILE__
                Dir.chdir File.expand_path File.dirname nolinkfile

                if File.exists? '.git' ; begin
                        git_out = `git log -1 --pretty="%h %H%n%ai" | git name-rev --stdin`.split("\n")
                        hash=git_out.first.split.first
                        branch=git_out.first.split('(').last.chomp(')')
                        date=git_out.last.split.first
                        changed=`git diff --no-ext-diff --quiet --exit-code`
                        branch << "*" unless $?.success?
                        info=" [#{branch}] #{hash} (#{date})"
                rescue
                        info=" (no info)"
                end ; end

                STDERR.puts "#{$0}: RCS fast-export, #{RFE_VERSION} version#{info}"
        else
                STDERR.puts "#{$0}: RCS fast-export, version #{RFE_VERSION}"
        end
end

def usage
        STDERR.puts <<EOM
#{$0} [options] file [file ...]

Fast-export the RCS history of one or more files. If a directory is specified,
all RCS-tracked files in the directory and its descendants are exported.

When importing single files, their pathname is discarded during import. When
importing directories, only the specified directory component is discarded.

When importing a single file, RCS commits are converted one by one. Otherwise,
some heuristics is used to determine how to coalesce commits touching different
files.

Currently, commits are coalesced if they share the exact same log and if their
date differs by no more than the user-specified fuzziness. Additionally, the
symbols in one of the commit must be a subset of the symbols in the other
commit, unless --no-symbol-check is specified or rcs.symbolCheck is set to
false in the git configuration.

Typical usage:
    git init && rcs-fast-export.rb . | git fast-import && git reset

Options:
        --help, -h, -?          display this help text
        --authors-file, -A      specify a file containing username = Full Name <email> mappings
        --rcs-commit-fuzz       fuzziness in RCS commits to be considered a single one when
                                importing multiple files
                                (in seconds, defaults to 300, i.e. 5 minutes)
        --[no-]symbol-check     [do not] check symbols when coalescing commits
        --[no-]tag-each-rev     [do not] create a lightweight tag for each RCS revision when
                                importing a single file
        --[no-]log-filename     [do not] prepend the filename to the commit log when importing
                                a single file
        --skip-branches         when exporting multiple files with a branched history, export
                                the main branch only instead of aborting due to the lack of
                                support for branched multi-file history export



Config options:
        rcs.authorsFile         for --authors-file
        rcs.tagEachRev          for --tag-each-rev
        rcs.logFilename         for --log-filename
        rcs.commitFuzz          for --rcs-commit-fuzz
        rcs.symbolCheck         for --rcs-symbol-check
        rcs.tagFuzz             for --rcs-tag-fuzz

EOM
end

def not_found(arg)
        STDERR.puts "Could not find #{arg}"
end

# returns a hash that maps usernames to author names & emails
def load_authors_file(fn)
        hash = {}
        begin
                File.open(File.expand_path(fn)) do |io|
                        io.each_line do |line|
                                uname, author = line.split('=', 2)
                                uname.strip!
                                author.strip!
                                STDERR.puts "Username #{uname} redefined to #{author}" if hash.has_key? uname
                                hash[uname] = author
                        end
                end
        rescue
                not_found(fn)
        end
        return hash
end

# display a message about a (recoverable) error
def alert(msg, action)
        STDERR.puts "ERROR:\t#{msg}"
        STDERR.puts "\t#{action}"
end

class Time
        def Time.rcs(string)
                fields = string.split('.')
                raise ArgumentError, "wrong number of fields for RCS date #{string}" unless fields.length == 6
                # in Ruby 1.9, '99' is interpreted as year 99, not year 1999
                if fields.first.length < 3
                        fields.first.insert 0, '19'
                end
                Time.utc(*fields)
        end
end

module RCS
        # strip an optional final ;
        def RCS.clean(arg)
                arg.chomp(';')
        end

        # strip the first and last @, and de-double @@s
        def RCS.sanitize(arg)
                case arg
                when Array
                        ret = arg.dup
                        raise 'malformed first line' unless ret.first[0,1] == '@'
                        raise 'malformed last line' unless ret.last[-1,1] == '@'
                        ret.first.sub!(/^@/,'')
                        ret.last.sub!(/@$/,'')
                        ret.map { |l| l.gsub('@@','@') }
                when String
                        arg.chomp('@').sub(/^@/,'').gsub('@@','@')
                else
                        raise
                end
        end

        # clean and sanitize
        def RCS.at_clean(arg)
                RCS.sanitize RCS.clean(arg)
        end

        def RCS.mark(key)
                @@marks ||= {}
                if @@marks.key? key
                        @@marks[key]
                else
                        @@marks[key] = @@marks.length + 1
                end
        end

        def RCS.blob(file, rev)
                RCS.mark([file, rev])
        end

        def RCS.commit(commit)
                RCS.mark(commit)
        end

        class File
                attr_accessor :head, :comment, :desc, :revision, :fname, :mode
                def initialize(fname, executable)
                        @fname = fname.dup
                        @head = nil
                        @comment = nil
                        @desc = []
                        @revision = Hash.new { |h, r| h[r] = Revision.new(self, r) }
                        @mode = executable ? '755' : '644'
                end

                def has_revision?(rev)
                        @revision.has_key?(rev) and not @revision[rev].author.nil?
                end

                def export_commits(opts={})
                        counter = 0
                        exported = []
                        until @revision.empty?
                                counter += 1

                                # a string sort is a very good candidate for
                                # export order, getting a miss only for
                                # multi-digit revision components
                                keys = @revision.keys.sort

                                STDERR.puts "commit export loop ##{counter}"
                                STDERR.puts "\t#{exported.length} commits exported so far: #{exported.join(', ')}" unless exported.empty?
                                STDERR.puts "\t#{keys.size} to export: #{keys.join(', ')}"

                                keys.each do |key|
                                        rev = @revision[key]
                                        # the parent commit is rev.next if we're on the
                                        # master branch (rev.branch is nil) or
                                        # rev.diff_base otherwise
                                        from = rev.branch.nil? ? rev.next : rev.diff_base
                                        # A commit can only be exported if it has no
                                        # parent, or if the parent has been exported
                                        # already. Skip this commit otherwise
                                        if from and not exported.include? from
                                                next
                                        end

                                        branch = rev.branch || 'master'
                                        author = opts[:authors][rev.author] || "#{rev.author} <empty>"
                                        date = "#{rev.date.tv_sec} +0000"
                                        log = String.new
                                        if opts[:log_filename]
                                                log << @fname << ": "
                                        end
                                        log << rev.log.join

                                        puts "commit refs/heads/#{branch}"
                                        puts "mark :#{RCS.commit key}"
                                        puts "committer #{author} #{date}"
                                        puts "data #{log.length}"
                                        puts log unless log.empty?
                                        puts "from :#{RCS.commit from}" if from
                                        puts "M #{@mode} :#{RCS.blob @fname, key} #{@fname}"

                                        # TODO FIXME this *should* be safe, in
                                        # that it should not unduly move
                                        # branches back in time, but I'm not
                                        # 100% sure ...
                                        rev.branches.each do |sym|
                                                puts "reset refs/heads/#{sym}"
                                                puts "from :#{RCS.commit key}"
                                        end
                                        rev.symbols.each do |sym|
                                                puts "reset refs/tags/#{sym}"
                                                puts "from :#{RCS.commit key}"
                                        end
                                        if opts[:tag_each_rev]
                                                puts "reset refs/tags/#{key}"
                                                puts "from :#{RCS.commit key}"
                                        end

                                        exported.push key
                                end
                                exported.each { |k| @revision.delete(k) }
                        end
                end
        end

        class Revision
                attr_accessor :rev, :author, :state, :next
                attr_accessor :branches, :log, :text, :symbols
                attr_accessor :branch, :diff_base, :branch_point
                attr_reader   :date
                def initialize(file, rev)
                        @file = file
                        @rev = rev
                        @author = nil
                        @date = nil
                        @state = nil
                        @next = nil
                        @branches = Set.new
                        @branch = nil
                        @branch_point = nil
                        @diff_base = nil
                        @log = []
                        @text = []
                        @symbols = Set.new
                end

                def date=(str)
                        @date = Time.rcs(str)
                end

                def blob
                        str = @text.join('')
                        ret = "blob\nmark :#{RCS.blob @file.fname, @rev}\ndata #{str.length}\n#{str}\n"
                        ret
                end
        end

        def RCS.parse(fname, rcsfile)
                rcs = RCS::File.new(fname, ::File.executable?(rcsfile))

                ::File.open(rcsfile, 'r:ASCII-8BIT') do |file|
                        status = [:basic]
                        rev = nil
                        lines = []
                        difflines = []
                        file.each_line do |line|
                                case status.last
                                when :basic
                                        command, args = line.split($;,2)
                                        next if command.empty?

                                        if command.chomp!(';')
                                                STDERR.puts "Skipping empty command #{command.inspect}" if $DEBUG
                                                next
                                        end

                                        case command
                                        when 'head'
                                                rcs.head = RCS.clean(args.chomp)
                                        when 'symbols'
                                                status.push :symbols
                                                next if args.empty?
                                                line = args; redo
                                        when 'comment'
                                                rcs.comment = RCS.at_clean(args.chomp)
                                        when /^[0-9.]+$/
                                                rev = command.dup
                                                if rcs.has_revision?(rev)
                                                        status.push :revision_data
                                                else
                                                        status.push :new_revision
                                                end
                                        when 'desc'
                                                status.push :desc
                                                lines.clear
                                                status.push :read_lines
                                        when 'branch', 'access', 'locks', 'expand'
                                                STDERR.puts "Skipping unhandled command #{command.inspect}" if $DEBUG
                                                status.push :skipping_lines
                                                next if args.empty?
                                                line = args; redo
                                        else
                                                raise "Unknown command #{command.inspect}"
                                        end
                                when :skipping_lines
                                        status.pop if line.strip.chomp!(';')
                                when :symbols
                                        # we can have multiple symbols per line
                                        pairs = line.strip.split($;)
                                        pairs.each do |pair|
                                                sym, rev = pair.strip.split(':',2);
                                                if rev
                                                        status.pop if rev.chomp!(';')
                                                        rcs.revision[rev].symbols << sym
                                                else
                                                        status.pop
                                                end
                                        end
                                when :desc
                                        rcs.desc.replace lines.dup
                                        status.pop
                                when :read_lines
                                        # we sanitize lines as we read them

                                        actual_line = line.dup

                                        # the first line must begin with a @, which we strip
                                        if lines.empty?
                                                ats = line.match(/^@+/)
                                                raise 'malformed line' unless ats
                                                actual_line.replace line.sub(/^@/,'')
                                        end

                                        # if the line ends with an ODD number of @, it's the
                                        # last line -- we work on actual_line so that content
                                        # such as @\n or @ work correctly (they would be
                                        # encoded respectively as ['@@@\n','@\n'] and
                                        # ['@@@@\n']
                                        ats = actual_line.chomp.match(/@+$/)
                                        if nomore = (ats && Regexp.last_match(0).length.odd?)
                                                actual_line.replace actual_line.chomp.sub(/@$/,'')
                                        end
                                        lines << actual_line.gsub('@@','@')
                                        if nomore
                                                status.pop
                                                redo
                                        end
                                when :new_revision
                                        case line.chomp
                                        when /^date\s+(\S+);\s+author\s+(\S+);\s+state\s+(\S+);$/
                                                rcs.revision[rev].date = $1
                                                rcs.revision[rev].author = $2
                                                rcs.revision[rev].state = $3
                                        when /^branches\s*;/
                                                next
                                        when /^branches(?:\s+|$)/
                                                status.push :branches
                                                if line.index(';')
                                                        line = line.sub(/^branches\s+/,'')
                                                        redo
                                                end
                                        when /^next\s+(\S+)?;$/
                                                nxt = rcs.revision[rev].next = $1
                                                next unless nxt
                                                raise "multiple diff_bases for #{nxt}" unless rcs.revision[nxt].diff_base.nil?
                                                rcs.revision[nxt].diff_base = rev
                                                rcs.revision[nxt].branch = rcs.revision[rev].branch
                                        else
                                                status.pop
                                        end
                                when :branches
                                        candidate = line.split(';',2)
                                        candidate.first.strip.split.each do |branch|
                                                raise "multiple diff_bases for #{branch}" unless rcs.revision[branch].diff_base.nil?
                                                rcs.revision[branch].diff_base = rev
                                                # we drop the last number from the branch name
                                                rcs.revision[branch].branch = branch.sub(/\.\d+$/,'.x')
                                                rcs.revision[branch].branch_point = rev
                                        end
                                        status.pop if candidate.length > 1
                                when :revision_data
                                        case line.chomp
                                        when 'log'
                                                status.push :log
                                                lines.clear
                                                status.push :read_lines
                                        when 'text'
                                                if rev == rcs.head
                                                        status.push :head
                                                else
                                                        status.push :diff
                                                end
                                                lines.clear
                                                status.push :read_lines
                                        else
                                                status.pop
                                        end
                                when :log
                                        rcs.revision[rev].log.replace lines.dup
                                        status.pop
                                when :head
                                        rcs.revision[rev].text.replace lines.dup
                                        puts rcs.revision[rev].blob
                                        status.pop
                                when :diff
                                        difflines.replace lines.dup
                                        difflines.pop if difflines.last.empty?
                                        if difflines.first.chomp.empty?
                                                alert "malformed diff: empty initial line @ #{rcsfile}:#{file.lineno-difflines.length-1}", "skipping"
                                                difflines.shift
                                        end unless difflines.empty?
                                        base = rcs.revision[rev].diff_base
                                        unless rcs.revision[base].text
                                                pp rcs
                                                puts rev, base
                                                raise 'no diff base!'
                                        end
                                        # deep copy
                                        buffer = []
                                        rcs.revision[base].text.each { |l| buffer << [l.dup] }

                                        adding = false
                                        index = nil
                                        count = nil

                                        while l = difflines.shift
                                                if adding
                                                        raise 'negative index during insertion' if index < 0
                                                        raise 'negative count during insertion' if count < 0
                                                        adding << l
                                                        count -= 1
                                                        # collected all the lines, put the before
                                                        unless count > 0
                                                                unless buffer[index]
                                                                        buffer[index] = []
                                                                end
                                                                buffer[index].unshift(*adding)
                                                                adding = false
                                                        end
                                                        next
                                                end

                                                l.chomp!
                                                raise "malformed diff @ #{rcsfile}:#{file.lineno-difflines.length-1} `#{l}`" unless l =~ /^([ad])(\d+) (\d+)$/
                                                diff_cmd = $1.intern
                                                index = $2.to_i
                                                count = $3.to_i
                                                case diff_cmd
                                                when :d
                                                        # for deletion, index 1 is the first index, so the Ruby
                                                        # index is one less than the diff one
                                                        index -= 1
                                                        # we replace them with empty string so that 'a' commands
                                                        # referring to the same line work properly
                                                        while count > 0
                                                                buffer[index].clear
                                                                index += 1
                                                                count -= 1
                                                        end
                                                when :a
                                                        # addition will prepend the appropriate lines
                                                        # to the given index, and in this case Ruby
                                                        # and diff indices are the same
                                                        adding = []
                                                end
                                        end

                                        # turn the buffer into an array of lines, deleting the empty ones
                                        buffer.delete_if { |l| l.empty? }
                                        buffer.flatten!

                                        rcs.revision[rev].text = buffer
                                        puts rcs.revision[rev].blob
                                        status.pop
                                else
                                        raise "Unknown status #{status.last}"
                                end
                        end
                end

                # clean up the symbols/branches: look for revisions that have
                # one or more symbols but no dates, and make them into
                # branches, pointing to the highest commit with that key
                branches = []
                keys = rcs.revision.keys
                rcs.revision.each do |key, rev|
                        if rev.date.nil? and not rev.symbols.empty?
                                top = keys.select { |k| k.match(/^#{key}\./) }.sort.last
                                tr = rcs.revision[top]
                                raise "unhandled complex branch structure met: #{rev.inspect} refers #{tr.inspect}" if tr.date.nil?
                                tr.branches |= rev.symbols
                                branches << key
                        end
                end
                branches.each { |k| rcs.revision.delete k }

                return rcs
        end

        class Tree
                def initialize(commit)
                        @commit = commit
                        @files = Hash.new
                end

                def merge!(tree)
                        testfiles = @files.dup
                        tree.each { |rcs, rev| self.add(rcs, rev, testfiles) }
                        # the next line is only reached if all the adds were
                        # successful, so the merge is atomic
                        @files.replace testfiles
                end

                def add(rcs, rev, file_list=@files)
                        if file_list.key? rcs
                                prev = file_list[rcs]
                                if prev.log == rev.log
                                        str = "re-adding existing file #{rcs.fname} (old: #{prev.rev}, new: #{rev.rev})"
                                else
                                        str = "re-adding existing file #{rcs.fname} (old: #{[prev.rev, prev.log.to_s].inspect}, new: #{[rev.rev, rev.log.to_s].inspect})"
                                end
                                if prev.text != rev.text
                                        raise str
                                else
                                        @commit.warn_about str
                                end
                        end
                        file_list[rcs] = rev
                end

                def each &block
                        @files.each &block
                end

                def to_a
                        files = []
                        @files.map do |rcs, rev|
                                if rev.state.downcase == "dead"
                                        files << "D #{rcs.fname}"
                                else
                                        files << "M #{rcs.mode} :#{RCS.blob rcs.fname, rev.rev} #{rcs.fname}"
                                end
                        end
                        files
                end

                def filenames
                        @files.map { |rcs, rev| rcs.fname }
                end

                def to_s
                        self.to_a.join("\n")
                end
        end

        class Commit
                attr_accessor :date, :log, :symbols, :author, :branch
                attr_accessor :tree
                attr_accessor :min_date, :max_date
                def initialize(rcs, rev)
                        raise NoBranchSupport if rev.branch
                        self.date = rev.date.dup
                        self.min_date = self.max_date = self.date
                        self.log = rev.log.dup
                        self.symbols = rev.symbols.dup
                        self.author = rev.author
                        self.branch = rev.branch

                        self.tree = Tree.new self
                        self.tree.add rcs, rev
                end

                def to_a
                        [self.min_date, self.date, self.max_date, self.branch, self.symbols, self.author, self.log, self.tree.to_a]
                end

                def warn_about(str)
                        warn str + " for commit on #{self.date}"
                end

                # Sort by date and then by number of symbols
                def <=>(other)
                        ds = self.date <=> other.date
                        if ds != 0
                                return ds
                        else
                                return self.symbols.length <=> other.symbols.length
                        end
                end

                def merge!(commit)
                        self.tree.merge! commit.tree
                        if commit.max_date > self.max_date
                                self.max_date = commit.max_date
                        end
                        if commit.min_date < self.min_date
                                self.min_date = commit.min_date
                        end
                        self.symbols.merge commit.symbols
                end

                def export(opts={})
                        xbranch = self.branch || 'master'
                        xauthor = opts[:authors][self.author] || "#{self.author} <empty>"
                        xlog = self.log.join
                        numdate = self.date.tv_sec
                        xdate = "#{numdate} +0000"
                        key = numdate.to_s

                        puts "commit refs/heads/#{xbranch}"
                        puts "mark :#{RCS.commit key}"
                        puts "committer #{xauthor} #{xdate}"
                        puts "data #{xlog.length}"
                        puts xlog unless xlog.empty?
                        # TODO branching support for multi-file export
                        # puts "from :#{RCS.commit from}" if self.branch_point
                        puts self.tree.to_s

                        # TODO branching support for multi-file export
                        # rev.branches.each do |sym|
                        #       puts "reset refs/heads/#{sym}"
                        #       puts "from :#{RCS.commit key}"
                        # end

                        self.symbols.each do |sym|
                                puts "reset refs/tags/#{sym}"
                                puts "from :#{RCS.commit key}"
                        end

                end
        end
end

require 'getoptlong'

opts = GetoptLong.new(
        # Authors file, like git-svn and git-cvsimport, more than one can be
        # specified
        ['--authors-file', '-A', GetoptLong::REQUIRED_ARGUMENT],
        # RCS file suffix, like RCS
        ['--rcs-suffixes', '-x', GetoptLong::REQUIRED_ARGUMENT],
        # Date fuzziness for commits to be considered the same (in seconds)
        ['--rcs-commit-fuzz', GetoptLong::REQUIRED_ARGUMENT],
        # check symbols when coalescing?
        ['--symbol-check', GetoptLong::NO_ARGUMENT],
        ['--no-symbol-check', GetoptLong::NO_ARGUMENT],
        # tag each revision?
        ['--tag-each-rev', GetoptLong::NO_ARGUMENT],
        ['--no-tag-each-rev', GetoptLong::NO_ARGUMENT],
        # prepend filenames to commit logs?
        ['--log-filename', GetoptLong::NO_ARGUMENT],
        ['--no-log-filename', GetoptLong::NO_ARGUMENT],
        # skip branches when exporting a whole tree?
        ['--skip-branches', GetoptLong::NO_ARGUMENT],
        # show current version
        ['--version', '-v', GetoptLong::NO_ARGUMENT],
        # show help/usage
        ['--help', '-h', '-?', GetoptLong::NO_ARGUMENT]
)

# We read options in order, but they apply to all passed parameters.
# TODO maybe they should only apply to the following, unless there's only one
# file?
opts.ordering = GetoptLong::RETURN_IN_ORDER

file_list = []
parse_options = {
        :authors => Hash.new,
        :commit_fuzz => 300,
        :tag_fuzz => -1,
}

# Read config options
`git config --get-all rcs.authorsfile`.each_line do |fn|
        parse_options[:authors].merge! load_authors_file(fn.chomp)
end

parse_options[:tag_each_rev] = (
        `git config --bool rcs.tageachrev`.chomp == 'true'
) ? true : false

parse_options[:log_filename] = (
        `git config --bool rcs.logfilename`.chomp == 'true'
) ? true : false

fuzz = `git config --int rcs.commitFuzz`.chomp
parse_options[:commit_fuzz] = fuzz.to_i unless fuzz.empty?

fuzz = `git config --int rcs.tagFuzz`.chomp
parse_options[:tag_fuzz] = fuzz.to_i unless fuzz.empty?

parse_options[:symbol_check] = (
        `git config --bool rcs.symbolcheck`.chomp == 'false'
) ? false : true

opts.each do |opt, arg|
        case opt
        when '--authors-file'
                authors = load_authors_file(arg)
                redef = parse_options[:authors].keys & authors.keys
                STDERR.puts "Authors file #{arg} redefines #{redef.join(', ')}" unless redef.empty?
                parse_options[:authors].merge!(authors)
        when '--rcs-suffixes'
                # TODO
        when '--rcs-commit-fuzz'
                parse_options[:commit_fuzz] = arg.to_i
        when '--rcs-tag-fuzz'
                parse_options[:tag_fuzz] = arg.to_i
        when '--symbol-check'
                parse_options[:symbol_check] = true
        when '--no-symbol-check'
                parse_options[:symbol_check] = false
        when '--tag-each-rev'
                parse_options[:tag_each_rev] = true
        when '--no-tag-each-rev'
                # this is the default, which is fine since the missing key
                # (default) returns nil which is false in Ruby
                parse_options[:tag_each_rev] = false
        when '--log-filename'
                parse_options[:log_filename] = true
        when '--no-log-filename'
                # this is the default, which is fine since the missing key
                # (default) returns nil which is false in Ruby
                parse_options[:log_filename] = false
        when '--skip-branches'
                parse_options[:skip_branches] = true
        when ''
                file_list << arg
        when '--version'
                version
                exit
        when '--help'
                usage
                exit
        end
end

if parse_options[:tag_fuzz] < parse_options[:commit_fuzz]
        parse_options[:tag_fuzz] = parse_options[:commit_fuzz]
end

require 'etc'

user = Etc.getlogin || ENV['USER']

# steal username/email data from other init files that may contain the
# information
def steal_username
        [
                # the user's .hgrc file for a username field
                ['~/.hgrc',   /^\s*username\s*=\s*(["'])?(.*)\1$/,       2],
                # the user's .(g)vimrc for a changelog_username setting
                ['~/.vimrc',  /changelog_username\s*=\s*(["'])?(.*)\1$/, 2],
                ['~/.gvimrc', /changelog_username\s*=\s*(["'])?(.*)\1$/, 2],
        ].each do |fn, rx, idx|
                file = File.expand_path fn
                if File.readable?(file) and File.read(file) =~ rx
                        parse_options[:authors][user] = Regexp.last_match(idx).strip
                        break
                end
        end
end

if user and not user.empty? and not parse_options[:authors].has_key?(user)
        name = ENV['GIT_AUTHOR_NAME'] || ''
        name.replace(`git config user.name`.chomp) if name.empty?
        name.replace(Etc.getpwnam(user).gecos) if name.empty?

        if name.empty?
                # couldn't find a name, try to steal data from other sources
                steal_username
        else
                # if we found a name, try to find an email too
                email = ENV['GIT_AUTHOR_EMAIL'] || ''
                email.replace(`git config user.email`.chomp) if email.empty?

                if email.empty?
                        # couldn't find an email, try to steal data too
                        steal_username
                else
                        # we got both a name and email, fill the info
                        parse_options[:authors][user] = "#{name} <#{email}>"
                end
        end
end

if file_list.empty?
        usage
        exit 1
end

SFX = ',v'

status = 0

rcs = []
file_list.each do |arg|
        case ftype = File.ftype(arg)
        when 'file'
                if arg[-2,2] == SFX
                        if File.exists? arg
                                rcsfile = arg.dup
                        else
                                not_found "RCS file #{arg}"
                                status |= 1
                        end
                        filename = File.basename(arg, SFX)
                else
                        filename = File.basename(arg)
                        path = File.dirname(arg)
                        rcsfile = File.join(path, 'RCS', filename) + SFX
                        unless File.exists? rcsfile
                                rcsfile.replace File.join(path, filename) + SFX
                                unless File.exists? rcsfile
                                        not_found "RCS file for #{filename} in #{path}"
                                end
                        end
                end
                rcs << RCS.parse(filename, rcsfile)
        when 'directory'
                argdirname = arg.chomp(File::SEPARATOR)
                pattern = File.join(argdirname, '**', '*' + SFX)
                Dir.glob(pattern, File::FNM_DOTMATCH).each do |rcsfile|
                        filename = File.basename(rcsfile, SFX)
                        path = File.dirname(rcsfile)
                        # strip trailing "/RCS" if present, or "RCS" if that's
                        # the full path
                        path.sub!(/(^|#{File::SEPARATOR})RCS$/, '')
                        # strip off the portion of the path specified
                        # on the command line from the front of the path
                        # (or delete the path completely if it is the same
                        # as the specified directory)
                        path.sub!(/^#{Regexp.escape argdirname}(#{File::SEPARATOR}|$)/, '')
                        filename = File.join(path, filename) unless path.empty?
                        begin
                                rcs << RCS.parse(filename, rcsfile)
                        rescue Exception => e
                                STDERR.puts "Failed to parse #{filename} @ #{rcsfile}:#{$.}"
                                raise e
                        end
                end
        else
                STDERR.puts "Cannot handle #{arg} of #{ftype} type"
                status |= 1
        end
end

if rcs.length == 1
        rcs.first.export_commits(parse_options)
else
        STDERR.puts "Preparing commits"

        commits = []

        rcs.each do |r|
                r.revision.each do |k, rev|
                        begin
                                commits << RCS::Commit.new(r, rev)
                        rescue NoBranchSupport
                                if parse_options[:skip_branches]
                                        STDERR.puts "Skipping revision #{rev.rev} for #{r.fname} (branch)"
                                else raise
                                end
                        end
                end
        end

        STDERR.puts "Sorting by date"

        commits.sort!

        if $DEBUG
                STDERR.puts "RAW commits (#{commits.length}):"
                commits.each do |c|
                        PP.pp c.to_a, $stderr
                end
        else
                STDERR.puts "#{commits.length} single-file commits"
        end

        STDERR.puts "Coalescing [1] by date with fuzz #{parse_options[:commit_fuzz]}"

        thisindex = commits.size
        commits.reverse_each do |c|
                nextindex = thisindex
                thisindex -= 1

                cfiles = Set.new c.tree.filenames
                ofiles = Set.new

                mergeable = []

                # test for mergeable commits by looking at following commits
                while nextindex < commits.size
                        k = commits[nextindex]
                        nextindex += 1

                        # commits are date-sorted, so we know we can quit early if we are too far
                        # for coalescing to work
                        break if k.min_date > c.max_date + parse_options[:commit_fuzz]

                        skipthis = false

                        kfiles = Set.new k.tree.filenames

                        if c.log != k.log or c.author != k.author or c.branch != k.branch
                                skipthis = true
                        end

                        unless c.symbols.subset?(k.symbols) or k.symbols.subset?(c.symbols)
                                cflist = cfiles.to_a.join(', ')
                                kflist = kfiles.to_a.join(', ')
                                if parse_options[:symbol_check]
                                        STDERR.puts "Not coalescing #{c.log.inspect}\n\tfor (#{cflist})\n\tand (#{kflist})"
                                        STDERR.puts "\tbecause their symbols disagree:\n\t#{c.symbols.to_a.inspect} and #{k.symbols.to_a.inspect} disagree on #{(c.symbols ^ k.symbols).to_a.inspect}"
                                        STDERR.puts "\tretry with the --no-symbol-check option if you want to merge these commits anyway"
                                        skipthis = true
                                elsif $DEBUG
                                        STDERR.puts "Coalescing #{c.log.inspect}\n\tfor (#{cflist})\n\tand (#{kflist})"
                                        STDERR.puts "\twith disagreeing symbols:\n\t#{c.symbols.to_a.inspect} and #{k.symbols.to_a.inspect} disagree on #{(c.symbols ^ k.symbols).to_a.inspect}"
                                end
                        end

                        # keep track of filenames touched by commits we are not merging with,
                        # since we don't want to merge with commits that touch them, to preserve
                        # the monotonicity of history for each file
                        # TODO we could forward-merge with them, unless some of our files were
                        # touched too.
                        if skipthis
                                # if the candidate touches any file already in the commit,
                                # we can stop looking forward
                                break unless cfiles.intersection(kfiles).empty?
                                ofiles |= kfiles
                                next
                        end

                        # the candidate has the same log, author, branch and appropriate symbols
                        # does it touch anything in ofiles?
                        unless ofiles.intersection(kfiles).empty?
                                if $DEBUG
                                        cflist = cfiles.to_a.join(', ')
                                        kflist = kfiles.to_a.join(', ')
                                        oflist = ofiles.to_a.join(', ')
                                        STDERR.puts "Not coalescing #{c.log.inspect}\n\tfor (#{cflist})\n\tand (#{kflist})"
                                        STDERR.puts "\tbecause the latter intersects #{oflist} in #{(ofiles & kfiles).to_a.inspect}"
                                end
                                next
                        end

                        mergeable << k
                end

                mergeable.each do |k|
                        begin
                                c.merge! k
                        rescue RuntimeError => err
                                fuzz = c.date - k.date
                                STDERR.puts "Fuzzy commit coalescing failed: #{err}"
                                STDERR.puts "\tretry with commit fuzz < #{fuzz} if you don't want to see this message"
                                break
                        end
                        commits.delete k
                end
        end

        if $DEBUG
                STDERR.puts "[1] commits (#{commits.length}):"
                commits.each do |c|
                        PP.pp c.to_a, $stderr
                end
        else
                STDERR.puts "#{commits.length} coalesced commits"
        end

        commits.each { |c| c.export(parse_options) }

end

exit status