rspec 1.0.0 → 1.3.1

data/lib/spec/dsl/behaviour_callbacks.rb

@@ -1,77 +0,0 @@
-module Spec
-  module DSL
-    module BehaviourCallbacks
-      def prepend_before(*args, &block)
-        scope, options = scope_and_options(*args)
-        add(scope, options, :before, :unshift, &block)
-      end
-      def append_before(*args, &block)
-        scope, options = scope_and_options(*args)
-        add(scope, options, :before, :<<, &block)
-      end
-      alias_method :before, :append_before
-
-      def prepend_after(*args, &block)
-        scope, options = scope_and_options(*args)
-        add(scope, options, :after, :unshift, &block)
-      end
-      alias_method :after, :prepend_after
-      def append_after(*args, &block)
-        scope, options = scope_and_options(*args)
-        add(scope, options, :after, :<<, &block)
-      end
-      
-      def scope_and_options(*args)
-        args, options = args_and_options(*args)
-        scope = (args[0] || :each), options
-      end
-      
-      def add(scope, options, where, how, &block)
-        scope ||= :each
-        options ||= {}
-        behaviour_type = options[:behaviour_type]
-        case scope
-          when :each; self.__send__("#{where}_each_parts", behaviour_type).__send__(how, block)
-          when :all;  self.__send__("#{where}_all_parts", behaviour_type).__send__(how, block)
-        end
-      end
-
-      # Deprecated. Use before(:each)
-      def setup(&block)
-        before(:each, &block)
-      end
-
-      # Deprecated. Use after(:each)
-      def teardown(&block)
-        after(:each, &block)
-      end
-
-      def before_all_parts(behaviour_type=nil) # :nodoc:
-        @before_all_parts ||= {}
-        @before_all_parts[behaviour_type] ||= []
-      end
-
-      def after_all_parts(behaviour_type=nil) # :nodoc:
-        @after_all_parts ||= {}
-        @after_all_parts[behaviour_type] ||= []
-      end
-
-      def before_each_parts(behaviour_type=nil) # :nodoc:
-        @before_each_parts ||= {}
-        @before_each_parts[behaviour_type] ||= []
-      end
-
-      def after_each_parts(behaviour_type=nil) # :nodoc:
-        @after_each_parts ||= {}
-        @after_each_parts[behaviour_type] ||= []
-      end
-
-      def clear_before_and_after! # :nodoc:
-        @before_all_parts = nil
-        @after_all_parts = nil
-        @before_each_parts = nil
-        @after_each_parts = nil
-      end
-    end
-  end
-end

data/lib/spec/dsl/behaviour_eval.rb

@@ -1,177 +0,0 @@
-module Spec
-  module DSL
-    module BehaviourEval
-      module ModuleMethods
-        include BehaviourCallbacks
-
-        attr_writer :behaviour
-        attr_accessor :description
-
-        def inherit(klass)
-          raise ArgumentError.new("Shared behaviours cannot inherit from classes") if @behaviour.shared?
-          @behaviour_superclass = klass
-          derive_execution_context_class_from_behaviour_superclass
-        end
-
-        def include(*mods)
-          mods.each do |mod|
-            included_modules << mod
-            mod.send :included, self
-          end
-        end
-
-        def it_should_behave_like(behaviour_description)
-          behaviour = @behaviour.class.find_shared_behaviour(behaviour_description)
-          if behaviour.nil?
-            raise RuntimeError.new("Shared Behaviour '#{behaviour_description}' can not be found")
-          end
-          behaviour.copy_to(self)
-        end
-
-        def copy_to(eval_module)
-          examples.each          { |e| eval_module.examples << e; }
-          before_each_parts.each { |p| eval_module.before_each_parts << p }
-          after_each_parts.each  { |p| eval_module.after_each_parts << p }
-          before_all_parts.each  { |p| eval_module.before_all_parts << p }
-          after_all_parts.each   { |p| eval_module.after_all_parts << p }
-          included_modules.each  { |m| eval_module.included_modules << m }
-          eval_module.included_modules << self
-        end
-        
-        # :call-seq:
-        #   predicate_matchers[method_on_object] = matcher_name
-        #
-        # Dynamically generates a custom matcher that will match
-        # a predicate on your class.
-        #
-        # == Example
-        #
-        #   class Fish
-        #     def can_swim?
-        #       true
-        #     end
-        #   end
-        #
-        #   describe Fish do
-        #     predicate_matchers[:swim] = :can_swim?
-        #     it "should swim" do
-        #       Fish.new.should swim
-        #     end
-        #   end
-        def predicate_matchers
-          @predicate_matchers ||= {:exist => :exist?}
-        end
-        
-        def define_predicate_matchers(hash=nil) # :nodoc:
-          if hash.nil?
-            define_predicate_matchers(predicate_matchers)
-            define_predicate_matchers(Spec::Runner.configuration.predicate_matchers)
-          else
-            hash.each_pair do |matcher_method, method_on_object|
-              define_method matcher_method do |*args|
-                eval("be_#{method_on_object.to_s.gsub('?','')}(*args)")
-              end
-            end
-          end
-        end
-        
-        def it(description=:__generate_description, opts={}, &block)
-          examples << Example.new(description, opts, &block)
-        end
-        
-        def specify(description, opts={}, &block)
-          it(description, opts, &block)
-        end
-
-        def methods
-          my_methods = super
-          my_methods |= behaviour_superclass.methods
-          my_methods
-        end
-
-      protected
-
-        def method_missing(method_name, *args)
-          if behaviour_superclass.respond_to?(method_name)
-            return execution_context_class.send(method_name, *args)
-          end
-          super
-        end
-
-        def before_all_proc(behaviour_type, &error_handler)
-          parts = []
-          parts.push(*Behaviour.before_all_parts(nil))
-          parts.push(*Behaviour.before_all_parts(behaviour_type)) unless behaviour_type.nil?
-          parts.push(*before_all_parts(nil))
-          parts.push(*before_all_parts(behaviour_type)) unless behaviour_type.nil?
-          CompositeProcBuilder.new(parts).proc(&error_handler)
-        end
-
-        def after_all_proc(behaviour_type, &error_handler)
-          parts = []
-          parts.push(*after_all_parts(behaviour_type)) unless behaviour_type.nil?
-          parts.push(*after_all_parts(nil))
-          parts.push(*Behaviour.after_all_parts(behaviour_type)) unless behaviour_type.nil?
-          parts.push(*Behaviour.after_all_parts(nil))
-          CompositeProcBuilder.new(parts).proc(&error_handler)
-        end
-
-        def before_each_proc(behaviour_type, &error_handler)
-          parts = []
-          parts.push(*Behaviour.before_each_parts(nil))
-          parts.push(*Behaviour.before_each_parts(behaviour_type)) unless behaviour_type.nil?
-          parts.push(*before_each_parts(nil))
-          parts.push(*before_each_parts(behaviour_type)) unless behaviour_type.nil?
-          CompositeProcBuilder.new(parts).proc(&error_handler)
-        end
-
-        def after_each_proc(behaviour_type, &error_handler)
-          parts = []
-          parts.push(*after_each_parts(behaviour_type)) unless behaviour_type.nil?
-          parts.push(*after_each_parts(nil))
-          parts.push(*Behaviour.after_each_parts(behaviour_type)) unless behaviour_type.nil?
-          parts.push(*Behaviour.after_each_parts(nil))
-          CompositeProcBuilder.new(parts).proc(&error_handler)
-        end
-
-      private
-
-        def execution_context_class
-          @execution_context_class ||= derive_execution_context_class_from_behaviour_superclass
-        end
-
-        def derive_execution_context_class_from_behaviour_superclass
-          @execution_context_class = Class.new(behaviour_superclass)
-          behaviour_superclass.spec_inherited(self) if behaviour_superclass.respond_to?(:spec_inherited)
-          @execution_context_class
-        end
-
-        def behaviour_superclass
-          @behaviour_superclass ||= Object
-        end
-
-        protected
-        def included_modules
-          @included_modules ||= [::Spec::Matchers]
-        end
-
-        def examples
-          @examples ||= []
-        end
-      end
-
-      module InstanceMethods
-        def initialize(*args, &block) #:nodoc:
-          # TODO - inheriting from TestUnit::TestCase fails without this
-          # - let's figure out why and move this somewhere else
-        end
-
-        def violated(message="")
-          raise Spec::Expectations::ExpectationNotMetError.new(message)
-        end
-
-      end
-
-    end
-  end
-end

data/lib/spec/dsl/behaviour_factory.rb

@@ -1,42 +0,0 @@
-module Spec
-  module DSL
-    class BehaviourFactory
-
-      class << self
-
-        BEHAVIOUR_CLASSES = {:default => Spec::DSL::Behaviour}
-        
-        # Registers a behaviour class +klass+ with the symbol
-        # +behaviour_type+. For example:
-        #
-        #   Spec::DSL::BehaviourFactory.add_behaviour_class(:farm, Spec::Farm::DSL::FarmBehaviour)
-        #
-        # This will cause Kernel#describe from a file living in 
-        # <tt>spec/farm</tt> to create behaviour instances of type
-        # Spec::Farm::DSL::FarmBehaviour.
-        def add_behaviour_class(behaviour_type, klass)
-          BEHAVIOUR_CLASSES[behaviour_type] = klass
-        end
-
-        def remove_behaviour_class(behaviour_type)
-          BEHAVIOUR_CLASSES.delete(behaviour_type)
-        end
-
-        def create(*args, &block)
-          opts = Hash === args.last ? args.last : {}
-          if opts[:shared]
-            behaviour_type = :default
-          elsif opts[:behaviour_type]
-            behaviour_type = opts[:behaviour_type]
-          elsif opts[:spec_path] =~ /spec\/(#{BEHAVIOUR_CLASSES.keys.join('|')})/
-            behaviour_type = $1.to_sym
-          else
-            behaviour_type = :default
-          end
-          return BEHAVIOUR_CLASSES[behaviour_type].new(*args, &block)
-        end
-
-      end
-    end
-  end
-end

data/lib/spec/dsl/composite_proc_builder.rb

@@ -1,28 +0,0 @@
-module Spec
-  module DSL
-    class CompositeProcBuilder < Array
-      def initialize(callbacks=[])
-        push(*callbacks)
-      end
-
-      def proc(&error_handler)
-        parts = self
-        Proc.new do
-          parts.collect do |part|
-            begin
-              if part.is_a?(UnboundMethod)
-                part.bind(self).call
-              else
-                instance_eval(&part)
-              end
-            rescue Exception => e
-              raise e unless error_handler
-              error_handler.call(e)
-              e
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spec/dsl/configuration.rb

@@ -1,119 +0,0 @@
-module Spec
-  module DSL
-    class Configuration
-      
-      # Chooses what mock framework to use. Example:
-      #
-      #   Spec::Runner.configure do |config|
-      #     config.mock_with :rspec # or :mocha, or :flexmock
-      #   end
-      #
-      # To use any other mock framework, you'll have to provide
-      # your own adapter. This is simply a module that responds to
-      # setup_mocks_for_rspec, verify_mocks_for_rspec and teardown_mocks_for_rspec.
-      # These are your hooks into the lifecycle of a given example. RSpec will
-      # call setup_mocks_for_rspec before running anything else in each Example.
-      # After executing the #after methods, RSpec will then call verify_mocks_for_rspec
-      # and teardown_mocks_for_rspec (this is guaranteed to run even if there are
-      # failures in verify_mocks_for_rspec).
-      #
-      # Once you've defined this module, you can pass that to mock_with:
-      #
-      #   Spec::Runner.configure do |config|
-      #     config.mock_with MyMockFrameworkAdapter
-      #   end
-      #
-      def mock_with(mock_framework)
-        @mock_framework = case mock_framework
-        when Symbol
-          mock_framework_path(mock_framework.to_s)
-        else
-          mock_framework
-        end
-      end
-      
-      def mock_framework # :nodoc:
-        @mock_framework ||= mock_framework_path("rspec")
-      end
-      
-      # Declares modules to be included in all behaviours (<tt>describe</tt> blocks).
-      #
-      #   config.include(My::Bottle, My::Cup)
-      #
-      # If you want to restrict the inclusion to a subset of all the behaviours then
-      # specify this in a Hash as the last argument:
-      #
-      #   config.include(My::Pony, My::Horse, :behaviour_type => :farm)
-      #
-      # Only behaviours that have that type will get the modules included:
-      #
-      #   describe "Downtown", :behaviour_type => :city do
-      #     # Will *not* get My::Pony and My::Horse included
-      #   end
-      #
-      #   describe "Old Mac Donald", :behaviour_type => :farm do
-      #     # *Will* get My::Pony and My::Horse included
-      #   end
-      #
-      def include(*args)
-        included_modules.push(*args)
-      end
-      
-      def included_modules # :nodoc:
-        @included_modules ||= []
-      end
-      
-      # Defines global predicate matchers. Example:
-      #
-      #   config.predicate_matchers[:swim] = :can_swim?
-      #
-      # This makes it possible to say:
-      #
-      #   person.should swim # passes if person.should_swim? returns true
-      #
-      def predicate_matchers
-        @predicate_matchers ||= {}
-      end
-      
-      # Prepends a global <tt>before</tt> block to all behaviours.
-      # See #append_before for filtering semantics.
-      def prepend_before(*args, &proc)
-        Behaviour.prepend_before(*args, &proc)
-      end
-      # Appends a global <tt>before</tt> block to all behaviours.
-      #
-      # If you want to restrict the block to a subset of all the behaviours then
-      # specify this in a Hash as the last argument:
-      #
-      #   config.prepend_before(:all, :behaviour_type => :farm)
-      #
-      # or
-      #
-      #   config.prepend_before(:behaviour_type => :farm)
-      #
-      def append_before(*args, &proc)
-        Behaviour.append_before(*args, &proc)
-      end
-      alias_method :before, :append_before
-
-      # Prepends a global <tt>after</tt> block to all behaviours.
-      # See #append_before for filtering semantics.
-      def prepend_after(*args, &proc)
-        Behaviour.prepend_after(*args, &proc)
-      end
-      alias_method :after, :prepend_after
-      # Appends a global <tt>after</tt> block to all behaviours.
-      # See #append_before for filtering semantics.
-      def append_after(*args, &proc)
-        Behaviour.append_after(*args, &proc)
-      end
-
-    private
-    
-      def mock_framework_path(framework_name)
-        File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "plugins", "mock_frameworks", framework_name))
-      end
-      
-    end
-  end
-end

data/lib/spec/dsl/description.rb

@@ -1,46 +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)
-        @described_type = args.first unless args.first.is_a?(String)
-        @description = self.class.generate_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
-
-    end
-  end
-end

data/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/lib/spec/dsl/example_matcher.rb

@@ -1,28 +0,0 @@
-module Spec
-  module DSL
-    class ExampleMatcher
-
-      attr_writer :example_desc
-      def initialize(context_desc, example_desc=nil)
-        @context_desc = context_desc
-        @example_desc = example_desc
-      end
-      
-      def matches?(specified_examples)
-        specified_examples.each do |specified_example|
-          return true if specified_example =~ /(^#{context_regexp} #{example_regexp}$|^#{context_regexp}$|^#{example_regexp}$)/
-        end
-        false
-      end
-      
-      private
-        def context_regexp
-          Regexp.escape(@context_desc.split('::').last)
-        end
-        
-        def example_regexp
-          Regexp.escape(@example_desc)
-        end
-    end
-  end
-end