messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,32 +0,0 @@
-require 'rspec/core/formatters/base_text_formatter'
-module RSpec
-  module Core
-    module Formatters
-
-      class ProgressFormatter < BaseTextFormatter
-
-        def example_passed(example)
-          super(example)
-          output.print green('.')
-        end
-
-        def example_pending(example)
-          super(example)
-          output.print yellow('*')
-        end
-
-        def example_failed(example)
-          super(example)
-          output.print red('F')
-        end
-
-        def start_dump
-          super()
-          output.puts
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-module RSpec
-  module Core
-    module Formatters
-      # This class extracts code snippets by looking at the backtrace of the passed error
-      class SnippetExtractor #:nodoc:
-        class NullConverter; def convert(code, pre); code; end; end #:nodoc:
-        begin; require 'syntax/convertors/html'; @@converter = Syntax::Convertors::HTML.for_syntax "ruby"; rescue LoadError => e; @@converter = NullConverter.new; end
-
-        def snippet(error)
-          raw_code, line = snippet_for(error.backtrace[0])
-          highlighted = @@converter.convert(raw_code, false)
-          highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter)
-          post_process(highlighted, line)
-        end
-
-        def snippet_for(error_line)
-          if error_line =~ /(.*):(\d+)/
-            file = $1
-            line = $2.to_i
-            [lines_around(file, line), line]
-          else
-            ["# Couldn't get snippet for #{error_line}", 1]
-          end
-        end
-
-        def lines_around(file, line)
-          if File.file?(file)
-            lines = File.read(file).split("\n")
-            min = [0, line-3].max
-            max = [line+1, lines.length-1].min
-            selected_lines = []
-            selected_lines.join("\n")
-            lines[min..max].join("\n")
-          else
-            "# Couldn't get snippet for #{file}"
-          end
-        end
-
-        def post_process(highlighted, offending_line)
-          new_lines = []
-          highlighted.split("\n").each_with_index do |line, i|
-            new_line = "<span class=\"linenum\">#{offending_line+i-2}</span>#{line}"
-            new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
-            new_lines << new_line
-          end
-          new_lines.join("\n")
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-require 'rspec/core/formatters/html_formatter'
-
-module RSpec
-  module Core
-    module Formatters
-      # Formats backtraces so they're clickable by TextMate
-      class TextMateFormatter < HtmlFormatter
-        def backtrace_line(line)
-          if line = super(line)
-            line.sub!(/([^:]*\.e?rb):(\d*)/) do
-              "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
-            end
-
-            line
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,149 +0,0 @@
-module RSpec
-  module Core
-    module Hooks
-
-      class Hook
-        attr_reader :options
-
-        def initialize(options, &block)
-          @options = options
-          @block = block
-        end
-
-        def options_apply?(example_or_group)
-          !example_or_group || example_or_group.apply?(:all?, 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(example_or_group)
-          self.class.new(select {|hook| hook.options_apply?(example_or_group)})
-        end
-
-        def without_hooks_for(example_or_group)
-          self.class.new(reject {|hook| hook.options_apply?(example_or_group)})
-        end
-      end
-
-      class BeforeHooks < HookCollection
-        def run_all(example_group_instance)
-          each {|h| h.run_in(example_group_instance) } unless empty?
-        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) } unless empty?
-        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, example = nil)
-        find_hook(hook, scope, group, example).run_all(example_group_instance)
-      end
-
-      def find_hook(hook, scope, example_group_class, example = nil)
-        found_hooks = hooks[hook][scope].find_hooks_for(example || example_group_class)
-
-        # ensure we don't re-run :all hooks that were applied to any of the parent groups
-        if scope == :all
-          super_klass = example_group_class.superclass
-          while super_klass != RSpec::Core::ExampleGroup
-            found_hooks = found_hooks.without_hooks_for(super_klass)
-            super_klass = super_klass.superclass
-          end
-        end
-
-        found_hooks
-      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/spec/ruby/1.9.1/gems/rspec-core-2.5.1/lib/rspec/core/let.rb

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

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

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

@@ -1,187 +0,0 @@
-module RSpec
-  module Core
-    class Metadata < Hash
-
-      module LocationKeys
-        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)
-            self[key]
-          else
-            super
-          end
-        end
-
-        def location
-          "#{self[:file_path]}:#{self[:line_number]}"
-        end
-
-        def file_and_line_number
-          first_caller_from_outside_rspec =~ /(.+?):(\d+)(|:\d+)/
-          return [$1, $2.to_i]
-        end
-
-        def first_caller_from_outside_rspec
-          self[:caller].detect {|l| l !~ /\/lib\/rspec\/core/}
-        end
-      end
-
-      def initialize(superclass_metadata=nil)
-        @superclass_metadata = superclass_metadata
-        if @superclass_metadata
-          update(@superclass_metadata)
-          example_group = {:example_group => @superclass_metadata[:example_group]}
-        else
-          example_group = {}
-        end
-
-        store(:example_group, example_group.extend(LocationKeys))
-        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].store(:caller, user_metadata.delete(:caller) || caller)
-        self[:example_group].store(:describes, described_class_from(*args))
-        self[:example_group].store(:description, description_from(*args))
-        self[:example_group].store(:full_description, full_description_from(*args))
-        self[:example_group].store(:block, user_metadata.delete(:example_group_block))
-
-        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, user_metadata)
-        dup.extend(LocationKeys).configure_for_example(description, user_metadata)
-      end
-
-      def configure_for_example(description, user_metadata)
-        store(:description, description.to_s)
-        store(:full_description, "#{self[:example_group][:full_description]} #{self[:description]}")
-        store(:execution_result, {})
-        store(:caller, user_metadata.delete(:caller) || caller)
-        update(user_metadata)
-      end
-
-      def apply?(predicate, filters)
-        filters.send(predicate) 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=self)
-        case value
-        when Hash
-          value.all? { |k, v| apply_condition(k, v, metadata[key]) }
-        when Regexp
-          metadata[key] =~ value
-        when Proc
-          if value.arity == 2
-            # Pass the metadata hash to allow the proc to check if it even has the key.
-            # This is necessary for the implicit :if exclusion filter:
-            #   {            } # => run the example
-            #   { :if => nil } # => exclude the example
-            # The value of metadata[:if] is the same in these two cases but
-            # they need to be treated differently.
-            value.call(metadata[key], metadata) rescue false
-          else
-            value.call(metadata[key]) rescue false
-          end
-        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)
-        superclass_metadata[:example_group][:describes] || begin
-          args.first unless args.first.is_a?(String) || args.first.is_a?(Symbol)
-        end
-      end
-    end
-  end
-end