rspec 0.7.5.1 → 0.8.0

data/lib/spec/runner/spec_matcher.rb

@@ -1,32 +1,25 @@
-class SpecMatcher
+module Spec
+  module Runner
+    class SpecMatcher
 
-  def initialize(context_and_or_spec_name, context_name)
-    @context_name = context_name
-    @name_to_match = context_and_or_spec_name
+      attr_writer :spec_desc
+      def initialize(context_desc, spec_desc=nil)
+        @context_desc = context_desc
+        @spec_desc = spec_desc
+      end
+      
+      def matches?(desc)
+        desc =~ /(^#{context_regexp} #{spec_regexp}$|^#{context_regexp}$|^#{spec_regexp}$)/
+      end
+      
+      private
+        def context_regexp
+          Regexp.escape(@context_desc)
+        end
+        
+        def spec_regexp
+          Regexp.escape(@spec_desc)
+        end
+    end
   end
-  
-  def matches?(spec_name)
-    return true if matches_context? && (matches_spec?(spec_name) || context_only?)
-    return true if matches_spec?(spec_name) && spec_only?(spec_name)
-    return false
-  end
-  
-  private
-  
-  def spec_only? spec
-    @name_to_match == spec
-  end
-  
-  def context_only?
-    @name_to_match == @context_name
-  end
-  
-  def matches_context?
-    @name_to_match =~ /^#{Regexp.escape(@context_name)}\b/
-  end
-  
-  def matches_spec?(spec_name)
-    @name_to_match =~ /\b#{Regexp.escape(spec_name)}$/
-  end
-  
 end

data/lib/spec/runner/spec_parser.rb

@@ -1,5 +1,6 @@
 module Spec
   module Runner
+    # Parses a spec file and finds the nearest spec for a given line number.
     class SpecParser
       def spec_name_for(io, line_number)
         source  = io.read

data/lib/spec/runner/specification.rb

@@ -1,27 +1,28 @@
 module Spec
   module Runner
     class Specification
-      module ClassMethods
-        attr_accessor :current
+
+      class << self
+        attr_accessor :current, :generated_description
         protected :current=
 
         callback_events :before_setup, :after_teardown
       end
-      extend ClassMethods
 
-      attr_reader :command
+      attr_reader :spec_block
       callback_events :before_setup, :after_teardown
 
-      def initialize(name, opts={}, &block)
+      def initialize(name, opts={}, &spec_block)
         @from = caller(0)[3]
-        @name = name
+        @description = name
         @options = opts
-        @command = block
+        @spec_block = spec_block
+        @description_generated_callback = lambda { |desc| @generated_description = desc }
       end
 
       def run(reporter, setup_block, teardown_block, dry_run, execution_context)
-        reporter.spec_started(@name) if reporter
-        return reporter.spec_finished(@name) if dry_run
+        reporter.spec_started(name) if reporter
+        return reporter.spec_finished(name) if dry_run
 
         errors = []
         begin
@@ -34,14 +35,23 @@ module Spec
         end
 
         SpecShouldRaiseHandler.new(@from, @options).handle(errors)
-        reporter.spec_finished(@name, errors.first, failure_location(setup_ok, spec_ok, teardown_ok)) if reporter
+        reporter.spec_finished(name, errors.first, failure_location(setup_ok, spec_ok, teardown_ok)) if reporter
       end
-
-      def matches_matcher?(matcher)
-        matcher.matches? @name 
+      
+      def matches?(matcher, description)
+        matcher.spec_desc = name
+        matcher.matches?(description)
       end
-
+      
       private
+      def name
+        @description == :__generate_description ? generated_description : @description
+      end
+      
+      def generated_description
+        @generated_description || "NAME NOT GENERATED"
+      end
+      
       def setup_spec(execution_context, errors, &setup_block)
         notify_before_setup(errors)
         execution_context.instance_eval(&setup_block) if setup_block
@@ -52,11 +62,13 @@ module Spec
       end
 
       def execute_spec(execution_context, errors)
-        execution_context.instance_eval(&command)
-        return true
-      rescue => e
-        errors << e
-        return false
+        begin
+          execution_context.instance_eval(&spec_block)
+          return true
+        rescue Exception => e
+          errors << e
+          return false
+        end
       end
 
       def teardown_spec(execution_context, errors, &teardown_block)
@@ -69,13 +81,13 @@ module Spec
       end
 
       def notify_before_setup(errors)
-        self.class.send(:notify_callbacks, :before_setup, self, &append_errors(errors))
+        notify_class_callbacks(:before_setup, self, &append_errors(errors))
         notify_callbacks(:before_setup, self, &append_errors(errors))
       end
       
       def notify_after_teardown(errors)
         notify_callbacks(:after_teardown, self, &append_errors(errors))
-        self.class.send(:notify_callbacks, :after_teardown, self, &append_errors(errors))
+        notify_class_callbacks(:after_teardown, self, &append_errors(errors))
       end
       
       def append_errors(errors)
@@ -83,16 +95,18 @@ module Spec
       end
       
       def set_current
+        Spec::Matchers.description_generated(&@description_generated_callback)
         self.class.send(:current=, self)
       end
 
       def clear_current
+        Spec::Matchers.unregister_callback(:description_generated, @description_generated_callback)
         self.class.send(:current=, nil)
       end
 
       def failure_location(setup_ok, spec_ok, teardown_ok)
         return 'setup' unless setup_ok
-        return @name unless spec_ok
+        return name unless spec_ok
         return 'teardown' unless teardown_ok
       end
     end

data/lib/spec/translator.rb

@@ -0,0 +1,87 @@
+require 'fileutils'
+
+module Spec
+  class Translator
+    def translate_dir(from, to)
+      from = File.expand_path(from)
+      to = File.expand_path(to)
+      if File.directory?(from)
+        FileUtils.mkdir_p(to) unless File.directory?(to)
+        Dir["#{from}/*"].each do |sub_from|
+          path = sub_from[from.length+1..-1]
+          sub_to = File.join(to, path)
+          translate_dir(sub_from, sub_to)
+        end
+      else
+        translate_file(from, to)
+      end
+    end
+    
+    def translate_file(from, to)
+      translation = ""
+      File.open(from) do |io|
+        io.each_line do |line|
+          translation << translate(line)
+        end
+      end
+      File.open(to, "w") do |io|
+        io.write(translation)
+      end
+    end
+
+    def translate(line)
+      return line if line =~ /(should_not|should)_receive/
+      
+      if line =~ /(.*\.)(should_not|should)(?:_be)(?!_)(.*)/m
+        pre = $1
+        should = $2
+        post = $3
+        be_or_equal = post =~ /(<|>)/ ? "be" : "equal"
+        
+        return "#{pre}#{should} #{be_or_equal}#{post}"
+      end
+      
+      if line =~ /(.*\.)(should_not|should)_(?!not)(.*)/m
+        pre = $1
+        should = $2
+        post = $3
+        
+        post.gsub!(/^raise/, 'raise_error')
+        post.gsub!(/^throw/, 'throw_symbol')
+        
+        unless standard_matcher?(post)
+          post = "be_#{post}"
+        end
+        
+        line = "#{pre}#{should} #{post}"
+      end
+
+      line
+    end
+    
+    def standard_matcher?(matcher)
+      patterns = [
+        /^be/, 
+        /^be_close/,
+        /^eql/, 
+        /^equal/, 
+        /^has/, 
+        /^have/, 
+        /^change/, 
+        /^include/,
+        /^match/, 
+        /^raise_error/, 
+        /^respond_to/, 
+        /^satisfy/, 
+        /^throw_symbol/,
+        # Extra ones that we use in spec_helper
+        /^pass/,
+        /^fail/,
+        /^fail_with/,
+      ]
+      matched = patterns.detect{ |p| matcher =~ p }
+      !matched.nil?
+    end
+    
+  end
+end

data/lib/spec/version.rb

@@ -1,16 +1,25 @@
 module Spec
   module VERSION
+    def self.build_tag
+      tag = "REL_" + [MAJOR, MINOR, TINY].join('_')
+      if defined?(RELEASE_CANDIDATE)
+        tag << "_" << RELEASE_CANDIDATE
+      end
+      tag
+    end
+
     unless defined? MAJOR
       MAJOR  = 0
-      MINOR  = 7
-      TINY   = 5
-      MINISCULE = 1
-      # RANDOM_TOKEN: 0.0543628986724853
-      REV    = "$LastChangedRevision: 1395 $".match(/LastChangedRevision: (\d+)/)[1]
+      MINOR  = 8
+      TINY   = 0
+      # RELEASE_CANDIDATE = "RC1"
+      
+      # RANDOM_TOKEN: 0.714915709821417
+      REV = "$LastChangedRevision: 1550 $".match(/LastChangedRevision: (\d+)/)[1]
 
-      STRING = [MAJOR, MINOR, TINY, MINISCULE].join('.')
+      STRING = [MAJOR, MINOR, TINY].join('.')
       FULL_VERSION = "#{STRING} (r#{REV})"
-      TAG    = "REL_" + [MAJOR, MINOR, TINY, MINISCULE].join('_')
+      TAG = build_tag
 
       NAME   = "RSpec"
       URL    = "http://rspec.rubyforge.org/"  

data/spec/spec/callback/callback_container_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "A CallbackContainer instance" do
+  setup do
+    @container = Callback::CallbackContainer.new
+  end
+
+  specify "should define and call callbacks" do
+    @container.define(:foo) {:bar}
+    @container.define(:foo) {:baz}
+    @container.notify(:foo).should == [:bar, :baz]
+  end
+
+  specify "should undefine callbacks" do
+    callback_to_undefine = @container.define(:foo) {:bar}
+    @container.define(:foo) {:baz}
+    @container.undefine(:foo, callback_to_undefine)
+    @container.notify(:foo).should == [:baz]
+  end
+  
+  specify "should clear all callbacks" do
+    @container.define(:foo) {:bar}
+    @container.define(:baz) {1}
+    @container.clear
+    @container.notify(:foo).should == []
+  end
+end

data/spec/spec/callback/module_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "A Module" do
+  specify "should provide callback_events and notify_callbacks methods" do
+    the_class = Class.new do
+      callback_events :foo
+    end
+
+    the_obj = the_class.new
+    the_obj.foo { :bar }
+    the_obj.notify_callbacks(:foo).should == [:bar]
+  end
+
+  specify "should support defining multiple callback_events with one call to callback_events" do
+    the_class = Class.new do
+      callback_events :foo, :bar
+    end
+
+    the_obj = the_class.new
+    the_obj.foo { 1 }
+    the_obj.bar { 2 }
+    the_obj.notify_callbacks(:foo).should == [1]
+    the_obj.notify_callbacks(:bar).should == [2]
+  end
+
+  specify "should provide unregister_callback method" do
+    the_class = Class.new do
+      callback_events :foo
+    end
+
+    the_obj = the_class.new
+    bar_proc = proc {:bar}
+    the_obj.foo &bar_proc
+    the_obj.unregister_callback(:foo, bar_proc)
+    the_obj.notify_callbacks(:foo).should == []
+  end
+end

data/spec/spec/callback/object_spec.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "An Object" do
+  setup do
+    @callback_object = Object.new
+  end
+
+  specify "should be defined as a block and notified" do
+    specify_registration_and_notification do |callback_key, expected_callback|
+      @callback_object.register_callback(callback_key, &expected_callback)
+    end
+  end
+
+  specify "should be defined as a proc and notified" do
+    specify_registration_and_notification do |callback_key, expected_callback|
+      @callback_object.register_callback(callback_key, expected_callback)
+    end
+  end
+
+  specify "define should require callback with the call method" do
+    proc do
+      specify_registration_and_notification do |callback_key, expected_callback|
+        @callback_object.register_callback(callback_key)
+      end
+    end.should_raise(RuntimeError, "You must define the callback that accepts the call method.")
+  end
+
+  specify "should undefine a proc" do
+    specify_unregistration do |callback_key, callback|
+      @callback_object.unregister_callback callback_key, callback
+    end
+  end
+
+  specify "undefine should require callback with the call method" do
+    proc do
+      specify_unregistration do |callback_key, expected_callback|
+        @callback_object.unregister_callback(callback_key, nil)
+      end
+    end.should_raise(RuntimeError, "You may only undefine callbacks that use the call method.")
+  end
+  
+  specify "should handle errors" do
+    @callback_object.register_callback(:error_callback) do
+      raise "First Error"
+    end
+
+    @callback_object.register_callback(:error_callback) do
+      raise "Second Error"
+    end
+
+    error_messages = []
+    @callback_object.notify_callbacks(:error_callback) do |e|
+      error_messages << e.message
+    end
+
+    error_messages.should_eql ["First Error", "Second Error"]
+  end
+
+  specify "should not fail with nothing to notify" do
+    @callback_object.notify_callbacks(:foobar, :argument)
+  end
+
+  protected
+  def specify_registration_and_notification
+    callback_key = :create
+    passed_callback_argument = nil
+    expected_callback = proc do |callback_argument|
+      passed_callback_argument = callback_argument
+    end
+
+    returned_callback = yield(callback_key, expected_callback)
+    returned_callback.should_equal expected_callback
+
+    expected_argument = Object.new
+    @callback_object.notify_callbacks(callback_key, expected_argument)
+    passed_callback_argument.should_equal expected_argument
+  end
+
+  def specify_unregistration
+    callback_key = :create
+    callback_called = false
+    callback = @callback_object.register_callback(callback_key) do
+      callback_called = true
+    end
+
+    yield(callback_key, callback)
+    @callback_object.notify_callbacks(callback_key)
+    callback_called.should_equal false
+  end
+end