mack 0.8.2 → 0.8.3

data/lib/gems/rspec-1.1.12/lib/spec/dsl.rb

@@ -0,0 +1 @@
+require 'spec/dsl/main'

data/lib/gems/{rspec-1.1.11/lib/spec/extensions → rspec-1.1.12/lib/spec/dsl}/main.rb

@@ -1,5 +1,5 @@
 module Spec
-  module Extensions
+  module DSL
     module Main
       # Creates and returns a class that includes the ExampleGroupMethods
       # module. Which ExampleGroup type is created depends on the directory of the file
@@ -20,10 +20,8 @@ module Spec
       # register special implementations.
       #
       def describe(*args, &block)
-        raise ArgumentError if args.empty?
-        raise ArgumentError unless block
-        args << {} unless Hash === args.last
-        args.last[:spec_path] = File.expand_path(caller(0)[1])
+        Spec::Example::add_spec_path_to(args)
+        Spec::Example::ExampleGroupFactory.assign_scope(self, args)
         Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
       end
       alias :context :describe
@@ -43,10 +41,10 @@ module Spec
       #      ...
       #    end
       #  end
-      def share_examples_for(name, &block)
-        describe(name, :shared => true, &block)
+      def share_examples_for(*args, &block)
+        Spec::Example::add_spec_path_to(args)
+        Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block)
       end
-      
       alias :shared_examples_for :share_examples_for
       
       # Creates a Shared Example Group and assigns it to a constant
@@ -75,7 +73,9 @@ module Spec
       #  end
       def share_as(name, &block)
         begin
-          Object.const_set(name, share_examples_for(name, &block))
+          args = [name]
+          Spec::Example::add_spec_path_to(args)
+          Object.const_set(name, Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block))
         rescue NameError => e
           raise NameError.new(e.message + "\nThe first argument to share_as must be a legal name for a constant\n")
         end
@@ -84,4 +84,4 @@ module Spec
   end
 end
 
-include Spec::Extensions::Main
+include Spec::DSL::Main

data/lib/gems/rspec-1.1.12/lib/spec/example.rb

@@ -0,0 +1,186 @@
+module Spec
+  # == Example Groups and Code Examples
+  #
+  # A Code Example is an executable example of how a bit of code is expected
+  # to behave.
+  #
+  # An Example Group is a group of code examples.
+  #
+  # RSpec exposes a DSL to describe groups of examples.
+  #  
+  #   describe Account do
+  #     it "should have a balance of $0" do
+  #       account = Account.new
+  #       account.balance.should == Money.new(0, :dollars)
+  #     end
+  #   end
+  #  
+  # == Before and After
+  #  
+  # You can use the <tt>before()</tt> and <tt>after()</tt> methods to extract
+  # common code within an Example Group. Both methods take an optional scope
+  # argument so you can run the block before :each example or before :all
+  # examples
+  #  
+  #   describe "..." do
+  #     before :all do
+  #       ...
+  #     end
+  #  
+  #     before :each do
+  #       ...
+  #     end
+  #  
+  #     it "should do something" do
+  #       ...
+  #     end
+  #  
+  #     it "should do something else" do
+  #       ...
+  #     end
+  #  
+  #     after :each do
+  #       ...
+  #     end
+  #  
+  #     after :all do
+  #       ...
+  #     end
+  #  
+  #   end
+  #  
+  # The <tt>before :each</tt> block will run before each of the examples, once
+  # for each example. Likewise, the <tt>after :each</tt> block will run after
+  # each of the examples.
+  #  
+  # It is also possible to specify a <tt>before :all</tt> and <tt>after
+  # :all</tt> block that will run only once for each example group, before the
+  # first <code>before :each</code> and after the last <code>after
+  # :each</code> respectively. The use of these is generally discouraged,
+  # because it introduces dependencies between the examples. Still, it might
+  # prove useful for very expensive operations if you know what you are doing.
+  #  
+  # == Local helper methods
+  #  
+  # You can include local helper methods by simply expressing them within an
+  # example group:
+  #  
+  #   describe "..." do
+  #    
+  #     it "..." do
+  #       helper_method
+  #     end
+  #  
+  #     def helper_method
+  #       ...
+  #     end
+  #  
+  #   end
+  #  
+  # == Included helper methods
+  #  
+  # You can include helper methods in multiple example groups by expressing
+  # them within a module, and then including that module in your example
+  # groups:
+  #  
+  #   module AccountExampleHelperMethods
+  #     def helper_method
+  #       ...
+  #     end
+  #   end
+  #  
+  #   describe "A new account" do
+  #     include AccountExampleHelperMethods
+  #     before do
+  #       @account = Account.new
+  #     end
+  #  
+  #     it "should have a balance of $0" do
+  #       helper_method
+  #       @account.balance.should eql(Money.new(0, :dollars))
+  #     end
+  #   end
+  #  
+  # == Shared Example Groups
+  #  
+  # You can define a shared example group, that may be used on other groups
+  #
+  #  share_examples_for "All Editions" do
+  #    it "all editions behaviour" ...
+  #  end
+  #
+  #  describe SmallEdition do
+  #    it_should_behave_like "All Editions"
+  #   
+  #    it "should do small edition stuff" do
+  #      ...
+  #    end
+  #  end
+  #
+  # You can also assign the shared group to a module and include that
+  #
+  #  share_as :AllEditions do
+  #    it "should do all editions stuff" ...
+  #  end
+  #
+  #  describe SmallEdition do
+  #    it_should_behave_like AllEditions
+  #   
+  #    it "should do small edition stuff" do
+  #      ...
+  #    end
+  #  end
+  #
+  # And, for those of you who prefer to use something more like Ruby, you can
+  # just include the module directly
+  #
+  #  describe SmallEdition do
+  #    include AllEditions
+  #   
+  #    it "should do small edition stuff" do
+  #      ...
+  #    end
+  #  end
+  module Example
+    class << self
+      def args_and_options(*args) # :nodoc:
+        with_options_from(args) do |options|
+          return args, options
+        end
+      end
+
+      def scope_from(*args) # :nodoc:
+        args[0] || :each
+      end
+
+      def scope_and_options(*args) # :nodoc:
+        args, options = args_and_options(*args)
+        return scope_from(*args), options
+      end
+
+      def add_spec_path_to(args) # :nodoc:
+        args << {} unless Hash === args.last
+        args.last[:spec_path] ||= caller(0)[2]
+      end
+
+    private
+    
+      def with_options_from(args)
+        yield Hash === args.last ? args.pop : {} if block_given?
+      end
+    end
+  end
+end
+
+require 'timeout'
+require 'spec/example/before_and_after_hooks'
+require 'spec/example/pending'
+require 'spec/example/module_reopening_fix'
+require 'spec/example/example_group_methods'
+require 'spec/example/example_methods'
+require 'spec/example/example_group'
+require 'spec/example/shared_example_group'
+require 'spec/example/example_group_factory'
+require 'spec/example/errors'
+require 'spec/example/example_matcher'
+

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/example/before_and_after_hooks.rb

@@ -1,41 +1,44 @@
 module Spec
   module Example
     module BeforeAndAfterHooks
+      class << self
+        def before_suite_parts
+          @before_suite_parts ||= []
+        end
+        
+        def after_suite_parts
+          @after_suite_parts ||= []
+        end
+      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)
+        before_parts(*args).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
+        before_parts(*args) << 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)
+        after_parts(*args).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
+        after_parts(*args) << block
       end
 
-      def remove_after(scope, &block)
+      # TODO - deprecate this unless there is a reason why it exists
+      def remove_after(scope, &block) # :nodoc:
         after_each_parts.delete(block)
       end
 
@@ -65,26 +68,29 @@ module Spec
         @after_each_parts ||= []
       end
       
-    private  
+      def before_suite_parts
+        BeforeAndAfterHooks.before_suite_parts
+      end
       
-      def scope_and_options(*args)
-        args, options = args_and_options(*args)
-        scope = (args[0] || :each), options
+      def after_suite_parts
+        BeforeAndAfterHooks.after_suite_parts
       end
-
-      def before_parts_from_scope(scope)
-        case scope
+      
+    private  
+      
+      def before_parts(*args)
+        case Spec::Example.scope_from(*args)
         when :each; before_each_parts
         when :all; before_all_parts
-        when :suite; Spec::Runner.options.before_suite_parts
+        when :suite; before_suite_parts
         end
       end
 
-      def after_parts_from_scope(scope)
-        case scope
+      def after_parts(*args)
+        case Spec::Example.scope_from(*args)
         when :each; after_each_parts
         when :all; after_all_parts
-        when :suite; Spec::Runner.options.after_suite_parts
+        when :suite; after_suite_parts
         end
       end
 

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/example/example_group.rb

@@ -10,6 +10,7 @@ module Spec
         @_options = options
         @_defined_description = defined_description
         @_implementation = implementation || pending_implementation
+        @_backtrace = caller
       end
       
     private

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/example/example_group_factory.rb

@@ -1,15 +1,17 @@
 module Spec
   module Example
     class ExampleGroupFactory
-      class << self
+      module ClassMethods
         def reset
           @example_group_types = nil
           default(ExampleGroup)
         end
 
-        def all_registered?(example_group_classes)
+        def registered_or_ancestor_of_registered?(example_group_classes) # :nodoc:
           example_group_classes.each do |example_group_class|
-            return false unless registered_or_ancestor_of_registered? example_group_class
+            return false unless registered_types.any? do |registered_type|
+              registered_type.ancestors.include? example_group_class
+            end
           end
           return true
         end
@@ -48,10 +50,28 @@ module Spec
         end
         
         def create_example_group(*args, &block)
-          opts = Hash === args.last ? args.last : {}
-          superclass = determine_superclass(opts)
+          raise ArgumentError if args.empty?
+          raise ArgumentError unless block
+          Spec::Example::add_spec_path_to(args)
+          superclass = determine_superclass(args.last)
           superclass.describe(*args, &block)
         end
+        
+        def create_shared_example_group(*args, &block)
+          Spec::Example::add_spec_path_to(args)
+          SharedExampleGroup.register(*args, &block)
+        end
+        
+        def include_constants_in(context, &block)
+          if (Spec::Ruby.version.to_f >= 1.9 && Module === context && !(Class === context))
+            return lambda {include context;instance_eval(&block)}
+          end
+          block
+        end
+        
+        def assign_scope(scope, args)
+          args.last[:scope] = scope
+        end
 
       protected
 
@@ -66,15 +86,12 @@ module Spec
         
       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
+      extend ClassMethods
       self.reset
     end
   end

data/lib/gems/{rspec-1.1.11 → rspec-1.1.12}/lib/spec/example/example_group_methods.rb

@@ -2,30 +2,53 @@ 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|\.|#)/)
-            result << arg.to_s
+          args.inject("") do |description, arg|
+            description << " " unless (description == "" || arg.to_s =~ /^(\s|\.|#)/)
+            description << arg.to_s
           end
         end
+
+        def example_group_creation_listeners
+          @example_group_creation_listeners ||= []
+        end
       end
 
-      attr_reader :description_text, :description_options, :spec_path
+      include Spec::Example::BeforeAndAfterHooks
+
+      attr_reader :description_options, :spec_path
       alias :options :description_options
       
+      # Provides the backtrace up to where this example_group was declared.
+      def backtrace
+        @backtrace
+      end
+
+      # Deprecated - use +backtrace()+
+      def example_group_backtrace
+        Kernel.warn <<-WARNING
+ExampleGroupMethods#example_group_backtrace is deprecated and will be removed
+from a future version. Please use ExampleGroupMethods#backtrace instead.
+WARNING
+        backtrace
+      end
+      
       def description_args
         @description_args ||= []
       end
 
       def inherited(klass)
         super
-        klass.register {}
-        Spec::Runner.register_at_exit_hook
+        register_example_group(klass)
+      end
+      
+      def register_example_group(klass)
+        ExampleGroupMethods.example_group_creation_listeners.each do |l|
+          l.register_example_group(klass)
+        end
       end
       
       # Makes the describe/it syntax available from a class. For example:
@@ -43,14 +66,13 @@ module Spec
       #   end
       #
       def describe(*args, &example_group_block)
-        args << {} unless Hash === args.last
         if example_group_block
+          Spec::Example::add_spec_path_to(args)
           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)
+            create_shared_example_group(*args, &example_group_block)
           else
-            create_nested_example_group(args, example_group_block)
+            create_example_group_subclass(*args, &example_group_block)
           end
         else
           set_description(*args)
@@ -58,19 +80,27 @@ module Spec
       end
       alias :context :describe
       
-      def create_shared_example_group(args, example_group_block)
-        SharedExampleGroup.new(*args, &example_group_block)
+      def create_shared_example_group(*args, &example_group_block) # :nodoc:
+        SharedExampleGroup.register(*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
+      # Creates a new subclass of self, with a name "under" our own name.
+      # Example:
+      #
+      #   x = Foo::Bar.subclass('Zap'){}
+      #   x.name # => Foo::Bar::Zap_1
+      #   x.superclass.name # => Foo::Bar
+      def create_example_group_subclass(*args, &example_group_block) # :nodoc:
+        @class_count ||= 0
+        @class_count += 1
+        klass = const_set("Subclass_#{@class_count}", Class.new(self))
+        klass.set_description(*args)
+        example_group_block = ExampleGroupFactory.include_constants_in(args.last[:scope], &example_group_block)
+        klass.module_eval(&example_group_block)
+        klass
       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_groups)
         shared_example_groups.each do |group|
           include_shared_example_group(group)
@@ -85,7 +115,7 @@ module Spec
       # a predicate on your class. RSpec provides a couple of these
       # out of the box:
       #
-      #   exist (or state expectations)
+      #   exist (for state expectations)
       #     File.should exist("path/to/file")
       #
       #   an_instance_of (for mock argument constraints)
@@ -106,7 +136,7 @@ module Spec
       #     end
       #   end
       def predicate_matchers
-        @predicate_matchers ||= {:an_instance_of => :is_a?}
+        @predicate_matchers ||= {}
       end
 
       # Creates an instance of the current example group class and adds it to
@@ -128,54 +158,69 @@ module Spec
       alias_method :xit, :xexample
       alias_method :xspecify, :xexample
 
-      def run
-        examples = examples_to_run
-        reporter.add_example_group(self) unless examples_to_run.empty?
+      def run(run_options)
+        examples = examples_to_run(run_options)
+        run_options.reporter.add_example_group(self) unless examples.empty?
         return true if examples.empty?
-        return dry_run(examples) if dry_run?
+        return dry_run(examples, run_options) if run_options.dry_run?
 
-        plugin_mock_framework
-        define_methods_from_predicate_matchers
+        plugin_mock_framework(run_options)
+        define_methods_from_predicate_matchers(run_options)
 
-        success, before_all_instance_variables = run_before_all
-        success, after_all_instance_variables  = execute_examples(success, before_all_instance_variables, examples)
-        success                                = run_after_all(success, after_all_instance_variables)
+        success, before_all_instance_variables = run_before_all(run_options)
+        success, after_all_instance_variables  = execute_examples(success, before_all_instance_variables, examples, run_options)
+        success                                = run_after_all(success, after_all_instance_variables, run_options)
       end
 
       def description
         result = ExampleGroupMethods.description_text(*description_parts)
-        if result.nil? || result == ""
-          return to_s
-        else
-          result
-        end
+        (result.nil? || result == "") ? to_s : result
       end
-
+      
       def described_type
-        description_parts.find {|part| part.is_a?(Module)}
+        description_parts.reverse.find {|part| part.is_a?(Module)}
       end
-
+      
+      # Defines an explicit subject for an example group which can then be the
+      # implicit receiver (through delegation) of calls to +should+.
+      #
+      # == Examples
+      #
+      #   describe CheckingAccount, "with $50" do
+      #     subject { CheckingAccount.new(:amount => 50, :currency => :USD) }
+      #     it { should have_a_balance_of(50, :USD)}
+      #     it { should_not be_overdrawn}
+      #   end
+      #
+      # See +ExampleMethods#should+ for more information about this approach.
+      def subject(&block)
+        @_subject_block = block
+      end
+      
+      def subject_block
+        @_subject_block || lambda {nil}
+      end
+      
       def description_parts #:nodoc:
-        parts = []
-        each_ancestor_example_group_class do |example_group_class|
-          parts << example_group_class.description_args
+        example_group_hierarchy.inject([]) do |parts, example_group_class|
+          [parts << example_group_class.description_args].flatten
         end
-        parts.flatten.compact
       end
 
       def set_description(*args)
-        args, options = args_and_options(*args)
+        args, options = Spec::Example.args_and_options(*args)
         @description_args = args
         @description_options = options
         @description_text = ExampleGroupMethods.description_text(*args)
+        @backtrace = caller(1)
         @spec_path = File.expand_path(options[:spec_path]) if options[:spec_path]
         self
       end
       
-      def examples #:nodoc:
+      def examples(run_options=nil) #:nodoc:
         examples = example_objects.dup
         add_method_examples(examples)
-        Spec::Runner.options.reverse ? examples.reverse : examples
+        (run_options && run_options.reverse) ? examples.reverse : examples
       end
 
       def number_of_examples #:nodoc:
@@ -190,136 +235,116 @@ module Spec
         @after_each_parts = nil
       end
 
-      def register(&registration_binding_block)
-        @registration_binding_block = registration_binding_block
-        Spec::Runner.options.add_example_group self
-      end
-
-      def unregister #:nodoc:
-        Spec::Runner.options.remove_example_group self
-      end
-
-      def registration_backtrace
-        eval("caller", @registration_binding_block)
-      end
-
       def run_before_each(example)
-        each_ancestor_example_group_class do |example_group_class|
-          example.eval_each_fail_fast(example_group_class.before_each_parts)
+        example.eval_each_fail_fast(all_before_each_parts)
+      end
+      
+      def all_before_each_parts
+        unless @all_before_each_parts
+          @all_before_each_parts = []
+          example_group_hierarchy.each do |example_group_class|
+            @all_before_each_parts += example_group_class.before_each_parts
+          end
         end
+        @all_before_each_parts
       end
 
       def run_after_each(example)
-        each_ancestor_example_group_class(:superclass_first) do |example_group_class|
+        example_group_hierarchy.reverse.each do |example_group_class|
           example.eval_each_fail_slow(example_group_class.after_each_parts)
         end
       end
 
     private
-      def dry_run(examples)
+      def dry_run(examples, run_options)
         examples.each do |example|
-          Spec::Runner.options.reporter.example_started(example)
-          Spec::Runner.options.reporter.example_finished(example)
+          run_options.reporter.example_started(example)
+          run_options.reporter.example_finished(example)
         end
-        return true
       end
 
-      def run_before_all
+      def run_before_all(run_options)
         before_all = new("before(:all)")
         begin
-          each_ancestor_example_group_class do |example_group_class|
+          example_group_hierarchy.each 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
-          reporter.failure(before_all, e)
+          run_options.reporter.failure(before_all, e)
           return [false, before_all.instance_variable_hash]
         end
       end
 
-      def execute_examples(success, instance_variables, examples)
+      def execute_examples(success, instance_variables, examples, run_options)
         return [success, instance_variables] unless success
 
         after_all_instance_variables = instance_variables
         examples.each do |example_group_instance|
-          success &= example_group_instance.execute(Spec::Runner.options, instance_variables)
+          success &= example_group_instance.execute(run_options, instance_variables)
           after_all_instance_variables = example_group_instance.instance_variable_hash
         end
         return [success, after_all_instance_variables]
       end
 
-      def run_after_all(success, instance_variables)
+      def run_after_all(success, instance_variables, run_options)
         after_all = new("after(:all)")
         after_all.set_instance_variables_from_hash(instance_variables)
-        each_ancestor_example_group_class(:superclass_first) do |example_group_class|
+        example_group_hierarchy.reverse.each do |example_group_class|
           after_all.eval_each_fail_slow(example_group_class.after_all_parts)
         end
         return success
       rescue Exception => e
-        reporter.failure(after_all, e)
+        run_options.reporter.failure(after_all, e)
         return false
       end
 
-      def examples_to_run
-        all_examples = examples
-        return all_examples unless specified_examples?
+      def examples_to_run(run_options)
+        all_examples = examples(run_options)
+        return all_examples unless specified_examples?(run_options)
         all_examples.reject do |example|
           matcher = ExampleGroupMethods.matcher_class.
             new(description.to_s, example.description)
-          !matcher.matches?(specified_examples)
+          !matcher.matches?(run_options.examples)
         end
       end
 
-      def specified_examples?
-        specified_examples && !specified_examples.empty?
-      end
-
-      def specified_examples
-        Spec::Runner.options.examples
-      end
-
-      def reporter
-        Spec::Runner.options.reporter
-      end
-
-      def dry_run?
-        Spec::Runner.options.dry_run
+      def specified_examples?(run_options)
+        run_options.examples && !run_options.examples.empty?
       end
 
       def example_objects
         @example_objects ||= []
       end
 
-      def each_ancestor_example_group_class(superclass_last=false)
-        classes = []
-        current_class = self
-        while is_example_group_class?(current_class)
-          superclass_last ? classes << current_class : classes.unshift(current_class)
-          current_class = current_class.superclass
-        end
-        
-        classes.each do |example_group|
-          yield example_group
+      class ExampleGroupHierarchy < Array
+        def initialize(example_group_class)
+          current_class = example_group_class
+          while current_class.kind_of?(ExampleGroupMethods)
+            unshift(current_class)
+            break unless current_class.respond_to? :superclass
+            current_class = current_class.superclass
+          end
         end
       end
-
-      def is_example_group_class?(klass)
-        klass.kind_of?(ExampleGroupMethods) && klass.included_modules.include?(ExampleMethods)
+      
+      def example_group_hierarchy
+        @example_group_hierarchy ||= ExampleGroupHierarchy.new(self)
       end
 
-      def plugin_mock_framework
-        case mock_framework = Spec::Runner.configuration.mock_framework
+      def plugin_mock_framework(run_options)
+        case mock_framework = run_options.mock_framework
         when Module
           include mock_framework
         else
-          require Spec::Runner.configuration.mock_framework
-          include Spec::Plugins::MockFramework
+          require mock_framework
+          include Spec::Adapters::MockFramework
         end
       end
 
-      def define_methods_from_predicate_matchers # :nodoc:
+      def define_methods_from_predicate_matchers(run_options) # :nodoc:
         all_predicate_matchers = predicate_matchers.merge(
-          Spec::Runner.configuration.predicate_matchers
+          run_options.predicate_matchers
         )
         all_predicate_matchers.each_pair do |matcher_method, method_on_object|
           define_method matcher_method do |*args|
@@ -329,7 +354,7 @@ module Spec
       end
 
       def add_method_examples(examples)
-        instance_methods.sort.each do |method_name|
+        instance_methods.each do |method_name|
           if example_method?(method_name)
             examples << new(method_name) do
               __send__(method_name)
@@ -354,7 +379,7 @@ module Spec
         when SharedExampleGroup
           include shared_example_group
         else
-          example_group = SharedExampleGroup.find_shared_example_group(shared_example_group)
+          example_group = SharedExampleGroup.find(shared_example_group)
           unless example_group
             raise RuntimeError.new("Shared Example Group '#{shared_example_group}' can not be found")
           end