gem_repackager 0.1.0

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

@@ -0,0 +1,110 @@
+module RSpec
+  module Core
+    module Let
+
+      module ExampleGroupMethods
+        # Generates a method whose return value is memoized after the first
+        # call. Useful for reducing duplication between examples that assign
+        # values to the same local variable.
+        #
+        # @note `let` _can_ enhance readability when used sparingly (1,2, or
+        #   maybe 3 declarations) in any given example group, but that can
+        #   quickly degrade with overuse. YMMV.
+        #
+        # @note `let` uses an `||=` conditional that has the potential to
+        #   behave in surprising ways in examples that spawn separate threads,
+        #   though we have yet to see this in practice. You've been warned.
+        #
+        # @example
+        #
+        #   describe Thing do
+        #     let(:thing) { Thing.new }
+        #
+        #     it "does something" do
+        #       # first invocation, executes block, memoizes and returns result
+        #       thing.do_something
+        #
+        #       # second invocation, returns the memoized value
+        #       thing.should be_something
+        #     end
+        #   end
+        def let(name, &block)
+          define_method(name) do
+            __memoized.fetch(name) {|k| __memoized[k] = instance_eval(&block) }
+          end
+        end
+
+        # Just like `let`, except the block is invoked by an implicit `before`
+        # hook. This serves a dual purpose of setting up state and providing a
+        # memoized reference to that state.
+        #
+        # @example
+        #
+        #   class Thing
+        #     def self.count
+        #       @count ||= 0
+        #     end
+        #
+        #     def self.count=(val)
+        #       @count += val
+        #     end
+        #
+        #     def self.reset_count
+        #       @count = 0
+        #     end
+        #
+        #     def initialize
+        #       self.class.count += 1
+        #     end
+        #   end
+        #
+        #   describe Thing do
+        #     after(:each) { Thing.reset_count }
+        #
+        #     context "using let" do
+        #       let(:thing) { Thing.new }
+        #
+        #       it "is not invoked implicitly" do
+        #         Thing.count.should eq(0)
+        #       end
+        #
+        #       it "can be invoked explicitly" do
+        #         thing
+        #         Thing.count.should eq(1)
+        #       end
+        #     end
+        #
+        #     context "using let!" do
+        #       let!(:thing) { Thing.new }
+        #
+        #       it "is invoked implicitly" do
+        #         Thing.count.should eq(1)
+        #       end
+        #
+        #       it "returns memoized version on first invocation" do
+        #         thing
+        #         Thing.count.should eq(1)
+        #       end
+        #     end
+        #   end
+        def let!(name, &block)
+          let(name, &block)
+          before { __send__(name) }
+        end
+      end
+
+      # @private
+      module ExampleMethods
+        # @private
+        def __memoized
+          @__memoized ||= {}
+        end
+      end
+
+      def self.included(mod)
+        mod.extend ExampleGroupMethods
+        mod.__send__ :include, ExampleMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+require 'rspec/core/ruby_project'
+
+RSpec::Core::RubyProject.add_to_load_path('lib', 'spec')

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

@@ -0,0 +1,276 @@
+module RSpec
+  module Core
+    # Each ExampleGroup class and Example instance owns an instance of
+    # Metadata, which is Hash extended to support lazy evaluation of values
+    # associated with keys that may or may not be used by any example or group.
+    #
+    # In addition to metadata that is used internally, this also stores
+    # user-supplied metadata, e.g.
+    #
+    #     describe Something, :type => :ui do
+    #       it "does something", :slow => true do
+    #         # ...
+    #       end
+    #     end
+    #
+    # `:type => :ui` is stored in the Metadata owned by the example group, and
+    # `:slow => true` is stored in the Metadata owned by the example. These can
+    # then be used to select which examples are run using the `--tag` option on
+    # the command line, or several methods on `Configuration` used to filter a
+    # run (e.g. `filter_run_including`, `filter_run_excluding`, etc).
+    #
+    # @see Example#metadata
+    # @see ExampleGroup.metadata
+    # @see FilterManager
+    # @see Configuration#filter_run_including
+    # @see Configuration#filter_run_excluding
+    class Metadata < Hash
+
+      def self.relative_path(line)
+        line = line.sub(File.expand_path("."), ".")
+        line = line.sub(/\A([^:]+:\d+)$/, '\\1')
+        return nil if line == '-e:1'
+        line
+      end
+
+      # @private
+      module MetadataHash
+
+        # @private
+        # Supports lazy evaluation of some values. Extended by
+        # ExampleMetadataHash and GroupMetadataHash, which get mixed in to
+        # Metadata for ExampleGroups and Examples (respectively).
+        def [](key)
+          return super if has_key?(key)
+          case key
+          when :location
+            store(:location, location)
+          when :file_path, :line_number
+            file_path, line_number = file_and_line_number
+            store(:file_path, file_path)
+            store(:line_number, line_number)
+            super
+          when :execution_result
+            store(:execution_result, {})
+          when :describes, :described_class
+            klass = described_class
+            store(:described_class, klass)
+            # TODO (2011-11-07 DC) deprecate :describes as a key
+            store(:describes, klass)
+          when :full_description
+            store(:full_description, full_description)
+          when :description
+            store(:description, build_description_from(*self[:description_args]))
+          else
+            super
+          end
+        end
+
+        private
+
+        def location
+          "#{self[:file_path]}:#{self[:line_number]}"
+        end
+
+        def file_and_line_number
+          first_caller_from_outside_rspec =~ /(.+?):(\d+)(|:\d+)/
+          return [Metadata::relative_path($1), $2.to_i]
+        end
+
+        def first_caller_from_outside_rspec
+          self[:caller].detect {|l| l !~ /\/lib\/rspec\/core/}
+        end
+
+        def build_description_from(*parts)
+          parts.map {|p| p.to_s}.inject do |desc, p|
+            p =~ /^(#|::|\.)/ ? "#{desc}#{p}" : "#{desc} #{p}"
+          end || ""
+        end
+      end
+
+      # Mixed in to Metadata for an Example (extends MetadataHash) to support
+      # lazy evaluation of some values.
+      module ExampleMetadataHash
+        include MetadataHash
+
+        def described_class
+          self[:example_group].described_class
+        end
+
+        def full_description
+          build_description_from(self[:example_group][:full_description], *self[:description_args])
+        end
+      end
+
+      # Mixed in to Metadata for an ExampleGroup (extends MetadataHash) to
+      # support lazy evaluation of some values.
+      module GroupMetadataHash
+        include MetadataHash
+
+        def described_class
+          container_stack.each do |g|
+            return g[:described_class] if g.has_key?(:described_class)
+            return g[:describes]       if g.has_key?(:describes)
+          end
+
+          container_stack.reverse.each do |g|
+            candidate = g[:description_args].first
+            return candidate unless String === candidate || Symbol === candidate
+          end
+
+          nil
+        end
+
+        def full_description
+          build_description_from(*container_stack.reverse.map {|a| a[:description_args]}.flatten)
+        end
+
+        def container_stack
+          @container_stack ||= begin
+                                 groups = [group = self]
+                                 while group.has_key?(:example_group)
+                                   groups << group[:example_group]
+                                   group = group[:example_group]
+                                 end
+                                 groups
+                               end
+        end
+      end
+
+      def initialize(parent_group_metadata=nil)
+        if parent_group_metadata
+          update(parent_group_metadata)
+          store(:example_group, {:example_group => parent_group_metadata[:example_group].extend(GroupMetadataHash)}.extend(GroupMetadataHash))
+        else
+          store(:example_group, {}.extend(GroupMetadataHash))
+        end
+
+        yield self if block_given?
+      end
+
+      # @private
+      def process(*args)
+        user_metadata = args.last.is_a?(Hash) ? args.pop : {}
+        ensure_valid_keys(user_metadata)
+
+        self[:example_group].store(:description_args, args)
+        self[:example_group].store(:caller, user_metadata.delete(:caller) || caller)
+
+        update(user_metadata)
+      end
+
+      # @private
+      def for_example(description, user_metadata)
+        dup.extend(ExampleMetadataHash).configure_for_example(description, user_metadata)
+      end
+
+      # @private
+      def any_apply?(filters)
+        filters.any? {|k,v| filter_applies?(k,v)}
+      end
+
+      # @private
+      def all_apply?(filters)
+        filters.all? {|k,v| filter_applies?(k,v)}
+      end
+
+      # @private
+      def filter_applies?(key, value, metadata=self)
+        return metadata.filter_applies_to_any_value?(key, value) if Array === metadata[key] && !(Proc === value)
+        return metadata.line_number_filter_applies?(value)       if key == :line_numbers
+        return metadata.location_filter_applies?(value)          if key == :locations
+        return metadata.filters_apply?(key, value)               if Hash === value
+
+        return false unless metadata.has_key?(key)
+
+        case value
+        when Regexp
+          metadata[key] =~ value
+        when Proc
+          case value.arity
+          when 0 then value.call
+          when 2 then value.call(metadata[key], metadata)
+          else value.call(metadata[key])
+          end
+        else
+          metadata[key].to_s == value.to_s
+        end
+      end
+
+      # @private
+      def filters_apply?(key, value)
+        value.all? {|k, v| filter_applies?(k, v, self[key])}
+      end
+
+      # @private
+      def filter_applies_to_any_value?(key, value)
+        self[key].any? {|v| filter_applies?(key, v, {key => value})}
+      end
+
+      # @private
+      def location_filter_applies?(locations)
+        # it ignores location filters for other files
+        line_number = example_group_declaration_line(locations)
+        line_number ? line_number_filter_applies?(line_number) : true
+      end
+
+      # @private
+      def line_number_filter_applies?(line_numbers)
+        preceding_declaration_lines = line_numbers.map {|n| RSpec.world.preceding_declaration_line(n)}
+        !(relevant_line_numbers & preceding_declaration_lines).empty?
+      end
+
+      protected
+
+      def configure_for_example(description, user_metadata)
+        store(:description_args, [description])
+        store(:caller, user_metadata.delete(:caller) || caller)
+        update(user_metadata)
+      end
+
+      private
+
+      RESERVED_KEYS = [
+        :description,
+        :example_group,
+        :execution_result,
+        :file_path,
+        :full_description,
+        :line_number,
+        :location
+      ]
+
+      def ensure_valid_keys(user_metadata)
+        RESERVED_KEYS.each do |key|
+          if user_metadata.has_key?(key)
+            raise <<-EOM
+            #{"*"*50}
+:#{key} is not allowed
+
+RSpec reserves some hash keys for its own internal use,
+including :#{key}, which is used on:
+
+            #{caller(0)[4]}.
+
+Here are all of RSpec's reserved hash keys:
+
+            #{RESERVED_KEYS.join("\n  ")}
+            #{"*"*50}
+            EOM
+          end
+        end
+      end
+
+      def example_group_declaration_line(locations)
+        locations[File.expand_path(self[:example_group][:file_path])] if self[:example_group]
+      end
+
+      # TODO - make this a method on metadata - the problem is
+      # metadata[:example_group] is not always a kind of GroupMetadataHash.
+      def relevant_line_numbers(metadata=self)
+        [metadata[:line_number]] + (metadata[:example_group] ? relevant_line_numbers(metadata[:example_group]) : [])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module RSpec
+  module Core
+    # @private
+    module MetadataHashBuilder
+      # @private
+      module Common
+        def build_metadata_hash_from(args)
+          metadata = args.last.is_a?(Hash) ? args.pop : {}
+
+          if RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values?
+            add_symbols_to_hash(metadata, args)
+          else
+            warn_about_symbol_usage(args)
+          end
+
+          metadata
+        end
+
+        private
+
+          def add_symbols_to_hash(hash, args)
+            while args.last.is_a?(Symbol)
+              hash[args.pop] = true
+            end
+          end
+
+          def warn_about_symbol_usage(args)
+            symbols = args.select { |a| a.is_a?(Symbol) }
+            return if symbols.empty?
+            Kernel.warn symbol_metadata_warning(symbols)
+          end
+      end
+
+      # @private
+      module WithConfigWarning
+        include Common
+
+        private
+
+          def symbol_metadata_warning(symbols)
+            <<-NOTICE
+
+*****************************************************************
+WARNING: You have passed symbols (#{symbols.inspect}) as metadata
+arguments to a configuration option.
+
+In RSpec 3, these symbols will be treated as metadata keys with
+a value of `true`.  To get this behavior now (and prevent this
+warning), you can set a configuration option:
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+Note that this config setting should go before your other config
+settings so that they can use symbols as metadata.
+*****************************************************************
+
+NOTICE
+          end
+      end
+
+      # @private
+      module WithDeprecationWarning
+        include Common
+
+        private
+
+          def symbol_metadata_warning(symbols)
+            <<-NOTICE
+
+*****************************************************************
+DEPRECATION WARNING: you are using deprecated behaviour that will
+be removed from RSpec 3.
+
+You have passed symbols (#{symbols.inspect}) as additional
+arguments for a doc string.
+
+In RSpec 3, these symbols will be treated as metadata keys with
+a value of `true`.  To get this behavior now (and prevent this
+warning), you can set a configuration option:
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+Alternately, if your intention is to use the symbol as part of the
+doc string (i.e. to specify a method name), you can change it to
+a string such as "#method_name" to remove this warning.
+*****************************************************************
+
+NOTICE
+          end
+      end
+    end
+  end
+end