gem_repackager 0.1.0

data/support/gems/rspec-core-2.11.1/lib/rspec/core/shared_example_group.rb

@@ -0,0 +1,96 @@
+module RSpec
+  module Core
+    module SharedExampleGroup
+      # @overload shared_examples(name, &block)
+      # @overload shared_examples(name, tags, &block)
+      #
+      # Wraps the `block` in a module which can then be included in example
+      # groups using `include_examples`, `include_context`, or
+      # `it_behaves_like`.
+      #
+      # @param [String] name to match when looking up this shared group
+      # @param block to be eval'd in a nested example group generated by `it_behaves_like`
+      #
+      # @example
+      #
+      #   shared_examples "auditable" do
+      #     it "stores an audit record on save!" do
+      #       lambda { auditable.save! }.should change(Audit, :count).by(1)
+      #     end
+      #   end
+      #
+      #   class Account do
+      #     it_behaves_like "auditable" do
+      #       def auditable; Account.new; end
+      #     end
+      #   end
+      #
+      # @see ExampleGroup.it_behaves_like
+      # @see ExampleGroup.include_examples
+      # @see ExampleGroup.include_context
+      def shared_examples *args, &block
+        if key? args.first
+          key = args.shift
+          raise_key_taken key if key_taken? key
+          RSpec.world.shared_example_groups[key] = block
+        end
+
+        unless args.empty?
+          mod = Module.new
+          (class << mod; self; end).send :define_method, :extended  do |host|
+            host.class_eval(&block)
+          end
+          RSpec.configuration.extend mod, *args
+        end
+      end
+
+      alias_method :shared_context,      :shared_examples
+      alias_method :share_examples_for,  :shared_examples
+      alias_method :shared_examples_for, :shared_examples
+
+      def share_as(name, &block)
+        if Object.const_defined?(name)
+          mod = Object.const_get(name)
+          raise_name_error unless mod.created_from_caller(caller)
+        end
+
+        mod = Module.new do
+          @shared_block = block
+          @caller_line = caller.last
+
+          def self.created_from_caller(other_caller)
+            @caller_line == other_caller.last
+          end
+
+          def self.included(kls)
+            kls.describe(&@shared_block)
+            kls.children.first.metadata[:shared_group_name] = name
+          end
+        end
+
+        shared_const = Object.const_set(name, mod)
+        RSpec.world.shared_example_groups[shared_const] = block
+      end
+
+    private
+
+      def key? candidate
+        [String, Symbol, Module].any? { |cls| cls === candidate }
+      end
+
+      def raise_name_error
+        raise NameError, "The first argument (#{name}) to share_as must be a legal name for a constant not already in use."
+      end
+
+      def raise_key_taken key
+        raise ArgumentError, "Shared example group '#{key}' already exists"
+      end
+
+      def key_taken? key
+        RSpec.world.shared_example_groups.has_key?(key)
+      end
+    end
+  end
+end
+
+include RSpec::Core::SharedExampleGroup

data/support/gems/rspec-core-2.11.1/lib/rspec/core/subject.rb

@@ -0,0 +1,219 @@
+module RSpec
+  module Core
+    module Subject
+      module ExampleMethods
+        # Returns the example group's `subject`.
+        #
+        # @note `subject` was contributed by Joe Ferris to support the one-liner
+        #   syntax embraced by shoulda matchers:
+        #
+        #       describe Widget do
+        #         it { should validate_presence_of(:name) }
+        #       end
+        #
+        #   While the examples below demonstrate how to use `subject`
+        #   explicitly in examples, we recommend that you define a method with
+        #   an intention revealing name instead.
+        #
+        # @example
+        #
+        #   # explicit declaration of subject
+        #   describe Person do
+        #     subject { Person.new(:birthdate => 19.years.ago) }
+        #     it "should be eligible to vote" do
+        #       subject.should be_eligible_to_vote
+        #       # ^ ^ explicit reference to subject not recommended
+        #     end
+        #   end
+        #
+        #   # implicit subject => { Person.new }
+        #   describe Person do
+        #     it "should be eligible to vote" do
+        #       subject.should be_eligible_to_vote
+        #       # ^ ^ explicit reference to subject not recommended
+        #     end
+        #   end
+        #
+        #   # one-liner syntax - should is invoked on subject
+        #   describe Person do
+        #     it { should be_eligible_to_vote }
+        #   end
+        #
+        # @see ExampleGroupMethods#subject
+        # @see #should
+        def subject
+          if defined?(@original_subject)
+            @original_subject
+          else
+            @original_subject = instance_eval(&self.class.subject)
+          end
+        end
+
+        # When `should` is called with no explicit receiver, the call is
+        # delegated to the object returned by `subject`. Combined with an
+        # implicit subject this supports very concise expressions.
+        #
+        # @example
+        #
+        #   describe Person do
+        #     it { should be_eligible_to_vote }
+        #   end
+        #
+        # @see #subject
+        def should(matcher=nil, message=nil)
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(subject, matcher, message)
+        end
+
+        # Just like `should`, `should_not` delegates to the subject (implicit or
+        # explicit) of the example group.
+        #
+        # @example
+        #
+        #   describe Person do
+        #     it { should_not be_eligible_to_vote }
+        #   end
+        #
+        # @see #subject
+        def should_not(matcher=nil, message=nil)
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(subject, matcher, message)
+        end
+
+        private
+
+        def _attribute_chain(attribute)
+          attribute.to_s.split('.')
+        end
+
+        def _nested_attribute(subject, attribute)
+          _attribute_chain(attribute).inject(subject) do |inner_subject, attr|
+            inner_subject.send(attr)
+          end
+        end
+      end
+
+      module ExampleGroupMethods
+        # Creates a nested example group named by the submitted `attribute`,
+        # and then generates an example using the submitted block.
+        #
+        # @example
+        #
+        #   # This ...
+        #   describe Array do
+        #     its(:size) { should eq(0) }
+        #   end
+        #
+        #   # ... generates the same runtime structure as this:
+        #   describe Array do
+        #     describe "size" do
+        #       it "should eq(0)" do
+        #         subject.size.should eq(0)
+        #       end
+        #     end
+        #   end
+        #
+        # The attribute can be a `Symbol` or a `String`. Given a `String`
+        # with dots, the result is as though you concatenated that `String`
+        # onto the subject in an expression.
+        #
+        # @example
+        #
+        #   describe Person do
+        #     subject do
+        #       Person.new.tap do |person|
+        #         person.phone_numbers << "555-1212"
+        #       end
+        #     end
+        #
+        #     its("phone_numbers.first") { should eq("555-1212") }
+        #   end
+        #
+        # When the subject is a `Hash`, you can refer to the Hash keys by
+        # specifying a `Symbol` or `String` in an array.
+        #
+        # @example
+        #
+        #   describe "a configuration Hash" do
+        #     subject do
+        #       { :max_users => 3,
+        #         'admin' => :all_permissions }
+        #     end
+        #
+        #     its([:max_users]) { should eq(3) }
+        #     its(['admin']) { should eq(:all_permissions) }
+        #
+        #     # You can still access to its regular methods this way:
+        #     its(:keys) { should include(:max_users) }
+        #     its(:count) { should eq(2) }
+        #   end
+        def its(attribute, &block)
+          describe(attribute) do
+            example do
+              self.class.class_eval do
+                define_method(:subject) do
+                  if defined?(@_subject)
+                    @_subject
+                  else
+                    @_subject = Array === attribute ? super()[*attribute] : _nested_attribute(super(), attribute)
+                  end
+                end
+              end
+              instance_eval(&block)
+            end
+          end
+        end
+
+        # Declares a `subject` for an example group which can then be the
+        # implicit receiver (through delegation) of calls to `should`.
+        #
+        # Given a `name`, defines a method with that name which returns the
+        # `subject`. This lets you declare the subject once and access it
+        # implicitly in one-liners and explicitly using an intention revealing
+        # name.
+        #
+        # @param [String,Symbol] name used to define an accessor with an
+        #   intention revealing name
+        # @param block defines the value to be returned by `subject` in examples
+        #
+        # @example
+        #
+        #   describe CheckingAccount, "with $50" do
+        #     subject { CheckingAccount.new(Money.new(50, :USD)) }
+        #     it { should have_a_balance_of(Money.new(50, :USD)) }
+        #     it { should_not be_overdrawn }
+        #   end
+        #
+        #   describe CheckingAccount, "with a non-zero starting balance" do
+        #     subject(:account) { CheckingAccount.new(Money.new(50, :USD)) }
+        #     it { should_not be_overdrawn }
+        #     it "has a balance equal to the starting balance" do
+        #       account.balance.should eq(Money.new(50, :USD))
+        #     end
+        #   end
+        #
+        # @see ExampleMethods#subject
+        # @see ExampleMethods#should
+        def subject(name=nil, &block)
+          define_method(name) { subject } if name
+          block ? @explicit_subject_block = block : explicit_subject || implicit_subject
+        end
+
+        attr_reader :explicit_subject_block
+
+        private
+
+        def explicit_subject
+          group = self
+          while group.respond_to?(:explicit_subject_block)
+            return group.explicit_subject_block if group.explicit_subject_block
+            group = group.superclass
+          end
+        end
+
+        def implicit_subject
+          described = described_class || description
+          Class === described ? proc { described.new } : proc { described }
+        end
+      end
+    end
+  end
+end

data/support/gems/rspec-core-2.11.1/lib/rspec/core/version.rb

@@ -0,0 +1,7 @@
+module RSpec
+  module Core
+    module Version
+      STRING = '2.11.1'
+    end
+  end
+end

data/support/gems/rspec-core-2.11.1/lib/rspec/core/world.rb

@@ -0,0 +1,128 @@
+module RSpec
+  module Core
+    class World
+
+      include RSpec::Core::Hooks
+
+      attr_reader :example_groups, :shared_example_groups, :filtered_examples
+      attr_accessor :wants_to_quit
+
+      def initialize(configuration=RSpec.configuration)
+        @configuration = configuration
+        @example_groups = [].extend(Extensions::Ordered)
+        @shared_example_groups = {}
+        @filtered_examples = Hash.new { |hash,group|
+          hash[group] = begin
+            examples = group.examples.dup
+            examples = filter_manager.prune(examples)
+            examples.uniq
+            examples.extend(Extensions::Ordered)
+          end
+        }
+      end
+
+      def reset
+        example_groups.clear
+        shared_example_groups.clear
+      end
+
+      def filter_manager
+        @configuration.filter_manager
+      end
+
+      def register(example_group)
+        example_groups << example_group
+        example_group
+      end
+
+      def inclusion_filter
+        @configuration.inclusion_filter
+      end
+
+      def exclusion_filter
+        @configuration.exclusion_filter
+      end
+
+      def configure_group(group)
+        @configuration.configure_group(group)
+      end
+
+      def example_count
+        example_groups.collect {|g| g.descendants}.flatten.inject(0) do |sum, g|
+          sum += g.filtered_examples.size
+        end
+      end
+
+      def preceding_declaration_line(filter_line)
+        declaration_line_numbers.sort.inject(nil) do |highest_prior_declaration_line, line|
+          line <= filter_line ? line : highest_prior_declaration_line
+        end
+      end
+
+      def reporter
+        @configuration.reporter
+      end
+
+      def announce_filters
+        filter_announcements = []
+
+        announce_inclusion_filter filter_announcements
+        announce_exclusion_filter filter_announcements
+
+        unless filter_manager.empty?
+          if filter_announcements.length == 1
+            reporter.message("Run options: #{filter_announcements[0]}")
+          else
+            reporter.message("Run options:\n  #{filter_announcements.join("\n  ")}")
+          end
+        end
+
+        if @configuration.run_all_when_everything_filtered? && example_count.zero?
+          reporter.message("#{everything_filtered_message}; ignoring #{inclusion_filter.description}")
+          filtered_examples.clear
+          inclusion_filter.clear
+        end
+
+        if example_count.zero?
+          example_groups.clear
+          if filter_manager.empty?
+            reporter.message("No examples found.")
+          elsif exclusion_filter.empty_without_conditional_filters?
+            message = everything_filtered_message
+            if @configuration.run_all_when_everything_filtered?
+              message << "; ignoring #{inclusion_filter.description}"
+            end
+            reporter.message(message)
+          elsif inclusion_filter.empty?
+            reporter.message(everything_filtered_message)
+          end
+        end
+      end
+
+      def everything_filtered_message
+        "\nAll examples were filtered out"
+      end
+
+      def announce_inclusion_filter(announcements)
+        unless inclusion_filter.empty?
+          announcements << "include #{inclusion_filter.description}"
+        end
+      end
+
+      def announce_exclusion_filter(announcements)
+        unless exclusion_filter.empty_without_conditional_filters?
+          announcements << "exclude #{exclusion_filter.description}"
+        end
+      end
+
+    private
+
+      def declaration_line_numbers
+        @line_numbers ||= example_groups.inject([]) do |lines, g|
+          lines + g.declaration_line_numbers
+        end
+      end
+
+    end
+  end
+end