rspec 1.3.2 → 2.0.0.a2

data/lib/spec/example/args_and_options.rb

@@ -1,27 +0,0 @@
-module Spec
-  module Example
-    module ArgsAndOptions
-      def args_and_options(*args) # :nodoc:
-        options = Hash === args.last ? args.pop : {}
-        return args, options
-      end
-
-      def add_options(args, options={}) # :nodoc:
-        args << {} unless Hash === args.last
-        args.extend WithOptions
-        args.options.merge!(options)
-        args.options
-      end
-
-      def set_location(options, location) # :nodoc:
-        options[:location] ||= location
-      end
-
-      module WithOptions # :nodoc:
-        def options
-          last
-        end
-      end
-    end
-  end
-end

data/lib/spec/example/before_and_after_hooks.rb

@@ -1,93 +0,0 @@
-module Spec
-  module Example
-    module BeforeAndAfterHooks
-      class << self
-        def before_suite_parts # :nodoc:
-          @before_suite_parts ||= []
-        end
-
-        def after_suite_parts # :nodoc:
-          @after_suite_parts ||= []
-        end
-      end
-
-      # Registers a block to be executed before examples. <tt>scope</tt> can be
-      # <tt>:each</tt> (default), <tt>:all</tt>, or <tt>:suite</tt>. When
-      # <tt>:each</tt>, the block is executed before each example. When
-      # <tt>:all</tt>, the block is executed only once before any examples are
-      # run.
-      def append_before(scope = :each, &block)
-        before_parts(scope) << block
-      end
-      alias_method :before, :append_before
-
-      # Registers a block to be executed before each example.
-      # This method prepends +block+ to existing before blocks.
-      #
-      # See <tt>append_before</tt> for scoping semantics.
-      def prepend_before(scope = :each, &block)
-        before_parts(scope).unshift(block)
-      end
-
-      # Registers a block to be executed after each example.
-      # This method prepends +block+ to existing after blocks.
-      #
-      # See <tt>append_before</tt> for scoping semantics.
-      def prepend_after(scope = :each, &block)
-        after_parts(scope).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.
-      #
-      # See <tt>append_before</tt> for scoping semantics.
-      def append_after(scope = :each, &block)
-        after_parts(scope) << block
-      end
-
-      def before_each_parts # :nodoc:
-        @before_each_parts ||= []
-      end
-
-      def after_each_parts # :nodoc:
-        @after_each_parts ||= []
-      end
-
-      def before_all_parts # :nodoc:
-        @before_all_parts ||= []
-      end
-
-      def after_all_parts # :nodoc:
-        @after_all_parts ||= []
-      end
-
-      def before_suite_parts # :nodoc:
-        BeforeAndAfterHooks.before_suite_parts
-      end
-
-      def after_suite_parts # :nodoc:
-        BeforeAndAfterHooks.after_suite_parts
-      end
-
-    private
-
-      def before_parts(scope)
-        case scope
-        when :each; before_each_parts
-        when :all; before_all_parts
-        when :suite; before_suite_parts
-        end
-      end
-
-      def after_parts(scope)
-        case scope
-        when :each; after_each_parts
-        when :all; after_all_parts
-        when :suite; after_suite_parts
-        end
-      end
-
-    end
-  end
-end

data/lib/spec/example/errors.rb

@@ -1,25 +0,0 @@
-module Spec
-  module Example
-    class ExamplePendingError < StandardError; end
-
-    class NotYetImplementedError < ExamplePendingError
-      MESSAGE = "Not Yet Implemented"
-      def initialize
-        super(MESSAGE)
-      end
-    end
-
-    class PendingExampleFixedError < StandardError; end
-
-    class NoDescriptionError < ArgumentError
-      class << self
-        def message(kind, location)
-          "No description supplied for #{kind} declared on #{location}"
-        end
-      end
-      def initialize(kind, location)
-        super(self.class.message(kind, location))
-      end
-    end
-  end
-end

data/lib/spec/example/example_group.rb

@@ -1,10 +0,0 @@
-module Spec
-  module Example
-    # 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
-    end
-  end
-end

data/lib/spec/example/example_group_factory.rb

@@ -1,82 +0,0 @@
-module Spec
-  module Example
-
-    class ExampleGroupFactory
-      module ClassMethods
-        include Spec::Example::ArgsAndOptions
-
-        def reset
-          @example_group_types = nil
-          default(ExampleGroup)
-        end
-
-        def example_group_creation_listeners
-          @example_group_creation_listeners ||= []
-        end
-
-        def register_example_group(klass)
-          example_group_creation_listeners.each do |listener|
-            listener.register_example_group(klass)
-          end
-        end
-
-        def create_shared_example_group(*args, &example_group_block) # :nodoc:
-          ::Spec::Example::SharedExampleGroup.register(*args, &example_group_block)
-        end
-
-        def create_example_group(*args, &block)
-          raise ArgumentError if args.empty? || block.nil?
-          add_options(args)
-          superclass = determine_superclass(args.last)
-          superclass.describe(*args, &block)
-        end
-
-        # Registers an example group class +klass+ with the symbol +type+. For
-        # example:
-        #
-        #   Spec::Example::ExampleGroupFactory.register(:farm, FarmExampleGroup)
-        #
-        # 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.to_sym] = example_group_class
-        end
-
-        # Sets the default ExampleGroup class
-        def default(example_group_class)
-          Spec.__send__ :remove_const, :ExampleGroup if Spec.const_defined?(:ExampleGroup)
-          Spec.const_set(:ExampleGroup, example_group_class)
-          old = @example_group_types
-          @example_group_types = Hash.new(example_group_class)
-          @example_group_types.merge!(old) if old
-        end
-
-        def [](key)
-          @example_group_types[key]
-        end
-
-      protected
-
-        def determine_superclass(opts)
-          if type = opts[:type]
-            self[type]
-          elsif opts[:location] =~ /spec(\\|\/)(#{@example_group_types.keys.sort_by{|k| k.to_s.length}.reverse.join('|')})/
-            self[$2 == '' ? nil : $2.to_sym]
-          else
-            self[nil]
-          end
-        end
-
-      end
-      extend ClassMethods
-      self.reset
-    end
-  end
-end

data/lib/spec/example/example_group_hierarchy.rb

@@ -1,53 +0,0 @@
-module Spec
-  module Example
-    class ExampleGroupHierarchy < Array
-      def initialize(example_group_class)
-        push example_group_class
-        if example_group_class.respond_to?(:superclass) && example_group_class.superclass.respond_to?(:example_group_hierarchy)
-          unshift example_group_class.superclass.example_group_hierarchy
-          flatten!
-        end
-      end
-
-      def run_before_all(example)
-        example.eval_each_fail_fast(before_all_parts)
-      end
-
-      def run_before_each(example)
-        example.eval_each_fail_fast(before_each_parts)
-      end
-
-      def run_after_each(example)
-        example.eval_each_fail_slow(after_each_parts)
-      end
-
-      def run_after_all(example)
-        example.eval_each_fail_slow(after_all_parts)
-      end
-
-      def before_all_parts
-        @before_all_parts ||= collect {|klass| klass.before_all_parts}.flatten
-      end
-
-      def before_each_parts
-        @before_each_parts ||= collect {|klass| klass.before_each_parts}.flatten
-      end
-
-      def after_each_parts
-        @after_each_parts ||= reverse.collect {|klass| klass.after_each_parts}.flatten
-      end
-
-      def after_all_parts
-        @after_all_parts ||= reverse.collect {|klass| klass.after_all_parts}.flatten
-      end
-
-      def nested_descriptions
-        @nested_descriptions ||= collect {|eg| nested_description_from(eg) == "" ? nil : nested_description_from(eg) }.compact
-      end
-
-      def nested_description_from(example_group)
-        example_group.description_args.join
-      end
-    end
-  end
-end

data/lib/spec/example/example_group_methods.rb

@@ -1,287 +0,0 @@
-module Spec
-  module Example
-
-    module ExampleGroupMethods
-      class << self
-        attr_accessor :matcher_class
-
-        def build_description_from(*args)
-          text = args.inject("") do |description, arg|
-            description << " " unless (description == "" || arg.to_s =~ /^(\s|\.|#)/)
-            description << arg.to_s
-          end
-          text == "" ? nil : text
-        end
-      end
-
-      include Spec::Example::BeforeAndAfterHooks
-      include Spec::Example::Subject::ExampleGroupMethods
-      include Spec::Example::PredicateMatchers
-      include Spec::Example::ArgsAndOptions
-
-      attr_reader :location
-
-      def options # :nodoc:
-        @options ||= {}
-      end
-
-      def inherited(klass) # :nodoc:
-        super
-        ExampleGroupFactory.register_example_group(klass)
-      end
-
-      # Makes the describe/it syntax available from a class. For example:
-      #
-      #   class StackSpec < Spec::ExampleGroup
-      #     describe Stack, "with no elements"
-      #
-      #     before
-      #       @stack = Stack.new
-      #     end
-      #
-      #     it "should raise on pop" do
-      #       lambda{ @stack.pop }.should raise_error
-      #     end
-      #   end
-      #
-      def describe(*args, &example_group_block)
-        raise Spec::Example::NoDescriptionError.new("example group", caller(0)[1]) if args.empty?
-        if example_group_block
-          options = add_options(args)
-          set_location(options, caller(0)[1])
-          if options[:shared]
-            ExampleGroupFactory.create_shared_example_group(*args, &example_group_block)
-          else
-            subclass(*args, &example_group_block)
-          end
-        else
-          set_description(*args)
-        end
-      end
-      alias :context :describe
-
-      # Use this to pull in examples from shared example groups.
-      def it_should_behave_like(*shared_example_groups)
-        shared_example_groups.each do |group|
-          include_shared_example_group(group)
-        end
-      end
-
-      # 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={}, backtrace=nil, &implementation)
-        example_proxy = ExampleProxy.new(description, options, backtrace || caller(0)[1])
-        example_proxies << example_proxy
-        example_implementations[example_proxy] = implementation || pending_implementation
-        example_proxy
-      end
-
-      def pending_implementation
-        lambda {|*args| raise(Spec::Example::NotYetImplementedError) }
-      end
-
-      alias_method :it, :example
-      alias_method :specify, :example
-
-      # Use this to temporarily disable an example.
-      def xexample(description=nil, opts={}, &block)
-        Kernel.warn("Example disabled: #{description}")
-      end
-
-      alias_method :xit, :xexample
-      alias_method :xspecify, :xexample
-
-      def run(run_options)
-        examples = examples_to_run(run_options)
-        notify(run_options.reporter) unless examples.empty?
-        return true if examples.empty?
-        return dry_run(examples, run_options) if run_options.dry_run?
-
-        define_methods_from_predicate_matchers
-
-        success, before_all_instance_variables = run_before_all(run_options)
-        success, after_all_instance_variables  = run_examples(success, before_all_instance_variables, examples, run_options)
-        success                                = run_after_all(success, after_all_instance_variables, run_options)
-      end
-
-      def set_description(*args)
-        @description_args, @options = args_and_options(*args)
-        @backtrace = caller(1)
-        @location = File.expand_path(options[:location]) if options[:location]
-        self
-      end
-
-      def notify(reporter) # :nodoc:
-        reporter.example_group_started(ExampleGroupProxy.new(self))
-      end
-
-      def description
-        @description ||= ExampleGroupMethods.build_description_from(*description_parts) || to_s
-      end
-
-      def described_type
-        @described_type ||= description_parts.reverse.find {|part| part.is_a?(Module)}
-      end
-
-      def described_class
-        @described_class ||= Class === described_type ? described_type : nil
-      end
-
-      def description_args
-        @description_args ||= []
-      end
-
-      def description_parts #:nodoc:
-        @description_parts ||= example_group_hierarchy.inject([]) do |parts, example_group_class|
-          [parts << example_group_class.description_args].flatten
-        end
-      end
-
-      def example_proxies # :nodoc:
-        @example_proxies ||= []
-      end
-
-      def example_implementations # :nodoc:
-        @example_implementations ||= {}
-      end
-
-      def examples(run_options=nil) #:nodoc:
-        (run_options && run_options.reverse) ? example_proxies.reverse : example_proxies
-      end
-
-      def number_of_examples #:nodoc:
-        example_proxies.length
-      end
-
-      def example_group_hierarchy
-        @example_group_hierarchy ||= ExampleGroupHierarchy.new(self)
-      end
-
-      def nested_descriptions
-        example_group_hierarchy.nested_descriptions
-      end
-
-      def include_constants_in(mod)
-        include mod if (Spec::Ruby.version.to_f >= 1.9) & (Module === mod) & !(Class === mod)
-      end
-
-      def let(name, &block)
-        define_method name do
-          @assignments ||= {}
-          @assignments[name] ||= instance_eval(&block)
-        end
-      end
-
-      def let!(name, &block)
-        let(name, &block)
-        before { __send__(name) }
-      end
-
-    private
-
-      def subclass(*args, &example_group_block)
-        @class_count ||= 0
-        @class_count += 1
-        klass = const_set("Subclass_#{@class_count}", Class.new(self))
-        klass.set_description(*args)
-        klass.include_constants_in(args.last[:scope])
-        klass.module_eval(&example_group_block)
-        klass
-      end
-
-      def dry_run(examples, run_options)
-        examples.each do |example|
-          run_options.reporter.example_started(example)
-          run_options.reporter.example_finished(example)
-        end
-      end
-
-      def run_before_all(run_options)
-        return [true,{}] if example_group_hierarchy.before_all_parts.empty?
-        example_proxy = ExampleProxy.new("before(:all)")
-        before_all = new(example_proxy)
-        begin
-          example_group_hierarchy.run_before_all(before_all)
-          return [true, before_all.instance_variable_hash]
-        rescue Exception => e
-          run_options.reporter.example_failed(example_proxy, e)
-          return [false, before_all.instance_variable_hash]
-        end
-      end
-
-      def run_examples(success, instance_variables, examples, run_options)
-        return [success, instance_variables] unless success
-
-        after_all_instance_variables = instance_variables
-
-        examples.each do |example|
-          example_group_instance = new(example, &example_implementations[example])
-          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, run_options)
-        return success if example_group_hierarchy.after_all_parts.empty?
-        example_proxy = ExampleProxy.new("after(:all)")
-        after_all = new(example_proxy)
-        after_all.set_instance_variables_from_hash(instance_variables)
-        example_group_hierarchy.run_after_all(after_all)
-        success
-      rescue Exception => e
-        run_options.reporter.example_failed(example_proxy, e)
-        false
-      end
-
-      def examples_to_run(run_options)
-        return example_proxies unless examples_were_specified?(run_options)
-        if run_options.line_number_requested?
-          if location =~ /:#{run_options.example_line}:?/
-            example_proxies
-          else
-            example_proxies.select {|proxy| proxy.location =~ /:#{run_options.example_line}:?/}
-          end
-        else
-          example_proxies.reject do |proxy|
-            matcher = ExampleGroupMethods.matcher_class.
-              new(description.to_s, proxy.description)
-            !matcher.matches?(run_options.examples)
-          end
-        end
-      end
-
-      def examples_were_specified?(run_options)
-        !run_options.examples.empty?
-      end
-
-      def method_added(name) # :nodoc:
-        example(name.to_s, {}, caller(0)[1]) {__send__ name.to_s} if example_method?(name.to_s)
-      end
-
-      def example_method?(method_name)
-        should_method?(method_name)
-      end
-
-      def should_method?(method_name)
-        !(method_name =~ /^should(_not)?$/) &&
-        method_name =~ /^should/ &&
-        instance_method(method_name).arity < 1
-      end
-
-      def include_shared_example_group(shared_example_group)
-        case shared_example_group
-        when SharedExampleGroup
-          include shared_example_group
-        else
-          unless example_group = SharedExampleGroup.find(shared_example_group)
-            raise RuntimeError.new("Shared Example Group '#{shared_example_group}' can not be found")
-          end
-          include(example_group)
-        end
-      end
-    end
-
-  end
-end