remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/rspec-core-2.12.2/spec/rspec/core/metadata_spec.rb

@@ -0,0 +1,486 @@
+require 'spec_helper'
+
+module RSpec
+  module Core
+    describe Metadata do
+
+      describe '.relative_path' do
+        let(:here) { File.expand_path(".") }
+        it "transforms absolute paths to relative paths" do
+          Metadata.relative_path(here).should == "."
+        end
+        it "transforms absolute paths to relative paths anywhere in its argument" do
+          Metadata.relative_path("foo #{here} bar").should == "foo . bar"
+        end
+        it "returns nil if passed an unparseable file:line combo" do
+          Metadata.relative_path("-e:1").should be_nil
+        end
+        # I have no idea what line = line.sub(/\A([^:]+:\d+)$/, '\\1') is supposed to do
+        it "gracefully returns nil if run in a secure thread" do
+          safely do
+            value = Metadata.relative_path(".")
+            # on some rubies, File.expand_path is not a security error, so accept "." as well
+            [nil, "."].should include(value)
+          end
+        end
+
+      end
+
+      describe "#process" do
+        Metadata::RESERVED_KEYS.each do |key|
+          it "prohibits :#{key} as a hash key" do
+            m = Metadata.new
+            expect do
+              m.process('group', key => {})
+            end.to raise_error(/:#{key} is not allowed/)
+          end
+        end
+
+        it "uses :caller if passed as part of the user metadata" do
+          m = Metadata.new
+          m.process('group', :caller => ['example_file:42'])
+          m[:example_group][:location].should eq("example_file:42")
+        end
+      end
+
+      describe "#filter_applies?" do
+        let(:parent_group_metadata) { Metadata.new.process('parent group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
+        let(:group_metadata) { Metadata.new(parent_group_metadata).process('group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
+        let(:example_metadata) { group_metadata.for_example('example', :caller => ["foo_spec.rb:#{__LINE__}"], :if => true) }
+        let(:next_example_metadata) { group_metadata.for_example('next_example', :caller => ["foo_spec.rb:#{example_line_number + 2}"]) }
+        let(:world) { World.new }
+
+        before { RSpec.stub(:world) { world } }
+
+        shared_examples_for "matching by line number" do
+          let(:preceeding_declaration_lines) {{
+            parent_group_metadata[:example_group][:line_number] => parent_group_metadata[:example_group][:line_number],
+            group_metadata[:example_group][:line_number] => group_metadata[:example_group][:line_number],
+            example_metadata[:line_number] => example_metadata[:line_number],
+            (example_metadata[:line_number] + 1) => example_metadata[:line_number],
+            (example_metadata[:line_number] + 2) => example_metadata[:line_number] + 2,
+          }}
+          before do
+            world.should_receive(:preceding_declaration_line).at_least(:once).and_return do |v|
+              preceeding_declaration_lines[v]
+            end
+          end
+
+          it "matches the group when the line_number is the example group line number" do
+            # this call doesn't really make sense since filter_applies? is only called
+            # for example metadata not group metadata
+            group_metadata.filter_applies?(condition_key, group_condition).should be_true
+          end
+
+          it "matches the example when the line_number is the grandparent example group line number" do
+            example_metadata.filter_applies?(condition_key, parent_group_condition).should be_true
+          end
+
+          it "matches the example when the line_number is the parent example group line number" do
+            example_metadata.filter_applies?(condition_key, group_condition).should be_true
+          end
+
+          it "matches the example when the line_number is the example line number" do
+            example_metadata.filter_applies?(condition_key, example_condition).should be_true
+          end
+
+          it "matches when the line number is between this example and the next" do
+            example_metadata.filter_applies?(condition_key, between_examples_condition).should be_true
+          end
+
+          it "does not match when the line number matches the next example" do
+            example_metadata.filter_applies?(condition_key, next_example_condition).should be_false
+          end
+        end
+
+        context "with a single line number" do
+          let(:condition_key){ :line_numbers }
+          let(:parent_group_condition) { [parent_group_metadata[:example_group][:line_number]] }
+          let(:group_condition) { [group_metadata[:example_group][:line_number]] }
+          let(:example_condition) { [example_metadata[:line_number]] }
+          let(:between_examples_condition) { [group_metadata[:example_group][:line_number] + 1] }
+          let(:next_example_condition) { [example_metadata[:line_number] + 2] }
+
+          it_has_behavior "matching by line number"
+        end
+
+        context "with multiple line numbers" do
+          let(:condition_key){ :line_numbers }
+          let(:parent_group_condition) { [-1, parent_group_metadata[:example_group][:line_number]] }
+          let(:group_condition) { [-1, group_metadata[:example_group][:line_number]] }
+          let(:example_condition) { [-1, example_metadata[:line_number]] }
+          let(:between_examples_condition) { [-1, group_metadata[:example_group][:line_number] + 1] }
+          let(:next_example_condition) { [-1, example_metadata[:line_number] + 2] }
+
+          it_has_behavior "matching by line number"
+        end
+
+        context "with locations" do
+          let(:condition_key){ :locations }
+          let(:parent_group_condition) do
+            {File.expand_path(parent_group_metadata[:example_group][:file_path]) => [parent_group_metadata[:example_group][:line_number]]}
+          end
+          let(:group_condition) do
+            {File.expand_path(group_metadata[:example_group][:file_path]) => [group_metadata[:example_group][:line_number]]}
+          end
+          let(:example_condition) do
+            {File.expand_path(example_metadata[:file_path]) => [example_metadata[:line_number]]}
+          end
+          let(:between_examples_condition) do
+            {File.expand_path(group_metadata[:example_group][:file_path]) => [group_metadata[:example_group][:line_number] + 1]}
+          end
+          let(:next_example_condition) do
+            {File.expand_path(example_metadata[:file_path]) => [example_metadata[:line_number] + 2]}
+          end
+
+          it_has_behavior "matching by line number"
+
+          it "ignores location filters for other files" do
+            example_metadata.filter_applies?(:locations, {"/path/to/other_spec.rb" => [3,5,7]}).should be_true
+          end
+        end
+
+        it "matches a proc with no arguments that evaluates to true" do
+          example_metadata.filter_applies?(:if, lambda { true }).should be_true
+        end
+
+        it "matches a proc that evaluates to true" do
+          example_metadata.filter_applies?(:if, lambda { |v| v }).should be_true
+        end
+
+        it "does not match a proc that evaluates to false" do
+          example_metadata.filter_applies?(:if, lambda { |v| !v }).should be_false
+        end
+
+        it "matches a proc with an arity of 2" do
+          example_metadata[:foo] = nil
+          example_metadata.filter_applies?(:foo, lambda { |v, m| m == example_metadata }).should be_true
+        end
+
+        it "raises an error when the proc has an incorrect arity" do
+          expect {
+            example_metadata.filter_applies?(:if, lambda { |a,b,c| true })
+          }.to raise_error(ArgumentError)
+        end
+
+        context "with an Array" do
+          let(:metadata_with_array) {
+            group_metadata.for_example('example_with_array', :tag => [:one, 2, 'three', /four/])
+          }
+
+          it "matches a symbol" do
+            metadata_with_array.filter_applies?(:tag, 'one').should be_true
+            metadata_with_array.filter_applies?(:tag, :one).should be_true
+            metadata_with_array.filter_applies?(:tag, 'two').should be_false
+          end
+
+          it "matches a string" do
+            metadata_with_array.filter_applies?(:tag, 'three').should be_true
+            metadata_with_array.filter_applies?(:tag, :three).should be_true
+            metadata_with_array.filter_applies?(:tag, 'tree').should be_false
+          end
+
+          it "matches an integer" do
+            metadata_with_array.filter_applies?(:tag, '2').should be_true
+            metadata_with_array.filter_applies?(:tag, 2).should be_true
+            metadata_with_array.filter_applies?(:tag, 3).should be_false
+          end
+
+          it "matches a regexp" do
+            metadata_with_array.filter_applies?(:tag, 'four').should be_true
+            metadata_with_array.filter_applies?(:tag, 'fourtune').should be_true
+            metadata_with_array.filter_applies?(:tag, 'fortune').should be_false
+          end
+
+          it "matches a proc that evaluates to true" do
+            metadata_with_array.filter_applies?(:tag, lambda { |values| values.include? 'three' }).should be_true
+          end
+
+          it "does not match a proc that evaluates to false" do
+            metadata_with_array.filter_applies?(:tag, lambda { |values| values.include? 'nothing' }).should be_false
+          end
+        end
+      end
+
+      describe "#for_example" do
+        let(:metadata)           { Metadata.new.process("group description") }
+        let(:mfe)                { metadata.for_example("example description", {:arbitrary => :options}) }
+        let(:line_number)        { __LINE__ - 1 }
+
+        it "stores the description" do
+          mfe.fetch(:description).should eq("example description")
+          mfe[:description].should eq("example description")
+        end
+
+        it "stores the full_description (group description + example description)" do
+          mfe.fetch(:full_description).should eq("group description example description")
+          mfe[:full_description].should eq("group description example description")
+        end
+
+        it "creates an empty execution result" do
+          mfe.fetch(:execution_result).should eq({})
+          mfe[:execution_result].should eq({})
+        end
+
+        it "extracts file path from caller" do
+          mfe.fetch(:file_path).should eq(relative_path(__FILE__))
+          mfe[:file_path].should eq(relative_path(__FILE__))
+        end
+
+        it "extracts line number from caller" do
+          mfe.fetch(:line_number).should eq(line_number)
+          mfe[:line_number].should eq(line_number)
+        end
+
+        it "extracts location from caller" do
+          mfe.fetch(:location).should eq("#{relative_path(__FILE__)}:#{line_number}")
+          mfe[:location].should eq("#{relative_path(__FILE__)}:#{line_number}")
+        end
+
+        it "uses :caller if passed as an option" do
+          example_metadata = metadata.for_example('example description', {:caller => ['example_file:42']})
+          example_metadata[:location].should eq("example_file:42")
+        end
+
+        it "merges arbitrary options" do
+          mfe.fetch(:arbitrary).should eq(:options)
+          mfe[:arbitrary].should eq(:options)
+        end
+
+        it "points :example_group to the same hash object" do
+          a = metadata.for_example("foo", {})[:example_group]
+          b = metadata.for_example("bar", {})[:example_group]
+          a[:description] = "new description"
+          b[:description].should eq("new description")
+        end
+      end
+
+      [:described_class, :describes].each do |key|
+        describe key do
+          context "with a String" do
+            it "returns nil" do
+              m = Metadata.new
+              m.process('group')
+
+              m[:example_group][key].should be_nil
+            end
+          end
+
+          context "with a Symbol" do
+            it "returns nil" do
+              m = Metadata.new
+              m.process(:group)
+
+              m[:example_group][key].should be_nil
+            end
+          end
+
+          context "with a class" do
+            it "returns the class" do
+              m = Metadata.new
+              m.process(String)
+
+              m[:example_group][key].should be(String)
+            end
+          end
+
+          context "in a nested group" do
+            it "returns the parent group's described class" do
+              sm = Metadata.new
+              sm.process(String)
+
+              m = Metadata.new(sm)
+              m.process(Array)
+
+              m[:example_group][key].should be(String)
+            end
+
+            it "returns own described class if parent doesn't have one" do
+              sm = Metadata.new
+              sm.process("foo")
+
+              m = Metadata.new(sm)
+              m.process(Array)
+
+              m[:example_group][key].should be(Array)
+            end
+
+            it "can override a parent group's described class" do
+              parent = Metadata.new
+              parent.process(String)
+
+              child = Metadata.new(parent)
+              child.process(Fixnum)
+              child[:example_group][key] = Hash
+
+              grandchild = Metadata.new(child)
+              grandchild.process(Array)
+
+              grandchild[:example_group][key].should be(Hash)
+              child[:example_group][key].should be(Hash)
+              parent[:example_group][key].should be(String)
+            end
+          end
+        end
+      end
+
+      describe ":description" do
+        it "just has the example description" do
+          m = Metadata.new
+          m.process("group")
+
+          m = m.for_example("example", {})
+          m[:description].should eq("example")
+        end
+
+        context "with a string" do
+          it "provides the submitted description" do
+            m = Metadata.new
+            m.process("group")
+
+            m[:example_group][:description].should eq("group")
+          end
+        end
+
+        context "with a non-string" do
+          it "provides the submitted description" do
+            m = Metadata.new
+            m.process("group")
+
+            m[:example_group][:description].should eq("group")
+          end
+        end
+
+        context "with a non-string and a string" do
+          it "concats the args" do
+            m = Metadata.new
+            m.process(Object, 'group')
+
+            m[:example_group][:description].should eq("Object group")
+          end
+        end
+
+        context "with empty args" do
+          it "returns empty string for [:example_group][:description]" do
+            m = Metadata.new
+            m.process()
+
+            m[:example_group][:description].should eq("")
+          end
+        end
+      end
+
+      describe ":full_description" do
+        it "concats example group name and description" do
+          group_metadata = Metadata.new
+          group_metadata.process('group')
+
+          example_metadata = group_metadata.for_example("example", {})
+          example_metadata[:full_description].should eq("group example")
+        end
+
+        it "concats nested example group descriptions" do
+          parent = Metadata.new
+          parent.process('parent')
+
+          child = Metadata.new(parent)
+          child.process('child')
+
+          child[:example_group][:full_description].should eq("parent child")
+          child.for_example('example', child)[:full_description].should eq("parent child example")
+        end
+
+        it "concats nested example group descriptions three deep" do
+          grandparent = Metadata.new
+          grandparent.process('grandparent')
+
+          parent = Metadata.new(grandparent)
+          parent.process('parent')
+
+          child = Metadata.new(parent)
+          child.process('child')
+
+          grandparent[:example_group][:full_description].should eq("grandparent")
+          parent[:example_group][:full_description].should eq("grandparent parent")
+          child[:example_group][:full_description].should eq("grandparent parent child")
+          child.for_example('example', child)[:full_description].should eq("grandparent parent child example")
+        end
+
+        %w[# . ::].each do |char|
+          context "with a 2nd arg starting with #{char}" do
+            it "removes the space" do
+              m = Metadata.new
+              m.process(Array, "#{char}method")
+              m[:example_group][:full_description].should eq("Array#{char}method")
+            end
+          end
+
+          context "with a description starting with #{char} nested under a module" do
+            it "removes the space" do
+              parent = Metadata.new
+              parent.process(Object)
+              child = Metadata.new(parent)
+              child.process("#{char}method")
+              child[:example_group][:full_description].should eq("Object#{char}method")
+            end
+          end
+
+          context "with a description starting with #{char} nested under a context string" do
+            it "does not remove the space" do
+              grandparent = Metadata.new
+              grandparent.process(Array)
+              parent = Metadata.new(grandparent)
+              parent.process("with 2 items")
+              child = Metadata.new(parent)
+              child.process("#{char}method")
+              child[:example_group][:full_description].should eq("Array with 2 items #{char}method")
+            end
+          end
+        end
+      end
+
+      describe ":file_path" do
+        it "finds the first non-rspec lib file in the caller array" do
+          m = Metadata.new
+          m.process(:caller => [
+                    "./lib/rspec/core/foo.rb",
+                    "#{__FILE__}:#{__LINE__}"
+          ])
+          m[:example_group][:file_path].should eq(relative_path(__FILE__))
+        end
+      end
+
+      describe ":line_number" do
+        it "finds the line number with the first non-rspec lib file in the backtrace" do
+          m = Metadata.new
+          m.process({})
+          m[:example_group][:line_number].should eq(__LINE__ - 1)
+        end
+
+        it "finds the line number with the first spec file with drive letter" do
+          m = Metadata.new
+          m.process(:caller => [ "C:/path/to/file_spec.rb:#{__LINE__}" ])
+          m[:example_group][:line_number].should eq(__LINE__ - 1)
+        end
+
+        it "uses the number after the first : for ruby 1.9" do
+          m = Metadata.new
+          m.process(:caller => [ "#{__FILE__}:#{__LINE__}:999" ])
+          m[:example_group][:line_number].should eq(__LINE__ - 1)
+        end
+      end
+
+      describe "child example group" do
+        it "nests the parent's example group metadata" do
+          parent = Metadata.new
+          parent.process(Object, 'parent')
+
+          child = Metadata.new(parent)
+          child.process()
+
+          child[:example_group][:example_group].should eq(parent[:example_group])
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.12.2/spec/rspec/core/option_parser_spec.rb

@@ -0,0 +1,208 @@
+require "spec_helper"
+
+module RSpec::Core
+  describe OptionParser do
+    let(:output_file){ mock File }
+
+    before do
+      RSpec.stub(:deprecate)
+      File.stub(:open).with("foo.txt",'w') { (output_file) }
+    end
+
+    it "does not parse empty args" do
+      parser = Parser.new
+      OptionParser.should_not_receive(:new)
+      parser.parse!([])
+    end
+
+    it "proposes you to use --help and returns an error on incorrect argument" do
+      parser = Parser.new
+      option = "--my_wrong_arg"
+
+      parser.should_receive(:abort) do |msg|
+        expect(msg).to include('use --help', option)
+      end
+
+      parser.parse!([option])
+    end
+
+    describe "--formatter" do
+      it "is deprecated" do
+        RSpec.should_receive(:deprecate)
+        Parser.parse!(%w[--formatter doc])
+      end
+
+      it "gets converted to --format" do
+        options = Parser.parse!(%w[--formatter doc])
+        options[:formatters].first.should eq(["doc"])
+      end
+    end
+
+    describe "--default_path" do
+      it "gets converted to --default-path" do
+        options = Parser.parse!(%w[--default_path foo])
+        options[:default_path].should == "foo"
+      end
+    end
+
+    describe "--line_number" do
+      it "gets converted to --line-number" do
+        options = Parser.parse!(%w[--line_number 3])
+        options[:line_numbers].should == ["3"]
+      end
+    end
+
+
+    describe "--default-path" do
+      it "sets the default path where RSpec looks for examples" do
+        options = Parser.parse!(%w[--default-path foo])
+        options[:default_path].should == "foo"
+      end
+    end
+
+    %w[--line-number -l].each do |option|
+      describe option do
+        it "sets the line number of an example to run" do
+          options = Parser.parse!([option, "3"])
+          options[:line_numbers].should == ["3"]
+        end
+      end
+    end
+
+    %w[--format -f].each do |option|
+      describe option do
+        it "defines the formatter" do
+          options = Parser.parse!([option, 'doc'])
+          options[:formatters].first.should eq(["doc"])
+        end
+      end
+    end
+
+    %w[--out -o].each do |option|
+      describe option do
+        let(:options) { Parser.parse!([option, 'out.txt']) }
+
+        it "sets the output stream for the formatter" do
+          options[:formatters].last.should eq(['progress', 'out.txt'])
+        end
+
+        context "with multiple formatters" do
+          context "after last formatter" do
+            it "sets the output stream for the last formatter" do
+              options = Parser.parse!(['-f', 'progress', '-f', 'doc', option, 'out.txt'])
+              options[:formatters][0].should eq(['progress'])
+              options[:formatters][1].should eq(['doc', 'out.txt'])
+            end
+          end
+
+          context "after first formatter" do
+            it "sets the output stream for the first formatter" do
+              options = Parser.parse!(['-f', 'progress', option, 'out.txt', '-f', 'doc'])
+              options[:formatters][0].should eq(['progress', 'out.txt'])
+              options[:formatters][1].should eq(['doc'])
+            end
+          end
+        end
+      end
+    end
+
+    %w[--example -e].each do |option|
+      describe option do
+        it "escapes the arg" do
+          options = Parser.parse!([option, "this (and that)"])
+          options[:full_description].length.should eq(1)
+          "this (and that)".should match(options[:full_description].first)
+        end
+      end
+    end
+
+    %w[--pattern -P].each do |option|
+      describe option do
+        it "sets the filename pattern" do
+          options = Parser.parse!([option, 'spec/**/*.spec'])
+          options[:pattern].should eq('spec/**/*.spec')
+        end
+      end
+    end
+
+    %w[--tag -t].each do |option|
+      describe option do
+        context "without ~" do
+          it "treats no value as true" do
+            options = Parser.parse!([option, 'foo'])
+            options[:inclusion_filter].should eq(:foo => true)
+          end
+
+          it "treats 'true' as true" do
+            options = Parser.parse!([option, 'foo:true'])
+            options[:inclusion_filter].should eq(:foo => true)
+          end
+
+          it "treats 'nil' as nil" do
+            options = Parser.parse!([option, 'foo:nil'])
+            options[:inclusion_filter].should eq(:foo => nil)
+          end
+
+          it "treats 'false' as false" do
+            options = Parser.parse!([option, 'foo:false'])
+            options[:inclusion_filter].should eq(:foo => false)
+          end
+
+          it "merges muliple invocations" do
+            options = Parser.parse!([option, 'foo:false', option, 'bar:true', option, 'foo:true'])
+            options[:inclusion_filter].should eq(:foo => true, :bar => true)
+          end
+
+          it "treats 'any_string' as 'any_string'" do
+            options = Parser.parse!([option, 'foo:any_string'])
+            options[:inclusion_filter].should eq(:foo => 'any_string')
+          end
+        end
+
+        context "with ~" do
+          it "treats no value as true" do
+            options = Parser.parse!([option, '~foo'])
+            options[:exclusion_filter].should eq(:foo => true)
+          end
+
+          it "treats 'true' as true" do
+            options = Parser.parse!([option, '~foo:true'])
+            options[:exclusion_filter].should eq(:foo => true)
+          end
+
+          it "treats 'nil' as nil" do
+            options = Parser.parse!([option, '~foo:nil'])
+            options[:exclusion_filter].should eq(:foo => nil)
+          end
+
+          it "treats 'false' as false" do
+            options = Parser.parse!([option, '~foo:false'])
+            options[:exclusion_filter].should eq(:foo => false)
+          end
+        end
+      end
+    end
+
+    describe "--order" do
+      it "is nil by default" do
+        Parser.parse!([])[:order].should be_nil
+      end
+
+      %w[rand random].each do |option|
+        context "with #{option}" do
+          it "defines the order as random" do
+            options = Parser.parse!(['--order', option])
+            options[:order].should eq(option)
+          end
+        end
+      end
+    end
+
+    describe "--seed" do
+      it "sets the order to rand:SEED" do
+        options = Parser.parse!(%w[--seed 123])
+        options[:order].should eq("rand:123")
+      end
+    end
+  end
+end