newbamboo-rspec 1.1.12

data/lib/spec/dsl/main.rb

@@ -0,0 +1,87 @@
+module Spec
+  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
+      # calling this method. For example, Spec::Rails will use different
+      # classes for specs living in <tt>spec/models</tt>,
+      # <tt>spec/helpers</tt>, <tt>spec/views</tt> and
+      # <tt>spec/controllers</tt>.
+      #
+      # It is also possible to override autodiscovery of the example group
+      # type with an options Hash as the last argument:
+      #
+      #   describe "name", :type => :something_special do ...
+      #
+      # The reason for using different behaviour classes is to have different
+      # matcher methods available from within the <tt>describe</tt> block.
+      #
+      # See Spec::Example::ExampleGroupFactory#register for details about how to
+      # register special implementations.
+      #
+      def describe(*args, &block)
+        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
+      
+      # Creates an example group that can be shared by other example groups
+      #
+      # == Examples
+      #
+      #  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
+      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
+      #
+      #  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
+      def share_as(name, &block)
+        begin
+          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
+      end
+    end
+  end
+end
+
+include Spec::DSL::Main

data/lib/spec/dsl.rb

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

data/lib/spec/example/before_and_after_hooks.rb

@@ -0,0 +1,99 @@
+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)
+        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)
+        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)
+        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)
+        after_parts(*args) << block
+      end
+
+      # TODO - deprecate this unless there is a reason why it exists
+      def remove_after(scope, &block) # :nodoc:
+        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
+      
+      def before_suite_parts
+        BeforeAndAfterHooks.before_suite_parts
+      end
+      
+      def after_suite_parts
+        BeforeAndAfterHooks.after_suite_parts
+      end
+      
+    private  
+      
+      def before_parts(*args)
+        case Spec::Example.scope_from(*args)
+        when :each; before_each_parts
+        when :all; before_all_parts
+        when :suite; before_suite_parts
+        end
+      end
+
+      def after_parts(*args)
+        case Spec::Example.scope_from(*args)
+        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

@@ -0,0 +1,30 @@
+module Spec
+  module Example
+    class ExamplePendingError < StandardError
+      attr_reader :pending_caller
+
+      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/lib/spec/example/example_group.rb

@@ -0,0 +1,26 @@
+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
+
+      def initialize(defined_description=nil, options={}, &implementation)
+        @_options = options
+        @_defined_description = defined_description
+        @_implementation = implementation || pending_implementation
+        @_backtrace = caller
+      end
+      
+    private
+      
+      def pending_implementation
+        error = NotYetImplementedError.new(caller)
+        lambda { raise(error) }
+      end
+    end
+  end
+end
+
+Spec::ExampleGroup = Spec::Example::ExampleGroup

data/lib/spec/example/example_group_factory.rb

@@ -0,0 +1,98 @@
+module Spec
+  module Example
+    class ExampleGroupFactory
+      module ClassMethods
+        def reset
+          @example_group_types = nil
+          default(ExampleGroup)
+        end
+
+        def registered_or_ancestor_of_registered?(example_group_classes) # :nodoc:
+          example_group_classes.each do |example_group_class|
+            return false unless registered_types.any? do |registered_type|
+              registered_type.ancestors.include? example_group_class
+            end
+          end
+          return true
+        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)
+          old = @example_group_types
+          @example_group_types = Hash.new(example_group_class)
+          @example_group_types.merge!(old) if old
+        end
+
+        def get(key=nil)
+          if @example_group_types.values.include?(key)
+            key
+          else
+            @example_group_types[key]
+          end
+        end
+
+        def create_example_group(*args, &block)
+          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
+
+        def determine_superclass(opts)
+          key = if opts[:type]
+            opts[:type]
+          elsif opts[:spec_path] =~ /spec(\\|\/)(#{@example_group_types.keys.sort_by{|k| k.to_s.length}.reverse.join('|')})/
+            $2 == '' ? nil : $2.to_sym
+          end
+          get(key)
+        end
+
+      private
+
+        def registered_types
+          @example_group_types.values
+        end
+
+      end
+      extend ClassMethods
+      self.reset
+    end
+  end
+end