nutshell-crm 0.0.1

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

@@ -0,0 +1,41 @@
+shared_examples_for "metadata hash builder" do
+  context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to true" do
+    let(:hash) { metadata_hash(:foo, :bar, :bazz => 23) }
+
+    before(:each) do
+      RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = true }
+    end
+
+    it 'treats symbols as metadata keys with a true value' do
+      hash[:foo].should be(true)
+      hash[:bar].should be(true)
+    end
+
+    it 'still processes hash values normally' do
+      hash[:bazz].should be(23)
+    end
+  end
+
+  context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to false" do
+    let(:warning_receiver) { Kernel }
+
+    before(:each) do
+      RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = false }
+      warning_receiver.stub(:warn)
+    end
+
+    it 'prints a deprecation warning about any symbols given as arguments' do
+      warning_receiver.should_receive(:warn).with(/In RSpec 3, these symbols will be treated as metadata keys/)
+      metadata_hash(:foo, :bar, :key => 'value')
+    end
+
+    it 'does not treat symbols as metadata keys' do
+      metadata_hash(:foo, :bar, :key => 'value').should_not include(:foo, :bar)
+    end
+
+    it 'does not print a warning if there are no symbol arguments' do
+      warning_receiver.should_not_receive(:warn)
+      metadata_hash(:foo => 23, :bar => 17)
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+shared_context "spec files" do
+  def failing_spec_filename
+    @failing_spec_filename ||= File.expand_path(File.dirname(__FILE__)) + "/_failing_spec.rb"
+  end
+
+  def passing_spec_filename
+    @passing_spec_filename ||= File.expand_path(File.dirname(__FILE__)) + "/_passing_spec.rb"
+  end
+
+  def create_passing_spec_file
+    File.open(passing_spec_filename, 'w') do |f|
+      f.write %q{
+        describe "passing spec" do
+          it "passes" do
+            1.should eq(1)
+          end
+        end
+      }
+    end
+  end
+
+  def create_failing_spec_file
+    File.open(failing_spec_filename, 'w') do |f|
+      f.write %q{
+        describe "failing spec" do
+          it "fails" do
+            1.should eq(2)
+          end
+        end
+      }
+    end
+  end
+
+  before(:all) do
+    create_passing_spec_file
+    create_failing_spec_file
+  end
+
+  after(:all) do
+    File.delete(passing_spec_filename)
+    File.delete(failing_spec_filename)
+  end
+
+end

data/vendor/bundle/gems/rspec-expectations-2.7.0/README.md

@@ -0,0 +1,24 @@
+# RSpec Expectations
+
+rspec-expectations adds `should` and `should_not` to every object and includes
+several standard matchers in RSpec::Matchers
+
+## Install
+
+    gem install rspec               # for rspec-core, rspec-expectations, rspec-mocks
+    gem install rspec-expectations  # for rspec-expectations only
+
+## Matchers
+
+Matchers are objects used to compose expectations:
+
+    result.should eq("this value")
+
+In that example, `eq("this value")` returns a `Matcher` object that
+compares the actual `result` to the expected `"this value"`.
+
+## Also see
+
+* [http://github.com/rspec/rspec](http://github.com/rspec/rspec)
+* [http://github.com/rspec/rspec-core](http://github.com/rspec/rspec-core)
+* [http://github.com/rspec/rspec-mocks](http://github.com/rspec/rspec-mocks)

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/README.markdown

@@ -0,0 +1,49 @@
+rspec-expectations is used to define expected outcomes.
+
+    describe Account do
+      it "has a balance of zero when first created" do
+        Account.new.balance.should eq(Money.new(0))
+      end
+    end
+
+## Basic structure
+
+The basic structure of an rspec expectation is:
+
+    actual.should matcher(expected)
+    actual.should_not matcher(expected)
+
+## `should` and `should_not`
+
+`rspec-expectations` adds `should` and `should_not` to every object in
+the system. These methods each accept a matcher as an argument. This allows
+each matcher to work in a positive or negative mode:
+
+    5.should eq(5)
+    5.should_not eq(4)
+
+## What is a matcher?
+
+A Matcher is any object that responds to the following methods:
+
+    matches?(actual)
+    failure_message_for_should
+
+These methods are also part of the matcher protocol, but are optional:
+
+    does_not_match?(actual)
+    failure_message_for_should_not
+    description
+
+RSpec ships with a number of built-in matchers and a DSL for writing custom
+matchers.
+
+## Issues
+
+The documentation for rspec-expectations is a work in progress. We'll be adding
+Cucumber features over time, and clarifying existing ones.  If you have
+specific features you'd like to see added, find the existing documentation
+incomplete or confusing, or, better yet, wish to write a missing Cucumber
+feature yourself, please [submit an
+issue](http://github.com/rspec/rspec-expectations/issues) or a [pull
+request](http://github.com/rspec/rspec-expectations).

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/Upgrade.md

@@ -0,0 +1,53 @@
+# Upgrade to rspec-expectations-2.0
+
+## What's new
+
+### New `eq` matcher.
+
+`RSpec::Matchers` now offers you two approaches to differentiating between
+object identity. You can use the rspec-1 approach:
+
+    actual.should == expected     # object equality
+    actual.should equal(expected) # object identity
+
+... or, if you prefer:
+
+    actual.should eq(expected) # object equality
+    actual.should be(expected) # object identity
+
+## What's been removed
+
+### simple_matcher
+
+Use RSpec::Matchers.define instead. For example, if you had:
+
+    def eat_cheese
+      simple_matcher("eat cheese") do |actual|
+        actual.eat?(:cheese)
+      end
+    end
+
+Change it to:
+
+    RSpec::Matchers.define :eat_cheese do
+      match do |actual|
+        actual.eat?(:cheese)
+      end
+    end
+
+### wrap_expectation
+
+Use RSpec::Matchers.define instead.
+
+    RSpec::Matchers.define :eat_cheese do
+      match do |actual|
+        actual.should eat?(:cheese)
+      end
+    end
+
+    RSpec::Matchers.define :eat_cheese do
+      include MyCheesyAssertions
+      match_unless_raises Test::Unit::AssertionFailedError do |actual|
+        assert_eats_chesse actual
+      end
+    end

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/built_in_matchers/README.md

@@ -0,0 +1,73 @@
+## Object identity
+
+    actual.should equal(expected) # passes if actual.equal?(expected)
+    
+## Object equivalence
+
+    actual.should == expected   # passes if actual == expected
+    actual.should eql(expected) # passes if actual.eql?(expected)
+
+## Optional APIs for identity/equivalence
+
+    actual.should eq(expected)  # passes if actual == expected
+    actual.should be(expected)  # passes if actual.equal?(expected)
+
+## Comparisons
+
+    actual.should be >  expected
+    actual.should be >= expected
+    actual.should be <= expected
+    actual.should be <  expected
+    actual.should =~ /expression/
+    actual.should match(/expression/)
+    actual.should be_within(delta).of(expected)
+
+## Types/classes
+
+    actual.should be_instance_of(expected)
+    actual.should be_kind_of(expected)
+
+## Truthiness and existentialism
+
+    actual.should be_true  # passes if actual is truthy (not nil or false)
+    actual.should be_false # passes if actual is falsy (nil or false)
+    actual.should be_nil   # passes if actual is nil
+    actual.should be       # passes if actual is truthy (not nil or false)
+
+## Expecting errors
+
+    expect { ... }.to raise_error
+    expect { ... }.to raise_error(ErrorClass)
+    expect { ... }.to raise_error("message")
+    expect { ... }.to raise_error(ErrorClass, "message")
+
+## Expecting throws
+
+    expect { ... }.to throw_symbol
+    expect { ... }.to throw_symbol(:symbol)
+    expect { ... }.to throw_symbol(:symbol, 'value')
+
+## Predicate matchers
+
+    actual.should be_xxx         # passes if actual.xxx?
+    actual.should have_xxx(:arg) # passes if actual.has_xxx?(:arg)
+
+### Examples
+
+    [].should be_empty # passes because [].empty? returns true
+    { :a => 1 }.should have_key(:a) # passes because the hash has the key :a
+
+## Collection membership
+
+    actual.should include(expected)
+
+### Examples
+
+    [1,2,3].should include(1)
+    [1,2,3].should include(1, 2)
+    {:a => 'b'}.should include(:a => 'b')
+    "this string".should include("is str")
+
+## Ranges (1.9 only)
+
+    (1..10).should cover(3)

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/built_in_matchers/be.feature

@@ -0,0 +1,135 @@
+Feature: "be" matchers
+
+  There are several related "be" matchers:
+
+      obj.should be_true  # passes if obj is truthy (not nil or false)
+      obj.should be_false # passes if obj is falsy (nil or false)
+      obj.should be_nil   # passes if obj is nil
+      obj.should be       # passes if obj is truthy (not nil or false)
+
+  Scenario: be_true matcher
+    Given a file named "be_true_spec.rb" with:
+      """
+      describe "be_true matcher" do
+        specify { true.should be_true }
+        specify { 7.should be_true }
+        specify { "foo".should be_true }
+        specify { nil.should_not be_true }
+        specify { false.should_not be_true }
+
+        # deliberate failures
+        specify { true.should_not be_true }
+        specify { 7.should_not be_true }
+        specify { "foo".should_not be_true }
+        specify { nil.should be_true }
+        specify { false.should be_true }
+      end
+      """
+    When I run `rspec be_true_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 5 failures       |
+      | expected true not to be true  |
+      | expected 7 not to be true     |
+      | expected "foo" not to be true |
+      | expected nil to be true       |
+      | expected false to be true     |
+
+  Scenario: be_false matcher
+    Given a file named "be_false_spec.rb" with:
+      """
+      describe "be_false matcher" do
+        specify { nil.should be_false }
+        specify { false.should be_false }
+        specify { true.should_not be_false }
+        specify { 7.should_not be_false }
+        specify { "foo".should_not be_false }
+
+        # deliberate failures
+        specify { nil.should_not be_false }
+        specify { false.should_not be_false }
+        specify { true.should be_false }
+        specify { 7.should be_false }
+        specify { "foo".should be_false }
+      end
+      """
+    When I run `rspec be_false_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 5 failures        |
+      | expected nil not to be false   |
+      | expected false not to be false |
+      | expected true to be false      |
+      | expected 7 to be false         |
+      | expected "foo" to be false     |
+
+  Scenario: be_nil matcher
+    Given a file named "be_nil_spec.rb" with:
+      """
+      describe "be_nil matcher" do
+        specify { nil.should be_nil }
+        specify { false.should_not be_nil }
+        specify { true.should_not be_nil }
+        specify { 7.should_not be_nil }
+        specify { "foo".should_not be_nil }
+
+        # deliberate failures
+        specify { nil.should_not be_nil }
+        specify { false.should be_nil }
+        specify { true.should be_nil }
+        specify { 7.should be_nil }
+        specify { "foo".should be_nil }
+      end
+      """
+    When I run `rspec be_nil_spec.rb`
+    Then the output should contain "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: not nil
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: false
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: "foo"
+      """
+
+  Scenario: be matcher
+    Given a file named "be_spec.rb" with:
+      """
+      describe "be_matcher" do
+        specify { true.should be }
+        specify { 7.should be }
+        specify { "foo".should be }
+        specify { nil.should_not be }
+        specify { false.should_not be }
+
+        # deliberate failures
+        specify { true.should_not be }
+        specify { 7.should_not be }
+        specify { "foo".should_not be }
+        specify { nil.should be }
+        specify { false.should be }
+      end
+      """
+    When I run `rspec be_spec.rb`
+    Then the output should contain all of these:
+      | 10 examples, 5 failures             |
+      | expected true to evaluate to false  |
+      | expected 7 to evaluate to false     |
+      | expected "foo" to evaluate to false |
+      | expected nil to evaluate to true    |
+      | expected false to evaluate to true  |

data/vendor/bundle/gems/rspec-expectations-2.7.0/features/built_in_matchers/be_within.feature

@@ -0,0 +1,43 @@
+Feature: be_within matcher
+
+  Normal equality expectations do not work well for floating point values.
+  Consider this irb session:
+
+      > radius = 3
+        => 3 
+      > area_of_circle = radius * radius * Math::PI
+        => 28.2743338823081 
+      > area_of_circle == 28.2743338823081
+        => false 
+
+  Instead, you should use the be_within matcher to check that the value
+  is within a delta of your expected value:
+
+      area_of_circle.should be_within(0.1).of(28.3)
+
+  Note that the difference between the actual and expected values must be
+  smaller than your delta; if it is equal, the matcher will fail.
+
+  Scenario: basic usage
+    Given a file named "be_within_matcher_spec.rb" with:
+      """
+      describe 27.5 do
+        it { should be_within(0.5).of(27.9) }
+        it { should be_within(0.5).of(27.1) }
+        it { should_not be_within(0.5).of(28) }
+        it { should_not be_within(0.5).of(27) }
+
+        # deliberate failures
+        it { should_not be_within(0.5).of(27.9) }
+        it { should_not be_within(0.5).of(27.1) }
+        it { should be_within(0.5).of(28) }
+        it { should be_within(0.5).of(27) }
+      end
+      """
+    When I run `rspec be_within_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                     |
+      | expected 27.5 not to be within 0.5 of 27.9 |
+      | expected 27.5 not to be within 0.5 of 27.1 |
+      | expected 27.5 to be within 0.5 of 28       |
+      | expected 27.5 to be within 0.5 of 27       |