opal-rspec 0.7.0.rc.1 → 0.7.0.rc.2

data/rspec-expectations/upstream/cucumber.yml

@@ -0,0 +1,10 @@
+<%
+def tags(tag)
+  tags = [tag]
+  tags << "~@ruby-1.9" if RUBY_VERSION.to_f < 1.9
+  tags.join(" --tags ")
+end
+%>
+
+default: --require features --tags <%= tags("~@wip") %> --format progress
+wip: --require features --tags <%= tags("@wip:3") --wip features

data/rspec-expectations/upstream/features/.nav

@@ -0,0 +1,41 @@
+- built_in_matchers:
+  - equality.feature
+  - comparisons.feature
+  - predicates.feature
+  - types.feature
+  - all.feature
+  - be.feature
+  - be_within.feature
+  - exist.feature
+  - change.feature
+  - contain_exactly.feature
+  - cover.feature
+  - end_with.feature
+  - exist.feature
+  - have.feature
+  - have_attributes.feature
+  - include.feature
+  - match.feature
+  - operators.feature
+  - raise_error.feature
+  - respond_to.feature
+  - satisfy.feature
+  - start_with.feature
+  - throw_symbol.feature
+  - yield.feature
+- custom_matchers:
+  - define_matcher.feature
+  - define_diffable_matcher.feature
+  - define_matcher_with_fluent_interface.feature
+  - access_running_example.feature
+  - define_matcher_outside_rspec.feature
+- composing_matchers.feature
+- compound_expectations.feature
+- define_negated_matcher.feature
+- customized_message.feature
+- diffing.feature
+- implicit_docstrings.feature
+- syntax_configuration.feature
+- test_frameworks:
+  - test_unit.feature
+- Changelog.md

data/rspec-expectations/upstream/features/README.md

@@ -0,0 +1,49 @@
+rspec-expectations is used to define expected outcomes.
+
+    RSpec.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
+
+These methods are also part of the matcher protocol, but are optional:
+
+    does_not_match?(actual)
+    failure_message_when_negated
+    description
+    supports_block_expectations?
+
+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/rspec-expectations/upstream/features/built_in_matchers/README.md

@@ -0,0 +1,137 @@
+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 be_between(minimum, maximum).inclusive
+    expect(actual).to be_between(minimum, maximum).exclusive
+    expect(actual).to match(/expression/)
+    expect(actual).to be_within(delta).of(expected)
+    expect(actual).to start_with expected
+    expect(actual).to end_with expected
+
+    # NOTE: `expect` does not support `=~` matcher.
+
+## Types/classes/response
+
+    expect(actual).to be_instance_of(expected)
+    expect(actual).to be_kind_of(expected)
+    expect(actual).to respond_to(expected)
+
+## Truthiness and existentialism
+
+    expect(actual).to be_truthy    # passes if actual is truthy (not nil or false)
+    expect(actual).to be true      # passes if actual == true
+    expect(actual).to be_falsey    # passes if actual is falsy (nil or false)
+    expect(actual).to be false     # passes if actual == false
+    expect(actual).to be_nil       # passes if actual is nil
+    expect(actual).to exist        # passes if actual.exist? and/or actual.exists? are truthy
+    expect(actual).to exist(*args) # passes if actual.exist?(*args) and/or actual.exists?(*args) are truthy
+
+## 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)
+    expect(array).to match_array(expected_array)
+    # ...which is the same as:
+    expect(array).to contain_exactly(individual, elements)
+
+### 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")
+    expect([1, 2, 3]).to     contain_exactly(2, 1, 3)
+    expect([1, 2, 3]).to     match_array([3, 2, 1])
+
+## Ranges (1.9 only)
+
+    expect(1..10).to cover(3)
+
+## Change observation
+
+    expect { object.action }.to change(object, :value).from(old).to(new)
+    expect { object.action }.to change(object, :value).by(delta)
+    expect { object.action }.to change(object, :value).by_at_least(minimum_delta)
+    expect { object.action }.to change(object, :value).by_at_most(maximum_delta)
+
+### Examples
+
+    expect { a += 1 }.to change { a }.by(1)
+    expect { a += 3 }.to change { a }.from(2)
+    expect { a += 3 }.to change { a }.by_at_least(2)
+
+## Satisfy
+
+    expect(actual).to satisfy { |value| value == expected }
+
+## Output capture
+
+    expect { actual }.to output("some output").to_stdout
+    expect { actual }.to output("some error").to_stderr
+
+## Block expectation
+
+    expect { |b| object.action(&b) }.to yield_control
+    expect { |b| object.action(&b) }.to yield_with_no_args           # only matches no args
+    expect { |b| object.action(&b) }.to yield_with_args              # matches any args
+    expect { |b| object.action(&b) }.to yield_successive_args(*args) # matches args against multiple yields
+
+### Examples
+
+    expect { |b| User.transaction(&b) }.to yield_control
+    expect { |b| User.transaction(&b) }.to yield_with_no_args
+    expect { |b| 5.tap(&b)            }.not_to yield_with_no_args         # because it yields with `5`
+    expect { |b| 5.tap(&b)            }.to yield_with_args(5)             # because 5 == 5
+    expect { |b| 5.tap(&b)            }.to yield_with_args(Fixnum)        # because Fixnum === 5
+    expect { |b| [1, 2, 3].each(&b)   }.to yield_successive_args(1, 2, 3)

data/rspec-expectations/upstream/features/built_in_matchers/all.feature

@@ -0,0 +1,60 @@
+Feature: `all` matcher
+
+  Use the `all` matcher to specify that a collection's objects all pass an expected matcher.
+  This works on any enumerable object.
+
+    ```ruby
+    expect([1, 3, 5]).to all( be_odd )
+    expect([1, 3, 5]).to all( be_an(Integer) )
+    expect([1, 3, 5]).to all( be < 10 )
+    expect([1, 3, 4]).to all( be_odd ) # fails
+    ```
+
+  The matcher also supports compound matchers:
+
+    ```ruby
+    expect([1, 3, 5]).to all( be_odd.and be < 10 )
+    expect([1, 4, 21]).to all( be_odd.or be < 10 )
+    ```
+
+  Scenario: array usage
+    Given a file named "array_all_matcher_spec.rb" with:
+      """ruby
+      RSpec.describe [1, 3, 5] do
+        it { is_expected.to all( be_odd ) }
+        it { is_expected.to all( be_an(Integer) ) }
+        it { is_expected.to all( be < 10 ) }
+
+        # deliberate failures
+        it { is_expected.to all( be_even ) }
+        it { is_expected.to all( be_a(String) ) }
+        it { is_expected.to all( be > 2 ) }
+      end
+      """
+    When I run `rspec array_all_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 6 examples, 3 failures                        |
+      | expected [1, 3, 5] to all be even             |
+      | expected [1, 3, 5] to all be a kind of String |
+      | expected [1, 3, 5] to all be > 2              |
+
+  Scenario: compound matcher usage
+    Given a file named "compound_all_matcher_spec.rb" with:
+      """ruby
+      RSpec.describe ['anything', 'everything', 'something'] do
+        it { is_expected.to all( be_a(String).and include("thing") ) }
+        it { is_expected.to all( be_a(String).and end_with("g") ) }
+        it { is_expected.to all( start_with("s").or include("y") ) }
+
+        # deliberate failures
+        it { is_expected.to all( include("foo").and include("bar") ) }
+        it { is_expected.to all( be_a(String).and start_with("a") ) }
+        it { is_expected.to all( start_with("a").or include("z") ) }
+      end
+      """
+    When I run `rspec compound_all_matcher_spec.rb`
+    Then the output should contain all of these:
+      | 6 examples, 3 failures                                                                         |
+      | expected ["anything", "everything", "something"] to all include "foo" and include "bar"        |
+      | expected ["anything", "everything", "something"] to all be a kind of String and start with "a" |
+      | expected ["anything", "everything", "something"] to all start with "a" or include "z"          |

data/rspec-expectations/upstream/features/built_in_matchers/be.feature

@@ -0,0 +1,175 @@
+Feature: `be` matchers
+
+  There are several related "be" matchers:
+
+    ```ruby
+    expect(obj).to be_truthy  # passes if obj is truthy (not nil or false)
+    expect(obj).to be_falsey  # passes if obj is falsy (nil or false)
+    expect(obj).to be_nil     # passes if obj is nil
+    expect(obj).to be         # passes if obj is truthy (not nil or false)
+    ```
+
+  Scenario: be_truthy matcher
+    Given a file named "be_truthy_spec.rb" with:
+      """ruby
+      RSpec.describe "be_truthy matcher" do
+        specify { expect(true).to be_truthy }
+        specify { expect(7).to be_truthy }
+        specify { expect("foo").to be_truthy }
+        specify { expect(nil).not_to be_truthy }
+        specify { expect(false).not_to be_truthy }
+
+        # deliberate failures
+        specify { expect(true).not_to be_truthy }
+        specify { expect(7).not_to be_truthy }
+        specify { expect("foo").not_to be_truthy }
+        specify { expect(nil).to be_truthy }
+        specify { expect(false).to be_truthy }
+      end
+      """
+    When I run `rspec be_truthy_spec.rb`
+    Then the output should contain "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: falsey value
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: falsey value
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: falsey value
+                  got: "foo"
+      """
+    And the output should contain:
+      """
+             expected: truthy value
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: truthy value
+                  got: false
+      """
+
+  Scenario: be_falsey matcher
+    Given a file named "be_falsey_spec.rb" with:
+      """ruby
+      RSpec.describe "be_falsey matcher" do
+        specify { expect(nil).to be_falsey }
+        specify { expect(false).to be_falsey }
+        specify { expect(true).not_to be_falsey }
+        specify { expect(7).not_to be_falsey }
+        specify { expect("foo").not_to be_falsey }
+
+        # deliberate failures
+        specify { expect(nil).not_to be_falsey }
+        specify { expect(false).not_to be_falsey }
+        specify { expect(true).to be_falsey }
+        specify { expect(7).to be_falsey }
+        specify { expect("foo").to be_falsey }
+      end
+      """
+    When I run `rspec be_falsey_spec.rb`
+    Then the output should contain "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: truthy value
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: truthy value
+                  got: false
+      """
+    And the output should contain:
+      """
+             expected: falsey value
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: falsey value
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: falsey value
+                  got: "foo"
+      """
+
+  Scenario: be_nil matcher
+    Given a file named "be_nil_spec.rb" with:
+      """ruby
+      RSpec.describe "be_nil matcher" do
+        specify { expect(nil).to be_nil }
+        specify { expect(false).not_to be_nil }
+        specify { expect(true).not_to be_nil }
+        specify { expect(7).not_to be_nil }
+        specify { expect("foo").not_to be_nil }
+
+        # deliberate failures
+        specify { expect(nil).not_to be_nil }
+        specify { expect(false).to be_nil }
+        specify { expect(true).to be_nil }
+        specify { expect(7).to be_nil }
+        specify { expect("foo").to 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
+      RSpec.describe "be_matcher" do
+        specify { expect(true).to be }
+        specify { expect(7).to be }
+        specify { expect("foo").to be }
+        specify { expect(nil).not_to be }
+        specify { expect(false).not_to be }
+
+        # deliberate failures
+        specify { expect(true).not_to be }
+        specify { expect(7).not_to be }
+        specify { expect("foo").not_to be }
+        specify { expect(nil).to be }
+        specify { expect(false).to 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  |