tuktuk-rails 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/License.txt

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2006 David Chelimsky, The RSpec Development Team
+Copyright (c) 2005 Steven Baker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/README.md

@@ -0,0 +1,184 @@
+# RSpec Expectations [![Build Status](https://secure.travis-ci.org/rspec/rspec-expectations.png?branch=master)](http://travis-ci.org/rspec/rspec-expectations) [![Code Climate](https://codeclimate.com/github/rspec/rspec-expectations.png)](https://codeclimate.com/github/rspec/rspec-expectations)
+
+RSpec::Expectations lets you express expected outcomes on an object in an
+example.
+
+    expect(account.balance).to eq(Money.new(37.42, :USD))
+
+## Install
+
+If you want to use rspec-expectations with rspec, just install the rspec gem
+and RubyGems will also install rspec-expectations for you (along with
+rspec-core and rspec-mocks):
+
+    gem install rspec
+
+If you want to use rspec-expectations with another tool, like Test::Unit,
+Minitest, or Cucumber, you can install it directly:
+
+    gem install rspec-expectations
+
+## Basic usage
+
+Here's an example using rspec-core:
+
+```ruby
+describe Order do
+  it "sums the prices of the items in its line items" do
+    order = Order.new
+    order.add_entry(LineItem.new(:item => Item.new(
+      :price => Money.new(1.11, :USD)
+    )))
+    order.add_entry(LineItem.new(:item => Item.new(
+      :price => Money.new(2.22, :USD),
+      :quantity => 2
+    )))
+    expect(order.total).to eq(Money.new(5.55, :USD))
+  end
+end
+```
+
+The `describe` and `it` methods come from rspec-core.  The `Order`, `LineItem`, `Item` and `Money` classes would be from _your_ code. The last line of the example
+expresses an expected outcome. If `order.total == Money.new(5.55, :USD)`, then
+the example passes. If not, it fails with a message like:
+
+    expected: #<Money @value=5.55 @currency=:USD>
+         got: #<Money @value=1.11 @currency=:USD>
+
+## Built-in matchers
+
+### Equivalence
+
+```ruby
+expect(actual).to eq(expected)  # passes if actual == expected
+expect(actual).to eql(expected) # passes if actual.eql?(expected)
+```
+
+Note: The new `expect` syntax no longer supports `==` matcher.
+
+### Identity
+
+```ruby
+expect(actual).to be(expected)    # passes if actual.equal?(expected)
+expect(actual).to equal(expected) # passes if actual.equal?(expected)
+```
+
+### Comparisons
+
+```ruby
+expect(actual).to be >  expected
+expect(actual).to be >= expected
+expect(actual).to be <= expected
+expect(actual).to be <  expected
+expect(actual).to be_within(delta).of(expected)
+```
+
+### Regular expressions
+
+```ruby
+expect(actual).to match(/expression/)
+```
+
+Note: The new `expect` syntax no longer supports `=~` matcher.
+
+### Types/classes
+
+```ruby
+expect(actual).to be_an_instance_of(expected)
+expect(actual).to be_a_kind_of(expected)
+```
+
+### Truthiness
+
+```ruby
+expect(actual).to be_true  # passes if actual is truthy (not nil or false)
+expect(actual).to be_false # passes if actual is falsy (nil or false)
+expect(actual).to be_nil   # passes if actual is nil
+```
+
+### Expecting errors
+
+```ruby
+expect { ... }.to raise_error
+expect { ... }.to raise_error(ErrorClass)
+expect { ... }.to raise_error("message")
+expect { ... }.to raise_error(ErrorClass, "message")
+```
+
+### Expecting throws
+
+```ruby
+expect { ... }.to throw_symbol
+expect { ... }.to throw_symbol(:symbol)
+expect { ... }.to throw_symbol(:symbol, 'value')
+```
+
+### Yielding
+
+```ruby
+expect { |b| 5.tap(&b) }.to yield_control # passes regardless of yielded args
+
+expect { |b| yield_if_true(true, &b) }.to yield_with_no_args # passes only if no args are yielded
+
+expect { |b| 5.tap(&b) }.to yield_with_args(5)
+expect { |b| 5.tap(&b) }.to yield_with_args(Fixnum)
+expect { |b| "a string".tap(&b) }.to yield_with_args(/str/)
+
+expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3)
+expect { |b| { :a => 1, :b => 2 }.each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
+```
+
+### Predicate matchers
+
+```ruby
+expect(actual).to be_xxx         # passes if actual.xxx?
+expect(actual).to have_xxx(:arg) # passes if actual.has_xxx?(:arg)
+```
+
+### Ranges (Ruby >= 1.9 only)
+
+```ruby
+expect(1..10).to cover(3)
+```
+
+### Collection membership
+
+```ruby
+expect(actual).to include(expected)
+expect(actual).to start_with(expected)
+expect(actual).to end_with(expected)
+```
+
+#### Examples
+
+```ruby
+expect([1,2,3]).to include(1)
+expect([1,2,3]).to include(1, 2)
+expect([1,2,3]).to start_with(1)
+expect([1,2,3]).to start_with(1,2)
+expect([1,2,3]).to end_with(3)
+expect([1,2,3]).to end_with(2,3)
+expect({:a => 'b'}).to include(:a => 'b')
+expect("this string").to include("is str")
+expect("this string").to start_with("this")
+expect("this string").to end_with("ring")
+```
+
+## `should` syntax
+
+In addition to the `expect` syntax, rspec-expectations continues to support the
+`should` syntax:
+
+```ruby
+actual.should eq expected
+actual.should be > 3
+[1, 2, 3].should_not include 4
+```
+
+See [detailed information on the `should` syntax and its usage.](https://github.com/rspec/rspec-expectations/blob/master/Should.md)
+
+## 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/ruby/2.0.0/gems/rspec-expectations-2.14.4/features/README.md

@@ -0,0 +1,48 @@
+rspec-expectations is used to define expected outcomes.
+
+    describe Account do
+      it "has a balance of zero when first created" do
+        expect(Account.new.balance).to eq(Money.new(0))
+      end
+    end
+
+## Basic structure
+
+The basic structure of an rspec expectation is:
+
+    expect(actual).to matcher(expected)
+    expect(actual).not_to matcher(expected)
+
+Note: You can also use `expect(..).to_not` instead of `expect(..).not_to`.
+      One is an alias to the other, so you can use whichever reads better to you.
+
+#### Examples
+
+    expect(5).to eq(5)
+    expect(5).not_to 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/ruby/2.0.0/gems/rspec-expectations-2.14.4/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/ruby/2.0.0/gems/rspec-expectations-2.14.4/features/built_in_matchers/README.md

@@ -0,0 +1,90 @@
+# Built-in Matchers
+
+rspec-expectations ships with a number of built-in matchers.
+Each matcher can be used with `expect(..).to` or `expect(..).not_to` to define
+positive and negative expectations respectively on an object. Most matchers can
+also be accessed using the `(...).should` and `(...).should_not` syntax, see
+[using should syntax](https://github.com/rspec/rspec-expectations/blob/master/Should.md)
+for why we recommend using `expect`.
+
+e.g.
+
+    expect(result).to   eq(3)
+    expect(list).not_to be_empty
+    pi.should be > 3
+
+## Object identity
+
+    expect(actual).to be(expected) # passes if actual.equal?(expected)
+
+## Object equivalence
+
+    expect(actual).to eq(expected) # passes if actual == expected
+
+## Optional APIs for identity/equivalence
+
+    expect(actual).to eql(expected)   # passes if actual.eql?(expected)
+    expect(actual).to equal(expected) # passes if actual.equal?(expected)
+
+    # NOTE: `expect` does not support `==` matcher.
+
+## Comparisons
+
+    expect(actual).to be >  expected
+    expect(actual).to be >= expected
+    expect(actual).to be <= expected
+    expect(actual).to be <  expected
+    expect(actual).to match(/expression/)
+    expect(actual).to be_within(delta).of(expected)
+
+    # NOTE: `expect` does not support `=~` matcher.
+
+## Types/classes
+
+    expect(actual).to be_instance_of(expected)
+    expect(actual).to be_kind_of(expected)
+
+## Truthiness and existentialism
+
+    expect(actual).to be_true  # passes if actual is truthy (not nil or false)
+    expect(actual).to be_false # passes if actual is falsy (nil or false)
+    expect(actual).to be_nil   # passes if actual is nil
+    expect(actual).to 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
+
+    expect(actual).to be_xxx         # passes if actual.xxx?
+    expect(actual).to have_xxx(:arg) # passes if actual.has_xxx?(:arg)
+
+### Examples
+
+    expect([]).to      be_empty
+    expect(:a => 1).to have_key(:a)
+
+## Collection membership
+
+    expect(actual).to include(expected)
+
+### Examples
+
+    expect([1,2,3]).to       include(1)
+    expect([1,2,3]).to       include(1, 2)
+    expect(:a => 'b').to     include(:a => 'b')
+    expect("this string").to include("is str")
+
+## Ranges (1.9 only)
+
+    expect(1..10).to cover(3)

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/features/built_in_matchers/be.feature

@@ -0,0 +1,175 @@
+Feature: "be" matchers
+
+  There are several related "be" matchers:
+
+    ```ruby
+    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:
+      """ruby
+      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 "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: non-true value
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: non-true value
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: non-true value
+                  got: "foo"
+      """
+    And the output should contain:
+      """
+             expected: true value
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: true value
+                  got: false
+      """
+
+  Scenario: be_false matcher
+    Given a file named "be_false_spec.rb" with:
+      """ruby
+      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 "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: non-false value
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: non-false value
+                  got: false
+      """
+    And the output should contain:
+      """
+             expected: false value
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: false value
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: false value
+                  got: "foo"
+      """
+
+  Scenario: be_nil matcher
+    Given a file named "be_nil_spec.rb" with:
+      """ruby
+      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:
+      """ruby
+      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  |