rspec 0.4.0 → 0.5.0

data/lib/spec/runner.rb

@@ -0,0 +1,9 @@
+require 'spec/runner/instance_exec'
+require 'spec/runner/context'
+require 'spec/runner/specification'
+require 'spec/runner/execution_context'
+require 'spec/runner/context_runner'
+require 'spec/runner/option_parser'
+require 'spec/runner/backtrace_tweaker'
+require 'spec/runner/rdoc_formatter'
+require 'spec/runner/simple_text_reporter'

data/lib/spec/runner/backtrace_tweaker.rb

@@ -0,0 +1,17 @@
+module Spec
+  module Runner
+    class BacktraceTweaker
+      def tweak_backtrace error, spec_name
+        return if error.backtrace.nil?
+        tweaked_backtrace = []
+        error.backtrace.each do |line|
+          if line.include?('__instance_exec')
+            line = line.split(':in')[0] + ":in `#{spec_name}'"
+          end
+          tweaked_backtrace.push line
+        end
+        error.set_backtrace tweaked_backtrace
+      end
+    end
+  end
+end

data/lib/spec/runner/context.rb

@@ -0,0 +1,47 @@
+module Spec
+  module Runner
+    class Context
+      @@context_runner = nil
+      
+      def self.context_runner= runner
+        @@context_runner = runner
+      end
+      
+      def initialize(name, &context_block)
+        @setup_block = nil
+        @teardown_block = nil
+        @specifications = []
+        @name = name
+        instance_exec(&context_block)
+        @@context_runner.add_context(self) unless @@context_runner.nil?
+        ContextRunner.standalone(self) if @@context_runner.nil?
+      end
+
+      def run(reporter)
+        reporter.add_context(@name)
+        @specifications.each do |specification|
+          specification.run(reporter, @setup_block, @teardown_block)
+        end
+      end
+      
+      def run_docs(reporter)
+        reporter.add_context(@name)
+        @specifications.each do |specification|
+          specification.run_docs(reporter)
+        end
+      end
+
+      def setup(&block)
+        @setup_block = block
+      end
+  
+      def teardown(&block)
+        @teardown_block = block
+      end
+  
+      def specify(spec_name, &block)
+        @specifications << Specification.new(spec_name, &block)
+      end
+    end
+  end
+end

data/lib/spec/runner/context_runner.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../../spec'
+
+module Spec
+  module Runner
+    class ContextRunner
+      
+      def self.standalone context
+        context_runner = ContextRunner.new(ARGV)
+        context_runner.add_context context
+        context_runner.run
+      end
+ 
+      def initialize(args)
+        options = OptionParser.parse(args)
+        @contexts = []
+        @out = options.out
+        @out = File.open(@out, 'w') if @out.is_a? String
+        @doc = options.doc
+        @listener = RDocFormatter.new(@out) if @doc
+        @listener = SimpleTextReporter.new(@out, options.verbose) unless @doc
+      end
+    
+      def add_context(context)
+        @contexts << context
+        self
+      end
+      
+      def run
+        run_specs unless @doc
+        run_docs if @doc
+      end
+    
+      private
+      
+      def run_specs
+        @listener.start
+        @contexts.each do |context|
+          context.run(@listener)
+        end
+        @listener.end
+        @listener.dump
+      end
+    
+      def run_docs
+        @contexts.each do |context|
+          context.run_docs(@listener)
+        end
+      end
+
+    end
+  end
+end

data/lib/spec/runner/execution_context.rb

@@ -0,0 +1,15 @@
+module Spec
+  module Runner
+    class ExecutionContext
+      def initialize(spec)
+        @spec = spec
+      end
+      
+      def mock(name)
+        mock = Api::Mock.new(name)
+        @spec.add_mock(mock)
+        mock
+      end
+    end
+  end
+end

data/lib/spec/runner/instance_exec.rb

@@ -0,0 +1,15 @@
+# http://eigenclass.org/hiki.rb?cmd=view&p=instance_exec&key=instance_exec
+class Object
+  module InstanceExecHelper; end
+  include InstanceExecHelper
+  def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
+    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+    InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
+    end
+    ret
+  end
+end

data/lib/spec/runner/kernel_ext.rb

@@ -0,0 +1,6 @@
+module Kernel
+  def context(name, &block)
+    Spec::Runner::Context.new(name, &block) unless $generating_docs
+    Spec::Runner::DocumentationContext.new(name, &block) if $generating_docs
+  end
+end

data/lib/spec/runner/option_parser.rb

@@ -0,0 +1,41 @@
+require 'ostruct'
+require 'optparse'
+module Spec
+  module Runner
+    class OptionParser
+
+      def self.parse(args)
+        options = OpenStruct.new
+        options.out = $stdout
+        options.verbose = false;
+        options.doc = false;
+
+        opts = ::OptionParser.new do |opts|
+          opts.banner = "Usage: specdoc [options] FILE|DIRECTORY"
+          opts.separator ""
+
+          opts.on("-o", "--of [FILE]", "Set the output file (defaults to STDOUT)") do |outfile|
+            options.out = outfile unless outfile.nil?
+            exit if outfile.nil?
+          end
+
+          opts.on("-v", "--verbose") do
+            options.verbose = true
+          end
+
+          opts.on("-d", "--doc", "Generate documentation") do
+            options.doc = true
+          end
+
+          opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+
+        end
+        opts.parse!(args)
+        options
+      end
+    end
+  end
+end

data/lib/spec/runner/rdoc_formatter.rb

@@ -0,0 +1,17 @@
+module Spec
+  module Runner
+    class RDocFormatter
+      def initialize(output=STDOUT)
+        @output = output
+      end
+  
+      def add_context(name)
+        @output << "# #{name}\n"
+      end
+  
+      def add_spec(name)
+        @output << "# * #{name}\n"
+      end
+    end
+  end
+end

data/lib/spec/runner/simple_text_reporter.rb

@@ -0,0 +1,92 @@
+module Spec
+  module Runner
+    class SimpleTextReporter
+      def initialize(output=STDOUT,verbose=false,backtrace_tweaker=BacktraceTweaker.new)
+        @output = output
+        @context_names = []
+        @errors = []
+        @spec_names = []
+        @verbose = verbose
+        @backtrace_tweaker = backtrace_tweaker
+      end
+  
+      def add_context(name)
+        @output << "\n" if @context_names.empty? unless @verbose
+        @output << "\n#{name}\n" if @verbose
+        @context_names << name
+      end
+      
+      def add_spec(name, errors=[])
+        if errors.empty?
+          spec_passed(name)
+        else
+          errors.each { |error| @backtrace_tweaker.tweak_backtrace(error, name) }
+          # only show the first one (there might be more)
+          spec_failed(name, errors[0])
+        end
+      end
+      
+      def start
+        @start_time = Time.new
+      end
+  
+      def end
+        @end_time = Time.new
+      end
+  
+      def dump
+        unless @verbose
+          @output << "\n"
+          dump_failures
+          @output << "\n\n" unless @errors.empty?
+        end
+        @output << "\n" if @errors.empty?
+        @output << "Finished in " << (duration).to_s << " seconds\n\n"
+        @output << "#{@context_names.length} context#{'s' unless @context_names.length == 1 }, "
+        @output << "#{@spec_names.length} specification#{'s' unless @spec_names.length == 1 }, "
+        @output << "#{@errors.length} failure#{'s' unless @errors.length == 1 }"
+        @output << "\n"
+      end
+
+      def dump_failures
+        return if @errors.empty?
+        @output << "\n"
+        @errors.inject(1) do |index, error|
+          @output << "\n\n" if index > 1
+          @output << index.to_s << ") " 
+          @output << "#{error.message} (#{error.class.name})\n"
+          dump_backtrace(error.backtrace)
+          index + 1
+        end
+      end
+
+      def dump_backtrace(trace)
+        @output << trace.join("\n") unless trace.nil?
+      end
+
+      private
+  
+        def duration
+          return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
+          return "0.0"
+        end
+
+        def spec_passed(name)
+          @spec_names << name
+          @output << "- #{name}\n" if @verbose
+          @output << '.' unless @verbose
+        end
+
+        def spec_failed(name, error)
+          @spec_names << name
+          @errors << error
+          if @verbose
+            @output << "- #{name} (FAILED)\n#{error.message} (#{error.class.name})\n#{error.backtrace.join("\n")}\n"
+          else
+            @output << 'F'
+          end
+        end
+
+    end
+  end
+end

data/lib/spec/runner/specification.rb

@@ -0,0 +1,42 @@
+module Spec
+  module Runner
+    class Specification
+    
+      def initialize(name, &block)
+        @name = name
+        @block = block
+        @mocks = []
+        @errors = []
+      end
+    
+      def run(reporter=nil, setup_block=nil, teardown_block=nil)
+        execution_context = ::Spec::Runner::ExecutionContext.new(self)
+        begin
+          execution_context.instance_exec(&setup_block) unless setup_block.nil?
+          execution_context.instance_exec(&@block)
+        rescue => e
+          @errors << e
+        end
+
+        begin
+          execution_context.instance_exec(&teardown_block) unless teardown_block.nil?
+          @mocks.each do |mock|
+            mock.__verify
+          end
+        rescue => e
+          @errors << e
+        end
+
+        reporter.add_spec(@name, @errors) unless reporter.nil?
+      end
+    
+      def run_docs(reporter)
+        reporter.add_spec(@name)
+      end
+    
+      def add_mock(mock)
+        @mocks << mock
+      end
+    end
+  end
+end

data/lib/spec/tool/command_line.rb

@@ -0,0 +1,39 @@
+require 'find'
+require 'fileutils'
+
+module Spec
+  module Tool
+    class CommandLine
+      def initialize(filesystem=nil)
+        @filesystem = filesystem.nil? ? self : filesystem
+        @translator = TestUnitTranslator.new
+      end
+    
+      def run(source, dest, out)
+        if FileTest.directory?(source)
+          raise "DEST must be a directory when SOURCE is a directory" if FileTest.file?(dest)
+          Find.find(source) do |path|
+            if FileTest.file?(path) and File.extname(path) == '.rb'
+              relative_path = path[source.length+1..-1]
+              dest_path = File.join dest, relative_path
+              run path, dest_path, out
+            end
+          end
+        else
+          raise "DEST must be a file when SOURCE is a file" if FileTest.directory?(dest)
+          out.puts "Writing: #{dest}"
+          @filesystem.write_translation(source, dest)
+        end
+      end
+      
+      def write_translation(source, dest)
+        dir = File.dirname(dest)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+        File.open(dest, "w") do |io|
+          translation = @translator.translate(source)
+          io.write(translation)
+        end
+      end
+    end
+  end
+end

data/lib/spec/tool/test_unit_translator.rb

@@ -0,0 +1,112 @@
+module Spec
+  module Tool
+    # Translates Test::Unit tests to RSpec specs.
+    class TestUnitTranslator
+      ONE_ARG_TRANSLATIONS = {
+        "assert"                => "should.not.be nil",
+        "assert_nil"            => "should.be nil",
+        "assert_not_nil"        => "should.not.be nil"
+        
+      }
+      TWO_ARG_TRANSLATIONS = {
+        "assert_equal"          => "should.equal",
+        "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_same"           => "should.be"
+      }
+      RAISE_TRANSLATIONS = {
+        "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
+
+            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
+
+            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
+
+            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"
+            end
+          elsif end_replacement && line =~ /(\s+)end/
+            spaces = $1
+            line = "#{spaces}end.#{end_replacement}"
+            end_replacement = nil
+          end
+          
+          translated += line unless line.nil?
+        end
+        translated
+      end
+    end
+  end
+end