perforce2svn 0.7.0

data/lib/perforce2svn/mapping/branch_mapping.rb

@@ -0,0 +1,32 @@
+require 'perforce2svn/errors'
+require 'perforce2svn/mapping/operation'
+
+module Perforce2Svn::Mapping
+  class BranchMapping < Operation
+    attr_reader :p4_path, :svn_path
+
+    def initialize(tok, p4_path, svn_path)
+      super(tok)
+      @p4_path = p4_path
+      @svn_path = svn_path
+      @path_match = /^#{@p4_path}/
+    end
+
+    def p4_dotted
+      @p4_path + '...'
+    end
+
+    def matches_perforce_path?(other_p4_path)
+      (other_p4_path =~ @path_match) != nil
+    end
+
+    def to_svn_path(other_p4_path)
+      opath = other_p4_path.gsub(p4_path, svn_path)
+      opath.gsub!("%40", "@")
+      opath.gsub!("%23", "#")
+      opath.gsub!("%2a", "*")
+      opath.gsub!("%25", "%")
+      opath
+    end
+  end
+end

data/lib/perforce2svn/mapping/commands.rb

@@ -0,0 +1,75 @@
+require 'perforce2svn/mapping/operation'
+
+module Perforce2Svn::Mapping
+  class Command < Operation
+    # Must be implemented by subclasses
+    def execute!(svn_txn)
+      raise Exception, "Not implemented"
+    end
+  end
+
+  class Copy < Command
+    attr_reader :svn_from, :svn_to
+    def initialize(tok,svn_from, svn_to)
+      super(tok)
+      @svn_from = svn_from
+      @svn_to = svn_to
+    end
+
+    def execute!(svn_txn)
+      svn_txn.copy(@svn_from, @svn_to)
+    end
+  end
+
+  class Mkdir < Command
+    attr_reader :svn_path
+    def initialize(tok, svn_path)
+      super(tok)
+      @svn_path = svn_path
+    end
+
+    def execute!(svn_txn)
+      svn_txn.mkdir(@svn_path)
+    end
+  end
+
+  class Move < Command
+    attr_reader :svn_from, :svn_to
+    def initialize(tok, svn_from, svn_to)
+      super(tok)
+      @svn_from = svn_from
+      @svn_to = svn_to
+    end
+
+    def execute!(svn_txn)
+      svn_txn.move(@svn_from, @svn_to)
+    end
+  end
+
+  class Update < Command
+    attr_reader :svn_path, :live_path
+    def initialize(tok, svn_path, live_path)
+      super(tok)
+      @svn_path = svn_path
+      @live_path = live_path
+    end
+
+    def execute!(svn_txn)
+      File.open(@live_path, 'r') do |fstream|
+        svn_txn.update(@svn_path, fstream)
+      end
+    end
+  end
+
+  class Delete < Command
+    attr_reader :svn_path
+    def initialize(tok, svn_path)
+      super(tok)
+      @svn_path = svn_path
+    end
+
+    def execute!(svn_txn)
+      svn_txn.delete(@svn_path)
+    end
+  end
+end

data/lib/perforce2svn/mapping/help.txt

@@ -0,0 +1,139 @@
+######################################################################
+# MAPPING FILE
+######################################################################
+#
+# This file has been colored for your convenience. Comments are in blue; 
+# commands in green.
+#
+# This is an example mapping file for describing a migration from Perforce 
+# into Subversion. Blank lines are ignored, and everything after the 
+# '#' character in a line is ignored.
+
+######################################################################
+# Migration Command
+#
+# There are several commands to be aware of, the most central of which is:
+migrate //depot/perforce/path  /trunk/absolute/path
+
+# As you can see, the migrate command takes 2 arguments: the path to migrate 
+# from and the path to migrate to.  It cannot handle individual files -- only 
+# directory structures. 
+#
+# Multiple migrate commands can be given in this file, mapping from Perforce
+# path to Subversion path. This is useful when migrating both 'trunk' and 
+# 'branches' inside a repository when a standard layout has not been supplied,
+# or for more significant code refactorings.
+#
+# Each part of the command is separated by spaces, and multiple spaces are 
+# ignored.
+#
+# Commands don't necessarily need to be on the same line.  If to continue a 
+# command on the next line, you can add a '\' character to the end of the 
+# line. So, the above command could have been  written:
+migrate //depot/perforce/path \
+        /trunk/absolute/path
+
+# If you have spaces in your path names, those spaces need to be escaped in a 
+# similar manner:
+migrate //depot/another\ path\ with/spaces \
+        /to\ a\ path/with/spaces
+
+######################################################################
+# Directives
+#
+# There are several directives, all of which are optional.
+
+## author
+# The first directive is 'author'. This directive informs the migration
+# that when the commands (discussed below) are committed to the repository,
+# the name of the author should be used.
+author gabe.mcarthur
+# Thus, when the log is scanned in the future in the SVN repository, this
+# will be the author of the commands. If no author is given, the system
+# will put in 'Perforce2Svn Migration Tool'
+
+## message
+# The next directive is like the first. It attaches the given log message
+# to the commit that occurs when the commands (discussed below) are 
+# executed.
+message This is a message about all of the cool things that will be \
+        will be done to the repository after the primary Perforce \
+        migration is complete. No need to worry about the multiple lines \
+        here, as long as the line is terminated with a '\' character.
+# If no message directive is given, the system supplies 'Perforce migration.'
+
+## svn-prefix
+# There is a special directive that you need to be aware of:
+svn-prefix /project/trunk
+
+# This directive informs the mapping system that every SVN path farther down 
+# in the file that don't start with a '/' character will have this path prefix
+# pre-pended.
+#
+# Paths that start with a '/' are considered absolute and will not be altered.
+#
+# Thus, given the previous directive, the following commands are now 
+# equivalent:
+migrate //depot/perforce/path /project/trunk/src/path
+migrate //depot/perforce/path                src/path
+
+# This feature is a convenience so that you don't have to type out the full 
+# path each time, which can become a hassle in a big migration.
+#
+# Note that you can call the 'svn-prefix' directive multiple times, and each 
+# relative SVN path that follows will have the directly preceeding directive 
+# take precedence.
+
+######################################################################
+# Additional Commands
+#
+# The 'migrate' command is obviously the most essential, but this tool 
+# provides several other convenience commands to help you migrate more 
+# complex directory structures.
+#
+# Each of these commands is pretty much the same as their SVN counterparts 
+# (with a few noted exceptions).
+
+## move
+# Moves paths internally within SVN after the migration:
+move original/svn/path.txt \
+     new/svn/path.txt
+
+## delete
+# Deletes paths internally after the migration:
+delete some/perforce/file/thats/no/longer/needed.sh
+
+## copy
+# Copies SVN paths, retaining their history within the tree after a 
+# migration
+copy /some/absolute/file.txt \
+     to/another/needed/location.txt
+
+## mkdir
+# Creates empty directories.  By default, directory structures are created for
+# you when you copy or move files, but this is occasionally useful when you 
+# want to set up the standard Subversion layout.
+mkdir /project/branches
+mkdir /project/tags
+
+## update
+# The 'update' command is a bit weird, as it will look at the 'live' sources that
+# you have edited externally and passed in via the '--live-path' flag.  
+# This migration tool will add the sources listed below that live path to the 
+# SVN repository. If the file doesn't exist in the Subversion repository, it
+# will be created.
+#
+# Obviously, this is an optional command, and if you don't need it, you don't 
+# need to supply the '--live-path' flag. If you have this directive, and the 
+# '--live-path' flag isn't present, the migration will fail and ask you for the 
+# live path
+#
+# The use case for this option lies in that not all migrations happen at once.
+# In particularly large refactorings, it may be necessary to update certain 
+# files that rely upon the new source control layout. This is a facility for
+# adding those files transparently at the end of a migration, so that you don't 
+# have to add them manually. The mapping analysis tool will flag if any addition
+# doesn't exist before the migration continues.
+update some/live/path/pom.xml
+update some/path/that/exists/in/live/and/in/svn/Klass.java
+

data/lib/perforce2svn/mapping/lexer.rb

@@ -0,0 +1,101 @@
+
+module Perforce2Svn
+  module Mapping
+    class Token
+      attr_reader :name, :args, :line_number
+
+      def initialize(name, args, line_number)
+        @name = name.gsub(/-/, '_')
+        @args = args
+        @line_number = line_number
+      end
+
+      def [](index)
+        @args[index]
+      end
+
+      def to_s
+        "{@(#{line_number}) name: #{name}; args: #{args.join(' ')} }"
+      end
+    end
+
+    class Lexer
+      def initialize(content)
+        @content = content
+      end
+      
+      # Yields each parsed line of the configuration
+      def each(&block)
+        if not block_given?
+          raise ArgumentError, "Requires a block"
+        end
+
+        lines = @content.readlines
+        i = 1
+        continues_from_previous = false
+        previous = []
+        
+        lines.each do |line|
+          parts= tokenize(line)
+
+          will_continue_on_next_line = false
+          if line =~ /\\\s*$/
+            will_continue_on_next_line = true
+          end
+
+          if parts.length > 0
+            if continues_from_previous
+              previous << parts
+            else
+              previous = []
+              name = parts.shift
+              yield Token.new(name, parts, i)
+            end
+          end
+
+          continues_from_previous = will_continue_on_next_line
+          i += 1
+        end
+      end
+
+      # Reads a line for all of the possible tokens
+      def tokenize(line)
+        chars = line.scan(/./)
+        parts = []
+        
+        part = ""
+        i = 0
+        while i < chars.length
+          current = chars[i]
+          if current == '\\'
+            nxt = chars[i + 1]
+            if nxt == ' '
+              i += 1
+              part << ' '
+            elsif nxt == "\n"
+              break
+            end
+          elsif current == ' '
+            if part.length > 0
+              parts << part
+              part = ""
+            end
+          elsif current == '#'
+            break
+          else
+            part << current
+          end
+
+          i += 1
+        end
+
+        if not parts[-1].eql?(part)
+          parts << part
+        end
+
+        parts.delete_if {|p| p =~ /^\s*$/}
+        parts
+      end
+    end
+  end
+end

data/lib/perforce2svn/mapping/mapping_file.rb

@@ -0,0 +1,65 @@
+require 'perforce2svn/logging'
+require 'perforce2svn/mapping/parser'
+require 'perforce2svn/mapping/analyzer'
+require 'choosy/terminal'
+require 'choosy/printing/color'
+
+module Perforce2Svn::Mapping
+  class MappingFile
+    
+    def self.help_file
+      map_file = File.join(File.dirname(__FILE__), 'help.txt')
+      contents = ""
+      color = Choosy::Printing::Color.new
+      File.open(map_file, 'r') do |file|
+        file.each_line do |line|
+          contents << if line =~ /^#/
+                        color.blue(line)
+                      elsif line =~ /^([\w-]+)(.*)/
+                        color.green($1) + $2 + "\n"
+                      else
+                        line
+                      end
+         end
+      end
+              
+      contents
+    end
+
+    attr_reader :mappings, :commands, :author, :message
+
+    def initialize(mapping_file, options)
+      load_mapping_file(mapping_file, options)
+      analyze(mapping_file)
+
+      if options[:analysis_only]
+        exit 0
+      end
+    end
+
+    private
+    def load_mapping_file(migration_file, options)
+      migration = nil
+      File.open(migration_file, 'r') do |file|
+        parser = Parser.new
+        migration = parser.parse!(file, options[:live_path])
+      end
+
+      if migration[:failed]
+        Choosy::Terminal.die "Parsing the mapping file failed"
+      end
+
+      @mappings = migration[:mappings]
+      @commands = migration[:commands]
+      @author = migration[:author]
+      @message = migration[:message]
+    end
+
+    def analyze(mapping_file)
+      analyzer = Analyzer.new(File.dirname(mapping_file))
+      if !analyzer.check(@commands) || !analyzer.check(@mappings)
+        Choosy::Terminal.die "Analysis of mapping file failed"
+      end
+    end
+  end
+end

data/lib/perforce2svn/mapping/operation.rb

@@ -0,0 +1,8 @@
+module Perforce2Svn::Mapping
+  class Operation
+    attr_reader :line_number
+    def initialize(tok)
+      @line_number = tok.line_number
+    end
+  end
+end

data/lib/perforce2svn/mapping/parser.rb

@@ -0,0 +1,145 @@
+require 'perforce2svn/logging'
+require 'perforce2svn/mapping/lexer'
+require 'perforce2svn/mapping/commands'
+require 'perforce2svn/mapping/branch_mapping'
+
+module Perforce2Svn::Mapping
+  class Parser
+    include Perforce2Svn::Logging
+
+    def parse!(content, live_path)
+      raise ArgumentError, "The content must respond to 'readlines'" unless content.respond_to? :readlines
+
+      live_path = live_path.dup
+      if !live_path.nil? && live_path !~ /\/$/
+        live_path << '/'
+      end
+
+      ctx = {
+        :failed => false, 
+        :commands => [], 
+        :mappings => [],
+        :svn_prefix => '',
+        :live_path => live_path,
+        :author => 'Perforce2Svn Migration Tool',
+        :message => 'Perforce Migration'
+      }
+
+      Lexer.new(content).each do |tok|
+        handle(tok, ctx)
+      end
+      ctx
+    end
+
+    private
+    def handle(tok, ctx)
+      if private_methods.include? tok.name
+        send(tok.name, tok, ctx)
+      else
+        log.error "(line: #{tok.line_number}) Unknown directive: '#{tok.name}'"
+        ctx[:failed] = true
+      end
+    end
+
+    def author(tok, ctx)
+      ctx[:author] = tok.args.join(' ')
+    end
+
+    def message(tok, ctx)
+      ctx[:message] = tok.args.join(' ')
+    end
+
+    def copy(tok, ctx)
+      return unless args_ok?(2, tok, ctx)
+      ctx[:commands] << Copy.new(tok, format_svn_path(tok, tok[0], ctx), format_svn_path(tok, tok[1], ctx))
+    end
+
+    def delete(tok, ctx)
+      return unless args_ok?(1, tok, ctx)
+      ctx[:commands] << Delete.new(tok, format_svn_path(tok, tok[0], ctx))
+    end
+
+    def mkdir(tok, ctx)
+      return unless args_ok?(1, tok, ctx)
+      ctx[:commands] << Mkdir.new(tok, format_svn_path(tok, tok[0], ctx))
+    end
+
+    def move(tok, ctx)
+      return unless args_ok?(2, tok, ctx)
+      ctx[:commands] << Move.new(tok, format_svn_path(tok, tok[0], ctx), format_svn_path(tok, tok[1], ctx))
+    end
+
+    def update(tok, ctx)
+      return unless args_ok?(1, tok, ctx)
+      ctx[:commands] << Update.new(tok, format_svn_path(tok, tok[0], ctx), format_live_path(tok, tok[0], ctx))
+    end
+
+    def migrate(tok, ctx)
+      return unless args_ok?(2, tok, ctx)
+      
+      p4_path = tok[0]
+      p4_path << '/' if not p4_path[-1].chr == '/'
+      svn_path = format_svn_path(tok, tok[1], ctx)
+      svn_path << '/' if not svn_path[-1].chr == '/'
+
+      if p4_path !~ %r|^//([^/]+/?)*$|
+        log.error "(line #{tok.line_number}) Perforce path was malformed: '#{p4_path}'"
+        ctx[:failed] = true
+      end
+
+      if svn_path !~ %r|^/([^/]+/?)*$|
+        log.error "(line #{tok.line_number}) Subversion path was malformed: '#{svn_path}'"
+        ctx[:failed] = true
+      end
+
+      ctx[:mappings] << BranchMapping.new(tok, p4_path, svn_path)
+    end
+
+    def svn_prefix(tok, ctx)
+      return unless args_ok?(1, tok, ctx)
+
+      svn_prefix = tok[0]
+      if svn_prefix !~ /^\//
+        log.error "(line: #{tok.line_number}) 'svn-prefix' directive must start with a '/'"
+        ctx[:failed] = true
+      elsif svn_prefix !~ /\/$/
+        svn_prefix << '/'
+      end
+
+      ctx[:svn_prefix] = svn_prefix
+    end
+
+    def args_ok?(required_count, tok, ctx)
+      if tok.args.size != required_count
+        log.error "(line: #{tok.line_number}) '#{tok.name}' requires #{required_count} argument(s), but found #{tok.args.size}"
+        ctx[:failed] = true
+        return false
+      end
+      return true
+    end
+
+    def format_svn_path(tok, path, ctx)
+      if ctx[:svn_prefix].empty? && path !~ /^\//
+        log.error "(line: #{tok.line_number}) No 'svn-prefix' defined, but a relative SVN path was used"
+        ctx[:failed] = true
+        nil
+      else
+        "#{ctx[:svn_prefix]}#{path}"
+      end
+    end
+
+    def format_live_path(tok, path, ctx)
+      if ctx[:live_path].nil?
+        log.error "(line: #{tok.line_number}) The command '#{tok.name}' requires a live path, but none was given."
+        ctx[:failed] = true
+        nil
+      else
+        if path =~ /^\//
+          "#{ctx[:live_path].chomp('/')}#{path}"
+        else
+          "#{ctx[:live_path].chomp('/')}#{ctx[:svn_prefix]}#{path}"
+        end
+      end
+    end
+  end#Parser
+end