rspec 1.0.0 → 1.3.1

data/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/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/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

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

@@ -1,17 +0,0 @@
-module Spec
-  module Expectations
-    module StringHelpers
-      def starts_with?(prefix)
-        to_s[0..(prefix.length - 1)] == prefix
-      end
-    end
-  end
-end
-
-class String
-  include Spec::Expectations::StringHelpers
-end
-
-class Symbol
-  include Spec::Expectations::StringHelpers
-end

data/lib/spec/extensions/object.rb

@@ -1,6 +0,0 @@
-class Object
-  def args_and_options(*args)
-    options = Hash === args.last ? args.pop : {}
-    return args, options
-  end
-end  

data/lib/spec/extensions.rb

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

data/lib/spec/matchers/raise_error.rb

@@ -1,100 +0,0 @@
-module Spec
-  module Matchers
-    
-    class RaiseError #:nodoc:
-      def initialize(exception=Exception, message=nil)
-        @expected_error = exception
-        @expected_message = message
-      end
-      
-      def matches?(proc)
-        @raised_expected_error = false
-        @raised_other = false
-        begin
-          proc.call
-        rescue @expected_error => @actual_error
-          if @expected_message.nil?
-            @raised_expected_error = true
-          else
-            case @expected_message
-            when Regexp
-              if @expected_message =~ @actual_error.message
-                @raised_expected_error = true
-              else
-                @raised_other = true
-              end
-            else
-              if @expected_message == @actual_error.message
-                @raised_expected_error = true
-              else
-                @raised_other = true
-              end
-            end
-          end
-        rescue => @actual_error
-          @raised_other = true
-        ensure
-          return @raised_expected_error
-        end
-      end
-      
-      def failure_message
-        return "expected #{expected_error}#{actual_error}" if @raised_other || !@raised_expected_error
-      end
-
-      def negative_failure_message
-        "expected no #{expected_error}#{actual_error}"
-      end
-      
-      def description
-        "raise #{expected_error}"
-      end
-      
-      private
-        def expected_error
-          case @expected_message
-          when nil
-            @expected_error
-          when Regexp
-            "#{@expected_error} with message matching #{@expected_message.inspect}"
-          else
-            "#{@expected_error} with #{@expected_message.inspect}"
-          end
-        end
-
-        def actual_error
-          @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
-        end
-    end
-    
-    # :call-seq:
-    #   should raise_error()
-    #   should raise_error(NamedError)
-    #   should raise_error(NamedError, String)
-    #   should raise_error(NamedError, Regexp)
-    #   should_not raise_error()
-    #   should_not raise_error(NamedError)
-    #   should_not raise_error(NamedError, String)
-    #   should_not raise_error(NamedError, Regexp)
-    #
-    # With no args, matches if any error is raised.
-    # With a named error, matches only if that specific error is raised.
-    # With a named error and messsage specified as a String, matches only if both match.
-    # With a named error and messsage specified as a Regexp, matches only if both match.
-    #
-    # == Examples
-    #
-    #   lambda { do_something_risky }.should raise_error
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky")
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/)
-    #
-    #   lambda { do_something_risky }.should_not raise_error
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError)
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky")
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/)
-    def raise_error(error=Exception, message=nil)
-      Matchers::RaiseError.new(error, message)
-    end
-  end
-end

data/lib/spec/mocks/argument_constraint_matchers.rb

@@ -1,12 +0,0 @@
-module Spec
-  module Mocks
-    module ArgumentConstraintMatchers
-
-      # Shortcut for creating an instance of Spec::Mocks::DuckTypeArgConstraint
-      def duck_type(*args)
-        return Spec::Mocks::DuckTypeArgConstraint.new(*args)
-      end
-
-    end
-  end
-end

data/lib/spec/mocks/spec_methods.rb

@@ -1,30 +0,0 @@
-module Spec
-  module Mocks
-    module SpecMethods
-      include Spec::Mocks::ArgumentConstraintMatchers
-
-      # Shortcut for creating an instance of Spec::Mocks::Mock.
-      def mock(name, options={})
-        Spec::Mocks::Mock.new(name, options)
-      end
-
-      # Shortcut for creating an instance of Spec::Mocks::Mock with
-      # predefined method stubs.
-      #
-      # == Examples
-      #
-      #   stub_thing = stub("thing", :a => "A")
-      #   stub_thing.a == "A" => true
-      #
-      #   stub_person = stub("thing", :name => "Joe", :email => "joe@domain.com")
-      #   stub_person.name => "Joe"
-      #   stub_person.email => "joe@domain.com"
-      def stub(name, stubs={})
-        object_stub = mock(name)
-        stubs.each { |key, value| object_stub.stub!(key).and_return(value) }
-        object_stub
-      end
-      
-    end
-  end
-end

data/lib/spec/runner/behaviour_runner.rb

@@ -1,102 +0,0 @@
-module Spec
-  module Runner
-    class BehaviourRunner
-      
-      def initialize(options)
-        @behaviours = []
-        @options = options
-      end
-    
-      def add_behaviour(behaviour)
-        unless specified_examples.nil? || specified_examples.empty? #|| behaviour.matches?(specified_examples)
-          behaviour.retain_examples_matching!(specified_examples) #if behaviour.matches?(specified_examples)
-        end
-        @behaviours << behaviour if behaviour.number_of_examples != 0 && !behaviour.shared?
-      end
-      
-      # Runs all contexts and returns the number of failures.
-      def run(paths, exit_when_done)
-        unless paths.nil? # It's nil when running single specs with ruby
-          paths = find_paths(paths)
-          sorted_paths = sort_paths(paths)
-          load_specs(sorted_paths) 
-        end
-        @options.reporter.start(number_of_examples)
-        behaviours = @options.reverse ? @behaviours.reverse : @behaviours
-        begin
-          run_behaviours(behaviours)
-        rescue Interrupt
-        ensure
-          @options.reporter.end
-        end
-        failure_count = @options.reporter.dump
-        
-        heckle if(failure_count == 0 && !@options.heckle_runner.nil?)
-        
-        if(exit_when_done)
-          exit_code = (failure_count == 0) ? 0 : 1
-          exit(exit_code)
-        end
-        failure_count
-      end
-
-      def run_behaviours(behaviours)
-        behaviours.each do |behaviour|
-          behaviour.run(@options.reporter, @options.dry_run, @options.reverse, @options.timeout)
-        end
-      end
-    
-      def number_of_examples
-        @behaviours.inject(0) {|sum, behaviour| sum + behaviour.number_of_examples}
-      end
-      
-      FILE_SORTERS = {
-        'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)}
-      }
-      
-      def sorter(paths)
-        FILE_SORTERS[@options.loadby]
-      end
-      
-      def sort_paths(paths)
-        sorter = sorter(paths)
-        paths = paths.sort(&sorter) unless sorter.nil?
-        paths
-      end
-
-    private
-      
-      def find_paths(paths)
-        result = []
-        paths.each do |path|
-          if File.directory?(path)
-            result += Dir["#{path}/**/*.rb"]
-          elsif File.file?(path)
-            result << path
-          else
-            raise "File or directory not found: #{path}"
-          end
-        end
-        result
-      end
-      
-      def load_specs(paths)
-        paths.each do |path|
-          require path
-        end
-      end
-      
-      def specified_examples
-        @options.examples
-      end
-      
-      def heckle
-        heckle_runner = @options.heckle_runner
-        @options.heckle_runner = nil
-        behaviour_runner = self.class.new(@options)
-        behaviour_runner.instance_variable_set(:@behaviours, @behaviours)
-        heckle_runner.heckle_with(behaviour_runner)
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# The following copyright applies to Object#copy_instance_variables_from,
-# which we borrowed from active_support.
-#
-# Copyright (c) 2004 David Heinemeier Hansson
-# 
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-# 
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-class Object
-  # From active_support
-  def copy_instance_variables_from(object, exclude = []) # :nodoc:
-    exclude += object.protected_instance_variables if object.respond_to? :protected_instance_variables
-    
-    instance_variables = object.instance_variables - exclude.map { |name| name.to_s }
-    instance_variables.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
-  end
-end

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

@@ -1,25 +0,0 @@
-module Spec
-  module Runner
-    module Formatter
-      class FailingBehavioursFormatter < BaseTextFormatter      
-        def add_behaviour(behaviour_name)
-          @behaviour_name = behaviour_name
-        end
-      
-        def example_failed(name, counter, failure)
-          unless @behaviour_name.nil?
-            @output.puts @behaviour_name 
-            @behaviour_name = nil
-            @output.flush
-          end
-        end
-
-        def dump_failure(counter, failure)
-        end
-
-        def dump_summary(duration, example_count, failure_count, not_implemented_count)
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Spec
-  module Runner
-    module Formatter
-      class RdocFormatter < BaseTextFormatter
-        def add_behaviour(name)
-          @output.puts "# #{name}"
-        end
-  
-        def example_passed(name)
-          @output.puts "# * #{name}"
-          @output.flush
-        end
-
-        def example_failed(name, counter, failure)
-          @output.puts "# * #{name} [#{counter} - FAILED]"
-        end
-        
-        def example_not_implemented(name)
-          @output.puts "# * #{name} [NOT IMPLEMENTED]"
-        end
-      end
-    end
-  end
-end

data/lib/spec/runner/formatter.rb

@@ -1,9 +0,0 @@
-require 'spec/runner/formatter/base_formatter'
-require 'spec/runner/formatter/base_text_formatter'
-require 'spec/runner/formatter/progress_bar_formatter'
-require 'spec/runner/formatter/rdoc_formatter'
-require 'spec/runner/formatter/specdoc_formatter'
-require 'spec/runner/formatter/html_formatter'
-require 'spec/runner/formatter/failing_examples_formatter'
-require 'spec/runner/formatter/failing_behaviours_formatter'
-require 'spec/runner/formatter/snippet_extractor'

data/lib/spec/runner/spec_parser.rb

@@ -1,50 +0,0 @@
-module Spec
-  module Runner
-    # Parses a spec file and finds the nearest example for a given line number.
-    class SpecParser
-      def spec_name_for(io, line_number)
-        source  = io.read
-        behaviour, behaviour_line = behaviour_at_line(source, line_number)
-        example, example_line = example_at_line(source, line_number)
-        if behaviour && example && (behaviour_line < example_line)
-          "#{behaviour} #{example}"
-        elsif behaviour
-          behaviour
-        else
-          nil
-        end
-      end
-
-    protected
-
-      def behaviour_at_line(source, line_number)
-        find_above(source, line_number, /^\s*(context|describe)\s+(.*)\s+do/)
-      end
-
-      def example_at_line(source, line_number)
-        find_above(source, line_number, /^\s*(specify|it)\s+(.*)\s+do/)
-      end
-
-      # Returns the context/describe or specify/it name and the line number
-      def find_above(source, line_number, pattern)
-        lines_above_reversed(source, line_number).each_with_index do |line, n|
-          return [parse_description($2), line_number-n] if line =~ pattern
-        end
-        nil
-      end
-
-      def lines_above_reversed(source, line_number)
-        lines = source.split("\n")
-      	lines[0...line_number].reverse
-      end
-      
-      def parse_description(str)
-        return str[1..-2] if str =~ /^['"].*['"]$/
-        if matches = /^(.*)\s*,\s*['"](.*)['"]$/.match(str)
-          return ::Spec::DSL::Description.generate_description(matches[1], matches[2])
-        end
-        return str
-      end
-    end
-  end
-end

data/lib/spec/test_case_adapter.rb

@@ -1,10 +0,0 @@
-require 'spec/expectations'
-require 'spec/matchers'
-
-module Test
-  module Unit
-    class TestCase
-      include Spec::Matchers
-    end
-  end
-end