rspec 0.5.7 → 0.5.8

data/doc/src/tools/index.page

@@ -45,5 +45,5 @@ it right away.
 
 h3. 7) Test::Unit translation
 
-Did you invest a lot of time in writing Test::Unit tests and want to switch to RSpec? Try out the test2rspec
-tool, which will do most of the translation for you. (test2rspec tool is experimental)
+Did you invest a lot of time in writing Test::Unit tests and want to switch to RSpec? Try out the test2spec
+tool, which will do most of the translation for you. (test2spec tool is experimental)

data/doc/src/tools/meta.info

@@ -10,7 +10,7 @@ rake.page:
 rcov.page:
   orderInfo: 13
 
-test2rspec.page:
+test2spec.page:
   orderInfo: 14
 
 rails.page:

data/doc/src/tools/test2spec.page

@@ -0,0 +1,73 @@
+---
+title: Test::Unit Migration
+inMenu: true
+---
+h2. Test::Unit migration
+
+RSpec's test2spec command line tool translates existing Test::Unit classes to RSpec.  
+
+Before you can use test2spec you must gem install ParseTree and RubyInline.
+RubyInline only work on systems that have a C compiler - i.e. most anything except Windows.
+
+If you're stuck on Windows, ask a friend who has a POSIX system to translate your specs.
+Once translated they can run on any Ruby platform (including Windows). After all, it's
+just Ruby.
+
+h2. The test2spec command line
+
+<pre>
+test2spec --help
+{execute: ruby ../bin/test2spec --help}
+</pre>
+
+A typical invocation might look like this:
+
+<pre>
+test2spec --specdir spec test
+</pre>
+
+h2. Sample output
+
+<notextile>
+<table>
+  <thead>
+    <tr>
+      <td>Test::Unit</td>
+      <td>RSpec (translated by test2spec)</td>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>
+        <ruby file="../test/spec/tool/test_unit_api_test.rb"/>
+      </td>
+      <td>
+        <ruby file="../test/spec/tool/test_unit_api_spec.rb"/>
+      </td>
+    </tr>
+  </tbody>
+</table>
+</notextile>
+
+h2. Troubleshooting
+
+In some cases, test2spec will not be able to translate a test class. In that case, please submit a bug report
+at RSpec's bug report system  along with some code so we can reproduce (and hopefully - fix) the problem. 
+-Or better - submit a patch.
+
+h2. Internals
+
+The test2spec tool is based on three other tools:
+
+* "RubyToRuby":http://blog.zenspider.com/archives/2005/02/rubytoruby.html
+* "ParseTree":http://rubyforge.org/projects/parsetree/
+* "RubyInline":http://rubyforge.org/projects/rubyinline/
+
+In fact, it's based on a modified version of "George Moschovitis' RubyToRuby enhancement":http://dark.fhtr.org/ruby2ruby.rb
+of "Ryan Davis' original RubyToRuby":http://blog.zenspider.com/archives/2005/02/rubytoruby.html.
+
+It has been modified to fix some subtle bugs that were not found by Gerorge's tests. The modified RubyToRuby
+currently lives in RSpec's subversion repository.
+
+The translation is done by TestUnitTranslator - subclass of RubyToRuby that writes out the syntax tree a little differently than
+its superclass. TestUnitTranslator looks for certain Test::Unit patterns and writes out an RSpec translation instead.

data/doc/src/tutorials/notes.txt

@@ -177,7 +177,7 @@ context "An empty stack" do
   end
 end
 </ruby>
-<br>
+
 <pre>$ spec stack_spec.rb -f s
 
 A new stack

data/doc/src/tutorials/stack_01.page

@@ -68,7 +68,7 @@ context "A new stack" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -153,7 +153,7 @@ context "A new stack" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -180,7 +180,7 @@ class Stack
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -206,7 +206,7 @@ class Stack
   end
 end
 </ruby>
-<br>
+
 <pre>
 spec stack_spec.rb -f s
 

data/doc/src/tutorials/stack_02.page

@@ -12,7 +12,7 @@ context "An empty stack" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -38,7 +38,7 @@ context "An empty stack" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -65,7 +65,7 @@ context "An empty stack" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -96,7 +96,7 @@ class Stack
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -126,7 +126,7 @@ context "An empty stack" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -161,7 +161,7 @@ class Stack
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 

data/doc/src/tutorials/stack_03.page

@@ -18,7 +18,7 @@ context "A stack with one item" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -49,7 +49,7 @@ context "A stack with one item" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -81,7 +81,7 @@ context "A stack with one item" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -113,7 +113,7 @@ class Stack
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -146,7 +146,7 @@ class Stack
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -187,7 +187,7 @@ class Stack
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -224,7 +224,7 @@ class Stack
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -257,7 +257,7 @@ class Stack
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 

data/doc/src/tutorials/stack_04.page

@@ -95,7 +95,7 @@ context "A stack with one item" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 
@@ -143,7 +143,7 @@ context "A stack with one item" do
   end
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 

data/doc/src/tutorials/stack_05.page

@@ -65,7 +65,7 @@ context "A stack with one item" do
   ...
 end
 </ruby>
-<br>
+
 <pre>
 $ spec stack_spec.rb -f s
 

data/lib/spec/api/sugar.rb

@@ -17,13 +17,13 @@ module Spec
         __orig_method_missing(sym, *args, &block)
       end
       
-      def __is_sweetened? sym
+      def __is_sweetened?(sym) #:nodoc:
         return true if sym.to_s =~ /^should_/
       end
     end
     
     module MessageExpectationSugar
-      def __is_sweetened? sym
+      def __is_sweetened?(sym) #:nodoc:
         return true if sym.to_s =~ /^and_|^at_|^any_|^once_/
       end
     end
@@ -35,7 +35,7 @@ class Object #:nodoc:
 end
 
 class Spec::Api::Mock #:nodoc:
-  #NOTE: this resolves a bug caused by a conflict between Sugar#method_missing and Mock#method_missing, specifically
+  # NOTE: this resolves a bug caused by a conflict between Sugar#method_missing and Mock#method_missing, specifically
   # when the mock is set null_object=>true. It would be nice to get rid of this.
   def should_receive(sym, &block)
     return receive(sym, &block)

data/lib/spec/runner/base_text_formatter.rb

@@ -22,18 +22,24 @@ module Spec
       # +name+ is the name of the context and +first+ is true if it is the
       # first context - otherwise it's false.
       #
+      # The next method to be invoked after this is #spec_started
+      def add_context(name, first)
+      end
+
+      # This method is invoked right before a spec is executed.
       # The next method to be invoked after this one is one of #spec_failed
       # or #spec_passed.
-      def add_context(name, first)
+      def spec_started(name)
       end
 
-      # This method is invoked whenever a spec fails, i.e. an exception occurred
+      # This method is invoked when a spec fails, i.e. an exception occurred
       # inside it (such as a failed should or other exception). +name+ is the name
-      # of the specification.
-      def spec_failed(name)
+      # of the specification. +counter+ is the sequence number of the failure
+      # (starting at 1) and +failure+ is the associated Failure object.
+      def spec_failed(name, counter, failure)
       end
 
-      # This method is invoked whwnever a spec passes. +name+ is the name of the
+      # This method is invoked when a spec passes. +name+ is the name of the
       # specification.
       def spec_passed(name)
       end

data/lib/spec/runner/option_parser.rb

@@ -65,7 +65,7 @@ module Spec
             exit if out == $stdout
           end
 
-          opts.on_tail("-h", "--help", "Show this message") do
+          opts.on_tail("-h", "--help", "You're looking at it") do
             out.puts opts
             exit if out == $stdout
           end

data/lib/spec/runner/progress_bar_formatter.rb

@@ -5,7 +5,7 @@ module Spec
         @output << "\n" if first
       end
       
-      def spec_failed(name, counter)
+      def spec_failed(name, counter, failure)
         @output << 'F'
       end
       

data/lib/spec/runner/rdoc_formatter.rb

@@ -9,7 +9,7 @@ module Spec
         @output << "# * #{name}\n"
       end
 
-      def spec_failed(name, counter)
+      def spec_failed(name, counter, failure)
         @output << "# * #{name} [#{counter} - FAILED]\n"
       end
     end

data/lib/spec/runner/reporter.rb

@@ -16,6 +16,11 @@ module Spec
         @context_names << name
       end
       
+      def spec_started(name)
+        @spec_names << name
+        @formatter.spec_started(name)
+      end
+      
       def spec_finished(name, error=nil, failure_location=nil)
         if error.nil?
           spec_passed(name)
@@ -58,14 +63,12 @@ module Spec
       end
 
       def spec_passed(name)
-        @spec_names << name
         @formatter.spec_passed(name)
       end
 
       def spec_failed(name, failure)
-        @spec_names << name
         @failures << failure
-        @formatter.spec_failed(name, @failures.length)
+        @formatter.spec_failed(name, @failures.length, failure)
       end
 
       class Failure

data/lib/spec/runner/specdoc_formatter.rb

@@ -5,7 +5,7 @@ module Spec
         @output << "\n#{name}\n"
       end
       
-      def spec_failed(name, counter)
+      def spec_failed(name, counter, failure)
         @output << "- #{name} (FAILED - #{counter})\n"
       end
       

data/lib/spec/runner/specification.rb

@@ -9,6 +9,7 @@ module Spec
       end
     
       def run(reporter=nil, setup_block=nil, teardown_block=nil, dry_run=false)
+        reporter.spec_started(@name)
         if dry_run
           reporter.spec_finished(@name)
         else

data/lib/spec/tool/ruby2ruby.rb

@@ -0,0 +1,485 @@
+# Taken from http://dark.fhtr.org/ruby2ruby.rb
+
+require 'rubygems'
+require 'parse_tree'
+require 'support'
+require 'sexp_processor'
+
+
+class RubySource < String
+
+  def inspect
+    "\n"+to_s
+  end
+
+end
+
+
+class Object
+
+  def parse_tree(method_name=nil)
+    if method_name
+      m = method(method_name)
+      klass = m.defined_in
+      method_name = m.name
+      return ParseTree.new.parse_tree_for_method(klass, method_name)
+    elsif is_a?(Class)
+      klass = self
+    else
+      klass = self.class
+    end
+    ParseTree.new.parse_tree(klass).first
+  end
+
+  def source(method_name=nil)
+    RubySource.new RubyToRuby.new.process(parse_tree(method_name))
+  end
+
+end
+
+
+class Method
+
+  def defined_in
+    full_name = to_s.split(" ").last.chop
+    klass_name = full_name.split(/[\#\.]/).first
+    if klass_name.include?("(")
+      klass_name = klass_name.split("(").last.chop
+    end
+    klass = klass_name.split("::").inject(Object){|o,n| o.const_get(n)}
+    klass
+  end
+
+  def name
+    full_name = to_s.split(" ").last.chop
+    full_name.split(/[\#\.]/).last
+  end
+
+end
+
+
+class RubyToRuby < SexpProcessor
+
+  def self.translate(klass, method=nil)
+    RubySource.new(
+      unless method.nil? then
+        self.new.process(ParseTree.new.parse_tree_for_method(klass, method))
+      else
+        self.new.process(ParseTree.new.parse_tree(klass).first) # huh? why is the :class node wrapped?
+      end
+    )
+  end
+
+  def initialize
+    super
+    @env = Environment.new
+    @indent = "  "
+    self.auto_shift_type = true
+    self.strict = true
+    self.expected = String
+  end
+  
+  def indent(s)
+    s.to_s.map{|line| @indent + line}.join
+  end
+  
+  def process_and(exp)
+    "(#{process exp.shift} and #{process exp.shift})"
+  end
+  
+  def process_args(exp)
+    args = []
+
+    until exp.empty? do
+      arg = exp.shift
+      if arg.is_a? Array
+        args[-(arg.size-1)..-1] = arg[1..-1].map{|a| process a}
+      else
+        args << arg
+      end
+    end
+
+    args.empty? ? "" : "(#{args.join ', '})"
+  end
+  
+  def process_array(exp)
+    code = []
+    until exp.empty? do
+      code << process(exp.shift)
+    end
+    return "[" + code.join(", ") + "]"
+  end
+
+  def process_attrasgn(exp)
+    process_call(exp)
+  end
+
+  def process_begin(exp)
+    s = "begin\n"
+    s << (process(exp.shift).to_s + "\n") until exp.empty?
+    s + "\nend"
+  end
+  
+  def process_block(exp)
+    code = []
+    catch_block_arg = false
+    until exp.empty? do
+      if catch_block_arg
+        if exp.first and exp.first.first == :block_arg
+          code[-1] = code[-1][0..-2] + ", #{process(exp.shift)})"
+        end
+        catch_block_arg = false
+      else
+        if exp.first.first == :args
+          catch_block_arg = true
+        end
+        if [:ensure, :rescue].include? exp.first.first 
+          code << process(exp.shift)
+        else
+          code << indent(process(exp.shift))
+        end
+      end
+    end
+
+    body = code.join("\n")
+    body += "\n"
+
+    return body
+  end
+
+  def process_block_arg(exp)
+    "&#{exp.shift}"
+  end
+  
+  def process_block_pass(exp)
+    bname = process(exp.shift)
+    fcall = process(exp.shift)
+    if fcall[-1,1] == ')'
+      "#{fcall[0..-2]}, &(#{bname}))"
+    else
+      "#{fcall}(&(#{bname}))"
+    end
+  end
+  
+  def process_call(exp)
+    receiver = process exp.shift
+    name = exp.shift
+    args_exp = exp.shift
+    if args_exp && args_exp.first == :array
+      args = "#{process(args_exp)[1..-2]}"
+    else
+      args = process args_exp
+    end
+
+    case name
+    when :<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :% then #
+      "(#{receiver} #{name} #{args})"
+    when :[] then
+      "#{receiver}[#{args}]"
+    else
+      "#{receiver}.#{name}#{args ? "(#{args})" : args}"
+    end
+  end
+  
+  def process_case(exp)
+    s = "case #{process exp.shift}\n"
+    until exp.empty?
+      pt = exp.shift
+      if pt and pt.first == :when
+        s << "#{process(pt)}\n"
+      else
+        s << "else\n#{indent(process(pt))}\n"
+      end
+    end
+    s + "\nend"
+  end
+  
+  def process_class(exp)
+    s = "class #{exp.shift} < #{exp.shift}\n"
+    body = ""
+    body << "#{process exp.shift}\n\n" until exp.empty?
+    s + indent(body) + "end"
+  end
+  
+  def process_colon2(exp)
+    "#{process(exp.shift)}::#{exp.shift}"
+  end
+  
+  def process_const(exp)
+    exp.shift.to_s
+  end
+  
+  def process_dasgn_curr(exp)
+    s = exp.shift.to_s 
+    unless exp.empty?
+      s += "=" + process(exp.shift) 
+    else 
+      if(@block_params)
+        s
+      else
+        ""
+      end
+    end
+  end
+  
+  def process_defn(exp)
+    if exp[1].first == :cfunc
+      s = "# method '#{exp.shift}' defined in a C function"
+      exp.shift
+      return s
+    else
+      name = exp.shift
+      args = process(exp.shift)
+      return "def #{name}#{args}end".gsub(/\n\s*\n+/, "\n")
+    end
+  end
+  
+  def process_dot2(exp)
+    "(#{process exp.shift}..#{process exp.shift})"
+  end
+
+  def process_dot3(exp)
+    "(#{process exp.shift}...#{process exp.shift})"
+  end
+  
+  def process_dstr(exp)
+    s = exp.shift.dump[0..-2]
+    until exp.empty?
+      pt = exp.shift
+      if pt.first == :str
+        s << process(pt)[1..-2]
+      else
+        s << '#{' + process(pt) + '}'
+      end
+    end
+    s + '"'
+  end
+
+  def process_dvar(exp)
+    exp.shift.to_s
+  end
+
+  def process_ensure(exp)
+    process(exp.shift) + "\n" +
+    "ensure\n" +
+    indent(process(exp.shift))
+  end
+  
+  def process_false(exp)
+    "false"
+  end
+  
+  def process_fbody(exp)
+    process(exp.shift)
+  end
+  
+  def process_fcall(exp)
+    exp_orig = exp.deep_clone
+    # [:fcall, :puts, [:array, [:str, "This is a weird loop"]]]
+    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
+    return "#{name}(#{code.join(', ')})"
+  end
+  
+  def process_for(exp)
+    s = "for #{process(exp[1])} in #{process(exp[0])}\n"
+    2.times{ exp.shift }
+    s += indent("#{process(exp.shift)}\n")
+    s += "end"
+  end
+  
+  def process_gvar(exp)
+    exp.shift.to_s
+  end
+  
+  def process_hash(exp)
+    body = []
+    body << "#{process(exp.shift)} => #{process(exp.shift)}" until exp.empty?
+    body_str = ""
+    body_str = "\n"+indent(body.join(",\n"))+"\n" unless body.empty?
+    "{" + body_str + "}"
+  end
+  
+  def process_iasgn(exp)
+    "#{exp.shift} = #{process exp.shift}"
+  end
+  
+  def cond_indent_process(pt)
+    (pt and pt.first == :block) ? process(pt) : indent(process(pt))
+  end
+  
+  def process_if(exp)
+    s = ["if (#{process exp.shift})"]
+    s << "#{cond_indent_process(exp.shift)}"
+    s << "else\n#{cond_indent_process(exp.shift)}" until exp.empty?
+    s << "end"
+    s.join("\n")
+  end
+  
+  def process_iter(exp)
+    owner = exp.shift
+    args = exp.shift
+    if !args.nil?
+      @block_params = true 
+    end
+    processed_args = process args
+    block_args = processed_args.nil? ? "" : "|#{processed_args}|"
+    
+    result = "#{process owner} {#{block_args}\n" +
+    indent("#{process exp.shift}\n") +
+    "}"
+    @block_params = false
+    result
+  end
+  
+  def process_ivar(exp)
+    exp.shift.to_s
+  end
+  
+  def process_lasgn(exp)
+    s = "#{exp.shift}" 
+    s += " = #{process exp.shift}" unless exp.empty?
+    s
+  end
+  
+  def process_lit(exp)
+    obj = exp.shift
+    if obj.is_a? Range # to get around how parsed ranges turn into lits and lose parens
+      "(" + obj.inspect + ")"
+    else
+      obj.inspect
+    end
+  end
+  
+  def process_lvar(exp)
+    exp.shift.to_s
+  end
+  
+  def process_masgn(exp)
+    process(exp.shift)[1..-2]
+  end
+
+  def process_module(exp)
+    s = "module #{exp.shift}\n"
+    body = ""
+    body << "#{process exp.shift}\n\n" until exp.empty?
+    s + indent(body) + "end"
+  end
+  
+  def process_nil(exp)
+    "nil"
+  end
+  
+  def process_not(exp)
+    "(not #{process exp.shift})"
+  end
+  
+  def process_or(exp)
+    "(#{process exp.shift} or #{process exp.shift})"
+  end
+  
+  def process_resbody(exp)
+    s = "rescue "
+    unless exp.empty?
+      if exp.first.first == :array
+        s << process(exp.shift)[1..-2]
+      end
+      s << "\n"
+    end
+    s << (process(exp.shift).to_s + "\n") until exp.empty?
+    s
+  end
+  
+  def process_rescue(exp)
+    s = ""
+    s << (process(exp.shift).to_s + "\n") until exp.empty?
+    s
+  end
+  
+  def process_retry(exp)
+    "retry"
+  end
+  
+  def process_return(exp)
+    return "return #{process exp.shift}"
+  end
+
+  def process_scope(exp)
+    return process(exp.shift)
+  end
+
+  def process_self(exp)
+    "self"
+  end
+  def process_str(exp)
+    return exp.shift.dump
+  end
+
+  def process_super(exp)
+    "super(#{process(exp.shift)})"
+  end
+  
+  def process_true(exp)
+    "true"
+  end
+
+  def process_until(exp)
+    cond_loop(exp, 'until')
+  end
+  
+  def process_vcall(exp)
+    return exp.shift.to_s
+  end
+  
+  def process_when(exp)
+    "when #{process(exp.shift).to_s[1..-2]}\n#{indent(process(exp.shift))}"
+  end
+
+  def process_while(exp)
+    cond_loop(exp, 'while')
+  end
+  
+  def process_yield(exp)
+    body = process(exp.shift)[1..-2] unless exp.empty?
+    "yield#{body and "(#{body})"}"
+  end
+  
+  def process_zarray(exp)
+    "[]"
+  end
+
+  def process_zsuper(exp)
+    "super"
+  end
+  
+#  def process_dxstr(exp)
+#    puts "DXSTR:#{exp.shift}"
+#  end
+  
+  def cond_loop(exp, name)
+    cond = process(exp.shift)
+    body = cond_indent_process(exp.shift)
+    head_controlled = exp.empty? ? false : exp.shift
+
+    code = []
+    if head_controlled then
+      code << "#{name} (#{cond}) do"
+      code << body
+      code << "end"
+    else
+      code << "begin"
+      code << body
+      code << "end #{name} (#{cond})"
+    end
+    code.join("\n")
+  end
+  
+end