rspec 0.0.10 → 0.1.0

data/lib/spec/example/example_matcher.rb

@@ -1,44 +0,0 @@
-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

@@ -1,112 +0,0 @@
-module Spec
-  module Example
-    module ExampleMethods
-      extend ExampleGroupMethods
-      extend ModuleReopeningFix
-      include ModuleInclusionWarnings
-      
-
-      PENDING_EXAMPLE_BLOCK = lambda {
-        raise Spec::Example::ExamplePendingError.new("Not Yet Implemented")
-      }
-
-      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_example
-            run_with_description_capturing
-          rescue Exception => e
-            execution_error ||= e
-          end
-          begin
-            after_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 || @_matcher_description || "NO NAME"
-      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 run_with_description_capturing
-        begin
-          return instance_eval(&(@_implementation || PENDING_EXAMPLE_BLOCK))
-        ensure
-          @_matcher_description = Spec::Matchers.generated_description
-          Spec::Matchers.clear_generated_description
-        end
-      end
-
-      def implementation_backtrace
-        eval("caller", @_implementation)
-      end
-      
-      protected
-      include Matchers
-      include Pending
-      
-      def before_example
-        setup_mocks_for_rspec
-        self.class.run_before_each(self)
-      end
-
-      def after_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_inclusion_warnings.rb

@@ -1,38 +0,0 @@
-module Spec
-  module Example
-    # In the future, modules will no longer be automatically included
-    # in the Example Group (based on the description name); when that 
-    # time comes, this code should be removed.
-    module ModuleInclusionWarnings
-      # Thanks, Francis Hwang.
-      class MethodDispatcher
-        def initialize(mod, target=nil)
-          @mod = mod
-          @target = target
-        end
-        
-        def respond_to?(sym)
-          @mod && @mod.instance_methods.include?(sym.to_s)
-        end
-        
-        def call(sym, *args, &blk)
-          Kernel.warn("Modules will no longer be automatically included in RSpec version 1.1.4.  Called from #{caller[2]}")
-          @target.extend @mod
-          @target.send(sym, *args, &blk)
-        end
-      end
-      
-      # NOTE - we don't need the second arg, but extenders do: http://www.ruby-doc.org/core/classes/Object.html#M000604
-      def respond_to?(sym, include_private_data=false)
-        MethodDispatcher.new(self.class.described_module).respond_to?(sym) ? true : super
-      end
-      
-    private
-      
-      def method_missing(sym, *args, &blk)
-        md = MethodDispatcher.new(self.class.described_module, self)
-        self.respond_to?(sym) ? md.call(sym, *args, &blk) : super
-      end
-    end
-  end
-end

data/lib/spec/example/module_reopening_fix.rb

@@ -1,21 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,58 +0,0 @@
-module Spec
-  module Example
-    class SharedExampleGroup < Module
-      class << self
-        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
-          # TODO - this needs to be global, or at least accessible from
-          # from subclasses of Example in a centralized place. I'm not loving
-          # this as a solution, but it works for now.
-          $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
-      include ExampleGroupMethods
-      public :include
-
-      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 execute_in_class_hierarchy(superclass_last=false)
-        classes = [self]
-        superclass_last ? classes << ExampleMethods : classes.unshift(ExampleMethods)
-        classes.each do |example_group|
-          yield example_group
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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.rb

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

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

@@ -1,63 +0,0 @@
-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=:use_operator_matcher, &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=:use_operator_matcher, &block)
-        NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
-      end
-
-    end
-  end
-end
-
-class Object
-  include Spec::Expectations::ObjectExpectations
-end