dchelimsky-rspec 1.1.12 → 1.1.99.1

data/lib/spec/matchers/satisfy.rb

@@ -6,18 +6,18 @@ module Spec
         @block = block
       end
       
-      def matches?(given, &block)
+      def matches?(actual, &block)
         @block = block if block
-        @given = given
-        @block.call(given)
+        @actual = actual
+        @block.call(actual)
       end
       
       def failure_message
-        "expected #{@given} to satisfy block"
+        "expected #{@actual} to satisfy block"
       end
 
       def negative_failure_message
-        "expected #{@given} not to satisfy block"
+        "expected #{@actual} not to satisfy block"
       end
     end
     

data/lib/spec/matchers/throw_symbol.rb

@@ -35,9 +35,7 @@ module Spec
             if @expected_arg.nil?
               return @caught_symbol == @expected_symbol
             else
-              # puts [@caught_symbol, @expected_symbol].inspect
-              # puts [@caught_arg, @expected_arg].inspect
-              return @caught_symbol == @expected_symbol && @caught_arg == @expected_arg
+              return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
             end
           end
         end

data/lib/spec/mocks/argument_expectation.rb

@@ -24,7 +24,7 @@ module Spec
       end
       
       def is_matcher?(obj)
-        return obj.respond_to?(:matches?) && obj.respond_to?(:description)
+        return obj.respond_to?(:matches?) & obj.respond_to?(:description)
       end
       
       def args_match?(given_args)

data/lib/spec/mocks/argument_matchers.rb

@@ -0,0 +1,233 @@
+module Spec
+  module Mocks
+
+    # ArgumentMatchers are messages that you can include in message
+    # expectations to match arguments against a broader check than simple
+    # equality.
+    #
+    # With the exception of any_args() and no_args(), the matchers
+    # are all positional - they match against the arg in the given position.
+    module ArgumentMatchers
+
+      class AnyArgsMatcher
+        def description
+          "any args"
+        end
+      end
+
+      class AnyArgMatcher
+        def initialize(ignore)
+        end
+
+        def ==(other)
+          true
+        end
+      end
+
+      class NoArgsMatcher
+        def description
+          "no args"
+        end
+      end
+
+      class RegexpMatcher
+        def initialize(regexp)
+          @regexp = regexp
+        end
+
+        def ==(value)
+          return value =~ @regexp unless value.is_a?(Regexp)
+          value == @regexp
+        end
+      end
+
+      class BooleanMatcher
+        def initialize(ignore)
+        end
+
+        def ==(value)
+          TrueClass === value || FalseClass === value
+        end
+      end
+
+      class HashIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do | key, value |
+            return false unless actual.has_key?(key) && value == actual[key]
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+      
+      class HashNotIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do | key, value |
+            return false if actual.has_key?(key) && value == actual[key]
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+      
+      class DuckTypeMatcher
+        def initialize(*methods_to_respond_to)
+          @methods_to_respond_to = methods_to_respond_to
+        end
+
+        def ==(value)
+          @methods_to_respond_to.all? { |sym| value.respond_to?(sym) }
+        end
+      end
+
+      class MatcherMatcher
+        def initialize(matcher)
+          @matcher = matcher
+        end
+
+        def ==(value)
+          @matcher.matches?(value)
+        end
+      end
+
+      class EqualityProxy
+        def initialize(given)
+          @given = given
+        end
+
+        def ==(expected)
+          @given == expected
+        end
+      end
+      
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.instance_of?(@klass)
+        end
+      end
+      
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.kind_of?(@klass)
+        end
+      end
+
+      # :call-seq:
+      #   object.should_receive(:message).with(any_args())
+      #
+      # Passes if object receives :message with any args at all. This is
+      # really a more explicit variation of object.should_receive(:message)
+      def any_args
+        AnyArgsMatcher.new
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(anything())
+      #
+      # Passes as long as there is an argument.
+      def anything
+        AnyArgMatcher.new(nil)
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(no_args)
+      #
+      # Passes if no arguments are passed along with the message
+      def no_args
+        NoArgsMatcher.new
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(duck_type(:hello))
+      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
+      #
+      # Passes if the argument responds to the specified messages.
+      #
+      # == Examples
+      #
+      #   array = []
+      #   display = mock('display')
+      #   display.should_receive(:present_names).with(duck_type(:length, :each))
+      #   => passes
+      def duck_type(*args)
+        DuckTypeMatcher.new(*args)
+      end
+
+      # :call-seq:
+      #   object.should_receive(:message).with(boolean())
+      #
+      # Passes if the argument is boolean.
+      def boolean
+        BooleanMatcher.new(nil)
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(hash_including(:key => val))
+      #   object.should_receive(:message).with(hash_including(:key))
+      #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
+      # Passes if the argument is a hash that includes the specified key(s) or key/value
+      # pairs. If the hash includes other keys, it will still pass.
+      def hash_including(*args)
+        HashIncludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(hash_not_including(:key => val))
+      #   object.should_receive(:message).with(hash_not_including(:key))
+      #   object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2))
+      #
+      # Passes if the argument is a hash that doesn't include the specified key(s) or key/value
+      def hash_not_including(*args)
+        HashNotIncludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+      
+      # Passes if arg.instance_of?(klass)
+      def instance_of(klass)
+        InstanceOf.new(klass)
+      end
+      
+      alias_method :an_instance_of, :instance_of
+      
+      # Passes if arg.kind_of?(klass)
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+      
+      alias_method :a_kind_of, :kind_of
+      
+      private
+      
+      def anythingize_lonely_keys(*args)
+        hash = args.last.class == Hash ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = anything }
+        hash
+      end
+    end
+  end
+end

data/lib/spec/mocks/error_generator.rb

@@ -57,15 +57,11 @@ module Spec
       end
       
       def format_args(*args)
-        return "(no args)" if args.empty? || args == [:no_args]
-        return "(any args)" if args == [:any_args]
-        "(" + arg_list(*args) + ")"
+        args.empty? ? "(no args)" : "(" + arg_list(*args) + ")"
       end
 
       def arg_list(*args)
-        args.collect do |arg|
-          arg.respond_to?(:description) ? arg.description : arg.inspect
-        end.join(", ")
+        args.collect {|arg| arg.respond_to?(:description) ? arg.description : arg.inspect}.join(", ")
       end
       
       def count_message(count)

data/lib/spec/mocks/message_expectation.rb

@@ -56,8 +56,6 @@ module Spec
                                                     @expected_received_count < values.size
         end
         @return_block = block_given? ? return_block : lambda { value }
-        # Ruby 1.9 - see where this is used below
-        @ignore_args = !block_given?
       end
       
       # :call-seq:
@@ -157,9 +155,7 @@ module Spec
       end
       
       def invoke_consecutive_return_block(args, block)
-        args << block unless block.nil?
-        value = @return_block.call(*args)
-        
+        value = invoke_return_block(args, block)
         index = [@actual_received_count, value.size-1].min
         value[index]
       end
@@ -169,13 +165,9 @@ module Spec
         # Ruby 1.9 - when we set @return_block to return values
         # regardless of arguments, any arguments will result in
         # a "wrong number of arguments" error
-        if @ignore_args
-          @return_block.call()
-        else
-          @return_block.call(*args)
-        end
+        @return_block.arity > 0 ? @return_block.call(*args) : @return_block.call()
       end
-
+      
       def clone_args_to_yield(args)
         @args_to_yield = args.clone
         @args_to_yield_were_cloned = true

data/lib/spec/mocks/mock.rb

@@ -22,7 +22,7 @@ module Spec
       end
 
       def method_missing(sym, *args, &block)
-        __mock_proxy.instance_eval {@messages_received << [sym, args, block]}
+        __mock_proxy.record_message_received(sym, args, block)
         begin
           return self if __mock_proxy.null_object?
           super(sym, *args, &block)

data/lib/spec/mocks/proxy.rb

@@ -82,6 +82,10 @@ module Spec
       def has_negative_expectation?(sym)
         @expectations.detect {|expectation| expectation.negative_expectation_for?(sym)}
       end
+      
+      def record_message_received(sym, args, block)
+        @messages_received << [sym, args, block]
+      end
 
       def message_received(sym, *args, &block)
         expectation = find_matching_expectation(sym, *args)
@@ -118,7 +122,7 @@ module Spec
       end
       
       def warn_if_nil_class(sym)
-        if proxy_for_nil_class? && @@warn_about_expectations_on_nil          
+        if proxy_for_nil_class? & @@warn_about_expectations_on_nil          
           Kernel.warn("An expectation of :#{sym} was set on nil. Called from #{caller[2]}. Use allow_message_expectations_on_nil to disable warnings.")
         end
       end

data/lib/spec/runner/configuration.rb

@@ -143,14 +143,14 @@ module Spec
         [get_type_from_options(options)].flatten.each do |required_example_group|
           required_example_group = required_example_group.to_sym if required_example_group
           modules.each do |mod|
-            Spec::Example::ExampleGroupFactory.get(required_example_group).__send__(action, mod)
+            Spec::Example::ExampleGroupFactory[required_example_group].__send__(action, mod)
           end
         end
       end
 
       def add_callback(sym, *args, &proc)
         scope, options = Spec::Example.scope_and_options(*args)
-        example_group = Spec::Example::ExampleGroupFactory.get(get_type_from_options(options))
+        example_group = Spec::Example::ExampleGroupFactory[get_type_from_options(options)]
         example_group.__send__(sym, scope, &proc)
       end
 
@@ -159,7 +159,7 @@ module Spec
       end
     
       def mock_framework_path(framework_name)
-        File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "adapters", "mock_frameworks", framework_name))
+        File.expand_path(File.join(File.dirname(__FILE__), "/../adapters/mock_frameworks/#{framework_name}"))
       end
     end
   end

data/lib/spec/runner/drb_command_line.rb

@@ -8,7 +8,8 @@ module Spec
       # CommandLine - making it possible for clients to use both interchangeably.
       def self.run(options)
         begin
-          DRb.start_service
+          # See http://redmine.ruby-lang.org/issues/show/496 as to why we specify localhost:0
+          DRb.start_service("druby://localhost:0")
           spec_server = DRbObject.new_with_uri("druby://127.0.0.1:8989")
           spec_server.run(options.argv, options.error_stream, options.output_stream)
         rescue DRb::DRbConnError => e

data/lib/spec/runner/example_group_runner.rb

@@ -27,7 +27,8 @@ module Spec
         finish
       end
 
-      protected
+    protected
+
       def prepare
         reporter.start(number_of_examples)
         example_groups.reverse! if reverse

data/lib/spec/runner/formatter/base_text_formatter.rb

@@ -1,4 +1,5 @@
 require 'spec/runner/formatter/base_formatter'
+require 'fileutils'
 
 module Spec
   module Runner
@@ -23,27 +24,31 @@ module Spec
         end
         
         def example_pending(example, message, pending_caller)
-          @pending_examples << [example.full_description, message, pending_caller]
+          @pending_examples << ["#{@example_group.description} #{example.description}", message, pending_caller]
         end
         
         def dump_failure(counter, failure)
           @output.puts
           @output.puts "#{counter.to_s})"
-          @output.puts colourise("#{failure.header}\n#{failure.exception.message}", failure)
+          @output.puts colorize_failure("#{failure.header}\n#{failure.exception.message}", failure)
           @output.puts format_backtrace(failure.exception.backtrace)
           @output.flush
         end
         
-        def colourise(s, failure)
-          if(failure.expectation_not_met?)
-            red(s)
-          elsif(failure.pending_fixed?)
-            blue(s)
-          else
-            magenta(s)
-          end
+        def colorize_failure(message, failure)
+          failure.pending_fixed? ? blue(message) : red(message)
         end
-      
+        
+        def colourise(message, failure)
+          Kernel.warn <<-NOTICE
+DEPRECATED: BaseTextFormatter#colourise is deprecated and will be
+removed from a future version of RSpec.
+
+Please use colorize_failure instead.
+NOTICE
+          colorize_failure(message, failure)
+        end
+        
         def dump_summary(duration, example_count, failure_count, pending_count)
           return if dry_run?
           @output.puts
@@ -78,9 +83,7 @@ module Spec
         end
         
         def close
-          if IO === @output && @output != $stdout
-            @output.close 
-          end
+          @output.close  if (IO === @output) & (@output != $stdout)
         end
         
         def format_backtrace(backtrace)
@@ -103,7 +106,7 @@ module Spec
         end
 
         def colour(text, colour_code)
-          return text unless colour? && output_to_tty?
+          return text unless ENV['RSPEC_COLOR'] || (colour? & output_to_tty?)
           "#{colour_code}#{text}\e[0m"
         end
 
@@ -117,10 +120,18 @@ module Spec
         
         def green(text); colour(text, "\e[32m"); end
         def red(text); colour(text, "\e[31m"); end
-        def magenta(text); colour(text, "\e[35m"); end
         def yellow(text); colour(text, "\e[33m"); end
         def blue(text); colour(text, "\e[34m"); end
-        
+
+        def magenta(text)
+          Kernel.warn <<-NOTICE
+DEPRECATED: BaseTextFormatter#magenta is deprecated and will be
+removed from a future version of RSpec.
+
+Please use red instead (it is red/green/refactor after all).
+NOTICE
+          red(text)
+        end
       end
     end
   end

data/lib/spec/runner/formatter/failing_example_groups_formatter.rb

@@ -6,21 +6,19 @@ module Spec
       class FailingExampleGroupsFormatter < BaseTextFormatter
         def example_failed(example, counter, failure)
           if @example_group
-            description_parts = @example_group.description_parts.collect do |description|
-              description =~ /(.*) \(druby.*\)$/ ? $1 : description
-            end
-            @output.puts ::Spec::Example::ExampleGroupMethods.description_text(*description_parts)
+            @output.puts @example_group.filtered_description(/(.*) \(druby.*\)$/)
 
             @output.flush
             @example_group = nil
           end
         end
-
+        
         def dump_failure(counter, failure)
         end
 
         def dump_summary(duration, example_count, failure_count, pending_count)
         end
+        
       end
     end
   end

data/lib/spec/runner/formatter/html_formatter.rb

@@ -38,7 +38,6 @@ module Spec
         def add_example_group(example_group)
           super
           @example_group_red = false
-          @example_group_red = false
           @example_group_number += 1
           unless example_group_number == 1
             @output.puts "  </dl>"
@@ -214,7 +213,7 @@ EOF
         def global_styles
           <<-EOF
 #rspec-header {
-  background: #65C400; color: #fff; height: 42px;
+  background: #65C400; color: #fff; height: 4em;
 }
 
 .rspec-report h1 {
@@ -222,7 +221,7 @@ EOF
   padding: 10px;
   font-family: "Lucida Grande", Helvetica, sans-serif;
   font-size: 1.8em;
-  float: left;
+  position: absolute;
 }
 
 #summary {

data/lib/spec/runner/formatter/nested_text_formatter.rb

@@ -4,33 +4,25 @@ module Spec
   module Runner
     module Formatter
       class NestedTextFormatter < BaseTextFormatter
-        attr_reader :previous_nested_example_groups
         def initialize(options, where)
           super
-          @previous_nested_example_groups = []
+          @last_nested_descriptions = []
         end
 
         def add_example_group(example_group)
           super
 
-          current_nested_example_groups = described_example_group_chain
-          current_nested_example_groups.each_with_index do |nested_example_group, i|
-            unless nested_example_group == previous_nested_example_groups[i]
-              output.puts "#{'  ' * i}#{nested_example_group.description_args.join}"
+          example_group.nested_descriptions.each_with_index do |nested_description, i|
+            unless nested_description == @last_nested_descriptions[i]
+              output.puts "#{'  ' * i}#{nested_description}"
             end
           end
 
-          @previous_nested_example_groups = described_example_group_chain
+          @last_nested_descriptions = example_group.nested_descriptions
         end
 
         def example_failed(example, counter, failure)
-          message = if failure.expectation_not_met?
-            "#{current_indentation}#{example.description} (FAILED - #{counter})"
-          else
-            "#{current_indentation}#{example.description} (ERROR - #{counter})"
-          end
-
-          output.puts(failure.expectation_not_met? ? red(message) : magenta(message))
+          output.puts(red("#{current_indentation}#{example.description} (FAILED - #{counter})"))
           output.flush
         end
 
@@ -47,17 +39,7 @@ module Spec
         end
 
         def current_indentation
-          '  ' * previous_nested_example_groups.length
-        end
-
-        def described_example_group_chain
-          example_group_chain = []
-          example_group.__send__(:example_group_hierarchy).each do |example_group_class|
-            unless example_group_class.description_args.empty?
-              example_group_chain << example_group_class
-            end
-          end
-          example_group_chain
+          '  ' * @last_nested_descriptions.length
         end
       end
     end

data/lib/spec/runner/formatter/progress_bar_formatter.rb

@@ -5,7 +5,7 @@ module Spec
     module Formatter
       class ProgressBarFormatter < BaseTextFormatter
         def example_failed(example, counter, failure)
-          @output.print colourise('F', failure)
+          @output.print colorize_failure('F', failure)
           @output.flush
         end
 

data/lib/spec/runner/formatter/specdoc_formatter.rb

@@ -12,13 +12,7 @@ module Spec
         end
       
         def example_failed(example, counter, failure)
-          message = if failure.expectation_not_met?
-            "- #{example.description} (FAILED - #{counter})"
-          else
-            "- #{example.description} (ERROR - #{counter})"
-          end
-          
-          output.puts(failure.expectation_not_met? ? red(message) : magenta(message))
+          output.puts(red("- #{example.description} (FAILED - #{counter})"))
           output.flush
         end
         

data/lib/spec/runner/heckle_runner_unsupported.rb

@@ -3,7 +3,7 @@ module Spec
     # Dummy implementation for Windows that just fails (Heckle is not supported on Windows)
     class HeckleRunner
       def initialize(filter)
-        raise "Heckle not supported on Windows"
+        raise "Heckle is not supported on Windows or Ruby 1.9"
       end
     end
   end