dchelimsky-rspec 1.1.10

data/lib/spec/example/example_matcher.rb

@@ -0,0 +1,44 @@
+module Spec
+  module Example
+    class ExampleMatcher
+      def initialize(example_group_description, example_name)
+        @example_group_description = example_group_description
+        @example_name = example_name
+      end
+      
+      def matches?(specified_examples)
+        specified_examples.each do |specified_example|
+          return true if matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example)
+        end
+        false
+      end
+      
+      protected
+      def matches_literal_example?(specified_example)
+        specified_example =~ /(^#{example_group_regex} #{example_regexp}$|^#{example_group_regex}$|^#{example_group_with_before_all_regexp}$|^#{example_regexp}$)/
+      end
+
+      def matches_example_not_considering_modules?(specified_example)
+        specified_example =~ /(^#{example_group_regex_not_considering_modules} #{example_regexp}$|^#{example_group_regex_not_considering_modules}$|^#{example_regexp}$)/
+      end
+
+      def example_group_regex
+        Regexp.escape(@example_group_description)
+      end
+
+      def example_group_with_before_all_regexp
+        Regexp.escape("#{@example_group_description} before(:all)")
+      end
+
+      def example_group_regex_not_considering_modules
+        Regexp.escape(@example_group_description.split('::').last)
+      end
+
+      def example_regexp
+        Regexp.escape(@example_name)
+      end
+    end
+
+    ExampleGroupMethods.matcher_class = ExampleMatcher
+  end
+end

data/lib/spec/example/example_methods.rb

@@ -0,0 +1,105 @@
+module Spec
+  module Example
+    module ExampleMethods
+      
+      extend ModuleReopeningFix
+      
+      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
+        instance_variables.inject({}) do |variable_hash, variable_name|
+          variable_hash[variable_name] = instance_variable_get(variable_name)
+          variable_hash
+        end
+      end
+
+      def violated(message="")
+        raise Spec::Expectations::ExpectationNotMetError.new(message)
+      end
+
+      def eval_each_fail_fast(procs) #:nodoc:
+        procs.each do |proc|
+          instance_eval(&proc)
+        end
+      end
+
+      def eval_each_fail_slow(procs) #:nodoc:
+        first_exception = nil
+        procs.each do |proc|
+          begin
+            instance_eval(&proc)
+          rescue Exception => e
+            first_exception ||= e
+          end
+        end
+        raise first_exception if first_exception
+      end
+
+      def description
+        @_defined_description || ::Spec::Matchers.generated_description || "NO NAME"
+      end
+      
+      def options
+        @_options
+      end
+
+      def __full_description
+        "#{self.class.description} #{self.description}"
+      end
+      
+      def set_instance_variables_from_hash(ivars)
+        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
+        instance_eval(&@_implementation)
+      end
+
+      def implementation_backtrace
+        eval("caller", @_implementation)
+      end
+      
+      protected
+      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
+    end
+  end
+end

data/lib/spec/example/module_reopening_fix.rb

@@ -0,0 +1,21 @@
+module Spec
+  module Example
+    # This is a fix for ...Something in Ruby 1.8.6??... (Someone fill in here please - Aslak)
+    module ModuleReopeningFix
+      def child_modules
+        @child_modules ||= []
+      end
+
+      def included(mod)
+        child_modules << mod
+      end
+
+      def include(mod)
+        super
+        child_modules.each do |child_module|
+          child_module.__send__(:include, mod)
+        end
+      end
+    end
+  end
+end

data/lib/spec/example/pending.rb

@@ -0,0 +1,18 @@
+module Spec
+  module Example      
+    module Pending
+      def pending(message = "TODO")
+        if block_given?
+          begin
+            yield
+          rescue Exception => e
+            raise Spec::Example::ExamplePendingError.new(message)
+          end
+          raise Spec::Example::PendingExampleFixedError.new("Expected pending '#{message}' to fail. No Error was raised.")
+        else
+          raise Spec::Example::ExamplePendingError.new(message)
+        end
+      end
+    end
+  end
+end

data/lib/spec/example/shared_example_group.rb

@@ -0,0 +1,52 @@
+module Spec
+  module Example
+    class SharedExampleGroup < Module
+      module ClassMethods
+        def add_shared_example_group(new_example_group)
+          guard_against_redefining_existing_example_group(new_example_group)
+          shared_example_groups << new_example_group
+        end
+
+        def find_shared_example_group(example_group_description)
+          shared_example_groups.find do |b|
+            b.description == example_group_description
+          end
+        end
+
+        def shared_example_groups
+          @shared_example_groups ||= []
+        end
+
+        private
+        def guard_against_redefining_existing_example_group(new_example_group)
+          existing_example_group = find_shared_example_group(new_example_group.description)
+          return unless existing_example_group
+          return if new_example_group.equal?(existing_example_group)
+          return if spec_path(new_example_group) == spec_path(existing_example_group)
+          raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists")
+        end
+
+        def spec_path(example_group)
+          File.expand_path(example_group.spec_path)
+        end
+      end
+
+      extend ClassMethods
+      include ExampleGroupMethods
+
+      def initialize(*args, &example_group_block)
+        describe(*args)
+        @example_group_block = example_group_block
+        self.class.add_shared_example_group(self)
+      end
+
+      def included(mod) # :nodoc:
+        mod.module_eval(&@example_group_block)
+      end
+
+      def each_ancestor_example_group_class(superclass_last=false)
+        yield self
+      end
+    end
+  end
+end

data/lib/spec/example.rb

@@ -0,0 +1,12 @@
+require 'timeout'
+require 'spec/example/before_and_after_hooks'
+require 'spec/example/pending'
+require 'spec/example/module_reopening_fix'
+require 'spec/example/example_group_methods'
+require 'spec/example/example_methods'
+require 'spec/example/example_group'
+require 'spec/example/shared_example_group'
+require 'spec/example/example_group_factory'
+require 'spec/example/errors'
+require 'spec/example/configuration'
+require 'spec/example/example_matcher'

data/lib/spec/expectations/differs/default.rb

@@ -0,0 +1,66 @@
+begin
+  require 'rubygems'
+  require 'diff/lcs' #necessary due to loading bug on some machines - not sure why - DaC
+  require 'diff/lcs/hunk'
+rescue LoadError ; raise "You must gem install diff-lcs to use diffing" ; end
+
+require 'pp'
+
+module Spec
+  module Expectations
+    module Differs
+
+      # TODO add some rdoc
+      class Default
+        def initialize(options)
+          @options = options
+        end
+
+        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+        def diff_as_string(data_new, data_old)
+          data_old = data_old.split(/\n/).map! { |e| e.chomp }
+          data_new = data_new.split(/\n/).map! { |e| e.chomp }
+          output = ""
+          diffs = Diff::LCS.diff(data_old, data_new)
+          return output if diffs.empty?
+          oldhunk = hunk = nil  
+          file_length_difference = 0
+          diffs.each do |piece|
+            begin
+              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
+                                         file_length_difference)
+              file_length_difference = hunk.file_length_difference      
+              next unless oldhunk      
+              # Hunks may overlap, which is why we need to be careful when our
+              # diff includes lines of context. Otherwise, we might print
+              # redundant lines.
+              if (context_lines > 0) and hunk.overlaps?(oldhunk)
+                hunk.unshift(oldhunk)
+              else
+                output << oldhunk.diff(format)
+              end
+            ensure
+              oldhunk = hunk
+              output << "\n"
+            end
+          end  
+          #Handle the last remaining hunk
+          output << oldhunk.diff(format) << "\n"
+        end  
+
+        def diff_as_object(target,expected)
+          diff_as_string(PP.pp(target,""), PP.pp(expected,""))
+        end
+
+        protected
+        def format
+          @options.diff_format
+        end
+
+        def context_lines
+          @options.context_lines
+        end
+      end
+    end
+  end
+end

data/lib/spec/expectations/errors.rb

@@ -0,0 +1,12 @@
+module Spec
+  module Expectations
+    # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit
+    # will report unmet RSpec expectations as failures rather than errors.
+    superclass = ['Test::Unit::AssertionFailedError', '::StandardError'].map do |c|
+      eval(c) rescue nil
+    end.compact.first
+    
+    class ExpectationNotMetError < superclass
+    end
+  end
+end

data/lib/spec/expectations/extensions/object.rb

@@ -0,0 +1,63 @@
+module Spec
+  module Expectations
+    # rspec adds #should and #should_not to every Object (and,
+    # implicitly, every Class).
+    module ObjectExpectations
+      # :call-seq:
+      #   should(matcher)
+      #   should == expected
+      #   should === expected
+      #   should =~ expected
+      #
+      #   receiver.should(matcher)
+      #     => Passes if matcher.matches?(receiver)
+      #
+      #   receiver.should == expected #any value
+      #     => Passes if (receiver == expected)
+      #
+      #   receiver.should === expected #any value
+      #     => Passes if (receiver === expected)
+      #
+      #   receiver.should =~ regexp
+      #     => Passes if (receiver =~ regexp)
+      #
+      # See Spec::Matchers for more information about matchers
+      #
+      # == Warning
+      #
+      # NOTE that this does NOT support receiver.should != expected.
+      # Instead, use receiver.should_not == expected
+      def should(matcher=nil, &block)
+        ExpectationMatcherHandler.handle_matcher(self, matcher, &block)
+      end
+
+      # :call-seq:
+      #   should_not(matcher)
+      #   should_not == expected
+      #   should_not === expected
+      #   should_not =~ expected
+      #
+      #   receiver.should_not(matcher)
+      #     => Passes unless matcher.matches?(receiver)
+      #
+      #   receiver.should_not == expected
+      #     => Passes unless (receiver == expected)
+      #
+      #   receiver.should_not === expected
+      #     => Passes unless (receiver === expected)
+      #
+      #   receiver.should_not =~ regexp
+      #     => Passes unless (receiver =~ regexp)
+      #
+      # See Spec::Matchers for more information about matchers
+      def should_not(matcher=nil, &block)
+        NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
+      end
+
+    end
+  end
+end
+
+class Object
+  include Spec::Expectations::ObjectExpectations
+end

data/lib/spec/expectations/extensions/string_and_symbol.rb

@@ -0,0 +1,17 @@
+module Spec
+  module Expectations
+    module StringHelpers
+      def starts_with?(prefix)
+        to_s[0..(prefix.to_s.length - 1)] == prefix.to_s
+      end
+    end
+  end
+end
+
+class String
+  include Spec::Expectations::StringHelpers
+end
+
+class Symbol
+  include Spec::Expectations::StringHelpers
+end

data/lib/spec/expectations/extensions.rb

@@ -0,0 +1,2 @@
+require 'spec/expectations/extensions/object'
+require 'spec/expectations/extensions/string_and_symbol'

data/lib/spec/expectations/handler.rb

@@ -0,0 +1,52 @@
+module Spec
+  module Expectations
+    class InvalidMatcherError < ArgumentError; end        
+    
+    class ExpectationMatcherHandler        
+      class << self
+        def handle_matcher(actual, matcher, &block)
+          ::Spec::Matchers.last_should = "should"
+          return Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
+
+          unless matcher.respond_to?(:matches?)
+            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+          end
+          
+          match = matcher.matches?(actual, &block)
+          ::Spec::Matchers.last_matcher = matcher
+          Spec::Expectations.fail_with(matcher.failure_message) unless match
+          match
+        end
+      end
+    end
+
+    class NegativeExpectationMatcherHandler
+      class << self
+        def handle_matcher(actual, matcher, &block)
+          ::Spec::Matchers.last_should = "should not"
+          return Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
+          
+          unless matcher.respond_to?(:matches?)
+            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+          end
+
+          unless matcher.respond_to?(:negative_failure_message)
+            Spec::Expectations.fail_with(
+<<-EOF
+Matcher does not support should_not.
+See Spec::Matchers for more information
+about matchers.
+EOF
+)
+          end
+          match = matcher.matches?(actual, &block)
+          ::Spec::Matchers.last_matcher = matcher
+          Spec::Expectations.fail_with(matcher.negative_failure_message) if match
+          match
+        end
+      end
+    end
+
+  end
+end
+