rspec 0.5.7 → 0.5.8

data/lib/spec/tool/test_unit_translator.rb

@@ -1,112 +1,143 @@
+require 'spec/tool/ruby2ruby'
+
 module Spec
   module Tool
-    # Translates Test::Unit tests to RSpec specs.
-    class TestUnitTranslator
-      ONE_ARG_TRANSLATIONS = {
-        "assert"                => "should_not_be nil",
+    # Translates Test::Unit tests to RSpec specs,
+    # Using RubyToRuby and Sexp
+    class TestUnitTranslator < RubyToRuby
+      ONE_ARG_ASSERTIONS = ["assert", "assert_nil", "assert_not_nil"]
+      
+      PLAIN_TRANSLATIONS = {
+        "assert"                => "should_be true",
         "assert_nil"            => "should_be nil",
-        "assert_not_nil"        => "should_not_be nil"
-        
-      }
-      TWO_ARG_TRANSLATIONS = {
+        "assert_not_nil"        => "should_not_be nil",
         "assert_equal"          => "should_equal",
+        "assert_in_delta"       => "should_be_close",
         "assert_instance_of"    => "should_be_instance_of",
         "assert_kind_of"        => "should_be_kind_of",
         "assert_match"          => "should_match",
         "assert_no_match"       => "should_not_match",
         "assert_not_equal"      => "should_not_equal",
         "assert_not_same"       => "should_not_be",
+        "assert_respond_to"     => "should_respond_to",
         "assert_same"           => "should_be"
       }
-      RAISE_TRANSLATIONS = {
+      PLAIN_PATTERN = /^#{PLAIN_TRANSLATIONS.keys.join("$|^")}$/
+      
+      BLOCK_TRANSLATIONS = {
+        "assert_block"          => "should_be true",
         "assert_nothing_raised" => "should_not_raise",
         "assert_nothing_thrown" => "should_not_throw",
         "assert_raise"          => "should_raise",
         "assert_raises"         => "should_raise",
         "assert_throws"         => "should_throw",
       }
-    
-      def translate(test_unit_file)
-        content = File.open(test_unit_file)
-        end_replacement = nil
-        translated = ""
-        content.each do |line|
-          if line =~ /^require .*test.*/
-            line = "require 'spec'\n"
-          elsif line =~ /^(\s*)def\s+setup/
-            spaces = $1
-            line = "#{spaces}setup do\n"
-          elsif line =~ /^(\s*)def\s+teardown/
-            spaces = $1
-            line = "#{spaces}teardown do\n"
-          elsif line =~ /^(\s*)class\s+(.*)\s+<\s+Test::Unit::TestCase/
-            spaces = $1
-            class_name = $2
+      BLOCK_PATTERN = /^#{BLOCK_TRANSLATIONS.keys.join("$|^")}$/
 
-            context_name = class_name.match(/(.*)Test/)[1]
-            line = "#{spaces}context \"#{context_name}\" do\n"
-            
-          elsif line =~ /(\s*)def\s+test_(.*)/
-            spaces = $1
-            method_meaning = $2
+      def translate(klass)
+        process(ParseTree.new.parse_tree(klass).first)
+      end
 
-            specification_name = method_meaning.gsub(/_/, " ").capitalize
-            line = "#{spaces}specify \"#{specification_name}\" do\n"
-            
-          elsif line =~ /(\s*)(assert[^\s$\(]*)\s*\(?([^\)^\{]*)\)?\s*(.*)/
-            spaces = $1
-            assertion = $2
-            args = $3
-            suffix = $4
-            
-            if(args =~ /^do/n and suffix =="")
-              # hack to handle methods taking no args and do at the end
-              args = ""
-              suffix = "do"
-            end
+      def process_class(exp)
+        if(exp[1].to_s == "Test::Unit::TestCase")
+          module_and_class_name = exp.shift.to_s.split("::")
+          modules = module_and_class_name[0..-2]
+          class_name = module_and_class_name[-1]
+          super_class_name = exp.shift.to_s
+          context_name = class_name.match(/(.*)Test/)[1]
+
+          s = ""
+          s << modules.collect{|m| "module #{m}\n"}.join("") unless modules.empty?
+          s << "context \"#{context_name}\" do\n"
+          body = ""
+          body << "#{process exp.shift}\n\n" until exp.empty?
+          s += indent(body) + "end\n"
+          s += modules.collect{|m| "end\n"}.join("") unless modules.empty?
+        else
+          super
+        end
+      end
+
+      def process_defn(exp)
+        method_name = exp[0].to_s
+        if exp[1].first != :cfunc
+          if method_name == "setup" || method_name == "teardown"
+            name = exp.shift
+            body = process(exp.shift)
+            return "#{method_name} do #{body}end".gsub(/\n\s*\n+/, "\n")
+          elsif method_name =~ /^test_(.*)/
+            exp.shift
+            spec_name = $1.gsub(/_/, " ")
+            body = process(exp.shift)
+            return "specify \"#{spec_name}\" do #{body}end".gsub(/\n\s*\n+/, "\n")
+          else
+            super
+          end
+        else
+          super
+        end
+      end
 
-            if translation = TWO_ARG_TRANSLATIONS[assertion]
-              expected, actual, message = args.split(",").collect{|arg| arg.strip}
-              line = "#{spaces}#{actual}.#{translation} #{expected}\n"
-              
-            elsif assertion == "assert_respond_to"
-              actual, method, message = args.split(",").collect{|arg| arg.strip}
-              line = "#{spaces}#{actual}.should_respond_to #{method}\n"
-              
-            elsif translation = ONE_ARG_TRANSLATIONS[assertion]
-              actual, message = args.split(",").collect{|arg| arg.strip}
-              line = "#{spaces}#{actual}.#{translation}\n"
-              
-            elsif translation = RAISE_TRANSLATIONS[assertion] and suffix =~ /\{.*\}/
-              expected, message = args.split(",").collect{|arg| arg.strip}
-              line = "#{spaces}lambda #{suffix}.#{translation} #{expected}\n"
-              
-            elsif translation = RAISE_TRANSLATIONS[assertion]
-              expected, message = args.split(",").collect{|arg| arg.strip}
-              line = "#{spaces}lambda do\n"
-              end_replacement = "#{translation} #{expected}\n"
-              
-            elsif assertion == "assert_block" and suffix =~ /\{.*\}/
-              line = "#{spaces}lambda #{suffix}.should_be true\n"
-              
-            elsif assertion == "assert_block"
-              line = "#{spaces}lambda do\n"
-              end_replacement = "should_be true\n"
-              
-            elsif assertion == "assert_in_delta"
-              expected, actual, delta, message = args.split(",").collect{|arg| arg.strip}
-              line = "#{spaces}#{actual}.should_be_close #{expected}, #{delta}\n"
+      def process_fcall(exp)
+        if exp[0].to_s =~ PLAIN_PATTERN
+          name = exp.shift.to_s
+          args = exp.shift
+          code = []
+          unless args.nil?
+            assert_type args, :array
+            args.shift # :array
+            until args.empty? do
+              code << process(args.shift)
             end
-          elsif end_replacement && line =~ /(\s+)end/
-            spaces = $1
-            line = "#{spaces}end.#{end_replacement}"
-            end_replacement = nil
           end
           
-          translated += line unless line.nil?
+          if ONE_ARG_ASSERTIONS.index(name)
+            expected = ""
+            actual = code[0]
+          elsif(name == "assert_in_delta")
+            expected = " #{code[0]}, #{code[2]}"
+            actual = code[1]
+          elsif(name == "assert_respond_to")
+            # test::unit got this wrong. we have to swap them
+            expected = " #{code[1]}"
+            actual = code[0]
+          else
+            expected = " #{code[0]}"
+            actual = code[1]
+          end
+          translation = PLAIN_TRANSLATIONS[name]
+          raise "No translation for '#{name}'" if translation.nil?
+          return "#{actual}.#{translation}#{expected}"
+        elsif exp[0].to_s =~ BLOCK_PATTERN
+          name = exp.shift.to_s
+          args = exp.shift
+          code = []
+          unless args.nil? then
+            assert_type args, :array
+            args.shift # :array
+            until args.empty? do
+              code << process(args.shift)
+            end
+          end
+          suffix_arg = code.empty? ? "" : "(#{code[0]})"
+          @lambda_suffix = "#{BLOCK_TRANSLATIONS[name]}#{suffix_arg}"
+          return "lambda"
+        else
+          super
+        end
+      end
+      
+      def process_iter(exp)
+        result = super
+        if(@lambda_suffix)
+          suffix = @lambda_suffix
+          @lambda_suffix = nil
+          "#{result}.#{suffix}"
+        else
+          result
         end
-        translated
       end
+      
     end
   end
 end

data/lib/spec/tool/translation_test_runner.rb

@@ -0,0 +1,118 @@
+require 'spec/tool/test_unit_translator'
+require 'fileutils'
+
+module Spec
+  module Tool
+    # A Test::Unit runner that doesn't run tests, but translates them instead!
+    class TranslationTestRunner
+      include FileUtils
+
+      def self.run(suite, output_level)
+        self.new(suite)
+      end
+      
+      def initialize(suite)
+        puts "Writing translated specs to #{$test2spec_options[:specdir]}"
+        translator = TestUnitTranslator.new
+        ObjectSpace.each_object(Class) do |klass|
+          if klass < ::Test::Unit::TestCase
+            begin
+              translation = translator.translate(klass)
+              
+              unless $test2spec_options[:dry_run]
+                relative_path = underscore(klass.name)
+                relative_path.gsub! /_test$/, "_spec"
+                relative_path += ".rb"
+                write(translation, relative_path)
+              else
+                puts "Successfully translated #{klass}"
+              end
+            rescue SexpProcessorError => e
+              puts "Failed to translate     #{klass}"
+            end
+          end
+        end
+        puts "\nDone"
+      end
+      
+      def passed?
+        true
+      end
+
+    private
+
+      def destination_path(relative_destination)
+        File.join($test2spec_options[:specdir], relative_destination)
+      end
+
+      def write(source, relative_destination)
+        destination         = destination_path(relative_destination)
+        destination_exists  = File.exists?(destination)
+        if destination_exists and identical?(source, destination)
+          return puts("Identical : #{relative_destination}")
+        end
+
+        if destination_exists
+          choice = case ($test2spec_options[:collision]).to_sym #|| :ask
+            when :ask   then force_file_collision?(relative_destination)
+            when :force then :force
+            when :skip  then :skip
+            else raise "Invalid collision option: #{$test2spec_options[:collision].inspect}"
+          end
+
+          case choice
+            when :force then puts("Forcing   : #{relative_destination}")
+            when :skip  then return(puts("Skipping  : #{relative_destination}"))
+            else raise "Invalid collision choice: #{choice}.inspect"
+          end
+        else
+          dir = File.dirname(destination)
+          unless File.directory?(dir)
+            puts "Creating  : #{dir}"
+            mkdir_p dir
+          end
+          puts "Creating  : #{destination}"
+        end
+
+        File.open(destination, 'w') do |df|
+          df.write(source)
+        end
+
+        if $test2spec_options[:chmod]
+          chmod($test2spec_options[:chmod], destination)
+        end
+      
+        system("svn add #{destination}") if $test2spec_options[:svn]
+      end
+
+      def identical?(source, destination, &block)
+        return false if File.directory? destination
+        destination = IO.read(destination)
+        source == destination
+      end
+      
+      def force_file_collision?(destination)
+        $stdout.print "overwrite #{destination}? [Ynaq] "
+        case $stdin.gets
+          when /a/i
+            $test2spec_options[:collision] = :force
+            $stdout.puts "Forcing ALL"
+            :force
+          when /q/i
+            $stdout.puts "Quitting"
+            raise SystemExit
+          when /n/i then :skip
+          else :force
+        end
+      end
+
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+    end
+  end
+end

data/lib/spec/version.rb

@@ -3,7 +3,7 @@ module Spec
     unless defined? MAJOR
       MAJOR  = 0
       MINOR  = 5
-      TINY   = 7
+      TINY   = 8
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG    = "REL_" + [MAJOR, MINOR, TINY].join('_')

data/test/spec/runner/context_test.rb

@@ -17,6 +17,7 @@ module Spec
       
       def test_should_run_spec
         @formatter.should.receive(:add_context).with :any_args
+        @formatter.should.receive(:spec_started).with "test"
         @formatter.should.receive(:spec_finished).with "test", :anything, :anything
         $spec_ran = false
         @context.specify("test") {$spec_ran = true}
@@ -27,6 +28,7 @@ module Spec
          
       def test_should_run_spec_dry
         @formatter.should.receive(:add_context).with :any_args
+        @formatter.should.receive(:spec_started).with "test"
         @formatter.should.receive(:spec_finished).with "test"
         $spec_ran = false
         @context.specify("test") {$spec_ran = true}
@@ -37,6 +39,7 @@ module Spec
       
       def test_setup
         @formatter.should.receive(:add_context).with :any_args
+        @formatter.should.receive(:spec_started).with "test"
         @formatter.should.receive(:spec_finished).with :any_args
         $setup_ran = false
         @context.setup {$setup_ran = true}
@@ -48,6 +51,7 @@ module Spec
 
       def test_teardwown
         @formatter.should.receive(:add_context).with :any_args
+        @formatter.should.receive(:spec_started).with "test"
         @formatter.should.receive(:spec_finished).with :any_args
         $teardwown_ran = false
         @context.teardown {$teardwown_ran = true}

data/test/spec/runner/progress_bar_formatter_test.rb

@@ -24,7 +24,7 @@ module Spec
       end
 
       def test_should_push_F_for_failing_spec
-        @formatter.spec_failed("spec", 98)
+        @formatter.spec_failed("spec", 98, nil)
         assert_equal("F", @io.string)
       end
       

data/test/spec/runner/rdoc_formatter_test.rb

@@ -19,7 +19,7 @@ module Spec
       end
 
       def test_should_push_out_failed_spec
-        @formatter.spec_failed("spec", 98)
+        @formatter.spec_failed("spec", 98, nil)
         assert_equal("# * spec [98 - FAILED]\n", @io.string)
       end
       

data/test/spec/runner/reporter_test.rb

@@ -39,24 +39,26 @@ module Spec
       end
   
       def test_should_account_for_spec_in_stats_for_pass
-        spec = Specification.new("spec")
+        @formatter.should_receive(:spec_started)
         @formatter.should_receive(:spec_passed)
         @formatter.should_receive(:start_dump)
         @formatter.should_receive(:dump_summary).with(:anything, 0, 1, 0)
-        @reporter.spec_finished spec
+        @reporter.spec_started "spec"
+        @reporter.spec_finished "spec"
         @reporter.dump
       end
   
       def test_should_account_for_spec_and_error_in_stats_for_pass
-        spec = Specification.new("spec")
         @formatter.should_receive(:add_context)
-        @formatter.should_receive(:spec_failed).with(spec, 1)
+        @formatter.should_receive(:spec_started).with("spec")
+        @formatter.should_receive(:spec_failed).with("spec", 1, failure)
         @formatter.should_receive(:start_dump)
         @formatter.should_receive(:dump_failure).with(1, :anything)
         @formatter.should_receive(:dump_summary).with(:anything, 1, 1, 1)
         @backtrace_tweaker.should.receive(:tweak_backtrace)
         @reporter.add_context "context"
-        @reporter.spec_finished spec, RuntimeError.new
+        @reporter.spec_started "spec"
+        @reporter.spec_finished "spec", RuntimeError.new
         @reporter.dump
       end
       
@@ -74,19 +76,30 @@ module Spec
       def test_should_handle_multiple_specs_same_name
         error = RuntimeError.new
         @formatter.should_receive(:add_context).exactly(2).times
+        @formatter.should.receive(:spec_started).with("spec").exactly(4).times
         @formatter.should_receive(:spec_passed).with("spec").exactly(2).times
-        @formatter.should_receive(:spec_failed).with("spec", 1)
-        @formatter.should_receive(:spec_failed).with("spec", 2)
+        @formatter.should_receive(:spec_failed).with("spec", 1, failure) 
+        @formatter.should_receive(:spec_failed).with("spec", 2, failure)
         @formatter.should_receive(:dump_failure).exactly(2).times
         @formatter.should_receive(:start_dump)
         @formatter.should_receive(:dump_summary).with(:anything, 2, 4, 2)
         @backtrace_tweaker.should.receive(:tweak_backtrace)
         @reporter.add_context "context"
+
+        @reporter.spec_started "spec"
         @reporter.spec_finished "spec"
+
+        @reporter.spec_started "spec"
         @reporter.spec_finished "spec", error
+
         @reporter.add_context "context"
+
+        @reporter.spec_started "spec"
         @reporter.spec_finished "spec"
+
+        @reporter.spec_started "spec"
         @reporter.spec_finished "spec", error
+
         @reporter.dump
       end
       
@@ -99,6 +112,10 @@ module Spec
         @backtrace_tweaker.__verify
       end
 
+      def failure
+        Api::DuckTypeArgConstraint.new(:header, :message, :backtrace)
+      end
+
     end
   end
 end