gemrage 0.0.0

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

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+
+require 'rspec/core/deprecation'
+require 'rake'
+require 'rake/tasklib'
+
+module RSpec
+  module Core
+    class RakeTask < ::Rake::TaskLib
+
+      # Name of task.
+      #
+      # default:
+      #   :spec
+      attr_accessor :name
+
+      # Glob pattern to match files.
+      #
+      # default:
+      #   'spec/**/*_spec.rb'
+      attr_accessor :pattern
+
+      # Deprecated. Use ruby_opts="-w" instead.
+      # When true, requests that the specs be run with the warning flag set.
+      # e.g. "ruby -w"
+      #
+      # default:
+      #   false
+      attr_reader :warning
+
+      def warning=(true_or_false)
+        RSpec.deprecate("warning", 'ruby_opts="-w"')
+        @warning = true_or_false
+      end
+
+      # Whether or not to fail Rake when an error occurs (typically when examples fail).
+      #
+      # default:
+      #   true
+      attr_accessor :fail_on_error
+
+      # A message to print to stderr when there are failures.
+      attr_accessor :failure_message
+
+      # Use verbose output. If this is set to true, the task will print the
+      # executed spec command to stdout.
+      #
+      # default:
+      #   true
+      attr_accessor :verbose
+
+      # Use rcov for code coverage?
+      #
+      # default:
+      #   false
+      attr_accessor :rcov
+
+      # Path to rcov.
+      #
+      # defaults:
+      #   'rcov'
+      attr_accessor :rcov_path
+
+      # Command line options to pass to rcov.
+      #
+      # default:
+      #   nil
+      attr_accessor :rcov_opts
+
+      # Command line options to pass to ruby.
+      #
+      # default:
+      #   nil
+      attr_accessor :ruby_opts
+
+      # Path to rspec
+      #
+      # default:
+      #   'rspec'
+      attr_accessor :rspec_path
+
+      # Command line options to pass to rspec.
+      #
+      # default:
+      #   nil
+      attr_accessor :rspec_opts
+
+      # Deprecated. Use rspec_opts instead.
+      def spec_opts=(opts)
+        RSpec.deprecate("spec_opts","rspec_opts")
+        @rspec_opts = opts
+      end
+
+      def initialize(*args)
+        @name = args.shift || :spec
+        @pattern, @rcov_path, @rcov_opts, @ruby_opts, @rspec_opts = nil, nil, nil, nil, nil
+        @warning, @rcov = false, false
+        @verbose, @fail_on_error = true, true
+
+        yield self if block_given?
+
+        @rcov_path  ||= 'rcov'
+        @rspec_path ||= 'rspec'
+        @pattern    ||= './spec/**/*_spec.rb'
+
+        desc("Run RSpec code examples") unless ::Rake.application.last_comment
+
+        task name do
+          RakeFileUtils.send(:verbose, verbose) do
+            if files_to_run.empty?
+              puts "No examples matching #{pattern} could be found"
+            else
+              begin
+                ruby(spec_command)
+              rescue
+                puts failure_message if failure_message
+                raise("ruby #{spec_command} failed") if fail_on_error
+              end
+            end
+          end
+        end
+      end
+
+    private
+
+      def files_to_run # :nodoc:
+        if ENV['SPEC']
+          FileList[ ENV['SPEC'] ]
+        else
+          FileList[ pattern ].map { |f| %["#{f}"] }
+        end
+      end
+
+      def spec_command
+        @spec_command ||= begin
+                            cmd_parts = [ruby_opts]
+                            cmd_parts << "-w" if warning?
+                            cmd_parts << "-S"
+                            cmd_parts << "bundle exec" if bundler?
+                            cmd_parts << runner
+                            if rcov
+                              cmd_parts << ["-Ispec", rcov_opts]
+                            else
+                              cmd_parts << rspec_opts
+                            end
+                            cmd_parts << files_to_run
+                            if rcov && rspec_opts
+                              cmd_parts << ["--",  rspec_opts]
+                            end
+                            cmd_parts.flatten.compact.reject(&blank).join(" ")
+                          end
+      end
+
+    private
+
+      def runner
+        rcov ? rcov_path : rspec_path
+      end
+
+      def bundler?
+        File.exist?("./Gemfile")
+      end
+
+      def warning?
+        warning
+      end
+
+      def blank
+        lambda {|s| s == ""}
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module RSpec::Core
+  class Reporter
+    def initialize(*formatters)
+      @formatters = formatters
+      @example_count = @failure_count = @pending_count = 0
+    end
+
+    def report(count)
+      start(count)
+      begin
+        yield self
+      ensure
+        conclude
+      end
+    end
+
+    def conclude
+      begin
+        stop
+        notify :start_dump
+        notify :dump_pending
+        notify :dump_failures
+        notify :dump_summary, @duration, @example_count, @failure_count, @pending_count
+      ensure
+        notify :close
+      end
+    end
+
+    alias_method :abort, :conclude
+
+    def start(expected_example_count)
+      @start = Time.now
+      notify :start, expected_example_count
+    end
+
+    def message(message)
+      notify :message, message
+    end
+
+    def example_group_started(group)
+      notify :example_group_started, group
+    end
+
+    def example_group_finished(group)
+      notify :example_group_finished, group
+    end
+
+    def example_started(example)
+      @example_count += 1
+      notify :example_started, example
+    end
+
+    def example_passed(example)
+      notify :example_passed, example
+    end
+
+    def example_failed(example)
+      @failure_count += 1
+      notify :example_failed, example
+    end
+
+    def example_pending(example)
+      @pending_count += 1
+      notify :example_pending, example
+    end
+
+    def stop
+      @duration = Time.now - @start if @start
+      notify :stop
+    end
+
+    def notify(method, *args, &block)
+      @formatters.each do |formatter|
+        formatter.send method, *args, &block
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# This is borrowed (slightly modified) from Scott Taylor's
+# project_path project:
+#   http://github.com/smtlaissezfaire/project_path
+
+require 'pathname'
+
+module RSpec
+  module Core
+    module RubyProject
+      def add_to_load_path(*dirs)
+        dirs.map {|dir| add_dir_to_load_path(File.join(root, dir))}
+      end
+
+      def add_dir_to_load_path(dir) # :nodoc:
+        $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+      end
+
+      def root # :nodoc:
+        @project_root ||= determine_root
+      end
+
+      def determine_root # :nodoc:
+        find_first_parent_containing('spec') || '.'
+      end
+
+      def find_first_parent_containing(dir) # :nodoc:
+        ascend_until {|path| File.exists?(File.join(path, dir))}
+      end
+
+      def ascend_until(&block) # :nodoc:
+        Pathname(File.expand_path('.')).ascend do |path|
+          return path if block.call(path)
+        end
+      end
+
+      module_function :add_to_load_path
+      module_function :add_dir_to_load_path
+      module_function :root
+      module_function :determine_root
+      module_function :find_first_parent_containing
+      module_function :ascend_until
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'drb/drb'
+
+module RSpec
+  module Core
+    class Runner
+
+      def self.autorun
+        return if autorun_disabled? || installed_at_exit? || running_in_drb?
+        @installed_at_exit = true
+        at_exit { run(ARGV, $stderr, $stdout) ? exit(0) : exit(1) }
+      end
+
+      def self.autorun_disabled?
+        @autorun_disabled ||= false
+      end
+
+      def self.disable_autorun!
+        @autorun_disabled = true
+      end
+
+      def self.installed_at_exit?
+        @installed_at_exit ||= false
+      end
+
+      def self.running_in_drb?
+        (DRb.current_server rescue false) &&
+        !!((DRb.current_server.uri) =~ /druby\:\/\/127.0.0.1\:/)
+      end
+
+      def self.trap_interrupt
+        trap('INT') do
+          exit!(1) if RSpec.wants_to_quit
+          RSpec.wants_to_quit = true
+          STDERR.puts "\nExiting... Interrupt again to exit immediately."
+        end
+      end
+
+      def self.run(args, err, out)
+        trap_interrupt
+        options = ConfigurationOptions.new(args)
+        options.parse_options
+
+        if options.options[:drb]
+          run_over_drb(options, err, out) || run_in_process(options, err, out)
+        else
+          run_in_process(options, err, out)
+        end
+      end
+
+      def self.run_over_drb(options, err, out)
+        DRbCommandLine.new(options).run(err, out)
+      end
+
+      def self.run_in_process(options, err, out)
+        CommandLine.new(options, RSpec::configuration, RSpec::world).run(err, out)
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,52 @@
+module RSpec
+  module Core
+    module SharedExampleGroup
+
+      def share_examples_for(name, &block)
+        ensure_shared_example_group_name_not_taken(name)
+        RSpec.world.shared_example_groups[name] = block
+      end
+
+      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
+
+      alias :shared_examples_for :share_examples_for
+
+    private
+
+      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 ensure_shared_example_group_name_not_taken(name)
+        if RSpec.world.shared_example_groups.has_key?(name)
+          raise ArgumentError.new("Shared example group '#{name}' already exists")
+        end
+      end
+
+    end
+  end
+end
+
+include RSpec::Core::SharedExampleGroup

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

@@ -0,0 +1,171 @@
+require 'ostruct'
+
+module RSpec
+  module Core
+    module Subject
+
+      def self.included(kls)
+        kls.class_eval do
+          extend ClassMethods
+          alias_method :__should_for_example_group__,     :should
+          alias_method :__should_not_for_example_group__, :should_not
+        end
+      end
+
+      # Returns the subject defined by the example group. The subject block is
+      # only executed once per example, the result of which is cached and
+      # returned by any subsequent calls to +subject+.
+      #
+      # If a class is passed to +describe+ and no subject is explicitly
+      # declared in the example group, then +subject+ will return a new
+      # instance of that class.
+      #
+      # == Examples
+      #
+      #   # explicit subject defined by the subject method
+      #   describe Person do
+      #     subject { Person.new(:birthdate => 19.years.ago) }
+      #     it "should be eligible to vote" do
+      #       subject.should be_eligible_to_vote
+      #     end
+      #   end
+      #
+      #   # implicit subject => { Person.new }
+      #   describe Person do
+      #     it "should be eligible to vote" do
+      #       subject.should be_eligible_to_vote
+      #     end
+      #   end
+      def subject
+        @original_subject ||= instance_eval(&self.class.subject)
+      end
+
+      # When +should+ is called with no explicit receiver, the call is
+      # delegated to the object returned by +subject+. Combined with
+      # an implicit subject (see +subject+), this supports very concise
+      # expressions.
+      #
+      # == Examples
+      #
+      #   describe Person do
+      #     it { should be_eligible_to_vote }
+      #   end
+      def should(matcher=nil, message=nil)
+        self == subject ? self.__should_for_example_group__(matcher) : subject.should(matcher,message)
+      end
+
+      # Just like +should+, +should_not+ delegates to the subject (implicit or
+      # explicit) of the example group.
+      #
+      # == Examples
+      #
+      #   describe Person do
+      #     it { should_not be_eligible_to_vote }
+      #   end
+      def should_not(matcher=nil, message=nil)
+        self == subject ? self.__should_not_for_example_group__(matcher) : subject.should_not(matcher,message)
+      end
+
+      module ClassMethods
+        # Creates a nested example group named by the submitted +attribute+,
+        # and then generates an example using the submitted block.
+        #
+        #   # This ...
+        #   describe Array do
+        #     its(:size) { should == 0 }
+        #   end
+        #
+        #   # ... generates the same runtime structure as this:
+        #   describe Array do
+        #     describe "size" do
+        #       it "should == 0" do
+        #         subject.size.should == 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.
+        #   
+        #   describe Person do
+        #     let(:person) do
+        #       person = Person.new
+        #       person.phone_numbers << "555-1212"
+        #     end
+        #
+        #     its("phone_numbers.first") { should == "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.
+        #
+        #   describe "a configuration Hash" do
+        #     subject do
+        #       { :max_users => 3,
+        #         'admin' => :all_permissions }
+        #     end
+        #
+        #     its([:max_users]) { should == 3 }
+        #     its(['admin']) { should == :all_permissions }
+        #
+        #     # You can still access to its regular methods this way:
+        #     its(:keys) { should include(:max_users) }
+        #     its(:count) { should == 2 }
+        #   end
+        def its(attribute, &block)
+          describe(attribute) do
+            example do
+              self.class.class_eval do
+                define_method(:subject) do
+                  if super().is_a?(Hash) && attribute.is_a?(Array)
+                    OpenStruct.new(super()).send(attribute.first)
+                  else
+                    attribute.to_s.split('.').inject(super()) do |target, method|
+                      target.send(method)
+                    end
+                  end
+                end
+              end
+              instance_eval(&block)
+            end
+          end
+        end
+
+        # Defines an explicit subject for an example group which can then be the
+        # implicit receiver (through delegation) of calls to +should+.
+        #
+        # == Examples
+        #
+        #   describe CheckingAccount, "with $50" do
+        #     subject { CheckingAccount.new(:amount => 50, :currency => :USD) }
+        #     it { should have_a_balance_of(50, :USD) }
+        #     it { should_not be_overdrawn }
+        #   end
+        #
+        # See +ExampleMethods#should+ for more information about this approach.
+        def subject(&block)
+          block ? @explicit_subject_block = block : explicit_subject || implicit_subject
+        end
+
+        attr_reader :explicit_subject_block # :nodoc:
+
+      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 = describes || description
+          Class === described ? proc { described.new } : proc { described }
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module RSpec # :nodoc:
+  module Core # :nodoc:
+    module Version # :nodoc:
+      STRING = '2.0.0'
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module RSpec
+  module Core
+    class World
+
+      attr_reader :example_groups, :filtered_examples, :wants_to_quit
+      attr_writer :wants_to_quit
+
+      def initialize(configuration=RSpec.configuration)
+        @configuration = configuration
+        @example_groups = []
+        @filtered_examples = Hash.new { |hash,group|
+          hash[group] = begin
+            examples = group.examples.dup
+            examples = apply_exclusion_filters(examples, exclusion_filter) if exclusion_filter
+            examples = apply_inclusion_filters(examples, inclusion_filter) if inclusion_filter
+            examples.uniq
+          end
+        }
+      end
+
+      def inclusion_filter
+        @configuration.filter
+      end
+
+      def exclusion_filter
+        @configuration.exclusion_filter
+      end
+
+      def configure_group(group)
+        @configuration.configure_group(group)
+      end
+
+      def shared_example_groups
+        @shared_example_groups ||= {}
+      end
+
+      def example_count
+        example_groups.collect {|g| g.descendants}.flatten.inject(0) { |sum, g| sum += g.filtered_examples.size }
+      end
+
+      def apply_inclusion_filters(examples, conditions={})
+        examples.select(&all_apply?(conditions))
+      end
+
+      alias_method :find, :apply_inclusion_filters
+
+      def apply_exclusion_filters(examples, conditions={})
+        examples.reject(&all_apply?(conditions))
+      end
+
+      def preceding_declaration_line(filter_line)
+        declaration_line_numbers.inject(nil) do |highest_prior_declaration_line, line|
+          line <= filter_line ? line : highest_prior_declaration_line
+        end
+      end
+
+      def announce_inclusion_filter
+        if inclusion_filter
+          if @configuration.run_all_when_everything_filtered? && RSpec.world.example_count.zero?
+            @configuration.reporter.message "No examples were matched by #{inclusion_filter.inspect}, running all"
+            @configuration.clear_inclusion_filter
+            filtered_examples.clear
+          else
+            @configuration.reporter.message "Run filtered using #{inclusion_filter.inspect}"
+          end
+        end
+      end
+      
+      def announce_exclusion_filter
+        if exclusion_filter && RSpec.world.example_count.zero?
+          @configuration.reporter.message(
+            "No examples were matched. Perhaps #{exclusion_filter.inspect} is excluding everything?")
+          example_groups.clear
+        end
+      end
+
+      include RSpec::Core::Hooks
+
+      def find_hook(hook, scope, group)
+        @configuration.find_hook(hook, scope, group)
+      end
+
+    private
+
+      def all_apply?(conditions)
+        lambda {|example| example.metadata.all_apply?(conditions)}
+      end
+
+      def declaration_line_numbers
+        @line_numbers ||= example_groups.inject([]) do |lines, g|
+          lines + g.declaration_line_numbers
+        end
+      end
+
+    end
+  end
+end