deckshuffler 0.0.2

data/vendor/plugins/rspec/lib/spec/dsl/example_runner.rb

@@ -0,0 +1,147 @@
+module Spec
+  module DSL
+    # TODO: We need RDoc here anyway (Aslak) 
+    class ExampleRunner
+      attr_reader :options, :example, :example_definition, :errors
+
+      def initialize(options, example)
+        @options = options
+        @example = example
+        @example_definition = example.rspec_definition
+        @errors = []
+        @behaviour = example.rspec_behaviour
+        @behaviour_type = @behaviour.behaviour_type
+      end
+
+      def run
+        reporter.example_started(example_definition)
+        if dry_run
+          example_definition.description = "NO NAME (Because of --dry-run)"
+          return reporter.example_finished(example_definition, nil, example_definition.description)
+        end
+
+        location = nil
+        Timeout.timeout(timeout) do
+          before_each_ok = before_example
+          example_ok = run_example if before_each_ok
+          after_each_ok = after_example
+          example_definition.description = description
+          location = failure_location(before_each_ok, example_ok, after_each_ok)
+          Spec::Matchers.clear_generated_description
+        end
+
+        if should_raise
+          ShouldRaiseHandler.new(from, should_raise).handle(errors)
+        end
+        reporter.example_finished(
+          example_definition,
+          errors.first,
+          location,
+          example_definition.pending?
+        )
+        ok?
+      end
+
+      def ok?
+        @errors.empty? || @errors.all? {|error| error.is_a?(Spec::DSL::ExamplePendingError)}
+      end
+
+      def failed?
+        !ok?
+      end
+
+      protected
+      def before_example
+        setup_mocks
+        example.before_each
+        return ok?
+      rescue Exception => e
+        errors << e
+        return false
+      end
+
+      def run_example
+        if example_block
+          example.run_example
+          return true
+        else
+          raise ExamplePendingError
+        end
+      rescue Exception => e
+        errors << e
+        return false
+      end
+
+      def after_example(&behaviour_after_each)
+        example.after_each
+
+        begin
+          verify_mocks
+        ensure
+          teardown_mocks
+        end
+
+        return ok?
+      rescue Exception => e
+        errors << e
+        return false
+      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
+        return nil
+      end
+
+      def example_block
+        example_definition.example_block
+      end
+
+      def reporter
+        @options.reporter
+      end
+
+      def timeout
+        @options.timeout
+      end
+      
+      def dry_run
+        @options.dry_run
+      end
+
+      def from
+        example_definition.from
+      end
+
+      def should_raise
+        example_definition.should_raise
+      end
+
+      def description
+        return example_definition.description unless example_definition.use_generated_description?
+        return Spec::Matchers.generated_description if Spec::Matchers.generated_description
+        return "NO NAME (Because of Error raised in matcher)" if failed?
+        "NO NAME (Because there were no expectations)"
+      end
+
+      def setup_mocks
+        if example.respond_to?(:setup_mocks_for_rspec)
+          example.setup_mocks_for_rspec
+        end
+      end
+
+      def verify_mocks
+        if example.respond_to?(:verify_mocks_for_rspec)
+          example.verify_mocks_for_rspec
+        end
+      end
+
+      def teardown_mocks
+        if example.respond_to?(:teardown_mocks_for_rspec)
+          example.teardown_mocks_for_rspec
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/example_suite.rb

@@ -0,0 +1,110 @@
+module Spec
+  module DSL
+    class ExampleSuite
+      extend Forwardable
+      attr_reader :examples, :behaviour, :name
+      alias_method :tests, :examples
+
+      def initialize(name, behaviour)
+        @name = name
+        @behaviour = behaviour
+        @examples = []
+      end
+
+      def run
+        retain_specified_examples
+        return true if examples.empty?
+
+        reporter.add_behaviour(description)
+        success = run_before_all
+        if success
+          example = nil
+          examples.each do |example|
+            example.copy_instance_variables_from(@before_and_after_all_example)
+
+            runner = ExampleRunner.new(rspec_options, example)
+            unless runner.run
+              success = false
+            end
+          end
+          @before_and_after_all_example.copy_instance_variables_from(example)
+        end
+
+        unless run_after_all
+          success = false
+        end
+        return success
+      end
+
+      def <<(example)
+        examples << example
+      end
+
+      def size
+        examples.length
+      end
+
+      def empty?
+        size == 0
+      end
+
+      def delete(example)
+        @examples.delete example
+      end
+
+      protected
+      def retain_specified_examples
+        return unless specified_examples
+        return if specified_examples.empty?
+        return if specified_examples.index(description.to_s)
+        examples.reject! do |example|
+          matcher = ExampleMatcher.new(description.to_s, example.rspec_definition.description)
+          !matcher.matches?(specified_examples)
+        end
+      end
+
+      def run_before_all
+        errors = []
+        unless dry_run
+          begin
+            @before_and_after_all_example = behaviour.new(nil)
+            @before_and_after_all_example.before_all
+          rescue Exception => e
+            errors << e
+            location = "before(:all)"
+            # The easiest is to report this as an example failure. We don't have an ExampleDefinition
+            # at this point, so we'll just create a placeholder.
+            reporter.example_finished(create_example_definition(location), e, location)
+            return false
+          end
+        end
+        return true
+      end
+
+      def run_after_all
+        unless dry_run
+          begin
+            @before_and_after_all_example ||= behaviour.new(nil)
+            @before_and_after_all_example.after_all
+          rescue Exception => e
+            location = "after(:all)"
+            reporter.example_finished(create_example_definition(location), e, location)
+            return false
+          end
+        end
+        return true
+      end
+
+      def_delegator :behaviour, :create_example_definition
+      def_delegator :behaviour, :description
+      def_delegator :behaviour, :behaviour_type
+      def_delegator :behaviour, :before_all_proc
+      def_delegator :behaviour, :before_each_proc
+      def_delegator :behaviour, :after_each_proc
+      def_delegator :behaviour, :after_all_proc
+      def_delegator :rspec_options, :examples, :specified_examples
+      def_delegator :rspec_options, :reporter
+      def_delegator :rspec_options, :dry_run
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/pending.rb

@@ -0,0 +1,18 @@
+module Spec
+  module DSL      
+    module Pending
+      def pending(message = "TODO")
+        if block_given?
+          begin
+            yield
+          rescue Exception => e
+            raise Spec::DSL::ExamplePendingError.new(message)
+          end
+          raise Spec::DSL::PendingFixedError.new("Expected pending '#{message}' to fail. No Error was raised.")
+        else
+          raise Spec::DSL::ExamplePendingError.new(message)
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/shared_behaviour.rb

@@ -0,0 +1,52 @@
+module Spec
+  module DSL
+    class SharedBehaviour < Module
+      class << self
+        def add_shared_behaviour(behaviour)
+          found_behaviour = find_shared_behaviour(behaviour.description)
+          return if behaviour.equal?(found_behaviour)
+          if(
+            found_behaviour and
+            File.expand_path(behaviour.description[:spec_path]) == File.expand_path(found_behaviour.description[:spec_path])
+          )
+            return
+          end
+          if found_behaviour
+            raise ArgumentError.new("Shared Example '#{behaviour.description}' already exists")
+          end
+          shared_behaviours << behaviour
+        end
+
+        def find_shared_behaviour(behaviour_description)
+          shared_behaviours.find { |b| b.description == behaviour_description }
+        end
+
+        def shared_behaviours
+          # TODO - this needs to be global, or at least accessible from
+          # from subclasses of Example in a centralized place. I'm not loving
+          # this as a solution, but it works for now.
+          $shared_behaviours ||= []
+        end
+      end
+      include Behaviour
+      public :include
+
+      def initialize(*args, &behaviour_block)
+        describe(*args, &behaviour_block)
+      end
+
+      def included(mod) # :nodoc:
+        example_definitions.each { |e| mod.example_definitions << e; }
+        before_each_parts.each   { |p| mod.before_each_parts << p }
+        after_each_parts.each    { |p| mod.after_each_parts << p }
+        before_all_parts.each    { |p| mod.before_all_parts << p }
+        after_all_parts.each     { |p| mod.after_all_parts << p }
+        included_modules.each    { |m| mod.__send__(:include, m) }
+      end
+
+      def register
+        Spec::DSL::SharedBehaviour.add_shared_behaviour(self)
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/dsl/should_raise_handler.rb

@@ -0,0 +1,64 @@
+module Spec
+  module DSL
+    class ShouldRaiseHandler
+      def initialize(file_and_line_number, should_raise)
+        @file_and_line_number = file_and_line_number
+        @should_raise = should_raise
+        @expected_error_class = determine_error_class
+        @expected_error_message = determine_error_message
+      end
+  
+      def determine_error_class
+        if @should_raise.is_a?(Class)
+          return @should_raise
+        elsif @should_raise.is_a?(Array)
+          return @should_raise[0]
+        else
+          return Exception
+        end
+      end
+  
+      def determine_error_message
+        if @should_raise.is_a?(Array)
+          return @should_raise[1]
+        end
+        return nil
+      end
+  
+      def build_message(exception=nil)
+        if @expected_error_message
+          message = "example block expected #{@expected_error_class.new(@expected_error_message.to_s).inspect}"
+        else
+          message = "example block expected #{@expected_error_class.to_s}"
+        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)
+        if @expected_error_message
+          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)
+        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

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