has_finder 0.1.3 → 0.1.4

data/spec/rails/vendor/plugins/rspec/lib/spec/dsl/description.rb

@@ -1,69 +0,0 @@
-module Spec
-  module DSL
-    class Description
-      module ClassMethods
-        def generate_description(*args)
-          description = args.shift.to_s
-          unless args.empty?
-            suffix = args.shift.to_s
-            description << " " unless suffix =~ /^\s|\.|#/
-            description << suffix
-          end
-          description
-        end
-      end
-      extend ClassMethods
-
-      attr_reader :description, :described_type
-      
-      def initialize(*args)
-        args, @options = args_and_options(*args)
-        init_behaviour_type(@options)
-        init_described_type(args)
-        init_description(*args)
-      end
-  
-      def [](key)
-        @options[key]
-      end
-      
-      def []=(key, value)
-        @options[key] = value
-      end
-      
-      def to_s; @description; end
-      
-      def ==(value)
-        case value
-        when Description
-          @description == value.description
-        else
-          @description == value
-        end
-      end
-      
-    private
-      def init_behaviour_type(options)
-        # NOTE - BE CAREFUL IF CHANGING THIS NEXT LINE:
-        #   this line is as it is to satisfy JRuby - the original version
-        #   read, simply: "if options[:behaviour_class]", which passed against ruby, but failed against jruby
-        if options[:behaviour_class] && options[:behaviour_class].ancestors.include?(Behaviour)
-          options[:behaviour_type] = parse_behaviour_type(@options[:behaviour_class])
-        end
-      end
-      
-      def init_description(*args)
-        @description = self.class.generate_description(*args)
-      end
-      
-      def init_described_type(args)
-        @described_type = args.first unless args.first.is_a?(String)
-      end
-    
-      def parse_behaviour_type(behaviour_class)
-        behaviour_class.to_s.split("::").reverse[0].gsub!('Behaviour', '').downcase.to_sym
-      end
-
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/lib/spec/dsl/example.rb

@@ -1,127 +0,0 @@
-require 'timeout'
-
-module Spec
-  module DSL
-    class Example
-      def initialize(description, options={}, &example_block)
-        @from = caller(0)[3]
-        @options = options
-        @example_block = example_block
-        @description = description
-        @description_generated_proc = lambda { |desc| @generated_description = desc }
-      end
-      
-      def run(reporter, before_each_block, after_each_block, dry_run, execution_context, timeout=nil)
-        @dry_run = dry_run
-        reporter.example_started(description)
-        return reporter.example_finished(description) if dry_run
-
-        errors = []
-        location = nil
-        Timeout.timeout(timeout) do
-          before_each_ok = setup_example(execution_context, errors, &before_each_block)
-          example_ok = run_example(execution_context, errors) if before_each_ok
-          after_each_ok = teardown_example(execution_context, errors, &after_each_block)
-          location = failure_location(before_each_ok, example_ok, after_each_ok)
-        end
-
-        ExampleShouldRaiseHandler.new(@from, @options).handle(errors)
-        reporter.example_finished(description, errors.first, location, @example_block.nil?) if reporter
-      end
-      
-      def matches?(matcher, specified_examples)
-        matcher.example_desc = description
-        matcher.matches?(specified_examples)
-      end
-      
-    private
-      def description
-        @description == :__generate_description ? generated_description : @description
-      end
-      
-      def generated_description
-        return @generated_description if @generated_description
-        if @dry_run
-          "NO NAME (Because of --dry-run)"
-        else
-          if @failed
-            "NO NAME (Because of Error raised in matcher)"
-          else
-            "NO NAME (Because there were no expectations)"
-          end
-        end
-      end
-      
-      def setup_example(execution_context, errors, &behaviour_before_block)
-        setup_mocks(execution_context)
-        Spec::Matchers.description_generated(@description_generated_proc)
-        
-        builder = CompositeProcBuilder.new
-        before_proc = builder.proc(&append_errors(errors))
-        execution_context.instance_eval(&before_proc)
-        
-        execution_context.instance_eval(&behaviour_before_block) if behaviour_before_block
-        return errors.empty?
-      rescue => e
-        @failed = true
-        errors << e
-        return false
-      end
-
-      def run_example(execution_context, errors)
-        begin
-          execution_context.instance_eval(&@example_block) if @example_block
-          return true
-        rescue Exception => e
-          @failed = true
-          errors << e
-          return false
-        end
-      end
-
-      def teardown_example(execution_context, errors, &behaviour_after_each)
-        execution_context.instance_eval(&behaviour_after_each) if behaviour_after_each
-
-        begin
-          verify_mocks(execution_context)
-        ensure
-          teardown_mocks(execution_context)
-        end
-
-        Spec::Matchers.unregister_description_generated(@description_generated_proc)
-
-        builder = CompositeProcBuilder.new
-        after_proc = builder.proc(&append_errors(errors))
-        execution_context.instance_eval(&after_proc)
-
-        return errors.empty?
-      rescue => e
-        @failed = true
-        errors << e
-        return false
-      end
-      
-      def setup_mocks(execution_context)
-        execution_context.setup_mocks_for_rspec if execution_context.respond_to?(:setup_mocks_for_rspec)
-      end
-      
-      def verify_mocks(execution_context)
-        execution_context.verify_mocks_for_rspec if execution_context.respond_to?(:verify_mocks_for_rspec)
-      end
-      
-      def teardown_mocks(execution_context)
-        execution_context.teardown_mocks_for_rspec if execution_context.respond_to?(:teardown_mocks_for_rspec)
-      end
-      
-      def append_errors(errors)
-        proc {|error| errors << error}
-      end
-      
-      def failure_location(before_each_ok, example_ok, after_each_ok)
-        return 'before(:each)' unless before_each_ok
-        return description unless example_ok
-        return 'after(:each)' unless after_each_ok
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/lib/spec/dsl/example_matcher.rb

@@ -1,40 +0,0 @@
-module Spec
-  module DSL
-    class ExampleMatcher
-
-      attr_writer :example_desc
-      def initialize(behaviour_desc, example_desc=nil)
-        @behaviour_desc = behaviour_desc
-        @example_desc = example_desc
-      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
-      
-      private
-        def matches_literal_example?(specified_example)
-          specified_example =~ /(^#{context_regexp} #{example_regexp}$|^#{context_regexp}$|^#{example_regexp}$)/
-        end
-
-        def matches_example_not_considering_modules?(specified_example)
-          specified_example =~ /(^#{context_regexp_not_considering_modules} #{example_regexp}$|^#{context_regexp_not_considering_modules}$|^#{example_regexp}$)/
-        end
-
-        def context_regexp
-          Regexp.escape(@behaviour_desc)
-        end
-
-        def context_regexp_not_considering_modules
-          Regexp.escape(@behaviour_desc.split('::').last)
-        end
-        
-        def example_regexp
-          Regexp.escape(@example_desc)
-        end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/lib/spec/dsl/example_should_raise_handler.rb

@@ -1,74 +0,0 @@
-module Spec
-  module DSL
-    class ExampleShouldRaiseHandler
-      def initialize(file_and_line_number, opts)
-        @file_and_line_number = file_and_line_number
-        @options = opts
-        @expected_error_class = determine_error_class(opts)
-        @expected_error_message = determine_error_message(opts)
-      end
-  
-      def determine_error_class(opts)
-        if candidate = opts[:should_raise]
-          if candidate.is_a?(Class)
-            return candidate
-          elsif candidate.is_a?(Array)
-            return candidate[0]
-          else
-            return Exception
-          end
-        end
-      end
-  
-      def determine_error_message(opts)
-        if candidate = opts[:should_raise]
-          if candidate.is_a?(Array)
-            return candidate[1]
-          end
-        end
-        return nil
-      end
-  
-      def build_message(exception=nil)
-        if @expected_error_message.nil?
-          message = "example block expected #{@expected_error_class.to_s}"
-        else
-          message = "example block expected #{@expected_error_class.new(@expected_error_message.to_s).inspect}"
-        end
-        message << " but raised #{exception.inspect}" if exception
-        message << " but nothing was raised" unless exception
-        message << "\n"
-        message << @file_and_line_number
-      end
-  
-      def error_matches?(error)
-        return false unless error.kind_of?(@expected_error_class)
-        unless @expected_error_message.nil?
-          if @expected_error_message.is_a?(Regexp)
-            return false unless error.message =~ @expected_error_message
-          else
-            return false unless error.message == @expected_error_message
-          end
-        end
-        return true
-      end
-
-      def handle(errors)
-        if @expected_error_class
-          if errors.empty?
-            errors << Spec::Expectations::ExpectationNotMetError.new(build_message)
-          else
-            error_to_remove = errors.detect do |error|
-              error_matches?(error)
-            end
-            if error_to_remove.nil?
-              errors.insert(0,Spec::Expectations::ExpectationNotMetError.new(build_message(errors[0])))
-            else
-              errors.delete(error_to_remove)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +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(format=:unified,context_lines=nil,colour=nil)
-
-          context_lines ||= 3
-          colour        ||= false
-
-          @format,@context_lines,@colour = format,context_lines,colour
-        end
-
-        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-        def diff_as_string(data_old, data_new)
-          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
-      end
-    end
-  end
-end

data/spec/rails/vendor/plugins/rspec/lib/spec/expectations/errors.rb

@@ -1,6 +0,0 @@
-module Spec
-  module Expectations
-    class ExpectationNotMetError < StandardError
-    end
-  end
-end

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

@@ -1,66 +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)
-        return ExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
-        Spec::Matchers::PositiveOperatorMatcher.new(self)
-      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)
-        return NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
-        Spec::Matchers::NegativeOperatorMatcher.new(self)
-      end
-
-    end
-  end
-end
-
-class Object
-  include Spec::Expectations::ObjectExpectations
-end