nutshell-crm 0.0.1

data/vendor/bundle/gems/rspec-core-2.7.1/spec/rspec/core/world_spec.rb

@@ -0,0 +1,315 @@
+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 "#example_groups" do
+      it "contains all registered example groups" do
+        group = RSpec::Core::ExampleGroup.describe("group"){}
+        world.register(group)
+        world.example_groups.should include(group)
+      end
+    end
+
+    describe "#apply_inclusion_filters" do
+      let(:group1) { 
+        RSpec::Core::ExampleGroup.describe(Bar, "find group-1", 
+          { :foo => 1, :color => 'blue', :feature => 'reporting' }
+        ) {}
+      }
+
+      let(:group2) {
+        RSpec::Core::ExampleGroup.describe(Bar, "find group-2",
+          { :pending => true, :feature => 'reporting' }
+        ) {}
+      }
+
+      let(:group3) {
+        RSpec::Core::ExampleGroup.describe(Bar, "find group-3", 
+          { :array => [1,2,3,4], :color => 'blue' }
+        ) {}
+      }
+
+      let(:group4) {
+        RSpec::Core::ExampleGroup.describe(Foo, "find these examples") do
+          it('I have no options') {}
+          it("this is awesome", :awesome => true) {}
+          it("this is too", :awesome => true) {}
+          it("not so awesome", :awesome => false) {}
+          it("I also have no options") {}
+        end
+      }
+      
+      let(:example_groups) { [group1, group2, group3, group4] }
+
+      it "finds no groups when given no search parameters" do
+        world.apply_inclusion_filters([],{}).should eq([])
+      end
+
+      it "finds matching groups when filtering on :describes (described class or module)" do
+        world.apply_inclusion_filters(example_groups, :example_group => { :describes => Bar }).should eq([group1, group2, group3])
+      end
+
+      it "finds matching groups when filtering on :description with text" do
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => 'Bar find group-1' }).should eq([group1])
+      end
+
+      it "finds matching groups when filtering on :description with a lambda" do
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should eq([group1, group3])
+      end
+
+      it "finds matching groups when filtering on :description with a regular expression" do
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => /find group/ }).should eq([group1, group2, group3])
+      end
+
+      it "finds one group when searching for :pending => true" do
+        world.apply_inclusion_filters(example_groups, :pending => true ).should eq([group2])
+      end
+
+      it "finds matching groups when filtering on arbitrary metadata with a number" do
+        world.apply_inclusion_filters(example_groups, :foo => 1 ).should eq([group1])
+      end
+
+      it "finds matching groups when filtering on arbitrary metadata with an array" do
+        world.apply_inclusion_filters(example_groups, :array => [1,2,3,4]).should eq([group3])
+      end
+
+      it "finds no groups when filtering on arbitrary metadata with an array but the arrays do not match" do
+        world.apply_inclusion_filters(example_groups, :array => [4,3,2,1]).should be_empty
+      end
+
+      it "finds matching examples when filtering on arbitrary metadata" do
+        world.apply_inclusion_filters(group4.examples, :awesome => true).should eq([group4.examples[1], group4.examples[2]])
+      end
+
+      it "finds matching examples for example that match any of the filters" do
+        world.apply_inclusion_filters(group4.examples, :awesome => true, :something => :else).should eq([group4.examples[1], group4.examples[2]])
+      end
+    end
+
+    describe "#apply_exclusion_filters" do
+
+      it "finds nothing if all describes match the exclusion filter" do
+        options = { :network_access => true }
+
+        group1 = ExampleGroup.describe(Bar, "find group-1", options) do
+          it("foo") {}
+          it("bar") {}
+        end
+
+        world.register(group1)
+
+        world.apply_exclusion_filters(group1.examples, :network_access => true).should eq([])
+
+        group2 = ExampleGroup.describe(Bar, "find group-1") do
+          it("foo", :network_access => true) {}
+          it("bar") {}
+        end
+
+        world.register(group2)
+
+        world.apply_exclusion_filters(group2.examples, :network_access => true).should eq([group2.examples.last])
+      end
+
+      it "finds nothing if a regexp matches the exclusion filter" do
+        group = ExampleGroup.describe(Bar, "find group-1", :name => "exclude me with a regex", :another => "foo") do
+          it("foo") {}
+          it("bar") {}
+        end
+        world.register(group)
+        world.apply_exclusion_filters(group.examples, :name => /exclude/).should eq([])
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should eq([])
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo", :example_group => {
+          :describes => lambda { |b| b == Bar } } ).should eq([])
+
+        world.apply_exclusion_filters(group.examples, :name => /exclude not/).should eq(group.examples)
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should eq([])
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should eq([])
+      end
+
+      it "finds all if filters are empty" do
+        group = ExampleGroup.describe(Bar) do
+          example("foo") {}
+          example("bar") {}
+        end
+        world.register(group)
+        world.apply_exclusion_filters(group.examples, {}).should eq(group.examples)
+      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
+          world.preceding_declaration_line(group_declaration_line - 1).should be_nil
+        end
+
+        it "returns the argument line number if a group starts on that line" do
+          world.preceding_declaration_line(group_declaration_line).should eq(group_declaration_line)
+        end
+
+        it "returns the argument line number if an example starts on that line" do
+          world.preceding_declaration_line(example_declaration_line).should eq(example_declaration_line)
+        end
+
+        it "returns line number of a group that immediately precedes the argument line" do
+          world.preceding_declaration_line(group_declaration_line + 1).should eq(group_declaration_line)
+        end
+
+        it "returns line number of an example that immediately precedes the argument line" do
+          world.preceding_declaration_line(example_declaration_line + 1).should 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
+          world.preceding_declaration_line(second_group_declaration_line).should 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.inclusion_filter = { :foo => 'bar' }
+            reporter.should_receive(:message).
+              with("No examples matched #{{ :foo => 'bar' }.inspect}.")
+            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.inclusion_filter = { :foo => 'bar' }
+            reporter.should_receive(:message).
+              with("No examples matched #{{ :foo => 'bar' }.inspect}. Running all.")
+            world.announce_filters
+          end
+        end
+
+        context "with an exclusion filter" do
+          it "announces" do
+            configuration.exclusion_filter = { :foo => 'bar' }
+            reporter.should_receive(:message).
+              with("No examples were matched. Perhaps #{{ :foo => 'bar' }.inspect} is excluding everything?")
+            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
+
+    describe "#inclusion_filter" do
+      describe "#description" do
+        it 'cleans up the description' do
+          # check the assumptions of this example
+          project_dir = File.expand_path('.')
+          lambda { }.inspect.should include(project_dir)
+          lambda { }.inspect.should include('0x')
+          lambda { }.inspect.should include(' (lambda)') if RUBY_VERSION > '1.9'
+
+          configuration.filter_run :foo => lambda { }
+          world.inclusion_filter.description.should_not include('0x')
+          world.inclusion_filter.description.should_not include(project_dir)
+          world.inclusion_filter.description.should_not include(' (lambda)')
+        end
+      end
+    end
+
+    describe "#exclusion_filter" do
+      describe "#description" do
+        it 'returns `{}` when it only contains the default filters' do
+          world.exclusion_filter.description.should eq({}.inspect)
+        end
+
+        it 'includes other filters' do
+          configuration.exclusion_filter[:foo] = :bar
+          world.exclusion_filter.description.should eq({ :foo => :bar }.inspect)
+        end
+
+        it 'includes an overriden :if filter' do
+          configuration.exclusion_filter[:if] = :custom_filter
+          world.exclusion_filter.description.should eq({ :if => :custom_filter }.inspect)
+        end
+
+        it 'includes an overriden :unless filter' do
+          configuration.exclusion_filter[:unless] = :custom_filter
+          world.exclusion_filter.description.should eq({ :unless => :custom_filter }.inspect)
+        end
+
+        it 'cleans up the description' do
+          # check the assumptions of this example
+          project_dir = File.expand_path('.')
+          lambda { }.inspect.should include(project_dir)
+          lambda { }.inspect.should include('0x')
+          lambda { }.inspect.should include(' (lambda)') if RUBY_VERSION > '1.9'
+
+          configuration.exclusion_filter[:foo] = lambda { }
+          configuration.filter_run_excluding :bar => lambda { }
+          world.exclusion_filter.description.should_not include('0x')
+          world.exclusion_filter.description.should_not include(project_dir)
+          world.exclusion_filter.description.should_not include(' (lambda)')
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/rspec/core_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe RSpec::Core do
+
+  describe "#configuration" do
+
+    it "returns the same object every time" do
+      RSpec.configuration.should equal(RSpec.configuration)
+    end
+
+  end
+
+  describe "#configure" do
+
+    it "yields the current configuration" do
+      RSpec.configure do |config|
+        config.should eq(RSpec::configuration)
+      end
+    end
+
+  end
+
+  describe "#world" do
+
+    it "returns the RSpec::Core::World instance the current run is using" do
+      RSpec.world.should be_instance_of(RSpec::Core::World)
+    end
+
+  end
+
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/spec_helper.rb

@@ -0,0 +1,92 @@
+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'
+
+  Dir['./spec/support/**/*.rb'].map {|f| require f}
+
+  class NullObject
+    private
+    def method_missing(method, *args, &block)
+      # ignore
+    end
+  end
+
+  def sandboxed(&block)
+    begin
+      @orig_config = RSpec.configuration
+      @orig_world  = RSpec.world
+      new_config = RSpec::Core::Configuration.new
+      new_world  = RSpec::Core::World.new(new_config)
+      RSpec.instance_variable_set(:@configuration, new_config)
+      RSpec.instance_variable_set(:@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_mock_space = RSpec::Mocks::space
+          RSpec::Mocks::space = RSpec::Mocks::Space.new
+          orig_run(reporter || NullObject.new)
+        ensure
+          RSpec::Mocks::space = @orig_mock_space
+        end
+      end
+
+      object.instance_eval(&block)
+  ensure
+    (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+      remove_method :run
+      alias_method :run, :orig_run
+      remove_method :orig_run
+    end
+
+    RSpec.instance_variable_set(:@configuration, @orig_config)
+    RSpec.instance_variable_set(:@world, @orig_world)
+end
+end
+
+def in_editor?
+  ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
+end
+
+RSpec.configure do |c|
+  c.color_enabled = !in_editor?
+  c.filter_run :focus => true
+  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
+  }
+  c.alias_it_should_behave_like_to 'it_has_behavior'
+  c.around do |example|
+    sandboxed { example.run }
+  end
+end
+end
+
+Spork.each_run do
+end
+

data/vendor/bundle/gems/rspec-core-2.7.1/spec/support/matchers.rb

@@ -0,0 +1,75 @@
+RSpec::Matchers.define :map_specs do |specs|
+  match do |autotest|
+    @specs = specs
+    @autotest = prepare(autotest)
+    autotest.test_files_for(@file) == specs
+  end
+
+  chain :to do |file|
+    @file = file
+  end
+
+  failure_message_for_should do
+    "expected #{@autotest.class} to map #{@specs.inspect} to #{@file.inspect}\ngot #{@actual.inspect}"
+  end
+
+  def prepare(autotest)
+    find_order = @specs.dup << @file
+    autotest.instance_eval { @find_order = find_order }
+    autotest
+  end
+end
+
+RSpec::Matchers.define :be_pending_with do |message|
+  match do |example|
+    example.metadata[:pending] && example.metadata[:execution_result][:pending_message] == message
+  end
+
+  failure_message_for_should do |example|
+    "expected example to pending with #{message.inspect}, got #{example.metadata[:execution_result][:pending_message].inspect}"
+  end
+end
+
+RSpec::Matchers.define :fail_with do |exception_klass|
+  match do |example|
+    failure_reason(example, exception_klass).nil?
+  end
+
+  failure_message_for_should do |example|
+    "expected example to fail with a #{exception_klass} exception, but #{failure_reason(example, exception_klass)}"
+  end
+
+  def failure_reason(example, exception_klass)
+    result = example.metadata[:execution_result]
+    case
+      when example.metadata[:pending] then "was pending"
+      when result[:status] != 'failed' then result[:status]
+      when !result[:exception].is_a?(exception_klass) then "failed with a #{result[:exception].class}"
+      else nil
+    end
+  end
+end
+
+RSpec::Matchers.define :pass do
+  match do |example|
+    failure_reason(example).nil?
+  end
+
+  failure_message_for_should do |example|
+    "expected example to pass, but #{failure_reason(example)}"
+  end
+
+  def failure_reason(example)
+    result = example.metadata[:execution_result]
+    case
+      when example.metadata[:pending] then "was pending"
+      when result[:status] != 'passed' then result[:status]
+      else nil
+    end
+  end
+end
+
+RSpec::Matchers.module_eval do
+  alias have_failed_with fail_with
+  alias have_passed pass
+end