messagebus_ruby_api 0.4.7 → 0.4.8

data/spec/ruby/1.9.1/gems/rspec-core-2.5.1/lib/rspec/core/reporter.rb

@@ -1,79 +0,0 @@
-module RSpec::Core
-  class Reporter
-    def initialize(*formatters)
-      @formatters = formatters
-      @example_count = @failure_count = @pending_count = 0
-      @duration = @start = nil
-    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/spec/ruby/1.9.1/gems/rspec-core-2.5.1/lib/rspec/core/ruby_project.rb

@@ -1,44 +0,0 @@
-# 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 # :nodoc:
-        Pathname(File.expand_path('.')).ascend do |path|
-          return path if yield(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/spec/ruby/1.9.1/gems/rspec-core-2.5.1/lib/rspec/core/runner.rb

@@ -1,61 +0,0 @@
-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/spec/ruby/1.9.1/gems/rspec-core-2.5.1/lib/rspec/core/shared_context.rb

@@ -1,16 +0,0 @@
-module RSpec
-  module Core
-    module SharedContext
-      include Hooks
-
-      def included(group)
-        [:before, :after].each do |type|
-          [:all, :each].each do |scope|
-            group.hooks[type][scope].concat hooks[type][scope]
-          end
-        end
-      end
-
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-core-2.5.1/lib/rspec/core/shared_example_group.rb

@@ -1,53 +0,0 @@
-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
-
-      alias :shared_examples_for :share_examples_for
-
-      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 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/spec/ruby/1.9.1/gems/rspec-core-2.5.1/lib/rspec/core/subject.rb

@@ -1,177 +0,0 @@
-require 'ostruct'
-
-module RSpec
-  module Core
-    module Subject
-      module InstanceMethods
-
-        # 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
-          if defined?(@original_subject)
-            @original_subject
-          else
-            @original_subject = instance_eval(&self.class.subject)
-          end
-        end
-
-        begin
-          require 'rspec/expectations/extensions/kernel'
-          alias_method :__should_for_example_group__,     :should
-          alias_method :__should_not_for_example_group__, :should_not
-
-          # 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
-        rescue LoadError
-        end
-      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
-        #     subject do
-        #       Person.new.tap do |person|
-        #         person.phone_numbers << "555-1212"
-        #       end
-        #     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
-                  @_subject ||= 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/spec/ruby/1.9.1/gems/rspec-core-2.5.1/lib/rspec/core/version.rb

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

data/spec/ruby/1.9.1/gems/rspec-core-2.5.1/lib/rspec/core/world.rb

@@ -1,102 +0,0 @@
-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 register(example_group)
-        example_groups << example_group
-        example_group
-      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(&apply?(:any?, conditions))
-      end
-
-      alias_method :find, :apply_inclusion_filters
-
-      def apply_exclusion_filters(examples, conditions={})
-        examples.reject(&apply?(:any?, 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, example = nil)
-        @configuration.find_hook(hook, scope, group, example)
-      end
-
-    private
-
-      def apply?(predicate, conditions)
-        lambda {|example| example.metadata.apply?(predicate, conditions)}
-      end
-
-      def declaration_line_numbers
-        @line_numbers ||= example_groups.inject([]) do |lines, g|
-          lines + g.declaration_line_numbers
-        end
-      end
-
-    end
-  end
-end