rspec 0.6.4 → 0.7.0

data/bin/test2spec

@@ -1,112 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-require 'test/unit/ui/testrunnerutilities'
-require 'test/unit/ui/testrunnermediator'
-require 'test/unit/autorunner'
-require 'optparse'
-
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-require 'spec/test_to_spec/translation_test_runner'
-require 'spec/version'
-
-$test2spec_options = {
-  :collision => :ask,
-  :verbose => false
-}
-
-opts = OptionParser.new do |opts|
-  opts.banner = "Usage: test2spec [options] (FILE|DIRECTORY|GLOB)+"
-  opts.separator ""
-
-  opts.on("-s", "--specdir DIRECTORY", "Directory where specs will be written") do |dir|
-    $test2spec_options[:specdir] = dir
-  end
-
-  opts.on("-t", "--template FILE", 
-    "ERB template that will be used to decorate each translated file.",
-    "The template has access to the following variables:",
-    "  translation   : the translated source code",
-    "  depth         : the directory depth of the file to be written",
-    "  relative_path : the relative name of the file to be written"
-  ) do |file|
-    $test2spec_options[:template] = file
-  end
-
-  opts.on("-c", "--chmod MODIFIERS", Integer, "Change file modifiers on written files (POSIX only)") do |mods|
-    $test2spec_options[:chmod] = mods
-  end
-
-  opts.on("--svn", "Add written files to subversion") do
-    $test2spec_options[:svn] = true
-  end
-
-  opts.on("-f", "--force", "Forcefully overwrite existing specs") do
-    $test2spec_options[:collision] = :force
-  end
-
-  opts.on("-q", "--quiet", "Don't print anything to stdout") do
-    $test2spec_options[:quiet] = true
-  end
-
-  opts.on("--verbose", "Be extra verbose (printing backtraces when classes can't be translated)") do
-    $test2spec_options[:verbose] = true
-  end
-
-  opts.on("-v", "--version", "Show version") do
-    puts "test2spec #{Spec::VERSION::DESCRIPTION}"
-    exit
-  end
-
-  opts.on("-d", "--dry-run", "Don't write anything - just verify that translation works") do
-    $test2spec_options[:dry_run] = true
-  end
-
-  opts.on_tail("-h", "--help", "You're looking at it") do
-    puts opts
-    exit
-  end
-end
-
-opts.parse! ARGV
-
-if($test2spec_options[:specdir].nil?)
-  STDERR.puts "ERROR: --specdir must be specified"
-  puts opts
-  exit 1
-end
-
-if(ARGV.empty?)
-  STDERR.puts "ERROR: At least one directory, file or glob must be specified"
-  puts opts
-  exit 1
-end
-
-module Test
-  module Unit
-    class AutoRunner
-      def initialize(standalone)
-        @standalone = standalone
-        @runner = proc { |r| Spec::TestToSpec::TranslationTestRunner }
-        @collector = COLLECTORS[(standalone ? :dir : :objectspace)]
-        @filters = []
-        @to_run = []
-        yield(self) if(block_given?)
-      end
-    end
-  end
-end
-
-# If ARGV is a glob, it will actually each over each one of the matching files.
-ARGV.each do |arg|
-  if File.directory?(arg)
-    Dir["#{arg}/**/*.rb"].each do |file| 
-      require "#{file}"
-    end
-  else
-    require arg
-  end
-end

data/examples/helper_method_spec.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__)  + '/../lib/spec'
-
-context "Rspec" do
-  specify "should allow you to define helper methods" do
-    a_method
-    @a_method_called.should_be true
-  end
-
-  def a_method
-    @a_method_called = true
-  end
-end

data/lib/spec/expectations/have_helper.rb

@@ -1,41 +0,0 @@
-module Spec
-  module Expectations
-    class HaveHelper < ShouldBase
-
-      def initialize(target, relativity=:exactly, expected=nil)
-        @target = target
-        @expected = expected == :no ? 0 : expected
-        @at_least = (relativity == :at_least)
-        @at_most = (relativity == :at_most)
-      end
-    
-      def method_missing(sym, *args)
-        fail_with_message(build_message(sym, args)) unless as_specified?(sym, args)
-      end
-    
-      def collection(sym, args)
-        @target.send(sym, *args)
-      end
-    
-      def actual_size(collection)
-        return collection.length if collection.respond_to? :length
-        return collection.size if collection.respond_to? :size
-      end
-    
-      def build_message(sym, args)
-        message = "#{@target.inspect_for_expectation_not_met_error} should have"
-        message += " at least" if @at_least
-        message += " at most" if @at_most
-        message += " #{@expected} #{sym} (has #{actual_size(collection(sym, args))})"
-      end
-    
-      def as_specified?(sym, args)
-        return actual_size(collection(sym, args)) >= @expected if @at_least
-        return actual_size(collection(sym, args)) <= @expected if @at_most
-        return actual_size(collection(sym, args)) == @expected
-      end
-
-    end
-  end
-
-end

data/lib/spec/expectations/helper.rb

@@ -1,4 +0,0 @@
-require 'spec/expectations/helper/should_base'
-require 'spec/expectations/helper/have_helper'
-require 'spec/expectations/helper/should_helper'
-require 'spec/expectations/helper/should_negator'

data/lib/spec/expectations/should_base.rb

@@ -1,52 +0,0 @@
-class Symbol
-  def supported_by_rspec?
-    return ["<","<=",">=",">","==","=~"].include?(to_s)
-  end
-end
-class Object
-  def inspect_for_expectation_not_met_error
-    return "#{inspect}" if inspect.include? "<"
-    return "<#{inspect}>" unless inspect.include? "<"
-  end
-end
-class TrueClass; def inspect_for_expectation_not_met_error; "true" end end
-class FalseClass; def inspect_for_expectation_not_met_error; "false" end end
-class NilClass; def inspect_for_expectation_not_met_error; "nil" end end
-class Class; def inspect_for_expectation_not_met_error; "<#{name}>" end end
-class Proc; def inspect_for_expectation_not_met_error; "<Proc>" end end
-class Array; def inspect_for_expectation_not_met_error; inspect end end
-class String; def inspect_for_expectation_not_met_error; inspect end end
-class Numeric; def inspect_for_expectation_not_met_error; inspect end end
-
-module Spec
-  module Expectations
-    class ShouldBase
-
-      instance_methods.each { |m| undef_method m unless m =~ /^(__|\w)/ }
-
-      def default_message(expectation, expected=:no_expectation_specified)
-        message = "#{@target.inspect_for_expectation_not_met_error} #{expectation}"
-        if (expected != :no_expectation_specified)
-          message << " " << expected.inspect_for_expectation_not_met_error
-        end
-        message
-       end
-
-      def fail_with_message(message)
-        Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
-      end
-    
-      def respond_to? sym
-        return true if super
-        return true if @target.respond_to? "#{sym.to_s}?"
-      end
-    
-      def find_supported_sym(original_sym)
-        ["#{original_sym}?", "#{original_sym}s?"].each do |alternate_sym|
-          return alternate_sym.to_s if @target.respond_to?(alternate_sym.to_s)
-        end
-        return original_sym.supported_by_rspec? ? original_sym : "#{original_sym}?"
-      end
-    end
-  end
-end

data/lib/spec/expectations/should_helper.rb

@@ -1,93 +0,0 @@
-module Spec
-  module Expectations
-    class ShouldHelper < ShouldBase
-
-      def initialize(target)
-        @target = target
-        @be_seen = false
-      end
-  
-      def not
-        ShouldNegator.new(@target)
-      end
-  
-      def have(expected_number=nil)
-        HaveHelper.new(@target, :exactly, expected_number)
-      end
-
-      def have_exactly(expected_number=nil)
-        HaveHelper.new(@target, :exactly, expected_number)
-      end
-
-      def have_at_least(expected_number=nil)
-        HaveHelper.new(@target, :at_least, expected_number)
-      end
-
-      def have_at_most(expected_number=nil)
-        HaveHelper.new(@target, :at_most, expected_number)
-      end
-
-      def satisfy(&block)
-        return if block.call(@target)
-        fail_with_message "Supplied expectation was not satisfied"
-      end
-      
-      def equal(expected)
-        fail_with_message(default_message("should equal", expected)) unless (@target == expected)
-      end
-
-      def be(expected = :___no_arg)
-        @be_seen = true
-        return self if (expected == :___no_arg)
-        return if (expected == false and @target.nil?)
-        return if (expected == true and (!@target.nil?) and (@target != false))
-        fail_with_message(default_message("should be", expected)) unless (@target.equal?(expected))
-      end
-
-      def an_instance_of expected_class
-        fail_with_message(default_message("should be an instance of", expected_class)) unless @target.instance_of? expected_class
-      end
-  
-      def a_kind_of expected_class
-        fail_with_message(default_message("should be a kind of", expected_class)) unless @target.kind_of? expected_class
-      end
-  
-      def respond_to message
-        fail_with_message(default_message("should respond to", message)) unless @target.respond_to? message
-      end
-  
-      def method_missing(original_sym, *args)
-        actual_sym = find_supported_sym(original_sym)      
-        return if @target.send(actual_sym, *args)
-        fail_with_message(default_message("should#{@be_seen ? ' be' : ''} #{original_sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))
-      end
-  
-      def match(expected)
-         fail_with_message(default_message("should match", expected)) unless (@target =~ expected)
-      end
-
-      def raise(exception=Exception, message=nil)
-        begin
-          @target.call
-        rescue exception => e
-          e.message.should_equal message unless message.nil?
-          return
-        rescue => e
-          fail_with_message("#{default_message("should raise", exception)} but raised #{e.inspect}")
-        end
-        fail_with_message("#{default_message("should raise", exception)} but raised nothing")
-      end
-  
-      def throw(symbol)
-        begin
-          catch symbol do
-            @target.call
-            fail_with_message(default_message("should throw", symbol.inspect))
-          end
-        rescue NameError
-          fail_with_message(default_message("should throw", symbol.inspect))
-        end
-      end
-    end
-  end
-end

data/lib/spec/expectations/should_negator.rb

@@ -1,71 +0,0 @@
-module Spec
-  module Expectations
-    class ShouldNegator < ShouldBase
-    
-      def initialize(target)
-        @target = target
-        @be_seen = false
-      end
-  
-      def satisfy
-        fail_with_message "Supplied expectation was satisfied, but should not have been" if (yield @target)
-      end
-        
-      def equal(expected)
-        fail_with_message(default_message("should not equal", expected)) if (@target == expected)
-      end
-    
-      def be(expected = :no_arg)
-        @be_seen = true
-        return self if (expected == :no_arg)
-        fail_with_message(default_message("should not be", expected)) if (@target.equal?(expected))
-      end
-
-      def an_instance_of expected_class
-        fail_with_message(default_message("should not be an instance of", expected_class)) if @target.instance_of? expected_class
-      end
-    
-      def a_kind_of expected_class
-        fail_with_message(default_message("should not be a kind of", expected_class)) if @target.kind_of? expected_class
-      end
-
-      def respond_to message
-        fail_with_message(default_message("should not respond to", message)) if @target.respond_to? message
-      end
-    
-      def match(expected)
-          fail_with_message(default_message("should not match", expected)) if (@target =~ expected)
-      end
-    
-      def raise(exception=Exception, message=nil)
-        begin
-          @target.call
-        rescue exception => e
-          return unless message.nil? || e.message == message
-          fail_with_message("#{default_message("should not raise", exception)}") if e.instance_of? exception
-          fail_with_message("#{default_message("should not raise", exception)} but raised #{e.inspect}") unless e.instance_of? exception
-        rescue
-          true
-        end
-      end
-    
-      def throw(symbol=:___this_is_a_symbol_that_will_likely_never_occur___)
-        begin
-          catch symbol do
-            @target.call
-            return true
-          end
-          fail_with_message(default_message("should not throw", symbol.inspect))
-        rescue NameError
-          true
-        end
-      end
-
-      def method_missing(original_sym, *args)
-        actual_sym = find_supported_sym(original_sym)      
-        return unless @target.__send__(actual_sym, *args)
-        fail_with_message(default_message("should not#{@be_seen ? ' be' : ''} #{original_sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))
-      end
-    end
-  end
-end

data/lib/spec/test_to_spec/ruby2ruby.rb

@@ -1,492 +0,0 @@
-# Taken from http://dark.fhtr.org/ruby2ruby.rb
-
-require 'pp'
-require 'rubygems'
-begin
-  require 'parse_tree'
-  require 'sexp_processor'
-rescue LoadError
-  raise "You must gem install ParseTree (and RubyInline)"
-end
-
-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
-    @block_params = false
-    @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
-
-  def process_bmethod(exp)
-    exp.clear
-    ""
-  end
-
-end