ageweke-rspec 1.2.9

data/lib/spec/example/example_group_proxy.rb

@@ -0,0 +1,61 @@
+module Spec
+  module Example
+    # Lightweight proxy for an example group. This is the object that is passed
+    # to Spec::Runner::Formatter::BaseFormatter#example_group_started
+    class ExampleGroupProxy
+
+      def initialize(example_group) # :nodoc:
+        @description         = example_group.description
+        @nested_descriptions = example_group.nested_descriptions
+        @examples            = example_group.example_proxies
+        @location            = example_group.location
+        @backtrace           = example_group.location # deprecated - see the backtrace method below
+        @options             = example_group.options.dup
+        @options.delete(:location)
+        @options.delete(:scope)
+      end
+
+      # Optional hash passed to the example group declaration. Note that RSpec uses
+      # this hash internally and reserves the keys :location and :scope for its own
+      # use (and removes them from this hash)
+      attr_reader :options
+
+      # This is the description passed to the <tt>describe()</tt> method or any
+      # of its aliases
+      attr_reader :description
+
+      # Used by Spec::Runner::Formatter::NestedTextFormatter to access the
+      # description of each example group in a nested group separately.
+      attr_reader :nested_descriptions
+
+      # A collection of ExampleGroupProxy objects, one for each example
+      # declared in this group.
+      attr_reader :examples
+
+      # The file and line number at which the proxied example group
+      # was declared. This is extracted from <tt>caller</tt>, and is therefore
+      # formatted as an individual line in a backtrace.
+      attr_reader :location
+
+      # Deprecated - use location() instead
+      def backtrace
+        Spec::deprecate("ExampleGroupProxy#backtrace","ExampleGroupProxy#location")
+        @backtrace
+      end
+
+      # Deprecated - just use gsub on the description instead.
+      def filtered_description(regexp)
+        Spec::deprecate("ExampleGroupProxy#filtered_description","gsub (or similar) to modify ExampleGroupProxy#description")
+        ExampleGroupMethods.build_description_from(
+          *nested_descriptions.collect do |description|
+            description =~ regexp ? description.gsub($1, "") : description
+          end
+        )
+      end
+
+      def ==(other) # :nodoc:
+        other.description == description
+      end
+    end
+  end
+end

data/lib/spec/example/example_matcher.rb

@@ -0,0 +1,43 @@
+module Spec
+  module Example
+    class ExampleMatcher
+      def initialize(example_group_description, example_name)
+        @example_group_description = example_group_description
+        @example_name = example_name
+      end
+
+      def matches?(specified_examples)
+        specified_examples.any? do |specified_example|
+          matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example)
+        end
+      end
+
+      protected
+      def matches_literal_example?(specified_example)
+        specified_example =~ /(^#{example_group_regex} #{example_regexp}$|^#{example_group_regex}$|^#{example_group_with_before_all_regexp}$|^#{example_regexp}$)/
+      end
+
+      def matches_example_not_considering_modules?(specified_example)
+        specified_example =~ /(^#{example_group_regex_not_considering_modules} #{example_regexp}$|^#{example_group_regex_not_considering_modules}$|^#{example_regexp}$)/
+      end
+
+      def example_group_regex
+        Regexp.escape(@example_group_description)
+      end
+
+      def example_group_with_before_all_regexp
+        Regexp.escape("#{@example_group_description} before(:all)")
+      end
+
+      def example_group_regex_not_considering_modules
+        Regexp.escape(@example_group_description.split('::').last)
+      end
+
+      def example_regexp
+        Regexp.escape(@example_name) if @example_name
+      end
+    end
+
+    ExampleGroupMethods.matcher_class = ExampleMatcher
+  end
+end

data/lib/spec/example/example_methods.rb

@@ -0,0 +1,148 @@
+module Spec
+  module Example
+    module ExampleMethods
+
+      extend  Spec::Example::ModuleReopeningFix
+      include Spec::Example::Subject::ExampleMethods
+
+      def violated(message="")
+        raise Spec::Expectations::ExpectationNotMetError.new(message)
+      end
+
+      # Declared description for this example:
+      #
+      #   describe Account do
+      #     it "should start with a balance of 0" do
+      #     ...
+      #
+      #   description
+      #   => "should start with a balance of 0"
+      def description
+        if description = @_proxy.description || ::Spec::Matchers.generated_description
+          description
+        else
+          Spec.warn Spec::Example::NoDescriptionError.message("example", @_proxy.location)
+        end
+      end
+
+      def options # :nodoc:
+        @_proxy.options
+      end
+
+      def execute(run_options, instance_variables) # :nodoc:
+        run_options.reporter.example_started(@_proxy)
+        set_instance_variables_from_hash(instance_variables)
+
+        execution_error = nil
+        Timeout.timeout(run_options.timeout) do
+          begin
+            before_each_example
+            instance_eval(&@_implementation)
+          rescue Exception => e
+            execution_error ||= e
+          end
+          begin
+            after_each_example
+          rescue Exception => e
+            execution_error ||= e
+          end
+        end
+
+        run_options.reporter.example_finished(@_proxy.update(description), execution_error)
+        success = execution_error.nil? || ExamplePendingError === execution_error
+      end
+
+      module BlockAliases
+        alias_method :to,     :should
+        alias_method :to_not, :should_not
+      end
+
+      # Extends the submitted block with aliases to and to_not
+      # for should and should_not. Allows expectations like this:
+      #
+      #   expect { this_block }.to change{this.expression}.from(old_value).to(new_value)
+      #   expect { this_block }.to raise_error
+      def expect(&block)
+        block.extend BlockAliases
+      end
+
+      def eval_each_fail_fast(blocks) # :nodoc:
+        blocks.each {|block| instance_eval(&block)}
+      end
+
+      def eval_each_fail_slow(blocks) # :nodoc:
+        first_exception = nil
+        blocks.each do |block|
+          begin
+            instance_eval(&block)
+          rescue Exception => e
+            first_exception ||= e
+          end
+        end
+        raise first_exception if first_exception
+      end
+
+      def instance_variable_hash # :nodoc:
+        instance_variables.inject({}) do |variable_hash, variable_name|
+          variable_hash[variable_name] = instance_variable_get(variable_name)
+          variable_hash
+        end
+      end
+
+      def set_instance_variables_from_hash(ivars) # :nodoc:
+        ivars.each do |variable_name, value|
+          # Ruby 1.9 requires variable.to_s on the next line
+          unless ['@_proxy', '@_implementation', '@method_name'].include?(variable_name.to_s)
+            instance_variable_set variable_name, value
+          end
+        end
+      end
+
+      # Run all the before(:each) blocks for this example
+      def run_before_each
+        example_group_hierarchy.run_before_each(self)
+      end
+
+      # Run all the after(:each) blocks for this example
+      def run_after_each
+        example_group_hierarchy.run_after_each(self)
+      end
+
+      def initialize(example_proxy, &implementation)
+        @_proxy = example_proxy
+        @_implementation = implementation
+        @_backtrace = caller
+      end
+      
+    private
+
+      include Matchers
+      include Pending
+
+      def before_each_example
+        setup_mocks_for_rspec
+        run_before_each
+      end
+
+      def after_each_example
+        run_after_each
+        verify_mocks_for_rspec
+      ensure
+        teardown_mocks_for_rspec
+      end
+
+      def described_class
+        self.class.described_class
+      end
+
+      def description_args
+        self.class.description_args
+      end
+
+      def example_group_hierarchy
+        self.class.example_group_hierarchy
+      end
+
+    end
+  end
+end

data/lib/spec/example/example_proxy.rb

@@ -0,0 +1,41 @@
+module Spec
+  module Example
+    # Lightweight proxy for an example. This is the object that is passed to
+    # example-related methods in Spec::Runner::Formatter::BaseFormatter
+    class ExampleProxy
+
+      def initialize(description=nil, options={}, location=nil) # :nodoc:
+        @description, @options, @location = description, options, location
+      end
+
+      # Optional hash passed to the example declaration
+      attr_reader :options
+
+      # This is the docstring passed to the <tt>it()</tt> method or any
+      # of its aliases
+      attr_reader :description
+
+      # The file and line number at which the represented example
+      # was declared. This is extracted from <tt>caller</tt>, and is therefore
+      # formatted as an individual line in a backtrace.
+      attr_reader :location
+
+      # Deprecated - use location()
+      def backtrace
+        Spec.deprecate("ExampleProxy#backtrace","ExampleProxy#location")
+        location
+      end
+
+      # Convenience method for example group - updates the value of
+      # <tt>description</tt> and returns self.
+      def update(description) # :nodoc:
+        @description = description
+        self
+      end
+
+      def ==(other) # :nodoc:
+        (other.description == description) & (other.location == location)
+      end
+    end
+  end
+end

data/lib/spec/example/module_reopening_fix.rb

@@ -0,0 +1,43 @@
+module Spec
+  module Example
+    # When you reopen a module that is included in another module that is included in a class,
+    # the new material you define does not make it to the class. This fixes that.
+    #
+    # == Example
+    #
+    #   module M1; end
+    #
+    #   module M2
+    #     def foo; "FOO"; end
+    #   end
+    #
+    #   class C
+    #     include M1
+    #   end
+    #
+    #   module M1
+    #     include M2
+    #   end
+    #
+    #   c = C.new
+    #   c.foo
+    #   NoMethodError: undefined method `foo' for #<C:0x5e89a4>
+    #     from (irb):12
+    module ModuleReopeningFix
+      def child_modules
+        @child_modules ||= []
+      end
+
+      def included(mod)
+        child_modules << mod
+      end
+
+      def include(mod)
+        super
+        child_modules.each do |child_module|
+          child_module.__send__(:include, mod)
+        end
+      end
+    end
+  end
+end

data/lib/spec/example/pending.rb

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

data/lib/spec/example/predicate_matchers.rb

@@ -0,0 +1,46 @@
+module Spec
+  module Example
+    module PredicateMatchers
+      # :call-seq:
+      #   predicate_matchers[matcher_name] = method_on_object
+      #   predicate_matchers[matcher_name] = [method1_on_object, method2_on_object]
+      #
+      # Dynamically generates a custom matcher that will match
+      # a predicate on your class. RSpec provides a couple of these
+      # out of the box:
+      #
+      #   exist (for state expectations)
+      #     File.should exist("path/to/file")
+      #
+      #   an_instance_of (for mock argument matchers)
+      #     mock.should_receive(:message).with(an_instance_of(String))
+      #
+      # == Examples
+      #
+      #   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 ||= Spec::HashWithDeprecationNotice.new("predicate_matchers", "the new Matcher DSL")
+      end
+
+      def define_methods_from_predicate_matchers # :nodoc:
+        predicate_matchers.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
+  end
+end

data/lib/spec/example/shared_example_group.rb

@@ -0,0 +1,59 @@
+module Spec
+  module Example
+    class SharedExampleGroup < Module
+      module ClassMethods
+        def register(*args, &block)
+          new_example_group = new(*args, &block)
+          shared_example_groups << new_example_group unless already_registered?(new_example_group)
+          new_example_group
+        end
+
+        def find(example_group_description)
+          shared_example_groups.find {|b| b.description == example_group_description}
+        end
+
+        def clear
+          shared_example_groups.clear
+        end
+
+        def include?(group)
+          shared_example_groups.include?(group)
+        end
+
+        def count
+          shared_example_groups.length
+        end
+
+      private
+
+        def shared_example_groups
+          @shared_example_groups ||= []
+        end
+
+        def already_registered?(new_example_group)
+          existing_example_group = find(new_example_group.description)
+          return false unless existing_example_group
+          return true if new_example_group.equal?(existing_example_group)
+          return true if expanded_path(new_example_group) == expanded_path(existing_example_group)
+          raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists")
+        end
+
+        def expanded_path(example_group)
+          File.expand_path(example_group.location)
+        end
+      end
+
+      extend ClassMethods
+      include ExampleGroupMethods
+
+      def initialize(*args, &example_group_block)
+        set_description(*args)
+        @example_group_block = example_group_block
+      end
+
+      def included(mod) # :nodoc:
+        mod.module_eval(&@example_group_block)
+      end
+    end
+  end
+end