#
# Migrate SVN (subversion) repositories (or parts of it) to OpenCM projects.
#
# You have to create an OpenCM project that is used as target, prior of using
# this script (cm create project proj-name).  Then, use this project name as
# --cm-project argument. 
#
# USE AT YOUR OWN RISK! NO WARRANTIES! MAKE BACKUPS!
#
#
# Copyright (C) 2003 by Michael Neumann (mneumann@ntecs.de)
#
# Requires: Ruby >= 1.8
#

raise "Ruby version >= 1.8 required!" unless RUBY_VERSION >= '1.8' 

require "rexml/document"
require "find"
require "getoptlong"

def usage
  STDERR.print <<EOF
usage: #{$0} ... 

  --cm-repository=file:/path/to/cm/repository (or opencm://...)
  --cm-user=OpenCM username (e.g. mneumann)  
  --cm-project=OpenCM project name (project must exist!)
  --svn-url=file:///path/to/repos/path/to/project
EOF
end

class String
  def annotate(pref)
    map{|l| pref + ": " + l}.join
  end
end

begin
GetoptLong.new(
  ["--cm-repository", GetoptLong::REQUIRED_ARGUMENT],
  ["--cm-user", GetoptLong::REQUIRED_ARGUMENT],
  ["--cm-project", GetoptLong::REQUIRED_ARGUMENT],
  ["--svn-url", GetoptLong::REQUIRED_ARGUMENT]
).each_option do |name, arg|
  STDOUT << (name + "=" + arg + "\n").annotate("ARGS")
  case name
  when "--cm-repository"
    CM_REPOS = arg
  when "--cm-user"
    CM_USER = arg
  when "--cm-project"
    CM_PROJECT = arg
  when "--svn-url"
    SVN_REPOS = arg
  else
    usage
    exit(1)
  end
end
rescue
  usage
  exit(1)
end

unless defined?(CM_REPOS) && defined?(CM_USER) && 
  defined?(CM_PROJECT) && defined?(SVN_REPOS) then
  usage
  exit(1)
end

STDOUT << (Time.now.to_s + "\n").annotate("START-TIME")

def mktemp(prefix, type=:file, auto_remove=true, &block)
  cmd = "mktemp -q -t #{ prefix } "
  case type
  when :file
  when :dir
    cmd << '-d'
  else
    raise ArgumentError
  end

  tmp = `#{ cmd }`.chomp
  raise "mktemp failed" if $? != 0 

  if block.nil?
    at_exit { `rm -rf #{ tmp }` } if auto_remove
    return tmp
  else
    begin
      block.call(tmp)
    ensure
      # cleanup afterwards (delete tmp file/directory)
      `rm -rf #{ tmp }`
    end
    return nil
  end
end

def svn_parseLog(input)
  doc = REXML::Document.new(input)
  revs = []
  doc.elements.each("log/logentry") do |element|
    h = {}
    h['rev'] = element.attributes['revision']
    h['date'] = element.elements['date'].text.chomp
    h['msg'] = element.elements['msg'].text.chomp
    revs << h
  end
  return revs.reverse
end

def cm
  "cm --user #{ CM_USER } --repository #{ CM_REPOS }"
end

def iterate_CM_Workspace(workspace, action)
  Find.find(workspace) { |path|
    if File.directory? path
      if File.basename(path) =~ /^\.opencm/
        Find.prune
      else
        next
      end
    end
    Dir.chdir(File.dirname(path)) { 
      STDOUT << `#{ cm } #{ action } #{ File.basename(path) }`.annotate("CM")
      if action == 'rm' then
        STDOUT << `rm -f #{ File.basename(path) }`.annotate("SHELL")
      end
    }
  }
end

def iterate_SVN_Workspace(workspace, &block)
  Find.find(workspace) { |path|
    if File.basename(path) =~ /^\.svn/
      Find.prune
    else
      block.call(path)
    end
  }
end

def iterate_CM_Workspace2(workspace, &block)
  Find.find(workspace) { |path|
    if File.basename(path) =~ /^\.opencm/
      Find.prune
    else
      block.call(path)
    end
  }
end


CM_WORKSPACE = mktemp('cm-workspace', :dir)
CM_TMP_MSGFILE = mktemp('cm-msgfile', :file)
SVN_BASEDIR = mktemp('svn-base', :dir)
SVN_SUBDIR = SVN_REPOS.split("/").last

#
# create and parse SVN Logfile 
#

mktemp('svn-latest-tmp', :dir) {|t|
  Dir.chdir(t) {
    # checkout trunk version of SVN 
    STDOUT << `svn checkout #{ SVN_REPOS }`.annotate("SVN-TRUNK")
    Dir.chdir(SVN_SUBDIR) {
      mktemp('svn-log', :file) {|log|
        # generate XML SVN logfile
        STDOUT << `svn --xml log > #{ log }`.annotate("SVN-LOG")
        # parse SVN logfile
        $svn_revs = svn_parseLog(File.read(log))
      }
    }
  }
}

#
# check OpenCM project initially out
#
Dir.chdir(CM_WORKSPACE) {
  STDOUT << `#{ cm } checkout #{ CM_PROJECT }`.annotate("CM-CHECKOUT")
}

# for each SVN revision do
for rev in $svn_revs
  STDOUT << "-----------------------------\n"
  STDOUT << ("Revision (SVN): " + rev['rev'] + "\n")
  STDOUT << "-----------------------------\n"

  # remove all files from CM workspace
  iterate_CM_Workspace(CM_WORKSPACE, "rm")
  iterate_CM_Workspace2(CM_WORKSPACE) {|path|
    next if path == CM_WORKSPACE or path == CM_WORKSPACE + "/"
    `rm -rf #{ path }`.annotate("SHELL")
  }

  # checkout svn revision tree
  Dir.chdir(SVN_BASEDIR) {
    STDOUT << `rm -rf #{ SVN_SUBDIR }`.annotate("SHELL")
    STDOUT << `svn checkout --revision #{ rev['rev'] } #{ SVN_REPOS }`.
      annotate("SVN")

    Dir.chdir(SVN_SUBDIR) {
      # for each file (except .svn directories) do
      #   svn info $file | parse last_mod_date
      #   touch $file last_mod_date
      # end
      iterate_SVN_Workspace(Dir.pwd) {|path|
        date = `svn info #{ path }|grep "Last Changed Date"`
        if date =~ /(\d\d\d\d)-(\d\d)-(\d\d)\s+(\d\d):(\d\d):(\d\d)/
          date = $1 + $2 + $3 + $4 + $5 + "." + $6
        else
          raise "svn info | parse date error" 
        end
        STDOUT << `touch -t #{ date } "#{ path }"`.annotate("TOUCH")
      }

      # remove all .svn directories recursively 
      STDOUT << `find . -name ".svn" -type d | xargs rm -rf`.annotate("FIND-RM")

      # move all files from SVN workspace into OpenCM workspace
      STDOUT << `mv -f * #{ CM_WORKSPACE }`.annotate("SHELL")
    }
  }
  
  # add each file in OpenCM workspace to the OpenCM repos (cm add)
  iterate_CM_Workspace(CM_WORKSPACE, "add")

  # create temporary commit message file
  File.open(CM_TMP_MSGFILE, "w+") {|f|
    f << "svn-revison: #{ rev['rev'] }\n" 
    f << "svn-date: #{ rev['date'] }\n" 
    f << "\n"
    f << rev['msg']
  }

  STDOUT << `cat #{ CM_TMP_MSGFILE }`.annotate("COMMIT-MSG")
  STDOUT << "\n"

  # cm commit
  Dir.chdir(CM_WORKSPACE) {
    STDOUT << `cm --force-hash --messagefile #{ CM_TMP_MSGFILE } commit`.
      annotate("CM")
  }
end

STDOUT << (Time.now.to_s + "\n").annotate("FINISH-TIME")