rcodetools 0.5.0.0 → 0.7.0.0

data/lib/rcodetools/xmpfilter.rb

@@ -3,8 +3,12 @@
 #                         rubikitch <rubikitch@ruby-lang.org>
 # Use and distribution subject to the terms of the Ruby license.
 
+require 'rcodetools/fork_config'
+
+module Rcodetools
+
 class XMPFilter
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 
   MARKER = "!XMP#{Time.new.to_i}_#{Process.pid}_#{rand(1000000)}!"
   XMP_RE = Regexp.new("^" + Regexp.escape(MARKER) + '\[([0-9]+)\] (=>|~>|==>) (.*)')
@@ -17,6 +21,22 @@ class XMPFilter
                      :include_paths => [], :warnings => true, 
                      :use_parentheses => true}
 
+  def self.windows?
+    /win|mingw/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM
+  end
+
+  Interpreter = Struct.new(:options, :execute_method, :accept_debug, :chdir_proc)
+  INTERPRETER_RUBY = Interpreter.new(["-w"],
+                                     windows? ? :execute_tmpfile : :execute_popen,
+                                     true, nil)
+  INTERPRETER_RBTEST = Interpreter.new(["-S", "rbtest"], :execute_script, false, nil)
+  INTERPRETER_FORK = Interpreter.new(["-S", "rct-fork-client"], :execute_tmpfile, false,
+                                     lambda { Fork::chdir_fork_directory })
+                                     
+  def self.detect_rbtest(code, opts)
+    opts[:use_rbtest] ||= (opts[:detect_rbtest] and code =~ /^=begin test./) ? true : false
+  end
+
   # The processor (overridable)
   def self.run(code, opts)
     new(opts).annotate(code)
@@ -24,6 +44,7 @@ class XMPFilter
 
   def initialize(opts = {})
     options = INITIALIZE_OPTS.merge opts
+    @interpreter_info = INTERPRETER_RUBY
     @interpreter = options[:interpreter]
     @options = options[:options]
     @libs = options[:libs]
@@ -34,8 +55,52 @@ class XMPFilter
     @warnings = options[:warnings]
     @parentheses = options[:use_parentheses]
     @ignore_NoMethodError = options[:ignore_NoMethodError]
-
+    test_script = options[:test_script]
+    test_method = options[:test_method]
+    filename = options[:filename]
     @postfix = ""
+    
+    initialize_rct_fork if options[:detect_rct_fork]
+    initialize_rbtest if options[:use_rbtest]
+    initialize_for_test_script test_script, test_method, filename if test_script and !options[:use_rbtest]
+  end
+
+  def initialize_rct_fork
+    if Fork::run?
+      @interpreter_info = INTERPRETER_FORK
+    end
+  end
+
+  def initialize_rbtest
+    @interpreter_info = INTERPRETER_RBTEST
+  end
+
+  def initialize_for_test_script(test_script, test_method, filename)
+    test_script.replace File.expand_path(test_script)
+    filename.replace File.expand_path(filename)
+    unless test_script == filename
+      basedir = common_path(test_script, filename)
+      relative_filename = filename[basedir.length+1 .. -1].sub(%r!^lib/!, '')
+      @evals << %Q!$LOADED_FEATURES << #{relative_filename.dump}!
+      @evals << %Q!require 'test/unit'!
+      @evals << %Q!load #{test_script.dump}!
+    end
+    test_method = get_test_method_from_lineno(test_script, test_method.to_i) if test_method =~ /^\d/
+    @evals << %Q!Test::Unit::AutoRunner.run(false, nil, ["-n", #{test_method.dump}])! if test_method
+  end
+
+  def get_test_method_from_lineno(filename, lineno)
+    lines = File.readlines(filename)
+    (lineno-1).downto(0) do |i|
+      if lines[i] =~ /^ *def *(test_[A-Za-z0-9?!_]+)$/
+        return $1
+      end
+    end
+    nil
+  end
+
+  def common_path(a, b)
+    (a.split(File::Separator) & b.split(File::Separator)).join(File::Separator)
   end
 
   def add_markers(code, min_codeline_size = 50)
@@ -82,10 +147,6 @@ class XMPFilter
     v = "#{VAR}"
     blocal = "__#{VAR}"
     blocal2 = "___#{VAR}"
-    # rubikitch: oneline-ized
-# <<EOF.chomp
-# ((#{v} = (#{expr}); $stderr.puts("#{MARKER}[#{idx}] => " + #{v}.class.to_s + " " + #{v}.inspect) || begin; $stderr.puts local_variables; local_variables.each{|#{blocal}| #{blocal2} = eval(#{blocal}); if #{v} == #{blocal2} && #{blocal} != %#{expr}.strip; $stderr.puts("#{MARKER}[#{idx}] ==> " + #{blocal}); elsif [#{blocal2}] == #{v}; $stderr.puts("#{MARKER}[#{idx}] ==> [" + #{blocal} + "]") end }; nil rescue Exception; nil end || #{v}))
-# EOF
     oneline_ize(<<-EOF).chomp
 #{v} = (#{expr})
 $stderr.puts("#{MARKER}[#{idx}] => " + #{v}.class.to_s + " " + #{v}.inspect) || begin
@@ -108,23 +169,33 @@ end || #{v}
   alias_method :prepare_line, :prepare_line_annotation
 
   def execute_tmpfile(code)
+    ios = %w[_ stdin stdout stderr]
     stdin, stdout, stderr = (1..3).map do |i|
-      fname = "xmpfilter.tmpfile_#{Process.pid}-#{i}.rb"
+      fname = if $DEBUG
+                "xmpfilter.tmpfile_#{ios[i]}.rb"
+              else
+                "xmpfilter.tmpfile_#{Process.pid}-#{i}.rb"
+              end
       f = File.open(fname, "w+")
-      at_exit { f.close unless f.closed?; File.unlink fname }
+      at_exit { f.close unless f.closed?; File.unlink fname unless $DEBUG}
       f
     end
     stdin.puts code
     stdin.close
     exe_line = <<-EOF.map{|l| l.strip}.join(";")
-      $stdout.reopen('#{stdout.path}', 'w')
-      $stderr.reopen('#{stderr.path}', 'w')
-      $0.replace '#{stdin.path}'
+      $stdout.reopen('#{File.expand_path(stdout.path)}', 'w')
+      $stderr.reopen('#{File.expand_path(stderr.path)}', 'w')
+      $0.replace '#{File.expand_path(stdin.path)}'
       ARGV.replace(#{@options.inspect})
-      load #{stdin.path.inspect}
+      load #{File.expand_path(stdin.path).inspect}
       #{@evals.join(";")}
     EOF
+    debugprint "execute command = #{(interpreter_command << "-e" << exe_line).join ' '}"
+
+    oldpwd = Dir.pwd
+    @interpreter_info.chdir_proc and @interpreter_info.chdir_proc.call
     system(*(interpreter_command << "-e" << exe_line))
+    Dir.chdir oldpwd
     [stdout, stderr]
   end
 
@@ -137,15 +208,30 @@ end || #{v}
     [stdout, stderr]
   end
 
-  if /win|mingw/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM
-    alias_method :execute, :execute_tmpfile
-  else
-    alias_method :execute, :execute_popen
+  def execute_script(code)
+    codefile = "xmpfilter.tmpfile_#{Process.pid}.rb"
+    File.open(codefile, "w"){|f| f.puts code}
+    path = File.expand_path(codefile)
+    at_exit { File.unlink path if File.exist? path}
+    stdout, stderr = (1..2).map do |i|
+      fname = "xmpfilter.tmpfile_#{Process.pid}-#{i}.rb"
+      fullname = File.expand_path(fname)
+      at_exit { File.unlink fullname if File.exist? fullname}
+      File.open(fname, "w+")
+    end
+    args = *(interpreter_command << %["#{codefile}"] << "2>" << 
+             %["#{stderr.path}"] << ">" << %["#{stdout.path}"])
+    system(args.join(" "))
+    [stdout, stderr]
+  end
+
+  def execute(code)
+    __send__ @interpreter_info.execute_method, code
   end
 
   def interpreter_command
-    r = [@interpreter, "-w"]
-    r << "-d" if $DEBUG
+    r = [ @interpreter ] + @interpreter_info.options
+    r << "-d" if $DEBUG and @interpreter_info.accept_debug
     r << "-I#{@include_paths.join(":")}" unless @include_paths.empty?
     @libs.each{|x| r << "-r#{x}" } unless @libs.empty?
     (r << "-").concat @options unless @options.empty?
@@ -207,3 +293,5 @@ class XMPAddMarkers < XMPFilter
     new(opts).add_markers(code, opts[:min_codeline_size])
   end
 end
+
+end

data/lib/rcodetools/xmptestunitfilter.rb

@@ -1,4 +1,7 @@
 require 'rcodetools/xmpfilter'
+
+module Rcodetools
+
 class XMPTestUnitFilter < XMPFilter
   def initialize(opts = {})
     super
@@ -117,81 +120,139 @@ end
 
 class XMPRSpecFilter < XMPTestUnitFilter
   private
-  def execute(code)
-    codefile = "xmpfilter.rspec_tmpfile_#{Process.pid}.rb"
-    File.open(codefile, "w"){|f| f.puts code}
-    path = File.expand_path(codefile)
-    at_exit { File.unlink path if File.exist? path}
-    stdout, stderr = (1..2).map do |i|
-      fname = "xmpfilter.rspec_tmpfile_#{Process.pid}-#{i}.rb"
-      fullname = File.expand_path(fname)
-      at_exit { File.unlink fullname if File.exist? fullname}
-      File.open(fname, "w+")
-    end
-    args = *(interpreter_command << %["#{codefile}"] << "2>" << 
-             %["#{stderr.path}"] << ">" << %["#{stdout.path}"])
-    system(args.join(" "))
-    [stdout, stderr]
-  end
+  alias :execute :execute_script
 
   def interpreter_command
     [@interpreter] + @libs.map{|x| "-r#{x}"}
   end
 
-  def raise_assertion(expression, exceptions, index)
-    ["lambda{#{expression}}.should_raise #{exceptions[index][0]}"]
+  begin
+    require 'spec/version'
+  rescue LoadError
+    require 'rubygems'
+    begin
+      require 'spec/version'
+    rescue LoadError # if rspec isn't available, use most recent conventions
+      module Spec::VERSION; STRING = "1.0.0" end
+    end
   end
 
-  module WithParentheses
-    def nil_assertion(expression)
-      ["(#{expression}).should_be_nil"]
+  if Spec::VERSION::STRING >= "0.8.0"
+
+    def raise_assertion(expression, exceptions, index)
+      ["lambda{#{expression}}.should raise_error(#{exceptions[index][0]})"]
     end
-    
-    def value_assertions(klass_txt, value_txt, value, expression)
-      case value
-      when Float
-        ["(#{expression}).should_be_close #{value.inspect}, 0.0001"]
-      when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
-        ["(#{expression}).should_equal #{value_txt}"]
-      else
-        object_assertions klass_txt, value_txt, expression
+
+    module WithParentheses
+      def nil_assertion(expression)
+        ["(#{expression}).should be_nil"]
       end
-    end
 
-    def object_assertions(klass_txt, value_txt, expression)
-      [ "(#{expression}).should_be_a_kind_of #{klass_txt}",
-        "(#{expression}.inspect).should_equal #{value_txt.inspect}" ]
-    end
+      def value_assertions(klass_txt, value_txt, value, expression)
+        case value
+        when Float
+          ["(#{expression}).should be_close(#{value.inspect}, 0.0001)"]
+        when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
+          ["(#{expression}).should == (#{value_txt})"]
+        else
+          object_assertions klass_txt, value_txt, expression
+        end
+      end
 
-    def equal_assertion(expected, actual)
-      "(#{actual}).should_equal #{expected}"
-    end
-  end
+      def object_assertions(klass_txt, value_txt, expression)
+        [ "(#{expression}).should be_a_kind_of(#{klass_txt})",
+          "(#{expression}.inspect).should == (#{value_txt.inspect})" ]
+      end
 
-  module Poetry
-    def nil_assertion(expression)
-      ["#{expression}.should_be_nil"]
+      def equal_assertion(expected, actual)
+        "(#{actual}).should == (#{expected})"
+      end
     end
 
-    def value_assertions(klass_txt, value_txt, value, expression)
-      case value
-      when Float
-        ["#{expression}.should_be_close #{value.inspect}, 0.0001"]
-      when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
-        ["#{expression}.should_equal #{value_txt}"]
-      else
-        object_assertions klass_txt, value_txt, expression
+    module Poetry
+      def nil_assertion(expression)
+        ["#{expression}.should be_nil"]
+      end
+
+      def value_assertions(klass_txt, value_txt, value, expression)
+        case value
+        when Float
+          ["#{expression}.should be_close(#{value.inspect}, 0.0001)"]
+        when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
+          ["#{expression}.should == #{value_txt}"]
+        else
+          object_assertions klass_txt, value_txt, expression
+        end
+      end
+
+      def object_assertions(klass_txt, value_txt, expression)
+        [ "#{expression}.should be_a_kind_of(#{klass_txt})",
+          "#{expression}.inspect.should == #{value_txt.inspect}" ]
+      end
+
+      def equal_assertion(expected, actual)
+        "#{actual}.should == #{expected}"
       end
     end
+  else
+    # old rspec, use deprecated syntax
+    def raise_assertion(expression, exceptions, index)
+      ["lambda{#{expression}}.should_raise_error(#{exceptions[index][0]})"]
+    end
 
-    def object_assertions(klass_txt, value_txt, expression)
-      [ "#{expression}.should_be_a_kind_of #{klass_txt}",
-        "#{expression}.inspect.should_equal #{value_txt.inspect}" ]
+    module WithParentheses
+      def nil_assertion(expression)
+        ["(#{expression}).should_be_nil"]
+      end
+
+      def value_assertions(klass_txt, value_txt, value, expression)
+        case value
+        when Float
+          ["(#{expression}).should_be_close(#{value.inspect}, 0.0001)"]
+        when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
+          ["(#{expression}).should_equal(#{value_txt})"]
+        else
+          object_assertions klass_txt, value_txt, expression
+        end
+      end
+
+      def object_assertions(klass_txt, value_txt, expression)
+        [ "(#{expression}).should_be_a_kind_of(#{klass_txt})",
+          "(#{expression}.inspect).should_equal(#{value_txt.inspect})" ]
+      end
+
+      def equal_assertion(expected, actual)
+        "(#{actual}).should_equal(#{expected})"
+      end
     end
 
-    def equal_assertion(expected, actual)
-      "#{actual}.should_equal #{expected}"
+    module Poetry
+      def nil_assertion(expression)
+        ["#{expression}.should_be_nil"]
+      end
+
+      def value_assertions(klass_txt, value_txt, value, expression)
+        case value
+        when Float
+          ["#{expression}.should_be_close #{value.inspect}, 0.0001"]
+        when Numeric, String, Hash, Array, Regexp, TrueClass, FalseClass, Symbol, NilClass
+          ["#{expression}.should_equal #{value_txt}"]
+        else
+          object_assertions klass_txt, value_txt, expression
+        end
+      end
+
+      def object_assertions(klass_txt, value_txt, expression)
+        [ "#{expression}.should_be_a_kind_of #{klass_txt}",
+          "#{expression}.inspect.should_equal #{value_txt.inspect}" ]
+      end
+
+      def equal_assertion(expected, actual)
+        "#{actual}.should_equal #{expected}"
+      end
     end
   end
+
 end
 
+end

data/lib/ruby_toggle_file.rb

@@ -0,0 +1,99 @@
+
+# The name is taken from EmacsLisp
+def run_hooks_with_args_until_success(regexp, *args)
+  private_methods(true).concat(methods(true)).grep(regexp).sort.each do |m|
+    _ = __send__(m, *args)
+    return _ if _
+  end
+  nil
+end
+
+class RubyToggleFile
+  def ruby_toggle_file(file)
+    if File.basename(file) =~ /(?:^test_|_test\.rb$)/
+      implementation_file(file)
+    else
+      test_file(file)
+    end
+  end
+
+  LIB_RE = %r!/lib/(.+)\.rb$!
+  TEST_RE = %r!/test/(.+/)?test_(.+)\.rb$!
+
+  def test_file(implementation)
+    if m = LIB_RE.match(implementation)
+      dir, node = File.split m[1]
+      dir = (dir == '.') ? nil : dir+"/"
+    else
+      dir = node = nil
+    end
+    run_hooks_with_args_until_success %r/^test_file_/, implementation, m&&(m.pre_match+"/"), dir, node
+  end
+
+  def implementation_file(test)
+    m = TEST_RE.match(test)
+    run_hooks_with_args_until_success %r/^implementation_file_/, test, m&&(m.pre_match+"/"), m&&m[1], m&&m[2]
+  end
+
+  private
+  def exist(file)
+    file if File.exist? file
+  end
+
+  RAILS_MVC2TESTNAME = { 'models' => 'unit', 'controllers' => 'functional' }
+  RAILS_TESTNAME2MVC = RAILS_MVC2TESTNAME.invert
+  def test_file_00_rails(implementation, basedir, dir, node) # rails
+    if m = %r!app/(models|controllers)/(.+)\.rb$!.match(implementation)
+      "%stest/%s/%s_test.rb" % [ m.pre_match, RAILS_MVC2TESTNAME[m[1]], m[2] ]
+    end
+  end
+
+  def test_file_05_rails_lib(implementation, basedir, dir, node)
+    if basedir and File.directory?( File.join(basedir, "app") )
+      "#{basedir}test/unit/test_#{node}.rb"
+    end
+  end
+
+  def test_file_10_no_match(implementation, basedir, dir, node)
+    if [basedir, dir, node].all?{|x| x.nil?}
+      "#{File.dirname(implementation)}/test_#{File.basename(implementation)}"
+    end
+  end
+
+  def test_file_20_simple(implementation, basedir, dir, node) # test/test_NODE.rb
+    exist "#{basedir}test/test_#{node}.rb"
+  end
+
+  def test_file_30_flat(implementation, basedir, dir, node) # lib/XXX/NODE.rb -> test/test_NODE.rb
+    exist "#{basedir}test/test_#{node}.rb" if dir
+  end
+
+  def test_file_99_autotest_default(implementation, basedir, dir, node) # lib/XXX/NODE.rb -> test/XXX/test_NODE.rb
+    "#{basedir}test/#{dir}test_#{node}.rb"
+  end
+
+  def implementation_file_00_rails(test, basedir, dir, node)
+    if m = %r!test/(unit|functional)/(.+)_test.rb$!.match(test)
+      "%sapp/%s/%s.rb" % [ m.pre_match, RAILS_TESTNAME2MVC[m[1]], m[2] ]
+    end
+  end
+
+  def implementation_file_10_no_match(test, basename, dir, node)
+    if dir == nil and node == nil and test =~ %r!/test_(.+)\.rb$!
+      test.sub("/test_", "/")
+    end
+  end
+
+  def implementation_file_20(test, basedir, dir, node)
+    exist("#{basedir}lib/#{dir}#{node}.rb")
+  end
+
+  def implementation_file_30_flat(test, basedir, dir, node)
+    Dir[ "#{basedir}lib/**/#{node}.rb" ].first
+  end
+
+  def implementation_file_99_default(test, basedir, dir, node)
+    "#{basedir}lib/#{dir}#{node}.rb"
+  end
+
+end