rspec-instructure 1.3.3

data/lib/spec/example.rb

@@ -0,0 +1,164 @@
+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
+  end
+end
+
+require 'timeout'
+require 'spec/example/args_and_options'
+require 'spec/example/predicate_matchers'
+require 'spec/example/example_group_proxy'
+require 'spec/example/example_proxy'
+require 'spec/example/subject'
+require 'spec/example/before_and_after_hooks'
+require 'spec/example/pending'
+require 'spec/example/module_reopening_fix'
+require 'spec/example/example_group_hierarchy'
+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/spec/example/args_and_options.rb

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,53 @@
+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