rcodetools 0.5.0.0 → 0.7.0.0

data/test/data/rspec_poetry-output.rb

@@ -11,42 +11,42 @@ class X
 end
 
 
-context "Testing xmpfilter's expectation expansion" do
-  setup do
+describe "xmpfilter's expectation expansion" do
+  before do
     @o = X.new
   end
 
-  specify "Should expand should_equal expectations" do
-    @o.foo(true).should_be_a_kind_of X::Y
-    @o.foo(true).inspect.should_equal "#<struct X::Y a=2>"
-    @o.foo(true).a.should_equal 2
-    @o.foo(false).should_equal 2
+  it "should expand should == expectations" do
+    @o.foo(true).should be_a_kind_of(X::Y)
+    @o.foo(true).inspect.should == "#<struct X::Y a=2>"
+    @o.foo(true).a.should == 2
+    @o.foo(false).should == 2
   end
   
-  specify "Should expand should_raise expectations" do
-    lambda{@o.bar}.should_raise RuntimeError
+  it "should expand should raise_error expectations" do
+    lambda{@o.bar}.should raise_error(RuntimeError)
   end
 
-  specify "Should expand should_be_nil expectations" do
-    @o.baz.should_be_nil
+  it "should expand should be_nil expectations" do
+    @o.baz.should be_nil
   end
 
-  specify "Should expand correct expectations for complex values" do
-    @o.babar.should_equal [1, 2]
+  it "should expand correct expectations for complex values" do
+    @o.babar.should == [1, 2]
   end
 
-  specify "Should expand should_be_close expectations" do
-    @o.fubar(10).should_be_close 101.0, 0.0001
+  it "should expand should be_close expectations" do
+    @o.fubar(10).should be_close(101.0, 0.0001)
   end
 end
 
-context "Testing binding" do
-  specify "Should expand should_equal expectations" do
+describe "xmpfilter's automagic binding detection" do
+  it "should expand should == expectations" do
     a = b = c = 1
     d = a
-    d.should_equal a
-    d.should_equal b
-    d.should_equal c
-    d.should_equal 1
+    d.should == a
+    d.should == b
+    d.should == c
+    d.should == 1
   end
 end

data/test/data/sample_test_script.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+class TestSample < Test::Unit::TestCase
+  def test_sample0
+    assert(true)
+  end
+
+  def test_sample1
+  end
+end

data/test/data/unit_test_detect_rbtest-input.rb

@@ -0,0 +1,50 @@
+
+class X
+  Y = Struct.new(:a)
+  def foo(b); b ? Y.new(2) : 2 end
+  def bar; raise "No good" end
+  def baz; nil end
+  def fubar(x); x ** 2.0 + 1 end
+  def babar; [1,2] end
+  A = 1
+  A = 1
+  def difftype() [1, "s"] end
+end
+
+
+require 'test/unit'
+class Test_X < Test::Unit::TestCase
+  def setup
+    @o = X.new
+  end
+
+  def test_foo
+    @o.foo(true)   # =>
+    @o.foo(true).a # =>
+    @o.foo(false)  # =>
+  end
+  
+  def test_bar
+    @o.bar         # =>
+  end
+
+  def test_baz
+    @o.baz         # =>
+  end
+
+  def test_babar
+    @o.babar       # =>
+  end
+
+  def test_fubar
+    @o.fubar(10)   # =>
+  end
+
+  def test_difftype
+    for x in @o.difftype
+      x            # =>
+    end
+  end
+
+end
+

data/test/data/unit_test_detect_rbtest-output.rb

@@ -0,0 +1,52 @@
+
+class X
+  Y = Struct.new(:a)
+  def foo(b); b ? Y.new(2) : 2 end
+  def bar; raise "No good" end
+  def baz; nil end
+  def fubar(x); x ** 2.0 + 1 end
+  def babar; [1,2] end
+  A = 1
+  A = 1 # !> already initialized constant A
+  def difftype() [1, "s"] end
+end
+
+
+require 'test/unit'
+class Test_X < Test::Unit::TestCase
+  def setup
+    @o = X.new
+  end
+
+  def test_foo
+    assert_kind_of(X::Y, @o.foo(true))
+    assert_equal("#<struct X::Y a=2>", @o.foo(true).inspect)
+    assert_equal(2, @o.foo(true).a)
+    assert_equal(2, @o.foo(false))
+  end
+  
+  def test_bar
+    assert_raise(RuntimeError){@o.bar}
+  end
+
+  def test_baz
+    assert_nil(@o.baz)
+  end
+
+  def test_babar
+    assert_equal([1, 2], @o.babar)
+  end
+
+  def test_fubar
+    assert_in_delta(101.0, @o.fubar(10), 0.0001)
+  end
+
+  def test_difftype
+    for x in @o.difftype
+      #xmpfilter: WARNING!! extra values ignored
+      assert_equal(1, x)
+    end
+  end
+
+end
+

data/test/data/unit_test_detect_rbtest2-input.rb

@@ -0,0 +1,6 @@
+=begin test_bar
+bar("bar")    # =>
+=end
+def bar(s)
+  s.upcase
+end

data/test/data/unit_test_detect_rbtest2-output.rb

@@ -0,0 +1,6 @@
+=begin test_bar
+assert_equal("BAR", bar("bar"))
+=end
+def bar(s)
+  s.upcase
+end

data/test/data/unit_test_rbtest-input.rb

@@ -0,0 +1,6 @@
+=begin test_bar
+bar("bar")    # =>
+=end
+def bar(s)
+  s.upcase
+end

data/test/data/unit_test_rbtest-output.rb

@@ -0,0 +1,6 @@
+=begin test_bar
+assert_equal("BAR", bar("bar"))
+=end
+def bar(s)
+  s.upcase
+end

data/test/test_completion.rb

@@ -3,6 +3,7 @@ require 'rcodetools/completion'
 require 'test/unit'
 
 class TestXMPCompletionFilter < Test::Unit::TestCase
+  include Rcodetools
   def doit(code, lineno, column=nil, options={})
     xmp = XMPCompletionFilter.new options
     xmp.candidates(code, lineno, column).sort
@@ -29,12 +30,13 @@ EOC
   end
 
   def test_complete_method__in_not_passing_method
-    ## FIXME I do not know how to handle not-passing method!!
-    assert_equal([], doit(<<EOC, 2))
+    assert_raises(XMPCompletionFilter::NoCandidates) do
+      doit(<<EOC, 2)
   def hoge
     "a".lengt
   end
 EOC
+    end
   end
 
   def test_complete_singleton_method
@@ -55,6 +57,16 @@ EOC
 EOC
   end
 
+  def test_complete_global_variable__list
+    gvars = doit(<<EOC, 3)
+  $foo = 3
+  $hoge = 100
+  $
+EOC
+    assert gvars.include?("$foo")
+    assert gvars.include?("$hoge")
+  end
+
   def test_complete_global_variable__with_class
     assert_equal(["open"], doit(<<EOC, 2))
   $hoge = File
@@ -107,6 +119,15 @@ EOC
 EOC
   end
 
+  def test_complete_class_variable__list
+    assert_equal(%w[@@foo @@hoge], doit(<<EOC, 3))
+  @@hoge = 100
+  @@foo = 2
+  @@
+EOC
+  end
+
+
   def test_complete_constant__nested
     assert_equal(["Stat"], doit('File::Sta',1))
   end
@@ -435,7 +456,9 @@ x = a[1][0] rescue "aaa"
 x.lengt
 EOC
     assert_equal(["length"], doit(code, 3))
-    assert_equal([], doit(code, 3, nil, :ignore_NoMethodError=>true))
+    assert_raises(XMPCompletionFilter::NoCandidates) do
+      doit(code, 3, nil, :ignore_NoMethodError=>true)
+    end
   end
 
   def test__syntax_error
@@ -496,6 +519,7 @@ end
 
 
 class TestXMPCompletionVerboseFilter < Test::Unit::TestCase
+  include Rcodetools
   def doit(code, lineno, column=nil, options={})
     xmp = XMPCompletionVerboseFilter.new options
     xmp.candidates(code, lineno, column).sort
@@ -515,6 +539,16 @@ EOC
 EOC
   end
 
+  def test_complete_list_instance_variable
+    assert_equal(%w[@bar @baz @foo @hoge], doit(<<EOC, 5))
+  @foo = 1
+  @bar = 2
+  @baz = 3
+  @hoge = 100
+  @
+EOC
+  end
+
   def test_complete_class_variable_module
     assert_equal(["@@hoge"], doit(<<EOC, 3))
   module X

data/test/test_doc.rb

@@ -3,6 +3,7 @@ require 'rcodetools/doc'
 require 'test/unit'
 
 class TestXMPDocFilter < Test::Unit::TestCase
+  include Rcodetools
   def doit(code, lineno, column=nil, options={})
     xmp = XMPDocFilter.new options
     xmp.doc(code, lineno, column)
@@ -428,6 +429,7 @@ EOC
 end
 
 class TestXMPRiFilter < Test::Unit::TestCase
+  include Rcodetools
   def doit(code, lineno, column=nil, options={})
     xmp = XMPRiFilter.new options
     xmp.doc(code, lineno, column)

data/test/test_functional.rb

@@ -1,18 +1,79 @@
 require 'test/unit'
 
-class TestFunctional < Test::Unit::TestCase
-  tests = {:simple_annotation => [], :unit_test => ["-u"], :rspec => ["-s"],
-           :no_warnings => ["--no-warnings"], :bindings => ["--poetry", "-u"],
-           :add_markers => ["-m"]
-  }
-  tests.each_pair do |test, opts|
-    define_method("test_#{test}") do
-      dir = File.expand_path(File.dirname(__FILE__))
-      libdir = File.expand_path(dir + '/../lib')
-      exec = File.expand_path(dir + '/../bin/xmpfilter')
-      output = `ruby -I#{libdir} #{exec} #{opts.join(" ")} #{dir}/data/#{test}-input.rb`
-      outputfile = "#{dir}/data/#{test}-output.rb"
-      assert_equal(File.read(outputfile), output)
+module TestFunctional
+  DIR = File.expand_path(File.dirname(__FILE__))
+  LIBDIR = File.expand_path(DIR + '/../lib')
+  
+  module DefineFunctionalTests
+    def define_functional_tests(exec, tests)
+      tests.each_pair do |test, opts|
+        define_method("test_#{test}") do
+          
+          output = `ruby -I#{LIBDIR} #{exec} #{opts.join(" ")} #{DIR}/data/#{test}-input.rb`
+          outputfile = "#{DIR}/data/#{test}-output.rb"
+          assert_equal(File.read(outputfile), output)
+        end
+      end 
     end
-  end 
+  end
+
+  class TestXmpfilter < Test::Unit::TestCase
+    extend DefineFunctionalTests
+    tests = {
+      :simple_annotation => [], :unit_test => ["-u"], :rspec => ["-s"],
+      :no_warnings => ["--no-warnings"], :bindings => ["--poetry", "-u"],
+      :add_markers => ["-m"], :unit_test_rbtest => ["-u", "--rbtest"],
+      :unit_test_detect_rbtest => ["-u", "--detect-rbtest"],
+      :unit_test_detect_rbtest2 => ["--detect-rbtest"],
+    }
+    define_functional_tests File.expand_path(DIR + '/../bin/xmpfilter'), tests
+  end
+
+  class TestRctComplete < Test::Unit::TestCase
+    extend DefineFunctionalTests
+    tests = {
+      :completion_rbtest => [ "--rbtest", "--line=6" ],
+      :completion_detect_rbtest => [ "--detect-rbtest", "--line=6" ],
+      :completion_detect_rbtest2 => [ "--detect-rbtest", "--line=1" ],
+    }
+    define_functional_tests File.expand_path(DIR + '/../bin/rct-complete'), tests
+  end
+
+  class TestRctDoc < Test::Unit::TestCase
+    extend DefineFunctionalTests
+    tests = {
+      :doc_rbtest => [ "--rbtest", "--line=6" ],
+      :doc_detect_rbtest => [ "--detect-rbtest", "--line=1" ],
+      :doc_detect_rbtest2 => [ "--detect-rbtest", "--line=6" ],
+    }
+    define_functional_tests File.expand_path(DIR + '/../bin/rct-doc'), tests
+  end
+
+
+  # Other tests are in test_run.rb
+  class TestRctCompleteTDC < Test::Unit::TestCase
+    test = :completion_in_method
+    inputfile = "#{DIR}/data/#{test}-input.rb"
+    outputfile = "#{DIR}/data/#{test}-output.rb"
+    test_script = "#{DIR}/data/#{test}-test.rb"
+    common_opts = ["--filename #{inputfile}", "--line 2"]
+    right_output = File.read(outputfile)
+    wrong_output = "\n"
+
+    tests = {
+      :completion_in_method__testscript =>
+        [ common_opts + ["-t #{test_script}"], right_output ],
+      :completion_in_method__testmethod =>
+        [ common_opts + ["-t #{test_script}@test_fooz"], right_output ],
+      :completion_in_method__wrong_testmethod =>
+        [ common_opts + ["-t #{test_script}@test_NOT_FOUND"], wrong_output ],
+    }
+    exec = File.expand_path(DIR + '/../bin/rct-complete')
+    tests.each_pair do |test, (opts, expected)|
+      define_method("test_#{test}") do 
+        output = `ruby -I#{LIBDIR} #{exec} #{opts.join(" ")} #{inputfile}`
+        assert_equal(expected, output)
+      end
+    end
+  end
 end

data/test/test_options.rb

@@ -5,6 +5,7 @@ require 'tmpdir'
 require 'fileutils'
 
 class TestOptionHandler < Test::Unit::TestCase
+  include Rcodetools
   include OptionHandler
 
   def include_paths_check

data/test/test_ruby_toggle_file.rb

@@ -0,0 +1,125 @@
+require 'fileutils'
+require 'test/unit'
+require 'ruby_toggle_file'
+require 'tmpdir'
+
+class TestRubyToggleFile < Test::Unit::TestCase
+  WORK_DIR = "#{Dir.tmpdir}/zdsfwfwejiotest".freeze
+  FileUtils.rm_rf WORK_DIR
+
+  FILE_MAP = {
+    :zero  => %w[lib/zero.rb     test/test_zero.rb],
+    :one   => %w[lib/one/one.rb  test/one/test_one.rb],
+    :two   => %w[lib/two/two.rb  test/test_two.rb],
+    :three => %w[three.rb        test_three.rb],
+    :four  => %w[four.rb],
+    :five  => %w[lib/five.rb],
+    :six   => %w[lib/six/six/six.rb],
+    :seven => %w[                test_seven.rb],
+    :eight => %w[                test/test_eight.rb],
+    :nine  => %w[                test/nine/nine/nine.rb],
+
+    # Rails
+    :rcontrollers => %w[app/controllers/c.rb   test/functional/c_test.rb],
+    :rmodels      => %w[app/models/m.rb        test/unit/m_test.rb],
+    :rlib         => %w[lib/l.rb               test/unit/test_l.rb app/models/m.rb],
+  }
+
+  def use_file_map(key, &block)
+    Dir.mkdir(WORK_DIR)
+    Dir.chdir(WORK_DIR) do
+      FILE_MAP[key].each do |file|
+        FileUtils.mkpath(File.dirname(file))
+        open(file, "w"){}
+      end
+    end
+
+    begin
+      yield
+    ensure
+      FileUtils.rm_rf WORK_DIR
+    end
+  end
+
+  def setup
+    @x = RubyToggleFile.new
+  end
+
+  def _(path)
+    WORK_DIR + "/" + path
+  end
+
+  def check(after, before)
+    assert_equal _(after), @x.ruby_toggle_file(_(before))
+  end
+
+  def test_test_file_file_exist
+    use_file_map(:zero)  { check "test/test_zero.rb",    "lib/zero.rb"    }
+    use_file_map(:one)   { check "test/one/test_one.rb", "lib/one/one.rb" }
+    use_file_map(:two)   { check "test/test_two.rb",     "lib/two/two.rb" }
+    use_file_map(:three) { check "test_three.rb",        "three.rb"       }
+    end
+
+  def test_test_file_file_not_exist
+    use_file_map(:four) { check "test_four.rb",             "four.rb"            }
+    use_file_map(:five) { check "test/test_five.rb",        "lib/five.rb"        }
+    use_file_map(:six)  { check "test/six/six/test_six.rb", "lib/six/six/six.rb" }
+  end
+
+  def test_implementation_file_file_exist
+    use_file_map(:zero)  { check "lib/zero.rb",    "test/test_zero.rb"    }
+    use_file_map(:one)   { check "lib/one/one.rb", "test/one/test_one.rb" }
+    use_file_map(:two)   { check "lib/two/two.rb", "test/test_two.rb"     }
+    use_file_map(:three) { check "three.rb",       "test_three.rb"        }
+  end
+
+  def test_implementation_file_file_not_exist
+    use_file_map(:seven) { check "seven.rb",     "test_seven.rb"      }
+    use_file_map(:eight) { check "lib/eight.rb", "test/test_eight.rb" }
+    use_file_map(:nine)  { check "lib/nine/nine/nine.rb", "test/nine/nine/test_nine.rb" }
+  end
+
+#  Rails test
+  def test_test_file_rails_controllers
+    use_file_map(:rcontrollers) { check "test/functional/c_test.rb", "app/controllers/c.rb" }
+  end
+
+  def test_test_file_rails_models
+    use_file_map(:rmodels) { check "test/unit/m_test.rb", "app/models/m.rb" }
+  end
+
+  def test_test_file_rails_lib
+    use_file_map(:rlib) { check "test/unit/test_l.rb", "lib/l.rb" }
+  end
+
+
+  def test_implementation_file_rails_controllers
+    use_file_map(:rcontrollers) { check "app/controllers/c.rb", "test/functional/c_test.rb" }
+  end
+
+  def test_implementation_file_rails_models
+    use_file_map(:rmodels) { check "app/models/m.rb", "test/unit/m_test.rb" }
+  end
+
+  def test_implementation_file_rails_lib
+    use_file_map(:rlib) { check "lib/l.rb", "test/unit/test_l.rb" }
+  end
+
+
+end
+
+
+class TestRunHooksWithArgsUntilSuccess < Test::Unit::TestCase
+  def m001(x) nil end
+  private
+  def m002(x) false end
+  def m003(x) 100*x end
+  def m004(x) 200 end
+
+  public
+  def test_run_hooks_with_args_until_success
+    assert_equal 1000, run_hooks_with_args_until_success(/^m\d+$/, 10)
+    assert_nil   run_hooks_with_args_until_success(/^m001$/, 10)
+    assert_equal 200, run_hooks_with_args_until_success(/^m004$/, 10)
+  end
+end