gemrage 0.0.0

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/hooks.rb

@@ -0,0 +1,134 @@
+module RSpec
+  module Core
+    module Hooks
+
+      class Hook
+        attr_reader :options
+
+        def initialize(options, &block)
+          @options = options
+          @block = block
+        end
+
+        def options_apply?(group)
+          !group || group.all_apply?(options)
+        end
+
+        def to_proc
+          @block
+        end
+
+        def call
+          @block.call
+        end
+      end
+
+      class BeforeHook < Hook
+        def run_in(example_group_instance)
+          if example_group_instance
+            example_group_instance.instance_eval(&self)
+          else
+            call
+          end
+        end
+      end
+
+      class AfterHook < Hook
+        def run_in(example_group_instance)
+          if example_group_instance
+            example_group_instance.instance_eval_with_rescue(&self)
+          else
+            call
+          end
+        end
+      end
+
+      class AroundHook < Hook
+        def call(wrapped_example)
+          @block.call(wrapped_example)
+        end
+      end
+
+      class HookCollection < Array
+        def find_hooks_for(group)
+          dup.reject {|hook| !hook.options_apply?(group)}
+        end
+      end
+
+      class BeforeHooks < HookCollection
+        def run_all(example_group_instance)
+          each {|h| h.run_in(example_group_instance) }
+        end
+
+        def run_all!(example_group_instance)
+          shift.run_in(example_group_instance) until empty?
+        end
+      end
+
+      class AfterHooks < HookCollection
+        def run_all(example_group_instance)
+          reverse.each {|h| h.run_in(example_group_instance) }
+        end
+
+        def run_all!(example_group_instance)
+          pop.run_in(example_group_instance) until empty?
+        end
+      end
+
+      class AroundHooks < HookCollection; end
+
+      def hooks
+        @hooks ||= {
+          :around => { :each => AroundHooks.new },
+          :before => { :each => BeforeHooks.new, :all => BeforeHooks.new, :suite => BeforeHooks.new },
+          :after => { :each => AfterHooks.new, :all => AfterHooks.new, :suite => AfterHooks.new }
+        }
+      end
+
+      def before(*args, &block)
+        scope, options = scope_and_options_from(*args)
+        hooks[:before][scope] << BeforeHook.new(options, &block)
+      end
+
+      def after(*args, &block)
+        scope, options = scope_and_options_from(*args)
+        hooks[:after][scope] << AfterHook.new(options, &block)
+      end
+
+      def around(*args, &block)
+        scope, options = scope_and_options_from(*args)
+        hooks[:around][scope] << AroundHook.new(options, &block)
+      end
+
+      # Runs all of the blocks stored with the hook in the context of the
+      # example. If no example is provided, just calls the hook directly.
+      def run_hook(hook, scope, example_group_instance=nil)
+        hooks[hook][scope].run_all(example_group_instance)
+      end
+
+      # Just like run_hook, except it removes the blocks as it evalutes them,
+      # ensuring that they will only be run once.
+      def run_hook!(hook, scope, example_group_instance)
+        hooks[hook][scope].run_all!(example_group_instance)
+      end
+
+      def run_hook_filtered(hook, scope, group, example_group_instance)
+        find_hook(hook, scope, group).run_all(example_group_instance)
+      end
+
+      def find_hook(hook, scope, example_group_class)
+        hooks[hook][scope].find_hooks_for(example_group_class)
+      end
+
+    private
+
+      def scope_and_options_from(scope=:each, options={})
+        if Hash === scope
+          options = scope
+          scope = :each
+        end
+        return scope, options
+      end
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/let.rb

@@ -0,0 +1,101 @@
+module RSpec
+  module Core
+    module Let
+
+      module ClassMethods
+        # Generates a method whose return value is memoized
+        # after the first call.
+        #
+        # == Examples
+        #
+        #  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[name] ||= instance_eval(&block)
+          end
+        end
+
+        # Just like <tt>let()</tt>, except the block is invoked
+        # by an implicit <tt>before</tt> hook. This serves a dual
+        # purpose of setting up state and providing a memoized
+        # reference to that state.
+        #
+        # == Examples
+        #
+        #  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 == 0
+        #      end
+        #
+        #      it "can be invoked explicitly" do
+        #        thing
+        #        Thing.count.should == 1
+        #      end
+        #    end
+        #
+        #    context "using let!" do
+        #      let!(:thing) { Thing.new }
+        #
+        #      it "is invoked implicitly" do
+        #        Thing.count.should == 1
+        #      end
+        #
+        #      it "returns memoized version on first invocation" do
+        #        thing
+        #        Thing.count.should == 1
+        #      end
+        #    end
+        #  end
+        def let!(name, &block)
+          let(name, &block)
+          before { __send__(name) }
+        end
+      end
+
+      module InstanceMethods
+        def __memoized # :nodoc:
+          @__memoized ||= {}
+        end
+      end
+
+      def self.included(mod) # :nodoc:
+        mod.extend ClassMethods
+        mod.__send__ :include, InstanceMethods
+      end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/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/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/metadata.rb

@@ -0,0 +1,183 @@
+module RSpec
+  module Core
+    class Metadata < Hash
+
+      def initialize(superclass_metadata=nil)
+        @superclass_metadata = superclass_metadata
+        if @superclass_metadata
+          update(@superclass_metadata)
+          example_group = {:example_group => @superclass_metadata[:example_group]}
+        end
+
+        store(:example_group, example_group || {})
+        yield self if block_given?
+      end
+
+      RESERVED_KEYS = [
+        :description,
+        :example_group,
+        :execution_result,
+        :file_path,
+        :full_description,
+        :line_number,
+        :location
+      ]
+
+      def process(*args)
+        user_metadata = args.last.is_a?(Hash) ? args.pop : {}
+        ensure_valid_keys(user_metadata)
+
+        self[:example_group][:describes] = described_class_from(*args)
+        self[:example_group][:description] = description_from(*args)
+        self[:example_group][:full_description] = full_description_from(*args)
+
+        self[:example_group][:block] = user_metadata.delete(:example_group_block)
+        self[:example_group][:caller] = user_metadata.delete(:caller) || caller(1)
+        self[:example_group][:file_path] = file_path_from(self[:example_group], user_metadata.delete(:file_path))
+        self[:example_group][:line_number] = line_number_from(self[:example_group], user_metadata.delete(:line_number))
+        self[:example_group][:location] = location_from(self[:example_group])
+
+        update(user_metadata)
+      end
+
+      def ensure_valid_keys(user_metadata)
+        RESERVED_KEYS.each do |key|
+          if user_metadata.keys.include?(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
+            raise ":#{key} is not allowed"
+          end
+        end
+      end
+
+      def for_example(description, options)
+        dup.configure_for_example(description,options)
+      end
+
+      def configure_for_example(description, options)
+        store(:description, description.to_s)
+        store(:full_description, "#{self[:example_group][:full_description]} #{self[:description]}")
+        store(:execution_result, {})
+        store(:caller, options.delete(:caller))
+        if self[:caller]
+          store(:file_path, file_path_from(self))
+          store(:line_number, line_number_from(self))
+        end
+        self[:location] = location_from(self)
+        update(options)
+      end
+
+      def all_apply?(filters)
+        filters.all? do |key, value|
+          apply_condition(key, value)
+        end
+      end
+
+      def relevant_line_numbers(metadata)
+        line_numbers = [metadata[:line_number]]
+        if metadata[:example_group]
+          line_numbers + relevant_line_numbers(metadata[:example_group])
+        else
+          line_numbers
+        end
+      end
+
+      def apply_condition(key, value, metadata=nil)
+        metadata ||= self
+        case value
+        when Hash
+          value.all? { |k, v| apply_condition(k, v, metadata[key]) }
+        when Regexp
+          metadata[key] =~ value
+        when Proc
+          value.call(metadata[key]) rescue false
+        when Fixnum
+          if key == :line_number
+            relevant_line_numbers(metadata).include?(world.preceding_declaration_line(value))
+          else
+            metadata[key] == value
+          end
+        else
+          metadata[key] == value
+        end
+      end
+
+    private
+
+      def world
+        RSpec.world
+      end
+
+      def superclass_metadata
+        @superclass_metadata ||= { :example_group => {} }
+      end
+
+      def description_from(*args)
+        args.inject("") do |result, a|
+          a = a.to_s.strip
+          if result == ""
+            a
+          elsif a =~ /^(#|::|\.)/
+            "#{result}#{a}"
+          else
+            "#{result} #{a}"
+          end
+        end
+      end
+
+      def full_description_from(*args)
+        if superclass_metadata[:example_group][:full_description]
+          description_from(superclass_metadata[:example_group][:full_description], *args)
+        else
+          description_from(*args)
+        end
+      end
+
+      def described_class_from(*args)
+        if args.first.is_a?(String) || args.first.is_a?(Symbol)
+          superclass_metadata[:example_group][:describes]
+        else
+          args.first
+        end
+      end
+
+      def file_path_from(metadata, given_file_path=nil)
+        return given_file_path if given_file_path
+        file = file_and_line_number(metadata)[0] if file_and_line_number(metadata)
+        file.strip if file
+      end
+
+      def line_number_from(metadata, given_line_number=nil)
+        return given_line_number if given_line_number
+        line_number = file_and_line_number(metadata)[1] if file_and_line_number(metadata)
+        line_number && line_number.to_i
+      end
+
+      def location_from(metadata)
+        "#{metadata[:file_path]}:#{metadata[:line_number]}"
+      end
+
+      def file_and_line_number(metadata)
+        entry = candidate_entries_from_caller(metadata).first
+        entry && entry.match(/(.+?):(\d+)(|:\d+)/)[1..2]
+      end
+
+      def candidate_entries_from_caller(metadata)
+        metadata[:caller].grep(/\_spec\.rb:/i)
+      end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/mocking/with_absolutely_nothing.rb

@@ -0,0 +1,11 @@
+module RSpec
+  module Core
+    module MockFrameworkAdapter
+
+      def setup_mocks_for_rspec; end
+      def verify_mocks_for_rspec; end
+      def teardown_mocks_for_rspec; end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/mocking/with_flexmock.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+#
+#  Created by Jim Weirich on 2007-04-10.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'flexmock/rspec'
+
+module RSpec
+  module Core
+    module MockFrameworkAdapter
+
+      include FlexMock::MockContainer
+      def setup_mocks_for_rspec
+        # No setup required
+      end
+      def verify_mocks_for_rspec
+        flexmock_verify
+      end
+      def teardown_mocks_for_rspec
+        flexmock_close
+      end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/mocking/with_mocha.rb

@@ -0,0 +1,21 @@
+require 'mocha/standalone'
+require 'mocha/object'
+
+module RSpec
+  module Core
+    module MockFrameworkAdapter
+
+      # Mocha::Standalone was deprecated as of Mocha 0.9.7.
+      begin
+        include Mocha::API
+      rescue NameError
+        include Mocha::Standalone
+      end
+
+      alias :setup_mocks_for_rspec :mocha_setup
+      alias :verify_mocks_for_rspec :mocha_verify
+      alias :teardown_mocks_for_rspec :mocha_teardown
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/mocking/with_rr.rb

@@ -0,0 +1,25 @@
+require 'rr'
+
+RSpec.configuration.backtrace_clean_patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
+
+module RSpec
+  module Core
+    module MockFrameworkAdapter
+
+      include RR::Extensions::InstanceMethods
+
+      def setup_mocks_for_rspec
+        RR::Space.instance.reset
+      end
+
+      def verify_mocks_for_rspec
+        RR::Space.instance.verify_doubles
+      end
+
+      def teardown_mocks_for_rspec
+        RR::Space.instance.reset
+      end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/mocking/with_rspec.rb

@@ -0,0 +1,21 @@
+require 'rspec/mocks'
+
+module RSpec
+  module Core
+    module MockFrameworkAdapter
+
+      def setup_mocks_for_rspec
+        RSpec::Mocks::setup(self)
+      end
+
+      def verify_mocks_for_rspec
+        RSpec::Mocks::verify
+      end
+
+      def teardown_mocks_for_rspec
+        RSpec::Mocks::teardown
+      end
+
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/option_parser.rb

@@ -0,0 +1,105 @@
+module RSpec::Core
+  class Parser
+    def self.parse!(args)
+      new.parse!(args)
+    end
+
+    class << self
+      alias_method :parse, :parse!
+    end
+
+    def parse!(args)
+      return {} if args.empty?
+      if args.include?("--formatter")
+        RSpec.deprecate("the --formatter option", "-f or --format")
+        args[args.index("--formatter")] = "--format"
+      end
+      options = {}
+      parser(options).parse!(args)
+      options
+    end
+
+    alias_method :parse, :parse!
+
+    def parser(options)
+      OptionParser.new do |parser|
+        parser.banner = "Usage: rspec [options] [files or directories]"
+
+        parser.on('-b', '--backtrace', 'Enable full backtrace') do |o|
+          options[:full_backtrace] = true
+        end
+
+        parser.on('-c', '--[no-]color', '--[no-]colour', 'Enable color in the output') do |o|
+          options[:color_enabled] = o
+        end
+
+        parser.on('-d', '--debug', 'Enable debugging') do |o|
+          options[:debug] = true
+        end
+
+        parser.on('-e', '--example PATTERN', "Run examples whose full descriptions match this pattern",
+                "(PATTERN is compiled into a Ruby regular expression)") do |o|
+          options[:full_description] = /#{o}/
+        end
+
+        parser.on('-f', '--format FORMATTER', 'Choose a formatter',
+                '  [p]rogress (default - dots)',
+                '  [d]ocumentation (group and example names)',
+                '  [h]tml',
+                '  [t]extmate',
+                '  custom formatter class name') do |o|
+          options[:formatter] = o
+        end
+
+        parser.on('-o', '--out FILE', 'output to a file instead of STDOUT') do |o|
+          options[:output_stream] = File.open(o,'w')
+        end
+
+        parser.on_tail('-h', '--help', "You're looking at it.") do
+          puts parser
+          exit
+        end
+
+        parser.on('-I DIRECTORY', 'specify $LOAD_PATH directory (may be used more than once)') do |dir|
+          options[:libs] ||= []
+          options[:libs] << dir
+        end
+
+        parser.on('-l', '--line_number LINE', 'Specify the line number of a single example to run') do |o|
+          options[:line_number] = o
+        end
+
+        parser.on('-p', '--profile', 'Enable profiling of examples with output of the top 10 slowest examples') do |o|
+          options[:profile_examples] = o
+        end
+
+        parser.on('-r', '--require PATH', 'Require a file') do |path|
+          options[:requires] ||= []
+          options[:requires] << path
+        end
+
+        parser.on('-v', '--version', 'Show version') do
+          puts RSpec::Core::Version::STRING
+          exit
+        end
+
+        parser.on('-X', '--drb', 'Run examples via DRb') do |o|
+          options[:drb] = true
+        end
+
+        parser.on('--configure COMMAND', 'Generate configuration files') do |cmd|
+          CommandLineConfiguration.new(cmd).run
+          exit
+        end
+
+        parser.on('--drb-port [PORT]', 'Port to connect to on the DRb server') do |o|
+          options[:drb_port] = o.to_i
+        end
+
+        parser.on('--autotest') do |o|
+          options[:autotest] = true
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.8/gems/rspec-core-2.0.0/lib/rspec/core/pending.rb

@@ -0,0 +1,19 @@
+module RSpec
+  module Core
+    module Pending
+      def pending(message = 'No reason given')
+        example.metadata[:pending] = true
+        example.metadata[:execution_result][:pending_message] = message
+        if block_given?
+          begin
+            result = yield
+            example.metadata[:pending] = false
+          rescue Exception => e
+          end
+          raise RSpec::Core::PendingExampleFixedError.new if result
+        end
+        throw :pending_declared_in_example, message
+      end
+    end
+  end
+end