gem_repackager 0.1.0

data/support/gems/rspec-expectations-2.11.2/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/support/gems/rspec-expectations-2.11.2/README.md

@@ -0,0 +1,224 @@
+# 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/badge.png)](https://codeclimate.com/github/rspec/rspec-expectations)
+
+RSpec::Expectations lets you express expected outcomes on an object in an
+example.
+
+    account.balance.should 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`,
+and `Item` 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
+actual.should eq(expected)  # passes if actual == expected
+actual.should == expected   # passes if actual == expected
+actual.should eql(expected) # passes if actual.eql?(expected)
+```
+
+### Identity
+
+```ruby
+actual.should be(expected)    # passes if actual.equal?(expected)
+actual.should equal(expected) # passes if actual.equal?(expected)
+```
+
+### Comparisons
+
+```ruby
+actual.should be >  expected
+actual.should be >= expected
+actual.should be <= expected
+actual.should be <  expected
+actual.should be_within(delta).of(expected)
+```
+
+### Regular expressions
+
+```ruby
+actual.should =~ /expression/
+actual.should match(/expression/)
+```
+
+### Types/classes
+
+```ruby
+actual.should be_an_instance_of(expected)
+actual.should be_a_kind_of(expected)
+```
+
+### Truthiness
+
+```ruby
+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
+```
+
+### 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
+actual.should be_xxx         # passes if actual.xxx?
+actual.should have_xxx(:arg) # passes if actual.has_xxx?(:arg)
+```
+
+### Ranges (Ruby >= 1.9 only)
+
+```ruby
+(1..10).should cover(3)
+```
+
+### Collection membership
+
+```ruby
+actual.should include(expected)
+actual.should start_with(expected)
+actual.should end_with(expected)
+```
+
+#### Examples
+
+```ruby
+[1,2,3].should include(1)
+[1,2,3].should include(1, 2)
+[1,2,3].should start_with(1)
+[1,2,3].should start_with(1,2)
+[1,2,3].should end_with(3)
+[1,2,3].should end_with(2,3)
+{:a => 'b'}.should include(:a => 'b')
+"this string".should include("is str")
+"this string".should start_with("this")
+"this string".should end_with("ring")
+```
+
+## `expect` syntax
+
+In addition to the `should` syntax, rspec-expectations supports
+a new `expect` syntax as of version 2.11.0:
+
+```ruby
+expect(actual).to eq expected
+expect(actual).to be > 3
+expect([1, 2, 3]).to_not include 4
+```
+
+If you want your project to only use one of these syntaxes, you can
+configure it:
+
+```ruby
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+    # or
+    c.syntax = :should
+    # or
+    c.syntax = [:should, :expect]
+  end
+end
+```
+
+See
+[RSpec::Expectations::Syntax#expect](http://rubydoc.info/gems/rspec-expectations/RSpec/Expectations/Syntax:expect)
+for more information.
+
+### Motivation for `expect`
+
+We added the `expect` syntax to resolve some edge case issues, most notably
+that objects whose definitions wipe out all but a few methods were throwing
+`should` and `should_not` away. `expect` solves that by not monkey patching
+those methods onto `Kernel` (or any global object).
+
+See
+[http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax](http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax)
+for a detailed explanation.
+
+### One-liners
+
+The one-liner syntax supported by
+[rspec-core](http://rubydoc.info/gems/rspec-core)  uses `should` even when
+`config.syntax = :expect`. It reads better than the alternative, and does not
+require a global monkey patch:
+
+```ruby
+describe User do
+  it { should validate_presence_of :email }
+end
+```
+
+## 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/support/gems/rspec-expectations-2.11.2/features/README.md

@@ -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/support/gems/rspec-expectations-2.11.2/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/support/gems/rspec-expectations-2.11.2/features/built_in_matchers/README.md

@@ -0,0 +1,90 @@
+# Built-in Matchers
+
+Here is a list of matchers that ship with rspec-expectations. Each matcher
+can be used with `should` or `should_not` e.g.
+
+    result.should eq(3)
+    list.should_not be_empty
+
+## Object identity
+
+    actual.should be(expected) # passes if actual.equal?(expected)
+    
+## Object equivalence
+
+    actual.should eq(expected) # passes if actual == expected
+
+## Optional APIs for identity/equivalence
+
+    actual.should == expected     # passes if actual == expected
+    actual.should eql(expected)   # passes if actual.eql?(expected)
+    actual.should equal(expected) # passes if actual.equal?(expected)
+
+    # NOTE: this can't work in Ruby 1.8, so we don't support it at all:
+    #   actual.should != expected
+    # The reason is that Ruby 1.8 parses it as:
+    #   !(actual.should.==(expected)),
+    # so by the time RSpec sees it it has no way to know that it's
+    # been negated. Use either of these instead:
+    #   actual.should_not eq(expected)
+    #   actual.should_not == 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/support/gems/rspec-expectations-2.11.2/features/built_in_matchers/be.feature

@@ -0,0 +1,173 @@
+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 "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:
+      """
+      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:
+      """
+      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  |