has_finder 0.1.1

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

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

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

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

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

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

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

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

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

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

data/spec/rails/vendor/plugins/rspec/lib/spec/expectations/extensions/object.rb

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