rscm 0.1.0

data/lib/rscm/cvs/cvs_log_parser.rb

@@ -0,0 +1,161 @@
+require 'rscm/changes'
+require 'rscm/abstract_log_parser'
+
+require 'ftools'
+
+module RSCM
+
+  class CVSLogParser < AbstractLogParser
+    REVISION_SEPARATOR = /^----------------------------$/
+    ENTRY_SEPARATOR = /^=============================================================================$/
+    
+    attr_accessor :cvspath
+    attr_accessor :cvsmodule
+    
+    def initialize(io)
+      super(io)
+      @log = ""
+    end
+  
+    def parse_changesets
+      changesets = ChangeSets.new
+      while(log_entry = next_log_entry)
+        @log<<log_entry
+        @log<<""
+        begin
+          parse_changes(log_entry, changesets)
+        rescue Exception => e
+          $stderr.puts("could not parse log entry: #{log_entry}\ndue to: #{e.message}\n\t")
+          $stderr.puts(e.backtrace.join("\n\t"))
+        end
+      end
+      changesets.sort!
+    end
+    
+    def next_log_entry
+      read_until_matching_line(ENTRY_SEPARATOR)
+    end
+    
+    def split_entries(log_entry)
+      entries = [""]
+      log_entry.each_line do |line|
+        if line=~REVISION_SEPARATOR
+          entries << ""
+        else
+          entries[entries.length-1] << line
+        end
+      end
+      entries
+    end
+    
+    def parse_changes(log_entry, changesets)
+      entries = split_entries(log_entry)
+
+      entries[1..entries.length].each do |entry|
+        change = parse_change(entry)
+        next if change.nil?
+        change.path = parse_path(entries[0])
+
+        change.status = Change::ADDED if change.revision =~ /1\.1$/
+
+        changeset = changesets.add(change)
+        # CVS doesn't have revision for changesets, use
+        # Fisheye-style revision
+#        changeset.revision = "MAIN:#{change.developer}:#{change.time.utc.strftime('%Y%m%d%H%M%S')}" if changeset
+      end
+      nil
+    end
+    
+    def parse_head_revision(first_entry)
+      head_revision = extract_match(first_entry, /^head: (.*?)$/m)
+    end
+    
+    def parse_path(first_entry)
+      working_file = extract_match(first_entry, /^Working file: (.*?)$/m)
+      return convert_all_slashes_to_forward_slashes(working_file) unless working_file.nil? || working_file == ""
+      make_relative_to_module(extract_required_match(first_entry, /^RCS file: (.*?)(,v|$)/m))
+    end
+    
+    def make_relative_to_module(file)
+      return file if cvspath.nil? || cvsmodule.nil? || file.nil?
+      cvspath = convert_all_slashes_to_forward_slashes(self.cvspath)
+      convert_all_slashes_to_forward_slashes(file).gsub(/^#{cvspath}\/#{cvsmodule}\//, "")
+    end
+    
+    def parse_change(change_entry)
+      raise "can't parse: #{change_entry}" if change_entry =~ REVISION_SEPARATOR
+         
+      change_entry_lines = change_entry.split(/\r?\n/)
+      change = Change.new
+
+      change.revision = extract_match(change_entry_lines[0], /revision (.*)$/)
+      
+      change.previous_revision = determine_previous_revision(change.revision)
+      change.time = parse_cvs_time(extract_required_match(change_entry_lines[1], /date: (.*?)(;|$)/))
+      change.developer = extract_match(change_entry_lines[1], /author: (.*?);/)
+      
+      state = extract_match(change_entry_lines[1], /state: (.*?);/)
+      change.status = STATES[state]
+      
+      message_start = 2
+      branches = nil
+      if(change_entry_lines[2] =~ /^branches:\s+(.*);/)
+        message_start = 3
+        branches = $1
+      end
+
+      change.message = change_entry_lines[message_start..-1].join("\n")
+         
+      # Ignore the initial revision from import - we will have two of them
+      if(change.message == "Initial revision" && branches == "1.1.1")
+        return nil
+      end
+
+      change
+    end
+    
+    def determine_previous_revision(revision)
+      if revision =~ /(.*)\.(.*)/
+        big_version_number = $1
+        small_version_number = $2.to_i
+        if small_version_number == 1
+          nil
+        else
+          "#{big_version_number}.#{small_version_number - 1}"
+        end
+      else
+        nil
+      end
+    end
+    
+    def parse_cvs_time(time)
+      # 2003/11/09 15:39:25
+      Time.utc(time[0..3], time[5..6], time[8..9], time[11..12], time[14..15], time[17..18])
+    end
+    
+    def extract_required_match(string, regexp)
+      if string=~regexp
+        return($1)
+      else
+        $stderr.puts("can't parse: '#{string}'\nexpected to match regexp: #{regexp.to_s}")
+      end
+    end
+    
+    def extract_match(string, regexp)
+      if string=~regexp
+        return($1)
+      else
+        ""
+      end
+    end
+    
+  private
+  
+    # The state field is "Exp" both for added and modified files. retards!
+    # We need some additional logic to figure out whether it is added or not.
+    # Maybe look at the revision. (1.1 means new I think. - deal with it later)
+    STATES = {"dead" => Change::DELETED, "Exp" => Change::MODIFIED}
+
+  end
+
+end

data/lib/rscm/darcs/darcs.rb

@@ -0,0 +1,69 @@
+require 'rscm/abstract_scm'
+require 'tempfile'
+require 'rscm/path_converter'
+require 'fileutils'
+
+module RSCM
+  class Darcs < AbstractSCM
+
+    def initialize(dir=nil)
+      @dir = File.expand_path(dir)
+    end
+
+    def name
+      "Darcs"
+    end
+
+    def create
+      with_working_dir(@dir) do
+        IO.popen("darcs initialize") do |stdout|
+          stdout.each_line do |line|
+            yield line if block_given?
+          end
+        end
+      end
+    end
+    
+    def import(dir, message)
+      ENV["EMAIL"] = "dcontrol@codehaus.org"
+      FileUtils.cp_r(Dir.glob("#{dir}/*"), @dir)
+      with_working_dir(@dir) do
+puts "IN::::: #{@dir}"
+        cmd = "darcs add --recursive ."
+puts cmd
+        IO.popen(cmd) do |stdout|
+          stdout.each_line do |line|
+            yield line if block_given?
+          end
+        end
+puts $?
+        logfile = Tempfile.new("darcs_logfile")
+        logfile.print(message)
+        logfile.close
+        
+        cmd = "darcs record --all --patch-name \"something nice\" --logfile #{PathConverter.filepath_to_nativepath(logfile.path, false)}"
+puts cmd
+        IO.popen(cmd) do |stdout|
+          stdout.each_line do |line|
+            yield line if block_given?
+          end
+        end
+puts $?
+      end
+    end
+
+    def checkout(checkout_dir) # :yield: file
+      with_working_dir(File.dirname(checkout_dir)) do
+cmd = "darcs get --verbose --repo-name #{File.basename(checkout_dir)} #{@dir}"
+puts cmd
+        IO.popen(cmd) do |stdout|
+          stdout.each_line do |line|
+puts line
+            yield line if block_given?
+          end
+        end
+      end
+puts $?
+    end
+  end
+end

data/lib/rscm/line_editor.rb

@@ -0,0 +1,46 @@
+require 'tempfile'
+require 'ftools'
+
+module RSCM
+  module LineEditor
+    # Comments out line by line if they match the line_regex.
+    # Does not comment out already commented out lines.
+    # If comment_template is nil, the matching lines will be deleted
+    # Returns true if at least one line is commented out or changed
+    def comment_out(original, line_regex, comment_template, output)
+      did_comment_out = false
+      already_commented_exp = /^[#{comment_template}]/ unless comment_template.nil?
+      original.each_line do |line|
+        out_line = nil
+        if(line_regex =~ line)
+          if(already_commented_exp && already_commented_exp =~ line)
+            out_line = line
+          else
+            did_comment_out = true
+            out_line = "#{comment_template}#{line}" unless comment_template.nil?
+          end
+        else
+          out_line = line
+        end
+        output << out_line unless out_line.nil?
+      end
+      did_comment_out
+    end
+    module_function :comment_out
+  end
+end
+
+class File
+
+  def File.comment_out(path, line_regex, comment_template)
+    temp_file = Tempfile.new(File.basename(path))
+    temp_file_path = temp_file.path
+    original = File.new(path)
+    RSCM::LineEditor.comment_out(original, line_regex, comment_template, temp_file)
+
+    temp_file.close
+    original.close
+
+    File.copy(temp_file_path, path)
+  end
+end

data/lib/rscm/logging.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require_gem 'log4r'
+
+Log = Log4r::Logger.new("rscm")
+Log.add Log4r::Outputter.stderr

data/lib/rscm/monotone/monotone.rb

@@ -0,0 +1,107 @@
+require 'rscm/abstract_scm'
+require 'fileutils'
+
+module RSCM
+  class Monotone < AbstractSCM
+    def initialize(db_file=nil, branch=nil, key=nil, passphrase=nil, keys_file=nil)
+      @db_file = File.expand_path(db_file) if db_file
+      @branch = branch
+      @key = key
+      @passphrase = passphrase
+      @keys_file = keys_file
+    end
+
+    def name
+      "Monotone"
+    end
+
+    def create
+      FileUtils.mkdir_p(File.dirname(@db_file))
+      monotone("db init")
+      monotone("read") do |io|
+        io.write(File.open(@keys_file).read)
+        io.close_write
+      end
+    end
+
+    def transactional?
+      true
+    end
+
+    def import(dir, message)
+      dir = File.expand_path(dir)
+
+      # post 0.17, this can be "cd dir && cmd add ."
+
+      files = Dir["#{dir}/*"]
+      relative_paths_to_add = to_relative(dir, files)
+
+      with_working_dir(dir) do
+        monotone("add #{relative_paths_to_add.join(' ')}")
+        monotone("commit '#{message}'", @branch, @key) do |io|
+          io.puts(@passphrase)
+          io.close_write
+          io.read
+        end
+      end
+    end
+
+    def checked_out?(checkout_dir)
+      File.exists?("#{checkout_dir}/MT")
+    end
+
+    def uptodate?(checkout_dir, from_identifier)
+      if (!checked_out?(checkout_dir))
+        false
+      else
+        with_working_dir(checkout_dir) do
+          monotone("heads") do |stdout|
+            stdout.each_line do |line|
+              next if (line =~ /^monotone:/)
+            end
+          end
+        end
+      end
+    end
+
+    def commit(checkout_dir, message)
+
+    end
+
+  protected
+
+    # Checks out silently. Called by superclass' checkout.
+    def checkout_silent(checkout_dir, to_identifier)
+      monotone("checkout #{checkout_dir}", @branch, @key) do |stdout|
+        stdout.each_line do |line|
+          # TODO: checkout prints nothing to stdout - may be fixed in a future monotone.
+          # When/if it happens we may want to do a kosher implementation of checkout
+          # to get yields as checkouts happen.
+          yield line if block_given?
+        end
+      end
+    end
+
+    # Administrative files that should be ignored when counting files.
+    def ignore_paths
+      return [/MT/, /\.mt-attrs/]
+    end
+
+  private
+  
+    def monotone(monotone_cmd, branch=nil, key=nil)
+      branch_opt = branch ? "--branch=\"#{branch}\"" : ""
+      key_opt = key ? "--key=\"#{key}\"" : ""
+      cmd = "monotone --db=\"#{@db_file}\" #{branch_opt} #{key_opt} #{monotone_cmd}"
+      safer_popen(cmd, "r+") do |io|
+        if(block_given?)
+          return(yield(io))
+        else
+          # just read stdout so we can exit
+          io.read
+        end
+      end
+    end
+  
+  end
+end

data/lib/rscm/mooky/mooky.rb

@@ -0,0 +1,13 @@
+require 'rscm/abstract_scm'
+
+module RSCM
+  class Mooky < AbstractSCM
+    attr_accessor :foo
+    attr_accessor :bar
+  
+    def name
+      "Mooky"
+    end
+
+  end
+end

data/lib/rscm/parser.rb

@@ -0,0 +1,39 @@
+module RSCM
+  class Parser
+  
+    def initialize(break_regexp)
+      @break_regexp = break_regexp
+    end
+  
+    def parse(io, skip_line_parsing=false, &line_proc)
+      parse_until_regexp_matches(io, skip_line_parsing, &line_proc)
+      if(skip_line_parsing)
+        nil
+      else
+        next_result
+      end
+    end
+
+  protected
+
+    def parse_line(line)
+      raise "Must override parse_line(line)"
+    end
+
+    def next_result
+      raise "Must override next_result(line)"
+    end
+    
+  private
+
+    def parse_until_regexp_matches(io, skip_line_parsing, &line_proc)
+      io.each_line { |line|
+        yield line if block_given?
+        if line =~ @break_regexp
+          return
+        end
+        parse_line(line) unless skip_line_parsing
+      }
+    end
+  end
+end