typo 5.2 → 5.2.98

data/vendor/plugins/rspec/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/vendor/plugins/rspec/lib/spec/example/example_methods.rb

@@ -1,105 +0,0 @@
-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/vendor/plugins/rspec/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/vendor/plugins/rspec/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/vendor/plugins/rspec/lib/spec/example/shared_example_group.rb

@@ -1,52 +0,0 @@
-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/vendor/plugins/rspec/lib/spec/expectations.rb

@@ -1,56 +0,0 @@
-require 'spec/matchers'
-require 'spec/expectations/errors'
-require 'spec/expectations/extensions'
-require 'spec/expectations/handler'
-
-module Spec
-  
-  # Spec::Expectations lets you set expectations on your objects.
-  #
-  #   result.should == 37
-  #   team.should have(11).players_on_the_field
-  #
-  # == How Expectations work.
-  #
-  # Spec::Expectations adds two methods to Object:
-  #
-  #   should(matcher=nil)
-  #   should_not(matcher=nil)
-  #
-  # Both methods take an optional Expression Matcher (See Spec::Matchers).
-  #
-  # When +should+ receives an Expression Matcher, it calls <tt>matches?(self)</tt>. If
-  # it returns +true+, the spec passes and execution continues. If it returns
-  # +false+, then the spec fails with the message returned by <tt>matcher.failure_message</tt>.
-  #
-  # Similarly, when +should_not+ receives a matcher, it calls <tt>matches?(self)</tt>. If
-  # it returns +false+, the spec passes and execution continues. If it returns
-  # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>.
-  #
-  # 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
-
-      # 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
-        end
-        Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
-      end
-    end
-  end
-end

data/vendor/plugins/rspec/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/vendor/plugins/rspec/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/vendor/plugins/rspec/lib/spec/expectations/extensions.rb

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

data/vendor/plugins/rspec/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=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