typo 5.1.3 → 5.1.98

data/vendor/plugins/rspec/lib/spec/example/configuration.rb

@@ -7,14 +7,20 @@ module Spec
       #     config.mock_with :rspec, :mocha, :flexmock, or :rr
       #   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.
+      # To use any other mock framework, you'll have to provide your own
+      # adapter. This is simply a module that responds to the following
+      # methods:
+      #
+      #   setup_mocks_for_rspec
+      #   verify_mocks_for_rspec
+      #   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).
+      # 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:
       #
@@ -35,12 +41,18 @@ module Spec
         @mock_framework ||= mock_framework_path("rspec")
       end
       
-      # Declares modules to be included in all example groups (<tt>describe</tt> blocks).
-      #
-      #   config.include(My::Bottle, My::Cup)
-      #
-      # If you want to restrict the inclusion to a subset of all the example groups then
-      # specify this in a Hash as the last argument:
+      # :call-seq:
+      #   include(Some::Helpers)
+      #   include(Some::Helpers, More::Helpers)
+      #   include(My::Helpers, :type => :key)
+      #
+      # Declares modules to be included in multiple example groups
+      # (<tt>describe</tt> blocks). With no :type, the modules listed will be
+      # included in all example groups. Use :type to restrict the inclusion to
+      # a subset of example groups. The value assigned to :type should be a
+      # key that maps to a class that is either a subclass of
+      # Spec::Example::ExampleGroup or extends Spec::Example::ExampleGroupMethods
+      # and includes Spec::Example::ExampleMethods
       #
       #   config.include(My::Pony, My::Horse, :type => :farm)
       #
@@ -55,12 +67,21 @@ module Spec
       #   end
       #
       def include(*args)
+        include_or_extend(:include, *args)
+      end
+      
+      def extend(*args)
+        include_or_extend(:extend, *args)
+      end
+      
+      def include_or_extend(*args)
+        action = args.shift
         args << {} unless Hash === args.last
         modules, options = args_and_options(*args)
         required_example_group = get_type_from_options(options)
         required_example_group = required_example_group.to_sym if required_example_group
         modules.each do |mod|
-          ExampleGroupFactory.get(required_example_group).send(:include, mod)
+          ExampleGroupFactory.get(required_example_group).send(action, mod)
         end
       end
 
@@ -70,7 +91,7 @@ module Spec
       #
       # This makes it possible to say:
       #
-      #   person.should swim # passes if person.should_swim? returns true
+      #   person.should swim # passes if person.can_swim? returns true
       #
       def predicate_matchers
         @predicate_matchers ||= {}
@@ -85,10 +106,11 @@ module Spec
         )
         example_group.prepend_before(scope, &proc)
       end
+      
       # Appends a global <tt>before</tt> block to all example groups.
       #
-      # If you want to restrict the block to a subset of all the example groups then
-      # specify this in a Hash as the last argument:
+      # If you want to restrict the block to a subset of all the example
+      # groups then specify this in a Hash as the last argument:
       #
       #   config.prepend_before(:all, :type => :farm)
       #
@@ -115,6 +137,7 @@ module Spec
         example_group.prepend_after(scope, &proc)
       end
       alias_method :after, :prepend_after
+      
       # Appends a global <tt>after</tt> block to all example groups.
       # See #append_before for filtering semantics.
       def append_after(*args, &proc)

data/vendor/plugins/rspec/lib/spec/example/errors.rb

@@ -1,9 +1,30 @@
 module Spec
   module Example
     class ExamplePendingError < StandardError
-    end
+      attr_reader :pending_caller
 
-    class PendingExampleFixedError < StandardError
+      def initialize(message=nil)
+        super
+        @pending_caller = caller[2]
+      end
+    end
+    
+    class NotYetImplementedError < ExamplePendingError
+      MESSAGE = "Not Yet Implemented"
+      RSPEC_ROOT_LIB = File.expand_path(File.dirname(__FILE__) + "/../..")
+      
+      def initialize(backtrace)
+        super(MESSAGE)
+        @pending_caller = pending_caller_from(backtrace)
+      end
+      
+    private
+      
+      def pending_caller_from(backtrace)
+        backtrace.detect {|line| !line.include?(RSPEC_ROOT_LIB) }
+      end
     end
+
+    class PendingExampleFixedError < StandardError; end
   end
 end

data/vendor/plugins/rspec/lib/spec/example/example_group.rb

@@ -1,13 +1,22 @@
 module Spec
   module Example
-    # The superclass for all regular RSpec examples.
+    # Base class for customized example groups. Use this if you
+    # want to make a custom example group.
     class ExampleGroup
       extend Spec::Example::ExampleGroupMethods
       include Spec::Example::ExampleMethods
 
-      def initialize(defined_description, &implementation)
+      def initialize(defined_description, options={}, &implementation)
+        @_options = options
         @_defined_description = defined_description
-        @_implementation = implementation
+        @_implementation = implementation || pending_implementation
+      end
+      
+    private
+      
+      def pending_implementation
+        error = NotYetImplementedError.new(caller)
+        lambda { raise(error) }
       end
     end
   end

data/vendor/plugins/rspec/lib/spec/example/example_group_factory.rb

@@ -7,52 +7,71 @@ module Spec
           default(ExampleGroup)
         end
 
-        # Registers an example group class +klass+ with the symbol
-        # +type+. For example:
+        def all_registered?(example_group_classes)
+          example_group_classes.each do |example_group_class|
+            return false unless registered_or_ancestor_of_registered? example_group_class
+          end
+          return true
+        end
+
+        # Registers an example group class +klass+ with the symbol +type+. For
+        # example:
         #
-        #   Spec::Example::ExampleGroupFactory.register(:farm, Spec::Farm::Example::FarmExampleGroup)
+        #   Spec::Example::ExampleGroupFactory.register(:farm, FarmExampleGroup)
         #
-        # This will cause Main#describe from a file living in 
-        # <tt>spec/farm</tt> to create example group instances of type
-        # Spec::Farm::Example::FarmExampleGroup.
-        def register(id, example_group_class)
-          @example_group_types[id] = example_group_class
+        # With that you can append a hash with :type => :farm to the describe
+        # method and it will load an instance of FarmExampleGroup.
+        #
+        #   describe Pig, :type => :farm do
+        #     ...
+        #
+        # If you don't use the hash explicitly, <tt>describe</tt> will
+        # implicitly use an instance of FarmExampleGroup for any file loaded
+        # from the <tt>./spec/farm</tt> directory.
+        def register(key, example_group_class)
+          @example_group_types[key] = example_group_class
         end
         
         # Sets the default ExampleGroup class
         def default(example_group_class)
           old = @example_group_types
           @example_group_types = Hash.new(example_group_class)
-          @example_group_types.merge(old) if old
+          @example_group_types.merge!(old) if old
         end
 
-        def get(id=nil)
-          if @example_group_types.values.include?(id)
-            id
+        def get(key=nil)
+          if @example_group_types.values.include?(key)
+            key
           else
-            @example_group_types[id]
+            @example_group_types[key]
           end
         end
         
         def create_example_group(*args, &block)
           opts = Hash === args.last ? args.last : {}
-          if opts[:shared]
-            SharedExampleGroup.new(*args, &block)
-          else
-            superclass = determine_superclass(opts)
-            superclass.describe(*args, &block)
-          end
+          superclass = determine_superclass(opts)
+          superclass.describe(*args, &block)
         end
 
-        protected
+      protected
 
         def determine_superclass(opts)
-          id = if opts[:type]
+          key = if opts[:type]
             opts[:type]
           elsif opts[:spec_path] =~ /spec(\\|\/)(#{@example_group_types.keys.join('|')})/
             $2 == '' ? nil : $2.to_sym
           end
-          get(id)
+          get(key)
+        end
+        
+      private
+        
+        def registered_or_ancestor_of_registered? example_group_class
+          registered_types.any? {|registered_type| registered_type.ancestors.include? example_group_class}
+        end
+        
+        def registered_types
+          @example_group_types.values
         end
 
       end

data/vendor/plugins/rspec/lib/spec/example/example_group_methods.rb

@@ -2,7 +2,11 @@ module Spec
   module Example
 
     module ExampleGroupMethods
+      include Spec::Example::BeforeAndAfterHooks
+
       class << self
+        attr_accessor :matcher_class
+
         def description_text(*args)
           args.inject("") do |result, arg|
             result << " " unless (result == "" || arg.to_s =~ /^(\s|\.|#)/)
@@ -11,7 +15,12 @@ module Spec
         end
       end
 
-      attr_reader :description_text, :description_args, :description_options, :spec_path, :registration_binding_block
+      attr_reader :description_text, :description_options, :spec_path
+      alias :options :description_options
+      
+      def description_args
+        @description_args ||= []
+      end
 
       def inherited(klass)
         super
@@ -34,33 +43,40 @@ module Spec
       #   end
       #
       def describe(*args, &example_group_block)
+        args << {} unless Hash === args.last
         if example_group_block
-          self.subclass("Subclass") do
-            describe(*args)
-            module_eval(&example_group_block)
+          options = args.last
+          options[:spec_path] = eval("caller(0)[1]", example_group_block) unless options[:spec_path]
+          if options[:shared]
+            create_shared_example_group(args, example_group_block)
+          else
+            create_nested_example_group(args, example_group_block)
           end
         else
           set_description(*args)
-          before_eval
-          self
         end
       end
-
+      alias :context :describe
+      
+      def create_shared_example_group(args, example_group_block)
+        SharedExampleGroup.new(*args, &example_group_block)
+      end
+      
+      def create_nested_example_group(args, example_group_block)
+        self.subclass("Subclass") do
+          describe(*args)
+          module_eval(&example_group_block)
+        end
+      end
+      
       # Use this to pull in examples from shared example groups.
       # See Spec::Runner for information about shared example groups.
-      def it_should_behave_like(shared_example_group)
-        case shared_example_group
-        when SharedExampleGroup
-          include shared_example_group
-        else
-          example_group = SharedExampleGroup.find_shared_example_group(shared_example_group)
-          unless example_group
-            raise RuntimeError.new("Shared Example Group '#{shared_example_group}' can not be found")
-          end
-          include(example_group)
+      def it_should_behave_like(*shared_example_groups)
+        shared_example_groups.each do |group|
+          include_shared_example_group(group)
         end
       end
-
+      
       # :call-seq:
       #   predicate_matchers[matcher_name] = method_on_object
       #   predicate_matchers[matcher_name] = [method1_on_object, method2_on_object]
@@ -93,25 +109,29 @@ module Spec
         @predicate_matchers ||= {:an_instance_of => :is_a?}
       end
 
-      # Creates an instance of Spec::Example::Example and adds
-      # it to a collection of examples of the current example group.
-      def it(description=nil, &implementation)
-        e = new(description, &implementation)
+      # Creates an instance of the current example group class and adds it to
+      # a collection of examples of the current example group.
+      def example(description=nil, options={}, &implementation)
+        e = new(description, options, &implementation)
         example_objects << e
         e
       end
 
-      alias_method :specify, :it
+      alias_method :it, :example
+      alias_method :specify, :example
 
       # Use this to temporarily disable an example.
-      def xit(description=nil, opts={}, &block)
+      def xexample(description=nil, opts={}, &block)
         Kernel.warn("Example disabled: #{description}")
       end
+      
+      alias_method :xit, :xexample
+      alias_method :xspecify, :xexample
 
       def run
         examples = examples_to_run
+        reporter.add_example_group(self) unless examples_to_run.empty?
         return true if examples.empty?
-        reporter.add_example_group(self)
         return dry_run(examples) if dry_run?
 
         plugin_mock_framework
@@ -137,8 +157,8 @@ module Spec
 
       def description_parts #:nodoc:
         parts = []
-        execute_in_class_hierarchy do |example_group|
-          parts << example_group.description_args
+        each_ancestor_example_group_class do |example_group_class|
+          parts << example_group_class.description_args
         end
         parts.flatten.compact
       end
@@ -149,86 +169,19 @@ module Spec
         @description_options = options
         @description_text = ExampleGroupMethods.description_text(*args)
         @spec_path = File.expand_path(options[:spec_path]) if options[:spec_path]
-        if described_type.class == Module
-          include described_type
-        end
         self
       end
-
+      
       def examples #:nodoc:
         examples = example_objects.dup
         add_method_examples(examples)
-        rspec_options.reverse ? examples.reverse : examples
+        Spec::Runner.options.reverse ? examples.reverse : examples
       end
 
       def number_of_examples #:nodoc:
         examples.length
       end
 
-      # Registers a block to be executed before each example.
-      # This method prepends +block+ to existing before blocks.
-      def prepend_before(*args, &block)
-        scope, options = scope_and_options(*args)
-        parts = before_parts_from_scope(scope)
-        parts.unshift(block)
-      end
-
-      # Registers a block to be executed before each example.
-      # This method appends +block+ to existing before blocks.
-      def append_before(*args, &block)
-        scope, options = scope_and_options(*args)
-        parts = before_parts_from_scope(scope)
-        parts << block
-      end
-      alias_method :before, :append_before
-
-      # Registers a block to be executed after each example.
-      # This method prepends +block+ to existing after blocks.
-      def prepend_after(*args, &block)
-        scope, options = scope_and_options(*args)
-        parts = after_parts_from_scope(scope)
-        parts.unshift(block)
-      end
-      alias_method :after, :prepend_after
-
-      # Registers a block to be executed after each example.
-      # This method appends +block+ to existing after blocks.
-      def append_after(*args, &block)
-        scope, options = scope_and_options(*args)
-        parts = after_parts_from_scope(scope)
-        parts << block
-      end
-
-      def remove_after(scope, &block)
-        after_each_parts.delete(block)
-      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 # :nodoc:
-        @before_all_parts ||= []
-      end
-
-      def after_all_parts # :nodoc:
-        @after_all_parts ||= []
-      end
-
-      def before_each_parts # :nodoc:
-        @before_each_parts ||= []
-      end
-
-      def after_each_parts # :nodoc:
-        @after_each_parts ||= []
-      end
-
       # Only used from RSpec's own examples
       def reset # :nodoc:
         @before_all_parts = nil
@@ -239,34 +192,34 @@ module Spec
 
       def register(&registration_binding_block)
         @registration_binding_block = registration_binding_block
-        rspec_options.add_example_group self
+        Spec::Runner.options.add_example_group self
       end
 
       def unregister #:nodoc:
-        rspec_options.remove_example_group self
+        Spec::Runner.options.remove_example_group self
       end
 
       def registration_backtrace
-        eval("caller", registration_binding_block.binding)
+        eval("caller", @registration_binding_block)
       end
 
       def run_before_each(example)
-        execute_in_class_hierarchy do |example_group|
-          example.eval_each_fail_fast(example_group.before_each_parts)
+        each_ancestor_example_group_class do |example_group_class|
+          example.eval_each_fail_fast(example_group_class.before_each_parts)
         end
       end
 
       def run_after_each(example)
-        execute_in_class_hierarchy(:superclass_first) do |example_group|
-          example.eval_each_fail_slow(example_group.after_each_parts)
+        each_ancestor_example_group_class(:superclass_first) do |example_group_class|
+          example.eval_each_fail_slow(example_group_class.after_each_parts)
         end
       end
 
     private
       def dry_run(examples)
         examples.each do |example|
-          rspec_options.reporter.example_started(example)
-          rspec_options.reporter.example_finished(example)
+          Spec::Runner.options.reporter.example_started(example)
+          Spec::Runner.options.reporter.example_finished(example)
         end
         return true
       end
@@ -274,8 +227,8 @@ module Spec
       def run_before_all
         before_all = new("before(:all)")
         begin
-          execute_in_class_hierarchy do |example_group|
-            before_all.eval_each_fail_fast(example_group.before_all_parts)
+          each_ancestor_example_group_class do |example_group_class|
+            before_all.eval_each_fail_fast(example_group_class.before_all_parts)
           end
           return [true, before_all.instance_variable_hash]
         rescue Exception => e
@@ -289,7 +242,7 @@ module Spec
 
         after_all_instance_variables = instance_variables
         examples.each do |example_group_instance|
-          success &= example_group_instance.execute(rspec_options, instance_variables)
+          success &= example_group_instance.execute(Spec::Runner.options, instance_variables)
           after_all_instance_variables = example_group_instance.instance_variable_hash
         end
         return [success, after_all_instance_variables]
@@ -298,8 +251,8 @@ module Spec
       def run_after_all(success, instance_variables)
         after_all = new("after(:all)")
         after_all.set_instance_variables_from_hash(instance_variables)
-        execute_in_class_hierarchy(:superclass_first) do |example_group|
-          after_all.eval_each_fail_slow(example_group.after_all_parts)
+        each_ancestor_example_group_class(:superclass_first) do |example_group_class|
+          after_all.eval_each_fail_slow(example_group_class.after_all_parts)
         end
         return success
       rescue Exception => e
@@ -311,7 +264,8 @@ module Spec
         all_examples = examples
         return all_examples unless specified_examples?
         all_examples.reject do |example|
-          matcher = ExampleMatcher.new(description.to_s, example.description)
+          matcher = ExampleGroupMethods.matcher_class.
+            new(description.to_s, example.description)
           !matcher.matches?(specified_examples)
         end
       end
@@ -321,37 +275,36 @@ module Spec
       end
 
       def specified_examples
-        rspec_options.examples
+        Spec::Runner.options.examples
       end
 
       def reporter
-        rspec_options.reporter
+        Spec::Runner.options.reporter
       end
 
       def dry_run?
-        rspec_options.dry_run
+        Spec::Runner.options.dry_run
       end
 
       def example_objects
         @example_objects ||= []
       end
 
-      def execute_in_class_hierarchy(superclass_last=false)
+      def each_ancestor_example_group_class(superclass_last=false)
         classes = []
         current_class = self
-        while is_example_group?(current_class)
+        while is_example_group_class?(current_class)
           superclass_last ? classes << current_class : classes.unshift(current_class)
           current_class = current_class.superclass
         end
-        superclass_last ? classes << ExampleMethods : classes.unshift(ExampleMethods)
-
+        
         classes.each do |example_group|
           yield example_group
         end
       end
 
-      def is_example_group?(klass)
-        Module === klass && klass.kind_of?(ExampleGroupMethods)
+      def is_example_group_class?(klass)
+        klass.kind_of?(ExampleGroupMethods) && klass.included_modules.include?(ExampleMethods)
       end
 
       def plugin_mock_framework
@@ -375,28 +328,6 @@ module Spec
         end
       end
 
-      def scope_and_options(*args)
-        args, options = args_and_options(*args)
-        scope = (args[0] || :each), options
-      end
-
-      def before_parts_from_scope(scope)
-        case scope
-        when :each; before_each_parts
-        when :all; before_all_parts
-        end
-      end
-
-      def after_parts_from_scope(scope)
-        case scope
-        when :each; after_each_parts
-        when :all; after_all_parts
-        end
-      end
-
-      def before_eval
-      end
-
       def add_method_examples(examples)
         instance_methods.sort.each do |method_name|
           if example_method?(method_name)
@@ -414,10 +345,23 @@ module Spec
       def should_method?(method_name)
         !(method_name =~ /^should(_not)?$/) &&
         method_name =~ /^should/ && (
-          instance_method(method_name).arity == 0 ||
-          instance_method(method_name).arity == -1
+          [-1,0].include?(instance_method(method_name).arity)
         )
       end
+
+      def include_shared_example_group(shared_example_group)
+        case shared_example_group
+        when SharedExampleGroup
+          include shared_example_group
+        else
+          example_group = SharedExampleGroup.find_shared_example_group(shared_example_group)
+          unless example_group
+            raise RuntimeError.new("Shared Example Group '#{shared_example_group}' can not be found")
+          end
+          include(example_group)
+        end
+      end
+
     end
 
   end

data/vendor/plugins/rspec/lib/spec/example/example_matcher.rb

@@ -38,5 +38,7 @@ module Spec
         Regexp.escape(@example_name)
       end
     end
+
+    ExampleGroupMethods.matcher_class = ExampleMatcher
   end
 end