rspec 0.6.4 → 0.7.0

data/lib/spec/test_to_spec/sexp_transformer.rb

@@ -1,196 +0,0 @@
-require 'rubygems'
-require 'sexp_processor'
-
-module Spec
-  module TestToSpec
-    # Transforms a Sexp tree (produced by ParseTree) for a Test::Unit class
-    # to a Sexp tree representing an RSpec context
-    class SexpTransformer < SexpProcessor
-      TRANSLATIONS = {
-        :assert_equal          => :should_equal,
-        :assert_not_equal      => :should_not_equal,
-        :assert_same           => :should_be,
-        :assert_not_same       => :should_not_be,
-        :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_respond_to     => :should_respond_to,
-        :assert                => :should_be,
-        :assert_nil            => :should_be,
-        :assert_not_nil        => :should_not_be,
-        :assert_in_delta       => :should_be_close,
-        :assert_block          => :should_be,
-        :assert_raise          => :should_raise,
-        :assert_raises         => :should_raise,
-        :assert_nothing_raised => :should_not_raise,
-        :assert_throws         => :should_throw,
-        :assert_nothing_thrown => :should_not_throw,
-      }
-
-      def initialize
-        super
-        self.expected = Array
-        @regular_method = false
-      end
-      
-      def process_class(exp)
-        # Get the class header
-        exp.shift
-        class_name = exp.shift.to_s.split("::").last
-        context_name = class_name.match(/(.*)Test/)[1]
-        exp.shift
-
-        # Partition all methods (and other stuff) into chunks, as we're
-        # going to handle them a bit differently
-        rest = exp
-        setup,    rest = rest.partition{|e| e[0] == :defn && e[1].to_s == "setup"}
-        teardown, rest = rest.partition{|e| e[0] == :defn && e[1].to_s == "teardown"}
-        tests,    rest = rest.partition{|e| e[0] == :defn && e[1].to_s =~ /^test/}
-        methods,  rest = rest.partition{|e| e[0] == :defn}
-        
-        if !methods.empty? && setup.empty?
-          # We have some methods, but no setup to put them in. Create empty setup
-          setup[0] = [:defn, :setup, [:scope, [:block, [:args], [:nil]]]]
-        end
-        
-        context_body = []
-        unless setup.empty?
-          setup_block = process(setup.shift)
-          context_body << setup_block
-        end
-        context_body << process(teardown.shift) until teardown.empty?
-        context_body << process(tests.shift)    until tests.empty?
-
-        # At this stage we don't want to translate :lvar to :dvar
-        begin
-          @regular_method = true
-          context_body << process(methods.shift)  until methods.empty?
-        ensure
-          @regular_method = false
-        end
-
-        context_body << process(rest.shift)     until rest.empty?
-        exp.clear
-
-        result = [:iter, [:fcall, :context, [:array, [:str, context_name]]], nil]
-        if context_body.length > 1
-          result << [:block] + context_body 
-        else
-          result += context_body
-        end
-        [result]
-      end
-      
-      def process_defn(exp)
-        method_name = exp[1].to_s
-        if method_name =~ /^test_(.*)/
-          spec_name = $1.gsub(/_/, " ")
-
-          test_body = exp[2][1][2..-1]
-          exp.clear
-          block_body = []
-          @dasgn_decl = []
-          block_body << process(test_body.shift) until test_body.empty?
-          result = [:iter, [:fcall, :specify, [:array, [:str, spec_name]]], nil]
-          result << [:block] unless block_body == [[:nil]]
-          result[-1] += @dasgn_decl unless @dasgn_decl.empty?
-          result[-1] += block_body unless block_body == [[:nil]]
-          result
-        elsif method_name == "setup" || method_name == "teardown"
-          test_body = exp[2][1][2..-1]
-          exp.clear
-          block_body = []
-          @dasgn_decl = []
-          block_body << process(test_body.shift) until test_body.empty?
-          result = [:iter, [:fcall, method_name.to_sym], nil]
-          result << [:block] unless block_body == [[:nil]]
-          result[-1] += @dasgn_decl unless @dasgn_decl.empty?
-          result[-1] += block_body unless block_body == [[:nil]]
-          result
-        else
-          # Return the same method, but process the innards
-          result = [exp.shift, exp.shift] + process(exp)
-          result
-        end
-      end
-      
-      def process_lasgn(exp)
-        result = exp.dup
-        exp.clear
-        unless @regular_method
-          result[0] = :dasgn_curr
-          decl = result[0..1].dup
-          if @dasgn_decl.empty?
-            @dasgn_decl += [decl]
-          else
-            @dasgn_decl_tail << decl
-          end
-          @dasgn_decl_tail = decl
-        end
-        result
-      end
-
-      # Handles 'block' assert_ calls
-      def process_iter(exp)
-        test_unit_fcall = exp[1][1]
-        rspec_should = TRANSLATIONS[test_unit_fcall]
-        unless rspec_should.nil?
-          body = exp[3]
-          args = exp[1][2]
-          args.delete_at(2) unless args.nil? # get rid of the message arg
-          result = [:call, [:iter, [:fcall, :lambda], nil, body], rspec_should]
-          result << args unless args.nil?
-          result << [:array, [:true]] if test_unit_fcall == :assert_block
-          exp.clear
-          result
-        else
-          exp.shift
-          result = [:iter]
-          result << process(exp.shift) until exp.empty?
-          result
-        end
-      end
-
-      # Handles regular assert_ calls
-      def process_fcall(exp)
-        test_unit_fcall = exp[1]
-        rspec_should = TRANSLATIONS[test_unit_fcall]
-        unless rspec_should.nil?
-          args = exp[2]
-          actual_index = [:assert, :assert_not_nil, :assert_nil, :assert_respond_to].index(test_unit_fcall) ? 1 : 2
-          actual = args.delete_at(actual_index)
-          expected = args
-          if test_unit_fcall == :assert_in_delta
-            expected.delete_at(3)
-            expected << args.delete_at(2)
-          else
-            msg_index = (test_unit_fcall == :assert_respond_to) ? 2 : actual_index
-            expected.delete_at(msg_index)
-          end
-          expected << [:true] if test_unit_fcall == :assert
-          expected << [:nil] if [:assert_not_nil, :assert_nil].index(test_unit_fcall)
-          
-          actual = process(actual)
-          
-          result = [:call, actual, rspec_should, expected]
-          exp.clear
-          result
-        else
-          result = exp.dup
-          exp.clear
-          result
-        end
-      end
-      
-      def process_lvar(exp)
-        result = exp.dup
-        exp.clear
-        unless @regular_method
-          result[0] = :dvar
-        end
-        result
-      end
-    end
-  end
-end

data/lib/spec/test_to_spec/test_case_ext.rb

@@ -1,22 +0,0 @@
-require 'rubygems'
-require 'parse_tree'
-require 'spec/test_to_spec/sexp_transformer'
-require 'spec/test_to_spec/ruby2ruby'
-
-module Test
-  module Unit
-    class TestCase
-      # Returns a String representing the RSpec translation of this class
-      def self.to_rspec
-        tree = ParseTree.new.parse_tree(self).first
-        rspec_tree = Spec::TestToSpec::SexpTransformer.new.process(tree)
-        modules = self.name.split("::")[0..-2]
-        result = ""
-        result += modules.collect{|m| "module #{m}\n"}.join("")
-        result += RubyToRuby.new.process(rspec_tree[0])
-        result += modules.collect{|m| "\nend"}.join("")
-        result
-      end
-    end
-  end
-end

data/lib/spec/test_to_spec/translation_test_runner.rb

@@ -1,147 +0,0 @@
-require 'spec/test_to_spec/test_case_ext'
-require 'fileutils'
-require 'erb'
-
-module Spec
-  module TestToSpec
-    # 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)
-        log "Writing translated specs to #{$test2spec_options[:specdir]}"
-        ObjectSpace.each_object(Class) do |klass|
-          if klass < ::Test::Unit::TestCase
-            begin
-              translation = klass.to_rspec
-              
-              unless $test2spec_options[:dry_run]
-                relative_path = underscore(klass.name)
-                template = $test2spec_options[:template] ? IO.read($test2spec_options[:template]) : nil
-                source = render(translation, relative_path, template)
-
-                relative_path.gsub! /_test$/, "_spec"
-                relative_path += ".rb"
-                write(source, relative_path)
-              else
-                log "Successfully translated #{klass}"
-              end
-            rescue => e
-              log "Failed to translate     #{klass}"
-              verbose "Message: #{e.message}"
-              verbose e.backtrace.join("\n")
-            end
-          end
-        end
-        puts "\nDone"
-      end
-      
-      def passed?
-        true
-      end
-
-    private
-    
-      def render(translation, relative_path, template)
-        unless template.nil?
-          depth = relative_path.split('/').length-1
-          erb = ERB.new(template)
-          erb.result(binding)
-        else
-          translation
-        end
-      end
-
-      def log(msg)
-        puts msg unless quiet?
-      end
-
-      def quiet?
-        $test2spec_options[:quiet] == true
-      end
-
-      def verbose(msg)
-        puts msg if verbose?
-      end
-
-      def verbose?
-        !quiet? && $test2spec_options[:verbose] == true
-      end
-
-      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 log("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
-          end
-
-          case choice
-            when :force then log("Forcing   : #{relative_destination}")
-            when :skip  then return(log("Skipping  : #{relative_destination}"))
-          end
-        else
-          dir = File.dirname(destination)
-          unless File.directory?(dir)
-            log "Creating  : #{dir}"
-            mkdir_p dir
-          end
-          log "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
-            log "Forcing ALL"
-            :force
-          when /q/i
-            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/test/spec/expectations/arbitrary_operator_test.rb

@@ -1,55 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Spec
-  module Expectations
-    module Helper
-
-      class ArbitraryOperatorTest < Test::Unit::TestCase
-
-        # == arg
-  
-        def test_should_pass_when_equals_operator_passes
-          assert_nothing_raised do
-            (2+2).should == 4
-          end
-        end
-        
-        def test_should_fail_when_equals_operator_fails
-          assert_raise(ExpectationNotMetError) do
-            (2+2).should == 5
-          end
-        end
-
-        # =~ arg
-  
-        def test_should_pass_when_match_operator_passes
-          assert_nothing_raised do
-            "foo".should =~ /oo/
-          end
-        end
-
-        def test_should_fail_when_match_operator_fails
-          assert_raise(ExpectationNotMetError) do
-            "fu".should =~ /oo/
-          end
-        end
-
-        # < and >
-  
-        def test_should_pass_when_comparison_passes
-          assert_nothing_raised do
-            3.should_be < 4
-          end
-        end
-
-        def test_should_fail_when_comparison_fails
-          assert_raise(ExpectationNotMetError) do
-            3.should_be > 4
-          end
-        end
-
-      end
-      
-    end
-  end
-end

data/test/spec/expectations/arbitrary_predicate_test.rb

@@ -1,163 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-module Spec
-  module Expectations
-    module Helper
-
-      class ShouldBeArbitraryPredicateTest < Test::Unit::TestCase
-
-        # should_be_<predicate>
-
-        def test_should_pass_when_predicate_returns_true
-          mock = HandCodedMock.new(true)
-          assert_nothing_raised do
-            mock.should_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_fail_when_predicate_returns_false
-          mock = HandCodedMock.new(false)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_be_funny
-          end
-        end
-
-        def test_should_fail_when_predicate_returns_nil
-          mock = HandCodedMock.new(nil)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_fail_when_method_returns_something_other_than_true_false_or_nil
-          mock = HandCodedMock.new(5)
-          assert_nothing_raised do
-            mock.should_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_raise_when_target_does_not_respond_to_predicate
-          assert_raise(NoMethodError) do
-            5.should_be_funny
-          end
-        end
-
-        # should_be_funny(args)
-  
-        def test_should_pass_when_predicate_accepts_args_and_returns_true
-          mock = HandCodedMock.new(true)
-          assert_nothing_raised do
-            mock.should_be_hungry(1, 2, 3)
-          end
-          mock.__verify
-        end
-
-        def test_should_fail_when_predicate_accepts_args_and_returns_false
-          mock = HandCodedMock.new(false)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_be_hungry(1, 2, 3)
-          end
-          mock.__verify
-        end
-
-        # should_exist => exists?
-        
-        def test_should_support_plural_form
-          mock = HandCodedMock.new(true)
-          assert_nothing_raised do
-            mock.should_exist
-          end
-        end
-        
-        def test_should_support_multi_word_predicates_with_should
-          assert_nothing_raised do
-            HandCodedMock.new(true).should_multi_word_predicate
-          end
-        end
-
-        def test_should_support_multi_word_predicates_with_should_be
-          assert_nothing_raised do
-            HandCodedMock.new(true).should_be_multi_word_predicate
-          end
-        end
-
-      end
-      
-      class ShouldNotBeArbitraryPredicateTest < Test::Unit::TestCase
-
-        # should_not_be_funny
-
-        def test_should_pass_when_predicate_returns_false
-          mock = HandCodedMock.new(false)
-          assert_nothing_raised do
-            mock.should_not_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_fail_when_predicate_returns_true
-          mock = HandCodedMock.new(true)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_not_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_pass_when_predicate_returns_nil
-          mock = HandCodedMock.new(nil)
-          assert_nothing_raised do
-            mock.should_not_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_fail_when_method_returns_something_other_than_true_false_or_nil
-          mock = HandCodedMock.new(5)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_not_be_funny
-          end
-          mock.__verify
-        end
-
-        def test_should_raise_when_target_does_not_respond_to_predicate
-          assert_raise(NoMethodError) do
-            5.should_not_be_funny
-          end
-        end
-          
-        # should_be_funny(args)
-  
-        def test_should_fail_when_predicate_accepts_args_and_returns_true
-          mock = HandCodedMock.new(true)
-          assert_raise(ExpectationNotMetError) do
-            mock.should_not_be_hungry(1, 2, 3)
-          end
-          mock.__verify
-        end
-
-        def test_should_pass_when_predicate_accepts_args_and_returns_false
-          mock = HandCodedMock.new(false)
-          assert_nothing_raised do
-            mock.should_not_be_hungry(1, 2, 3)
-          end
-          mock.__verify
-        end
-
-        def test_should_support_multi_word_predicates_with_should
-          assert_nothing_raised do
-            HandCodedMock.new(false).should_not_multi_word_predicate
-          end
-        end
-
-        def test_should_support_multi_word_predicates_with_should_be
-          assert_nothing_raised do
-            HandCodedMock.new(false).should_not_be_multi_word_predicate
-          end
-        end
-      end
-    end
-  end
-end