dxruby_rp5 0.0.1

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

@@ -0,0 +1,181 @@
+require "spec_helper"
+require "rspec/core/rake_task"
+require 'tempfile'
+
+module RSpec::Core
+  describe RakeTask do
+    let(:task) { RakeTask.new }
+
+    def ruby
+      FileUtils::RUBY
+    end
+
+    def with_rcov
+      task.rcov = true
+      yield
+    end
+
+    def spec_command
+      task.__send__(:spec_command)
+    end
+
+    context "with a name passed to the constructor" do
+      let(:task) { RakeTask.new(:task_name) }
+
+      it "correctly sets the name" do
+        expect(task.name).to eq :task_name
+      end
+    end
+
+    context "with args passed to the rake task" do
+      it "correctly passes along task arguments" do
+        task = RakeTask.new(:rake_task_args, :files) do |t, args|
+          expect(args[:files]).to eq "first_spec.rb"
+        end
+
+        task.should_receive(:run_task) { true }
+        expect(Rake.application.invoke_task("rake_task_args[first_spec.rb]")).to be_true
+      end
+    end
+
+    context "default" do
+      it "renders rspec" do
+        expect(spec_command).to match(/^#{ruby} -S rspec/)
+      end
+    end
+
+    context "with rcov" do
+      it "renders rcov" do
+        with_rcov do
+          expect(spec_command).to match(/^#{ruby} -S rcov/)
+        end
+      end
+    end
+
+    context "with ruby options" do
+      it "renders them before -S" do
+          task.ruby_opts = "-w"
+          expect(spec_command).to match(/^#{ruby} -w -S rspec/)
+      end
+    end
+
+    context "with rcov_opts" do
+      context "with rcov=false (default)" do
+        it "does not add the rcov options to the command" do
+          task.rcov_opts = '--exclude "mocks"'
+          expect(spec_command).not_to match(/--exclude "mocks"/)
+        end
+      end
+
+      context "with rcov=true" do
+        it "renders them after rcov" do
+          task.rcov = true
+          task.rcov_opts = '--exclude "mocks"'
+          expect(spec_command).to match(/rcov.*--exclude "mocks"/)
+        end
+
+        it "ensures that -Ispec:lib is in the resulting command" do
+          task.rcov = true
+          task.rcov_opts = '--exclude "mocks"'
+          expect(spec_command).to match(/rcov.*-Ispec:lib/)
+        end
+      end
+    end
+
+    context "with rspec_opts" do
+      context "with rcov=true" do
+        it "adds the rspec_opts after the rcov_opts and files" do
+          task.stub(:files_to_run) { "this.rb that.rb" }
+          task.rcov = true
+          task.rspec_opts = "-Ifoo"
+          expect(spec_command).to match(/this.rb that.rb -- -Ifoo/)
+        end
+      end
+      context "with rcov=false (default)" do
+        it "adds the rspec_opts" do
+          task.rspec_opts = "-Ifoo"
+          expect(spec_command).to match(/rspec.*-Ifoo/)
+        end
+      end
+    end
+
+    def specify_consistent_ordering_of_files_to_run(pattern, task)
+      orderings = [
+        %w[ a/1.rb a/2.rb a/3.rb ],
+        %w[ a/2.rb a/1.rb a/3.rb ],
+        %w[ a/3.rb a/2.rb a/1.rb ]
+      ].map do |files|
+        FileList.should_receive(:[]).with(pattern) { files }
+        task.__send__(:files_to_run)
+      end
+
+      expect(orderings.uniq.size).to eq(1)
+    end
+
+    context "with SPEC env var set" do
+      it "sets files to run" do
+        with_env_vars 'SPEC' => 'path/to/file' do
+          expect(task.__send__(:files_to_run)).to eq(["path/to/file"])
+        end
+      end
+
+      it "sets the files to run in a consistent order, regardless of the underlying FileList ordering" do
+        with_env_vars 'SPEC' => 'a/*.rb' do
+          specify_consistent_ordering_of_files_to_run('a/*.rb', task)
+        end
+      end
+    end
+
+    it "sets the files to run in a consistent order, regardless of the underlying FileList ordering" do
+      task = RakeTask.new(:consistent_file_order) do |t|
+        t.pattern = 'a/*.rb'
+      end
+
+      # since the config block is deferred til task invocation, must fake
+      # calling the task so the expected pattern is picked up
+      task.should_receive(:run_task) { true }
+      expect(Rake.application.invoke_task(task.name)).to be_true
+
+      specify_consistent_ordering_of_files_to_run('a/*.rb', task)
+    end
+
+    context "with paths with quotes or spaces" do
+      it "escapes the quotes and spaces" do
+        task.pattern = File.join(Dir.tmpdir, "*spec.rb")
+        ["first_spec.rb", "second_\"spec.rb", "third_\'spec.rb", "fourth spec.rb"].each do |file_name|
+          FileUtils.touch(File.join(Dir.tmpdir, file_name))
+        end
+        expect(task.__send__(:files_to_run).sort).to eq([
+          File.join(Dir.tmpdir, "first_spec.rb"),
+          File.join(Dir.tmpdir, "fourth\\ spec.rb"),
+          File.join(Dir.tmpdir, "second_\\\"spec.rb"),
+          File.join(Dir.tmpdir, "third_\\\'spec.rb")
+        ])
+      end
+    end
+
+    context "with paths including symlinked directories" do
+      it "finds the files" do
+        project_dir = File.join(Dir.tmpdir, "project")
+        FileUtils.rm_rf project_dir
+
+        foos_dir = File.join(project_dir, "spec/foos")
+        FileUtils.mkdir_p foos_dir
+        FileUtils.touch(File.join(foos_dir, "foo_spec.rb"))
+
+        bars_dir = File.join(Dir.tmpdir, "shared/spec/bars")
+        FileUtils.mkdir_p bars_dir
+        FileUtils.touch(File.join(bars_dir, "bar_spec.rb"))
+
+        FileUtils.ln_s bars_dir, File.join(project_dir, "spec/bars")
+
+        FileUtils.cd(project_dir) do
+          expect(RakeTask.new.__send__(:files_to_run).sort).to eq([
+            "./spec/bars/bar_spec.rb",
+            "./spec/foos/foo_spec.rb"
+          ])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require "spec_helper"
+
+module RSpec::Core
+  describe Reporter do
+    describe "abort" do
+      let(:formatter) { double("formatter") }
+      let(:example)   { double("example") }
+      let(:reporter)  { Reporter.new(formatter) }
+
+      %w[start_dump dump_pending dump_failures dump_summary close].each do |message|
+        it "sends #{message} to the formatter(s) that respond to message" do
+          formatter.should_receive(message)
+          reporter.abort(nil)
+        end
+
+        it "doesnt notify formatters about messages they dont implement" do
+          expect { reporter.abort(nil) }.to_not raise_error
+        end
+      end
+    end
+
+    context "given one formatter" do
+      it "passes messages to that formatter" do
+        formatter = double("formatter", :example_started => nil)
+        example = double("example")
+        reporter = Reporter.new(formatter)
+
+        formatter.should_receive(:example_started).
+          with(example)
+
+        reporter.example_started(example)
+      end
+
+      it "passes example_group_started and example_group_finished messages to that formatter in that order" do
+        order = []
+
+        formatter = double("formatter")
+        formatter.stub(:example_group_started) { |group| order << "Started: #{group.description}" }
+        formatter.stub(:example_group_finished) { |group| order << "Finished: #{group.description}" }
+
+        group = ExampleGroup.describe("root")
+        group.describe("context 1") do
+          example("ignore") {}
+        end
+        group.describe("context 2") do
+          example("ignore") {}
+        end
+
+        group.run(Reporter.new(formatter))
+
+        expect(order).to eq([
+           "Started: root",
+           "Started: context 1",
+           "Finished: context 1",
+           "Started: context 2",
+           "Finished: context 2",
+           "Finished: root"
+        ])
+      end
+    end
+
+    context "given an example group with no examples" do
+      it "does not pass example_group_started or example_group_finished to formatter" do
+        formatter = double("formatter")
+        formatter.should_not_receive(:example_group_started)
+        formatter.should_not_receive(:example_group_finished)
+
+        group = ExampleGroup.describe("root")
+
+        group.run(Reporter.new(formatter))
+      end
+    end
+
+    context "given multiple formatters" do
+      it "passes messages to all formatters" do
+        formatters = (1..2).map { double("formatter", :example_started => nil) }
+        example = double("example")
+        reporter = Reporter.new(*formatters)
+
+        formatters.each do |formatter|
+          formatter.
+            should_receive(:example_started).
+            with(example)
+        end
+
+        reporter.example_started(example)
+      end
+    end
+
+    describe "#report" do
+      it "supports one arg (count)" do
+        Reporter.new.report(1) {}
+      end
+
+      it "supports two args (count, seed)" do
+        Reporter.new.report(1, 2) {}
+      end
+
+      it "yields itself" do
+        reporter = Reporter.new
+        yielded = nil
+        reporter.report(3) {|r| yielded = r}
+        expect(yielded).to eq(reporter)
+      end
+    end
+
+    describe "#register_listener" do
+      let(:reporter) { Reporter.new }
+      let(:listener) { double("listener", :start => nil) }
+
+      before { reporter.register_listener listener, :start }
+
+      it 'will register the listener to specified notifications' do
+        expect(reporter.registered_listeners :start).to eq [listener]
+      end
+
+      it 'will send notifications when a subscribed event is triggered' do
+        listener.should_receive(:start).with(42)
+        reporter.start 42
+      end
+    end
+
+    describe "timing" do
+      it "uses RSpec::Core::Time as to not be affected by changes to time in examples" do
+        formatter = double(:formatter)
+        duration = nil
+        formatter.stub(:dump_summary) do |dur, _, _, _|
+          duration = dur
+        end
+
+        reporter = Reporter.new formatter
+        reporter.start 1
+        Time.stub(:now => ::Time.utc(2012, 10, 1))
+
+
+        reporter.finish 1234
+        expect(duration).to be < 0.2
+      end
+    end
+  end
+end

data/spec/vendor/rspec-core-2.14.7/spec/rspec/core/resources/a_spec.rb

@@ -0,0 +1 @@
+# Empty - used by ../options_spec.rb

data/spec/vendor/rspec-core-2.14.7/spec/rspec/core/resources/custom_example_group_runner.rb

@@ -0,0 +1,14 @@
+module Custom
+  class ExampleGroupRunner
+    attr_reader :options, :arg
+    def initialize(options, arg)
+      @options, @arg = options, arg
+    end
+
+    def load_files(files)
+    end
+
+    def run
+    end
+  end
+end

data/spec/vendor/rspec-core-2.14.7/spec/rspec/core/resources/formatter_specs.rb

@@ -0,0 +1,60 @@
+# Deliberately named _specs.rb to avoid being loaded except when specified
+
+describe "pending spec with no implementation" do
+  it "is pending"
+end
+
+describe "pending command with block format" do
+  context "with content that would fail" do
+    it "is pending" do
+      pending do
+        expect(1).to eq(2)
+      end
+    end
+  end
+
+  context "with content that would pass" do
+    it "fails" do
+      pending do
+        expect(1).to eq(1)
+      end
+    end
+  end
+end
+
+describe "passing spec" do
+  it "passes" do
+    expect(1).to eq(1)
+  end
+end
+
+describe "failing spec" do
+  it "fails" do
+    expect(1).to eq(2)
+  end
+end
+
+describe "a failing spec with odd backtraces" do
+  it "fails with a backtrace that has no file" do
+    require 'erb'
+
+    ERB.new("<%= raise 'foo' %>").result
+  end
+
+  it "fails with a backtrace containing an erb file" do
+    e = Exception.new
+
+    def e.backtrace
+      ["/foo.html.erb:1:in `<main>': foo (RuntimeError)",
+        "   from /lib/ruby/1.9.1/erb.rb:753:in `eval'"]
+    end
+
+    def e.message
+      # Redefining message steps around this behaviour
+      # on JRuby: http://jira.codehaus.org/browse/JRUBY-5637
+      self.class.name
+    end
+
+    raise e
+  end
+end

data/spec/vendor/rspec-core-2.14.7/spec/rspec/core/resources/utf8_encoded.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+module Custom
+  class ExampleUTF8ClassNameVarietà
+    def self.è
+      così = :però
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module RSpec::Matchers
+  def __method_with_super
+    super
+  end
+
+  module ModThatIncludesMatchers
+    include RSpec::Matchers
+  end
+
+  RSpec.configure do |c|
+    c.include RSpec::Matchers, :include_rspec_matchers => true
+    c.include ModThatIncludesMatchers, :include_mod_that_includes_rspec_matchers => true
+  end
+
+  describe self do
+    shared_examples_for "a normal module with a method that supers" do
+      it "raises the expected error (and not SystemStackError)" do
+        expect { __method_with_super }.to raise_error(NoMethodError) # there is no __method_with_super in an ancestor
+      end
+    end
+
+    it_behaves_like "a normal module with a method that supers"
+
+    context "when RSpec::Matchers has been included in an example group" do
+      include RSpec::Matchers
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when a module that includes RSpec::Matchers has been included in an example group" do
+      include RSpec::Matchers::ModThatIncludesMatchers
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when RSpec::Matchers is included via configuration", :include_rspec_matchers => true do
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when RSpec::Matchers is included in a module that is included via configuration", :include_mod_that_includes_rspec_matchers => true do
+      it_behaves_like "a normal module with a method that supers"
+    end
+  end
+end
+

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module RSpec
+  module Core
+    describe RubyProject do
+
+      describe "#determine_root" do
+
+        context "with ancestor containing spec directory" do
+          it "returns ancestor containing the spec directory" do
+            RubyProject.stub(:ascend_until).and_return('foodir')
+            expect(RubyProject.determine_root).to eq("foodir")
+          end
+        end
+
+        context "without ancestor containing spec directory" do
+          it "returns current working directory" do
+            RubyProject.stub(:find_first_parent_containing).and_return(nil)
+            expect(RubyProject.determine_root).to eq(".")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'rspec/core/drb_command_line'
+
+module RSpec::Core
+  describe Runner do
+    describe 'at_exit' do
+      it 'sets an at_exit hook if none is already set' do
+        RSpec::Core::Runner.stub(:installed_at_exit?).and_return(false)
+        RSpec::Core::Runner.stub(:running_in_drb?).and_return(false)
+        RSpec::Core::Runner.stub(:at_exit_hook_disabled?).and_return(false)
+        RSpec::Core::Runner.stub(:run).and_return(-1)
+        RSpec::Core::Runner.should_receive(:at_exit)
+        RSpec::Core::Runner.autorun
+      end
+
+      it 'does not set the at_exit hook if it is already set' do
+        RSpec::Core::Runner.stub(:installed_at_exit?).and_return(true)
+        RSpec::Core::Runner.stub(:running_in_drb?).and_return(false)
+        RSpec::Core::Runner.stub(:at_exit_hook_disabled?).and_return(false)
+        RSpec::Core::Runner.should_receive(:at_exit).never
+        RSpec::Core::Runner.autorun
+      end
+    end
+
+    describe "#run" do
+      let(:err) { StringIO.new }
+      let(:out) { StringIO.new }
+
+      it "tells RSpec to reset" do
+        RSpec.configuration.stub(:files_to_run => [])
+        RSpec.should_receive(:reset)
+        RSpec::Core::Runner.run([], err, out)
+      end
+
+      context "with --drb or -X" do
+
+        before(:each) do
+          @options = RSpec::Core::ConfigurationOptions.new(%w[--drb --drb-port 8181 --color])
+          RSpec::Core::ConfigurationOptions.stub(:new) { @options }
+        end
+
+        def run_specs
+          RSpec::Core::Runner.run(%w[ --drb ], err, out)
+        end
+
+        context 'and a DRb server is running' do
+          it "builds a DRbCommandLine and runs the specs" do
+            drb_proxy = double(RSpec::Core::DRbCommandLine, :run => true)
+            drb_proxy.should_receive(:run).with(err, out)
+
+            RSpec::Core::DRbCommandLine.should_receive(:new).and_return(drb_proxy)
+
+            run_specs
+          end
+        end
+
+        context 'and a DRb server is not running' do
+          before(:each) do
+            RSpec::Core::DRbCommandLine.should_receive(:new).and_raise(DRb::DRbConnError)
+          end
+
+          it "outputs a message" do
+            RSpec.configuration.stub(:files_to_run) { [] }
+            err.should_receive(:puts).with(
+              "No DRb server is running. Running in local process instead ..."
+            )
+            run_specs
+          end
+
+          it "builds a CommandLine and runs the specs" do
+            process_proxy = double(RSpec::Core::CommandLine, :run => 0)
+            process_proxy.should_receive(:run).with(err, out)
+
+            RSpec::Core::CommandLine.should_receive(:new).and_return(process_proxy)
+
+            run_specs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+require "spec_helper"
+
+describe RSpec::SharedContext do
+  it "is accessible as RSpec::Core::SharedContext" do
+    RSpec::Core::SharedContext
+  end
+
+  it "is accessible as RSpec::SharedContext" do
+    RSpec::SharedContext
+  end
+
+  it "supports before and after hooks" do
+    before_all_hook = false
+    before_each_hook = false
+    after_each_hook = false
+    after_all_hook = false
+    shared = Module.new do
+      extend RSpec::SharedContext
+      before(:all) { before_all_hook = true }
+      before(:each) { before_each_hook = true }
+      after(:each)  { after_each_hook = true }
+      after(:all)  { after_all_hook = true }
+    end
+    group = RSpec::Core::ExampleGroup.describe do
+      include shared
+      example { }
+    end
+
+    group.run
+
+    expect(before_all_hook).to be_true
+    expect(before_each_hook).to be_true
+    expect(after_each_hook).to be_true
+    expect(after_all_hook).to be_true
+  end
+
+  it "runs the before each hooks in configuration before those of the shared context" do
+    ordered_hooks = []
+    RSpec.configure do |c|
+      c.before(:each) { ordered_hooks << "config" }
+    end
+
+    shared_context("before each stuff", :example => :before_each_hook_order) do
+      before(:each) { ordered_hooks << "shared_context"}
+    end
+
+    group = RSpec::Core::ExampleGroup.describe :example => :before_each_hook_order do
+      before(:each) { ordered_hooks << "example_group" }
+      example {}
+    end
+
+    group.run
+
+    expect(ordered_hooks).to be == ["config", "shared_context", "example_group"]
+  end
+
+  it "supports let" do
+    shared = Module.new do
+      extend RSpec::SharedContext
+      let(:foo) { 'foo' }
+    end
+    group = RSpec::Core::ExampleGroup.describe do
+      include shared
+    end
+
+    expect(group.new.foo).to eq('foo')
+  end
+
+  it 'supports explicit subjects' do
+    shared = Module.new do
+      extend RSpec::SharedContext
+      subject { 17 }
+    end
+
+    group = RSpec::Core::ExampleGroup.describe do
+      include shared
+    end
+
+    expect(group.new.subject).to eq(17)
+  end
+
+  it 'supports `its` with an implicit subject' do
+    shared = Module.new do
+      extend RSpec::SharedContext
+      its(:size) { should eq 0 }
+    end
+
+    group = RSpec::Core::ExampleGroup.describe(Array) do
+      include shared
+    end
+
+    group.run
+    expect(group.children.first.examples.first.execution_result).to include(:status => "passed")
+  end
+
+  %w[describe context].each do |method_name|
+    it "supports nested example groups using #{method_name}" do
+      shared = Module.new do
+        extend RSpec::SharedContext
+        send(method_name, "nested using describe") do
+          example {}
+        end
+      end
+      group = RSpec::Core::ExampleGroup.describe do
+        include shared
+      end
+
+      group.run
+
+      expect(group.children.length).to eq(1)
+      expect(group.children.first.examples.length).to eq(1)
+    end
+  end
+end