mack 0.8.2 → 0.8.3

data/lib/gems/rspec-1.1.12/lib/spec/example/example_methods.rb

@@ -0,0 +1,168 @@
+module Spec
+  module Example
+    module ExampleMethods
+      
+      extend ModuleReopeningFix
+      
+      def subject # :nodoc: this is somewhat experimental
+        @subject ||= ( instance_variable_get(subject_variable_name) ||
+                       instance_eval(&self.class.subject_block) ||
+                       (described_class ? described_class.new : nil) )
+      end
+
+      # When +should+ is called with no explicit receiver, the call is
+      # delegated to the *subject* of the example group. This could be either
+      # an explicit subject generated by calling the block passed to
+      # +ExampleGroupMethods#subject+, or, if the group is describing a class,
+      # an implicitly generated instance of that class.
+      def should(matcher=nil)
+        if matcher
+          subject.should(matcher)
+        else
+          subject.should
+        end
+      end
+
+      # Just like +should+, +should_not+ delegates to the subject (implicit or
+      # explicit) of the example group.
+      def should_not(matcher)
+        subject.should_not(matcher)
+      end
+      
+      def violated(message="")
+        raise Spec::Expectations::ExpectationNotMetError.new(message)
+      end
+
+      def description
+        @_defined_description || ::Spec::Matchers.generated_description || "NO NAME"
+      end
+      
+      def options
+        @_options
+      end
+
+      def execute(options, instance_variables)
+        options.reporter.example_started(self)
+        set_instance_variables_from_hash(instance_variables)
+        
+        execution_error = nil
+        Timeout.timeout(options.timeout) do
+          begin
+            before_each_example
+            eval_block
+          rescue Exception => e
+            execution_error ||= e
+          end
+          begin
+            after_each_example
+          rescue Exception => e
+            execution_error ||= e
+          end
+        end
+
+        options.reporter.example_finished(self, execution_error)
+        success = execution_error.nil? || ExamplePendingError === execution_error
+      end
+
+      def instance_variable_hash # :nodoc:
+        instance_variables.inject({}) do |variable_hash, variable_name|
+          variable_hash[variable_name] = instance_variable_get(variable_name)
+          variable_hash
+        end
+      end
+
+      def eval_each_fail_fast(examples) # :nodoc:
+        examples.each do |example|
+          instance_eval(&example)
+        end
+      end
+
+      def eval_each_fail_slow(examples) # :nodoc:
+        first_exception = nil
+        examples.each do |example|
+          begin
+            instance_eval(&example)
+          rescue Exception => e
+            first_exception ||= e
+          end
+        end
+        raise first_exception if first_exception
+      end
+
+      # Concats the class description with the example description.
+      #
+      #   describe Account do
+      #     it "should start with a balance of 0" do
+      #     ...
+      #
+      #   full_description
+      #   => "Account should start with a balance of 0"
+      def full_description
+        "#{self.class.description} #{self.description}"
+      end
+      
+      def set_instance_variables_from_hash(ivars) # :nodoc:
+        ivars.each do |variable_name, value|
+          # Ruby 1.9 requires variable.to_s on the next line
+          unless ['@_implementation', '@_defined_description', '@_matcher_description', '@method_name'].include?(variable_name.to_s)
+            instance_variable_set variable_name, value
+          end
+        end
+      end
+
+      def eval_block # :nodoc:
+        instance_eval(&@_implementation)
+      end
+
+      # Provides the backtrace up to where this example was declared.
+      def backtrace
+        @_backtrace
+      end
+      
+      # Deprecated - use +backtrace()+
+      def implementation_backtrace
+        Kernel.warn <<-WARNING
+ExampleMethods#implementation_backtrace is deprecated and will be removed
+from a future version. Please use ExampleMethods#backtrace instead.
+WARNING
+        backtrace
+      end
+
+      private
+      include Matchers
+      include Pending
+      
+      def before_each_example
+        setup_mocks_for_rspec
+        self.class.run_before_each(self)
+      end
+
+      def after_each_example
+        self.class.run_after_each(self)
+        verify_mocks_for_rspec
+      ensure
+        teardown_mocks_for_rspec
+      end
+
+      def subject_variable_name
+        '@' << (described_class ? underscore(described_class.name) : '__this_does_not_exist')
+      end
+      
+      def described_class
+        Class === described_type ? described_type : nil
+      end
+      
+      def described_type
+        self.class.described_type
+      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/lib/gems/rspec-1.1.12/lib/spec/example/shared_example_group.rb

@@ -0,0 +1,59 @@
+module Spec
+  module Example
+    class SharedExampleGroup < Module
+      module ClassMethods
+        def register(*args, &block)
+          new_example_group = new(*args, &block)
+          shared_example_groups << new_example_group unless already_registered?(new_example_group)
+          new_example_group
+        end
+        
+        def find(example_group_description)
+          shared_example_groups.find {|b| b.description == example_group_description}
+        end
+
+        def clear
+          shared_example_groups.clear
+        end
+        
+        def include?(group)
+          shared_example_groups.include?(group)
+        end
+        
+        def count
+          shared_example_groups.length
+        end
+
+      private
+      
+        def shared_example_groups
+          @shared_example_groups ||= []
+        end
+      
+        def already_registered?(new_example_group)
+          existing_example_group = find(new_example_group.description)
+          return false unless existing_example_group
+          return true if new_example_group.equal?(existing_example_group)
+          return true if expanded_path(new_example_group) == expanded_path(existing_example_group)
+          raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists")
+        end
+
+        def expanded_path(example_group)
+          File.expand_path(example_group.spec_path)
+        end
+      end
+
+      extend ClassMethods
+      include ExampleGroupMethods
+
+      def initialize(*args, &example_group_block)
+        set_description(*args)
+        @example_group_block = example_group_block
+      end
+
+      def included(mod) # :nodoc:
+        mod.module_eval(&@example_group_block)
+      end
+    end
+  end
+end

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/expectations.rb

@@ -30,27 +30,31 @@ module Spec
   # RSpec ships with a standard set of useful matchers, and writing your own
   # matchers is quite simple. See Spec::Matchers for details.
   module Expectations
-    class << self
-      attr_accessor :differ
+    def self.differ
+      @differ
+    end
+    
+    def self.differ=(differ)
+      @differ = differ
+    end
 
-      # raises a Spec::Expectations::ExpectationNotMetError with message
-      #
-      # When a differ has been assigned and fail_with is passed
-      # <code>expected</code> and <code>target</code>, passes them
-      # to the differ to append a diff message to the failure message.
-      def fail_with(message, expected=nil, target=nil) # :nodoc:
-        if Array === message && message.length == 3
-          message, expected, target = message[0], message[1], message[2]
-        end
-        unless (differ.nil? || expected.nil? || target.nil?)
-          if expected.is_a?(String)
-            message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected)
-          elsif !target.is_a?(Proc)
-            message << "\nDiff:" << self.differ.diff_as_object(target, expected)
-          end
+    # raises a Spec::Expectations::ExpectationNotMetError with message
+    #
+    # When a differ has been assigned and fail_with is passed
+    # <code>expected</code> and <code>target</code>, passes them
+    # to the differ to append a diff message to the failure message.
+    def self.fail_with(message, expected=nil, target=nil) # :nodoc:
+      if Array === message && message.length == 3
+        message, expected, target = message[0], message[1], message[2]
+      end
+      unless (differ.nil? || expected.nil? || target.nil?)
+        if expected.is_a?(String)
+          message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected)
+        elsif !target.is_a?(Proc)
+          message << "\nDiff:" << self.differ.diff_as_object(target, expected)
         end
-        Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
       end
+      Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
     end
   end
 end

data/lib/gems/rspec-1.1.12/lib/spec/expectations/handler.rb

@@ -0,0 +1,32 @@
+module Spec
+  module Expectations
+    class InvalidMatcherError < ArgumentError; end        
+    
+    class ExpectationMatcherHandler        
+      def self.handle_matcher(actual, matcher, &block)
+        ::Spec::Matchers.last_should = :should
+        ::Spec::Matchers.last_matcher = matcher
+
+        return ::Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
+
+        match = matcher.matches?(actual, &block)
+        ::Spec::Expectations.fail_with(matcher.failure_message) unless match
+        match
+      end
+    end
+
+    class NegativeExpectationMatcherHandler
+      def self.handle_matcher(actual, matcher, &block)
+        ::Spec::Matchers.last_should = :should_not
+        ::Spec::Matchers.last_matcher = matcher
+
+        return ::Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
+        
+        match = matcher.matches?(actual, &block)
+        ::Spec::Expectations.fail_with(matcher.negative_failure_message) if match
+        match
+      end
+    end
+  end
+end
+

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/interop/test/unit/testcase.rb

@@ -23,26 +23,24 @@ module Test
       extend Spec::Example::ExampleGroupMethods
       include Spec::Example::ExampleMethods
 
-      before(:each) {setup}
-      after(:each) {teardown}
-
-      class << self
-        def suite
-          Test::Unit::TestSuiteAdapter.new(self)
-        end
+      def self.suite
+        Test::Unit::TestSuiteAdapter.new(self)
+      end
 
-        def example_method?(method_name)
-          should_method?(method_name) || test_method?(method_name)
-        end
+      def self.example_method?(method_name)
+        should_method?(method_name) || test_method?(method_name)
+      end
 
-        def test_method?(method_name)
-          method_name =~ /^test[_A-Z]./ && (
-            instance_method(method_name).arity == 0 ||
-            instance_method(method_name).arity == -1
-          )
-        end
+      def self.test_method?(method_name)
+        method_name =~ /^test[_A-Z]./ && (
+          instance_method(method_name).arity == 0 ||
+          instance_method(method_name).arity == -1
+        )
       end
 
+      before(:each) {setup}
+      after(:each) {teardown}
+
       def initialize(defined_description, options={}, &implementation)
         @_defined_description = defined_description
         
@@ -51,9 +49,13 @@ module Test
         @_implementation = implementation || pending_implementation
 
         @_result = ::Test::Unit::TestResult.new
-        # @method_name is important to set here because it "complies" with Test::Unit's interface.
+        # @method_name is important to set here because it complies with Test::Unit's interface.
         # Some Test::Unit extensions depend on @method_name being present.
         @method_name = @_defined_description
+
+        # TODO - this is necessary to run single examples in rspec-rails, but I haven't
+        # found a good way to write a failing example just within rspec core
+        @_backtrace = caller
       end
 
       def run(ignore_this_argument=nil)

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/interop/test/unit/testresult.rb

@@ -1,6 +1,6 @@
 class Test::Unit::TestResult
   alias_method :tu_passed?, :passed?
   def passed?
-    return tu_passed? & ::Spec.run
+    return tu_passed? & ::Spec::Runner.run
   end
 end

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/interop/test/unit/testsuite_adapter.rb

@@ -14,7 +14,7 @@ module Test
 
       def run(*args)
         return true unless args.empty?
-        example_group.run
+        example_group.run(Spec::Runner.options)
       end
 
       def size

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/matchers.rb

@@ -1,7 +1,12 @@
+require 'spec/matchers/operator_matcher'
+require 'spec/matchers/generated_descriptions'
+require 'spec/matchers/errors'
+require 'spec/matchers/method_missing'
 require 'spec/matchers/simple_matcher'
 require 'spec/matchers/be'
 require 'spec/matchers/be_close'
 require 'spec/matchers/change'
+require 'spec/matchers/match_array'
 require 'spec/matchers/eql'
 require 'spec/matchers/equal'
 require 'spec/matchers/exist'
@@ -13,7 +18,7 @@ require 'spec/matchers/raise_error'
 require 'spec/matchers/respond_to'
 require 'spec/matchers/satisfy'
 require 'spec/matchers/throw_symbol'
-require 'spec/matchers/operator_matcher'
+require 'spec/matchers/wrap_expectation'
 
 module Spec
 
@@ -132,31 +137,5 @@ module Spec
   #     config.include(CustomGameMatchers)
   #   end
   #
-  module Matchers
-    module ModuleMethods
-      attr_accessor :last_matcher, :last_should
-
-      def clear_generated_description
-        self.last_matcher = nil
-        self.last_should = nil
-      end
-      
-      def generated_description
-        last_should.nil? ? nil :
-          "#{last_should} #{last_matcher.respond_to?(:description) ? last_matcher.description : 'NO NAME'}"
-      end
-    end
-
-    extend ModuleMethods
-
-    def method_missing(sym, *args, &block) # :nodoc:
-      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
-      return Matchers::Has.new(sym, *args) if sym.starts_with?("have_")
-      super
-    end
-
-    class MatcherError < StandardError
-    end
-    
-  end
+  module Matchers; end
 end