dxruby_rp5 0.0.1

data/spec/vendor/rspec-core-2.14.7/spec/rspec/core/shared_example_group/collection_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module RSpec::Core::SharedExampleGroup
+  describe Collection do
+
+    # this represents:
+    #
+    # shared_examples "top level group"
+    #
+    # context do
+    #   shared_examples "nested level one"
+    # end
+    #
+    # context do
+    #   shared_examples "nested level two"
+    # end
+    #
+    let(:examples) do
+      Hash.new { |hash,k| hash[k] = Hash.new }.tap do |hash|
+        hash["main"]     = { "top level group"  => example_1 }
+        hash["nested 1"] = { "nested level one" => example_2 }
+        hash["nested 2"] = { "nested level two" => example_3 }
+      end
+    end
+    (1..3).each { |num| let("example_#{num}") { double "example #{num}" } }
+
+    context 'setup with one source, which is the top level' do
+
+      let(:collection) { Collection.new ['main'], examples }
+
+      it 'fetches examples from the top level' do
+        expect(collection['top level group']).to eq example_1
+      end
+
+      it 'fetches examples across the nested context' do
+        RSpec.stub(:warn_deprecation)
+        expect(collection['nested level two']).to eq example_3
+      end
+
+      it 'warns about deprecation when you fetch across nested contexts' do
+        RSpec.should_receive(:warn_deprecation)
+        collection['nested level two']
+      end
+    end
+
+    context 'setup with multiple sources' do
+
+      let(:collection) { Collection.new ['main','nested 1'], examples }
+
+      it 'fetches examples from the context' do
+        expect(collection['nested level one']).to eq example_2
+      end
+
+      it 'fetches examples from main' do
+        expect(collection['top level group']).to eq example_1
+      end
+
+      it 'fetches examples across the nested context' do
+        RSpec.stub(:warn_deprecation)
+        expect(collection['nested level two']).to eq example_3
+      end
+
+      it 'warns about deprecation when you fetch across nested contexts' do
+        RSpec.should_receive(:warn_deprecation)
+        collection['nested level two']
+      end
+
+    end
+  end
+end

data/spec/vendor/rspec-core-2.14.7/spec/rspec/core/shared_example_group_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+module RandomTopLevelModule
+  def self.setup!
+    shared_examples_for("top level in module") {}
+  end
+end
+
+module RSpec::Core
+  describe SharedExampleGroup do
+
+    ExampleModule = Module.new
+    ExampleClass = Class.new
+
+    it 'does not add a bunch of private methods to Module' do
+      seg_methods = RSpec::Core::SharedExampleGroup.private_instance_methods
+      expect(Module.private_methods & seg_methods).to eq([])
+    end
+
+    module SharedExampleGroup
+      describe Registry do
+        it "can safely be reset when there aren't any shared groups" do
+          expect { Registry.new.clear }.to_not raise_error
+        end
+      end
+    end
+
+    before(:all) do
+      # this is a work around as SharedExampleGroup is not world safe
+      RandomTopLevelModule.setup!
+    end
+
+    %w[share_examples_for shared_examples_for shared_examples shared_context].each do |shared_method_name|
+      describe shared_method_name do
+        it "is exposed to the global namespace" do
+          expect(Kernel).to respond_to(shared_method_name)
+        end
+
+        it "displays a warning when adding a second shared example group with the same name" do
+          group = ExampleGroup.describe('example group')
+          group.send(shared_method_name, 'some shared group') {}
+          original_declaration = [__FILE__, __LINE__ - 1].join(':')
+
+          warning = nil
+          Kernel.stub(:warn) { |msg| warning = msg }
+
+          group.send(shared_method_name, 'some shared group') {}
+          second_declaration = [__FILE__, __LINE__ - 1].join(':')
+          expect(warning).to include('some shared group', original_declaration, second_declaration)
+        end
+
+        it 'works with top level defined examples in modules' do
+          expect(RSpec::configuration.reporter).to_not receive(:deprecation)
+          group = ExampleGroup.describe('example group') { include_context 'top level in module' }
+        end
+
+        ["name", :name, ExampleModule, ExampleClass].each do |object|
+          type = object.class.name.downcase
+          context "given a #{type}" do
+            it "captures the given #{type} and block in the collection of shared example groups" do
+              implementation = lambda {}
+              send(shared_method_name, object, &implementation)
+              expect(SharedExampleGroup.registry.shared_example_groups[self][object]).to eq implementation
+            end
+          end
+        end
+
+        context "given a hash" do
+          it "delegates extend on configuration" do
+            implementation = Proc.new { def bar; 'bar'; end }
+            send(shared_method_name, :foo => :bar, &implementation)
+            a = RSpec.configuration.include_or_extend_modules.first
+            expect(a[0]).to eq(:extend)
+            expect(Class.new.extend(a[1]).new.bar).to eq('bar')
+            expect(a[2]).to eq(:foo => :bar)
+          end
+        end
+
+        context "given a string and a hash" do
+          it "captures the given string and block in the World's collection of shared example groups" do
+            implementation = lambda {}
+            send(shared_method_name, "name", :foo => :bar, &implementation)
+            expect(SharedExampleGroup.registry.shared_example_groups[self]["name"]).to eq implementation
+          end
+
+          it "delegates extend on configuration" do
+            implementation = Proc.new { def bar; 'bar'; end }
+            send(shared_method_name, "name", :foo => :bar, &implementation)
+            a = RSpec.configuration.include_or_extend_modules.first
+            expect(a[0]).to eq(:extend)
+            expect(Class.new.extend(a[1]).new.bar).to eq('bar')
+            expect(a[2]).to eq(:foo => :bar)
+          end
+        end
+      end
+    end
+
+    describe "#share_as" do
+      before { allow(RSpec).to receive(:deprecate) }
+
+      it "is exposed to the global namespace" do
+        expect(Kernel).to respond_to("share_as")
+      end
+
+      it "adds examples to current example_group using include", :compat => 'rspec-1.2' do
+        share_as('Cornucopia') do
+          it "is plentiful" do
+            expect(5).to eq(4)
+          end
+        end
+        group = ExampleGroup.describe('group') { include Cornucopia }
+        phantom_group = group.children.first
+        expect(phantom_group.description).to eql("")
+        expect(phantom_group.metadata[:shared_group_name]).to eql('Cornucopia')
+        expect(phantom_group.examples.length).to eq(1)
+        expect(phantom_group.examples.first.metadata[:description]).to eq("is plentiful")
+      end
+    end
+  end
+end

data/spec/vendor/rspec-core-2.14.7/spec/rspec/core/world_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+class Bar; end
+class Foo; end
+
+module RSpec::Core
+
+  describe RSpec::Core::World do
+    let(:configuration) { RSpec::Core::Configuration.new }
+    let(:world) { RSpec::Core::World.new(configuration) }
+
+    describe '#reset' do
+      it 'clears #example_groups' do
+        world.example_groups << :example_group
+        world.reset
+        expect(world.example_groups).to be_empty
+      end
+    end
+
+    describe "#example_groups" do
+      it "contains all registered example groups" do
+        group = RSpec::Core::ExampleGroup.describe("group"){}
+        world.register(group)
+        expect(world.example_groups).to include(group)
+      end
+    end
+
+    describe "#preceding_declaration_line (again)" do
+      let(:group) do
+        RSpec::Core::ExampleGroup.describe("group") do
+
+          example("example") {}
+
+        end
+      end
+
+      let(:second_group) do
+        RSpec::Core::ExampleGroup.describe("second_group") do
+
+          example("second_example") {}
+
+        end
+      end
+
+      let(:group_declaration_line) { group.metadata[:example_group][:line_number] }
+      let(:example_declaration_line) { group_declaration_line + 2 }
+
+      context "with one example" do
+        before { world.register(group) }
+
+        it "returns nil if no example or group precedes the line" do
+          expect(world.preceding_declaration_line(group_declaration_line - 1)).to be_nil
+        end
+
+        it "returns the argument line number if a group starts on that line" do
+          expect(world.preceding_declaration_line(group_declaration_line)).to eq(group_declaration_line)
+        end
+
+        it "returns the argument line number if an example starts on that line" do
+          expect(world.preceding_declaration_line(example_declaration_line)).to eq(example_declaration_line)
+        end
+
+        it "returns line number of a group that immediately precedes the argument line" do
+          expect(world.preceding_declaration_line(group_declaration_line + 1)).to eq(group_declaration_line)
+        end
+
+        it "returns line number of an example that immediately precedes the argument line" do
+          expect(world.preceding_declaration_line(example_declaration_line + 1)).to eq(example_declaration_line)
+        end
+      end
+
+      context "with two exaples and the second example is registre first" do
+        let(:second_group_declaration_line) { second_group.metadata[:example_group][:line_number] }
+
+        before do
+          world.register(second_group)
+          world.register(group)
+        end
+
+        it 'return line number of group if a group start on that line' do
+          expect(world.preceding_declaration_line(second_group_declaration_line)).to eq(second_group_declaration_line)
+        end
+      end
+    end
+
+    describe "#announce_filters" do
+      let(:reporter) { double('reporter').as_null_object }
+      before { world.stub(:reporter) { reporter } }
+
+      context "with no examples" do
+        before { world.stub(:example_count) { 0 } }
+
+        context "with no filters" do
+          it "announces" do
+            reporter.should_receive(:message).
+              with("No examples found.")
+            world.announce_filters
+          end
+        end
+
+        context "with an inclusion filter" do
+          it "announces" do
+            configuration.filter_run_including :foo => 'bar'
+            reporter.should_receive(:message).
+              with(/All examples were filtered out/)
+            world.announce_filters
+          end
+        end
+
+        context "with an inclusion filter and run_all_when_everything_filtered" do
+          it "announces" do
+            configuration.stub(:run_all_when_everything_filtered?) { true }
+            configuration.filter_run_including :foo => 'bar'
+            reporter.should_receive(:message).
+              with(/All examples were filtered out/)
+            world.announce_filters
+          end
+        end
+
+        context "with an exclusion filter" do
+          it "announces" do
+            configuration.filter_run_excluding :foo => 'bar'
+            reporter.should_receive(:message).
+              with(/All examples were filtered out/)
+            world.announce_filters
+          end
+        end
+      end
+
+      context "with examples" do
+        before { world.stub(:example_count) { 1 } }
+
+        context "with no filters" do
+          it "does not announce" do
+            reporter.should_not_receive(:message)
+            world.announce_filters
+          end
+        end
+      end
+    end
+  end
+end

data/spec/vendor/rspec-core-2.14.7/spec/rspec/core_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe RSpec do
+  describe "::configuration" do
+    it "returns the same object every time" do
+      expect(RSpec.configuration).to equal(RSpec.configuration)
+    end
+  end
+
+  describe "::configuration=" do
+    it "sets the configuration object" do
+      configuration = RSpec::Core::Configuration.new
+
+      RSpec.configuration = configuration
+
+      expect(RSpec.configuration).to equal(configuration)
+    end
+  end
+
+  describe "::configure" do
+    it "yields the current configuration" do
+      RSpec.configure do |config|
+        expect(config).to equal(RSpec::configuration)
+      end
+    end
+  end
+
+  describe "::world" do
+    it "returns the same object every time" do
+      expect(RSpec.world).to equal(RSpec.world)
+    end
+  end
+
+  describe "::world=" do
+    it "sets the world object" do
+      world = RSpec::Core::World.new
+
+      RSpec.world = world
+
+      expect(RSpec.world).to equal(world)
+    end
+  end
+
+  describe "::reset" do
+    it "resets the configuration and world objects" do
+      config_before_reset = RSpec.configuration
+      world_before_reset  = RSpec.world
+
+      RSpec.reset
+
+      expect(RSpec.configuration).not_to equal(config_before_reset)
+      expect(RSpec.world).not_to equal(world_before_reset)
+    end
+  end
+
+  # This is hard to test :(. Best way I could come up with was starting
+  # fresh ruby process w/o this stuff already loaded.
+  it "loads mocks and expectations when the constants are referenced" do
+    code = "$LOAD_PATH.replace(#{$LOAD_PATH.inspect}); " +
+           'require "rspec"; ' +
+           "puts RSpec::Mocks.name; " +
+           "puts RSpec::Expectations.name"
+
+    result = `ruby -e '#{code}'`.chomp
+    expect(result.split("\n")).to eq(%w[ RSpec::Mocks RSpec::Expectations ])
+  end
+
+  it 'correctly raises an error when an invalid const is referenced' do
+    expect {
+      RSpec::NotAConst
+    }.to raise_error(NameError, /uninitialized constant RSpec::NotAConst/)
+  end
+end
+

data/spec/vendor/rspec-core-2.14.7/spec/spec_helper.rb

@@ -0,0 +1,132 @@
+require 'rubygems'
+
+begin
+  require 'spork'
+rescue LoadError
+  module Spork
+    def self.prefork
+      yield
+    end
+
+    def self.each_run
+      yield
+    end
+  end
+end
+
+Spork.prefork do
+  require 'rspec/autorun'
+  require 'autotest/rspec2'
+  require 'aruba/api'
+
+  if RUBY_PLATFORM == 'java'
+    # Works around https://jira.codehaus.org/browse/JRUBY-5678
+    require 'fileutils'
+    ENV['TMPDIR'] = File.expand_path('../../tmp', __FILE__)
+    FileUtils.mkdir_p(ENV['TMPDIR'])
+  end
+
+  Dir['./spec/support/**/*.rb'].map {|f| require f}
+
+  class NullObject
+    private
+    def method_missing(method, *args, &block)
+      # ignore
+    end
+  end
+
+  module Sandboxing
+    def self.sandboxed(&block)
+      @orig_config = RSpec.configuration
+      @orig_world  = RSpec.world
+      new_config = RSpec::Core::Configuration.new
+      new_world  = RSpec::Core::World.new(new_config)
+      RSpec.configuration = new_config
+      RSpec.world = new_world
+      object = Object.new
+      object.extend(RSpec::Core::SharedExampleGroup)
+
+      (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+        alias_method :orig_run, :run
+        def run(reporter=nil)
+          orig_run(reporter || NullObject.new)
+        end
+      end
+
+      RSpec::Core::SandboxedMockSpace.sandboxed do
+        object.instance_eval(&block)
+      end
+    ensure
+      (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+        remove_method :run
+        alias_method :run, :orig_run
+        remove_method :orig_run
+      end
+
+      RSpec.configuration = @orig_config
+      RSpec.world = @orig_world
+    end
+  end
+
+  def in_editor?
+    ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
+  end
+
+  module EnvHelpers
+    def with_env_vars(vars)
+      original = ENV.to_hash
+      vars.each { |k, v| ENV[k] = v }
+
+      begin
+        yield
+      ensure
+        ENV.replace(original)
+      end
+    end
+
+    def without_env_vars(*vars)
+      original = ENV.to_hash
+      vars.each { |k| ENV.delete(k) }
+
+      begin
+        yield
+      ensure
+        ENV.replace(original)
+      end
+    end
+  end
+
+  RSpec.configure do |c|
+    # structural
+    c.alias_it_behaves_like_to 'it_has_behavior'
+    c.around {|example| Sandboxing.sandboxed { example.run }}
+    c.include(RSpecHelpers)
+    c.include Aruba::Api, :example_group => {
+      :file_path => /spec\/command_line/
+    }
+
+    c.expect_with :rspec do |expectations|
+      expectations.syntax = :expect
+    end
+
+    # runtime options
+    c.treat_symbols_as_metadata_keys_with_true_values = true
+    c.color = !in_editor?
+    c.filter_run :focus
+    c.include EnvHelpers
+    c.run_all_when_everything_filtered = true
+    c.filter_run_excluding :ruby => lambda {|version|
+      case version.to_s
+      when "!jruby"
+        RUBY_ENGINE == "jruby"
+      when /^> (.*)/
+        !(RUBY_VERSION.to_s > $1)
+      else
+        !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
+      end
+    }
+  end
+end
+
+Spork.each_run do
+end

data/spec/vendor/rspec-core-2.14.7/spec/support/config_options_helper.rb

@@ -0,0 +1,15 @@
+module ConfigOptionsHelper
+  extend RSpec::SharedContext
+
+  around(:each) { |e| without_env_vars('SPEC_OPTS', &e) }
+
+  def config_options_object(*args)
+    coo = RSpec::Core::ConfigurationOptions.new(args)
+    coo.parse_options
+    coo
+  end
+
+  def parse_options(*args)
+    config_options_object(*args).options
+  end
+end

data/spec/vendor/rspec-core-2.14.7/spec/support/helper_methods.rb

@@ -0,0 +1,36 @@
+module RSpecHelpers
+  def relative_path(path)
+    RSpec::Core::Metadata.relative_path(path)
+  end
+
+  def ignoring_warnings
+    original = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original
+    result
+  end
+
+  def safely
+    Thread.new do
+      ignoring_warnings { $SAFE = 3 }
+      yield
+    end.join
+
+    # $SAFE is not supported on Rubinius
+    unless defined?(Rubinius)
+      expect($SAFE).to eql 0 # $SAFE should not have changed in this thread.
+    end
+  end
+
+  def expect_deprecation_with_call_site(file, line)
+    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
+      expect(options[:call_site]).to include([file, line].join(':'))
+    end
+  end
+
+  def allow_deprecation
+    allow(RSpec.configuration.reporter).to receive(:deprecation)
+  end
+
+end

data/spec/vendor/rspec-core-2.14.7/spec/support/in_sub_process.rb

@@ -0,0 +1,37 @@
+module InSubProcess
+  if RUBY_PLATFORM == 'java'
+    def in_sub_process
+      pending "This spec requires forking to work properly, " +
+              "and JRuby does not support forking"
+    end
+  else
+    # Useful as a way to isolate a global change to a subprocess.
+    def in_sub_process
+      readme, writeme = IO.pipe
+
+      pid = Process.fork do
+        exception = nil
+        begin
+          yield
+        rescue Exception => e
+          exception = e
+        end
+
+        writeme.write Marshal.dump(exception)
+
+        readme.close
+        writeme.close
+        exit! # prevent at_exit hooks from running (e.g. minitest)
+      end
+
+      writeme.close
+      Process.waitpid(pid)
+
+      exception = Marshal.load(readme.read)
+      readme.close
+
+      raise exception if exception
+    end
+  end
+end
+

data/spec/vendor/rspec-core-2.14.7/spec/support/isolate_load_path_mutation.rb

@@ -0,0 +1,6 @@
+shared_context "isolate load path mutation" do
+  original_load_path = nil
+  before { original_load_path = $LOAD_PATH.dup }
+  after  { $LOAD_PATH.replace(original_load_path) }
+end
+

data/spec/vendor/rspec-core-2.14.7/spec/support/isolated_directory.rb

@@ -0,0 +1,10 @@
+require 'tmpdir'
+require 'fileutils'
+
+shared_context "isolated directory", :isolated_directory => true do
+  around do |ex|
+    Dir.mktmpdir do |tmp_dir|
+      Dir.chdir(tmp_dir, &ex)
+    end
+  end
+end

data/spec/vendor/rspec-core-2.14.7/spec/support/isolated_home_directory.rb

@@ -0,0 +1,16 @@
+require 'tmpdir'
+require 'fileutils'
+
+shared_context "isolated home directory", :isolated_home => true do
+  around do |ex|
+    Dir.mktmpdir do |tmp_dir|
+      original_home = ENV['HOME']
+      begin
+        ENV['HOME'] = tmp_dir
+        ex.call
+      ensure
+        ENV['HOME'] = original_home
+      end
+    end
+  end
+end