whistle 0.1

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/difftool.rb

@@ -0,0 +1,44 @@
+require 'rscm/tempdir'
+require 'rscm/path_converter'
+require 'rscm/difftool'
+
+module RSCM
+  module Difftool
+    # assertion method that reports differences as diff.
+    # useful when comparing big strings
+    def assert_equal_with_diff(expected, actual, message="", temp_basedir=File.dirname(__FILE__) + "/../../target")
+      diff(expected, actual, temp_basedir) do |diff_io, cmd|
+        diff_string = diff_io.read
+        if(diff_string.strip != "")
+          flunk "#{message}\nThere were differences\ndiff command: #{cmd}\ndiff:\n#{diff_string}"
+        end
+      end
+    end
+    module_function :assert_equal_with_diff
+  
+    def diff(expected, actual, temp_basedir, &block)
+      dir = RSCM.new_temp_dir("diff", temp_basedir)
+
+      expected_file = nil
+      if(File.exist?(expected))
+        expected_file = expected
+      else
+        expected_file = "#{dir}/expected"
+        File.open(expected_file, "w") {|io| io.write(expected)}
+      end
+
+      actual_file = "#{dir}/actual"
+      File.open(actual_file, "w") {|io| io.write(actual)}
+
+      difftool = WINDOWS ? File.dirname(__FILE__) + "/../../bin/diff.exe" : "diff"
+      e = RSCM::PathConverter.filepath_to_nativepath(expected_file, false)
+      a = RSCM::PathConverter.filepath_to_nativepath(actual_file, false)
+      cmd = "#{difftool} --ignore-space-change #{e} #{a}"
+      IO.popen(cmd) do |io|
+        yield io, cmd
+      end
+    end
+    module_function :diff
+
+  end
+end

data/vendor/rscm-0.5.1-patched-stripped/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/vendor/rscm-0.5.1-patched-stripped/lib/rscm/mockit.rb

@@ -0,0 +1,157 @@
+require 'test/unit/assertions'
+
+module Test #:nodoc:
+  module Unit #:nodoc:
+    class TestCase #:nodoc:
+      def setup_with_mocks
+        @to_verify = []
+      end
+      alias_method :setup, :setup_with_mocks 
+         
+      def teardown_with_mocks
+        if(@test_passed && @to_verify)
+          @to_verify.each{|m| m.__verify}
+        end
+      end
+      alias_method :teardown, :teardown_with_mocks 
+
+      def self.method_added(method)
+        case method.to_s
+        when 'setup'
+          unless method_defined?(:setup_without_mocks)
+            alias_method :setup_without_mocks, :setup
+            define_method(:setup) do
+              setup_with_mocks
+              setup_without_mocks
+            end
+          end
+        when 'teardown'
+          unless method_defined?(:teardown_without_mocks)
+            alias_method :teardown_without_mocks, :teardown
+            define_method(:teardown) do
+              teardown_without_mocks
+              teardown_with_mocks
+            end
+          end
+        end
+      end
+  
+      def new_mock
+        mock = MockIt::Mock.new
+        @to_verify = [] unless @to_verify
+        @to_verify << mock
+        mock
+      end
+
+    end
+  end
+end
+
+module MockIt
+  class Mock
+    include Test::Unit::Assertions
+    
+    def initialize
+      @expected_methods=[]
+      @expected_validation_procs=[]
+      @setup_call_procs={}
+      @unexpected_calls = []
+    end
+    
+    def __expect(method, &validation_proc)
+      validation_proc=Proc.new {|*args| nil} if validation_proc.nil?
+      @expected_methods<<method
+      @expected_validation_procs<<validation_proc
+      self
+    end
+    
+    def __setup(method, &proc)
+      proc=Proc.new {|*args| nil} if proc.nil?
+      @setup_call_procs[method]=proc
+      self
+    end
+    
+    def __verify
+      begin
+        assert_no_unexpected_calls
+        assert_all_expected_methods_called
+      ensure
+        initialize
+      end
+    end
+    
+    def method_missing(method, *args, &proc)
+      if(is_expected_call(method))
+        handle_expected_call(method, *args, &proc)
+      elsif(is_setup_call(method))
+        handle_setup_call(method, *args, &proc)
+      else
+        handle_unexpected_call(method)
+      end
+    end
+    
+    def respond_to?(method)
+      return super.respond_to?(method) if super.respond_to?(method)
+      method = symbol(method)
+      return true if is_setup_call(method)
+      return true if currently_expected_method == method
+      false
+    end
+    
+  private
+    
+    def symbol(string)
+      return nil if string==""
+      if string.is_a? String then string.intern else string end
+    end
+    
+    def assert_no_unexpected_calls
+      assert_equal([], @unexpected_calls, "got unexpected call")
+    end
+    
+    def assert_all_expected_methods_called
+      assert(@expected_validation_procs.empty?, "not all expected methods called, calls left: #{@expected_methods.inspect}")
+    end
+    
+    def is_expected_call(method)
+      @expected_methods.index(method)
+    end
+    
+    def is_setup_call(method)
+      not @setup_call_procs[method].nil?
+    end
+    
+    def handle_setup_call(method, *args, &proc)
+      @setup_call_procs[method].call(*args, &proc)
+    end
+    
+    def handle_expected_call(method, *args, &proc)
+      assert_equal(currently_expected_method, method, "got unexpected call")
+      validation_proc = current_validation_proc
+      next_call
+      validation_proc.call(*args, &proc)
+    end
+    
+    def handle_unexpected_call(method)
+      @unexpected_calls << method
+      flunk("Unexpected method invocation: #{method}")
+    end
+    
+    def currently_expected_method
+      if @expected_methods.empty? then nil 
+      else @expected_methods[0] end
+    end
+    
+    def current_validation_proc
+      if @expected_validation_procs.empty? then nil 
+      else @expected_validation_procs[0] end
+    end
+    
+    def next_call
+      @expected_methods.delete_at(0)
+      @expected_validation_procs.delete_at(0)
+    end
+    
+  end
+end
+

data/vendor/rscm-0.5.1-patched-stripped/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

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/path_converter.rb

@@ -0,0 +1,60 @@
+WIN32 = RUBY_PLATFORM == "i386-mswin32"
+CYGWIN = RUBY_PLATFORM == "i386-cygwin"
+WINDOWS = WIN32 || CYGWIN
+
+require 'fileutils'
+
+# Utility for converting between win32 and cygwin paths. Does nothing on *nix.
+module RSCM
+  module PathConverter
+    def filepath_to_nativepath(path, escaped)
+      return nil if path.nil?
+      path = File.expand_path(path)
+      if(WIN32)
+        escaped ? path.gsub(/\//, "\\\\\\\\") : path.gsub(/\//, "\\")
+      elsif(CYGWIN)
+        cygpath = `cygpath --windows #{path}`.chomp
+        escaped ? cygpath.gsub(/\\/, "\\\\\\\\") : cygpath
+      else
+        path
+      end
+    end
+    module_function :filepath_to_nativepath
+
+    def filepath_to_nativeurl(path)
+      return nil if path.nil?
+      if(WINDOWS)
+        urlpath = filepath_to_nativepath(path, false).gsub(/\\/, "/")
+        "file:///#{urlpath}"
+      else
+        "file://#{File.expand_path(path)}"
+      end
+    end
+    module_function :filepath_to_nativeurl
+
+    def nativepath_to_filepath(path)
+      return nil if path.nil?
+      path = File.expand_path(path)
+      if(WIN32)
+        path.gsub(/\//, "\\")
+      elsif(CYGWIN)
+        path = path.gsub(/\\/, "/")
+        `cygpath --unix #{path}`.chomp
+      else
+        path
+      end
+    end
+    module_function :nativepath_to_filepath
+    
+    def ensure_trailing_slash(url)
+      return nil if url.nil?
+      if(url && url[-1..-1] != "/")
+        "#{url}/"
+      else
+        url
+      end
+    end
+    module_function :ensure_trailing_slash
+
+  end
+end

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/platform.rb

@@ -0,0 +1,26 @@
+require 'rbconfig'
+
+module RSCM
+  module Platform
+    def family
+      target_os = Config::CONFIG["target_os"] or ""
+      return "powerpc-darwin" if target_os.downcase =~ /darwin/
+      return "mswin32"  if target_os.downcase =~ /32/
+      return "cygwin" if target_os.downcase =~ /cyg/
+      return "freebsd" if target_os.downcase =~ /freebsd/
+      return "freebsd" if target_os.downcase =~ /linux/
+      return "unknown"
+    end
+    module_function :family
+    
+    def user
+      family == "mswin32" ? ENV['USERNAME'] : ENV['USER']
+    end
+    module_function :user
+    
+    def prompt(dir=Dir.pwd)
+      prompt = "#{dir.gsub(/\//, File::SEPARATOR)} #{user}$"
+    end
+    module_function :prompt
+  end
+end

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/revision.rb

@@ -0,0 +1,103 @@
+require 'rscm/time_ext'
+require 'rscm/revision_file'
+require 'yaml'
+
+module RSCM
+  # Represents a collection of RevisionFile that were committed at the 
+  # same time, or "more or less at the same time" for non-atomic 
+  # SCMs (such as CVS and StarTeam). See Revisions for how to emulate
+  # atomicity for non-atomic SCMs.
+  class Revision
+    include Enumerable
+
+    attr_writer :identifier
+    attr_accessor :developer
+    attr_accessor :message
+    
+    def initialize(identifier=nil, time=nil)
+      @identifier = identifier
+      @time = time
+      @files = []
+    end
+
+    def add(file)
+      raise "Can't add #{file} to this revision" unless accept? file
+      @files << file
+      self.developer = file.developer if file.developer
+      self.message = file.message if file.message
+    end
+    
+    def identifier(min_or_max = :max)
+      @identifier || time(min_or_max)
+    end
+    
+    # The time of this revision. Depending on the value of +min_or_max+,
+    # (should be :min or :max), returns the min or max time of this
+    # revision. (min or max only matters for non-transactional scms)
+    def time(min_or_max = :max)
+      @time || self.collect{|file| file.time}.__send__(min_or_max)
+    end
+
+    # Sets the time for this revision. Should only be used by atomic SCMs.
+    # Non-atomic SCMs should <b>not</b> invoke this method, but instead create
+    # revisions by adding RscmFile objects to a Revisions object.
+    def time=(t)
+      raise "time must be a Time object - it was a #{t.class.name} with the string value #{t}" unless t.is_a?(Time)
+      raise "can't set time to an inferiour value than the previous value" if @time && (t < @time)
+      @time = t
+    end
+    
+    # Whether +file+ can be added to this instance.
+    def accept?(file) #:nodoc:
+      return true if empty? || @time
+
+      close_enough_to_min = (time(:min) - file.time).abs <= 60
+      close_enough_to_max = (time(:max) - file.time).abs <= 60
+      close_enough = close_enough_to_min or close_enough_to_max
+
+      close_enough and
+      self.developer == file.developer and
+      self.message == file.message
+    end
+
+    def ==(other)
+      self.to_s == other.to_s
+    end
+
+    # String representation that can be used for debugging.
+    def to_s
+      if(@to_s.nil?)
+        min = time(:min)
+        max = time(:max)
+        t = (min==max) ? min : "#{min}-#{max}"
+        @to_s = "#{identifier} | #{developer} | #{t} | #{message}\n"
+        self.each do |file|
+          @to_s << " " << file.to_s << "\n"
+        end
+        @to_s
+      end
+      @to_s
+    end
+
+    def each(&block)
+      @files.each(&block)
+    end
+
+    def [](n)
+      @files[n]
+    end
+
+    def length
+      @files.length
+    end
+
+    def pop
+      @files.pop
+    end
+
+    def empty?
+      @files.empty?
+    end
+
+  end
+end