tuktuk-rails 0.0.6 → 0.0.7

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

@@ -0,0 +1,161 @@
+Feature: yield matchers
+
+  There are four related matchers that allow you to specify whether
+  or not a method yields, how many times it yields, whether or not
+  it yields with arguments, and what those arguments are.
+
+    * `yield_control` matches if the method-under-test yields, regardless
+      of whether or not arguments are yielded.
+    * `yield_with_args` matches if the method-under-test yields with
+      arguments. If arguments are provided to this matcher, it will
+      only pass if the actual yielded arguments match the expected ones
+      using `===` or `==`.
+    * `yield_with_no_args` matches if the method-under-test yields with
+      no arguments.
+    * `yield_successive_args` is designed for iterators, and will match
+      if the method-under-test yields the same number of times as arguments
+      passed to this matcher, and all actual yielded arguments match the
+      expected ones using `===` or `==`.
+
+  Note: your expect block _must_ accept an argument that is then passed on to
+  the method-under-test as a block. This acts as a "probe" that allows the matcher
+  to detect whether or not your method yields, and, if so, how many times and what
+  the yielded arguments are.
+
+  Background:
+    Given a file named "my_class.rb" with:
+      """ruby
+      class MyClass
+        def self.yield_once_with(*args)
+          yield *args
+        end
+
+        def self.yield_twice_with(*args)
+          2.times { yield *args }
+        end
+
+        def self.raw_yield
+          yield
+        end
+
+        def self.dont_yield
+        end
+      end
+      """
+
+  Scenario: yield_control matcher
+    Given a file named "yield_control_spec.rb" with:
+      """ruby
+      require './my_class'
+
+      describe "yield_control matcher" do
+        specify { expect { |b| MyClass.yield_once_with(1, &b) }.to yield_control }
+        specify { expect { |b| MyClass.dont_yield(&b) }.not_to yield_control }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.twice }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.exactly(2).times }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.at_least(1) }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.at_most(3).times }
+
+        # deliberate failures
+        specify { expect { |b| MyClass.yield_once_with(1, &b) }.not_to yield_control }
+        specify { expect { |b| MyClass.dont_yield(&b) }.to yield_control }
+        specify { expect { |b| MyClass.yield_once_with(1, &b) }.to yield_control.at_least(2).times }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.twice }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_least(2).times }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_least(1) }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_most(3).times }
+      end
+      """
+    When I run `rspec yield_control_spec.rb`
+    Then the output should contain all of these:
+      | 13 examples, 7 failures                                   |
+      | expected given block to yield control                     |
+      | expected given block not to yield control                 |
+      | expected given block not to yield control at least twice  |
+      | expected given block not to yield control at most 3 times |
+
+  Scenario: yield_with_args matcher
+    Given a file named "yield_with_args_spec.rb" with:
+      """ruby
+      require './my_class'
+
+      describe "yield_with_args matcher" do
+        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args }
+        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args("foo") }
+        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args(String) }
+        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args(/oo/) }
+
+        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args("foo", "bar") }
+        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args(String, String) }
+        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args(/fo/, /ar/) }
+
+        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.not_to yield_with_args(17, "baz") }
+
+        # deliberate failures
+        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args }
+        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args("foo") }
+        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args(String) }
+        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args(/oo/) }
+        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.not_to yield_with_args("foo", "bar") }
+        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args(17, "baz") }
+      end
+      """
+    When I run `rspec yield_with_args_spec.rb`
+    Then the output should contain all of these:
+      | 14 examples, 6 failures                                                               |
+      | expected given block not to yield with arguments, but did                             |
+      | expected given block not to yield with arguments, but yielded with expected arguments |
+      | expected given block to yield with arguments, but yielded with unexpected arguments   |
+
+  Scenario: yield_with_no_args matcher
+    Given a file named "yield_with_no_args_spec.rb" with:
+      """ruby
+      require './my_class'
+
+      describe "yield_with_no_args matcher" do
+        specify { expect { |b| MyClass.raw_yield(&b) }.to yield_with_no_args }
+        specify { expect { |b| MyClass.dont_yield(&b) }.not_to yield_with_no_args }
+        specify { expect { |b| MyClass.yield_once_with("a", &b) }.not_to yield_with_no_args }
+
+        # deliberate failures
+        specify { expect { |b| MyClass.raw_yield(&b) }.not_to yield_with_no_args }
+        specify { expect { |b| MyClass.dont_yield(&b) }.to yield_with_no_args }
+        specify { expect { |b| MyClass.yield_once_with("a", &b) }.to yield_with_no_args }
+      end
+      """
+    When I run `rspec yield_with_no_args_spec.rb`
+    Then the output should contain all of these:
+      | 6 examples, 3 failures                                                             |
+      | expected given block not to yield with no arguments, but did                       |
+      | expected given block to yield with no arguments, but did not yield                 |
+      | expected given block to yield with no arguments, but yielded with arguments: ["a"] |
+
+  Scenario: yield_successive_args matcher
+    Given a file named "yield_successive_args_spec.rb" with:
+      """ruby
+      def array
+        [1, 2, 3]
+      end
+
+      def array_of_tuples
+        [[:a, :b], [:c, :d]]
+      end
+
+      describe "yield_successive_args matcher" do
+        specify { expect { |b| array.each(&b) }.to yield_successive_args(1, 2, 3) }
+        specify { expect { |b| array_of_tuples.each(&b) }.to yield_successive_args([:a, :b], [:c, :d]) }
+        specify { expect { |b| array.each(&b) }.to yield_successive_args(Fixnum, Fixnum, Fixnum) }
+        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(1, 2) }
+
+        # deliberate failures
+        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(1, 2, 3) }
+        specify { expect { |b| array_of_tuples.each(&b) }.not_to yield_successive_args([:a, :b], [:c, :d]) }
+        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(Fixnum, Fixnum, Fixnum) }
+        specify { expect { |b| array.each(&b) }.to yield_successive_args(1, 2) }
+      end
+      """
+    When I run `rspec yield_successive_args_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                                                             |
+      | expected given block not to yield successively with arguments, but yielded with expected arguments |
+      | expected given block to yield successively with arguments, but yielded with unexpected arguments   |

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/features/custom_matchers/access_running_example.feature

@@ -0,0 +1,53 @@
+Feature: access running example
+
+  In order to take advantage of services that are available
+    in my examples when I'm writing matchers
+  As a spec author
+  I want to call methods on the running example
+
+  If the method exists in the context of the example, it gets
+  called. If not, a NoMethodError is raised on the Matcher itself
+  (not the example).
+
+  Scenario: call method defined on example from matcher
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :bar do
+        match do |_|
+          foo == "foo"
+        end
+      end
+
+      describe "something" do
+        def foo
+          "foo"
+        end
+
+        it "does something" do
+          "foo".should bar
+        end
+      end
+      """
+    When I run `rspec ./example_spec.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: call method _not_ defined on example from matcher
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :bar do
+        match do |_|
+          foo == "foo"
+        end
+      end
+
+      describe "something" do
+        it "does something" do
+          "foo".should bar
+        end
+      end
+      """
+    When I run `rspec ./example_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should match /undefined.*method/
+    And the output should contain "RSpec::Matchers::DSL::Matcher"
+    And the output should not contain "ExampleGroup"

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/features/custom_matchers/define_diffable_matcher.feature

@@ -0,0 +1,27 @@
+Feature: define diffable matcher
+
+  When a matcher is defined as diffable, and the --diff
+  flag is set, the output will include a diff of the submitted
+  objects.
+
+  @wip
+  Scenario: define a diffable matcher
+    Given a file named "diffable_matcher_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :be_just_like do |expected|
+        match do |actual|
+          actual == expected
+        end
+
+        diffable
+      end
+
+      describe "this" do
+        it {should be_just_like("that")}
+      end
+      """
+    When I run `rspec ./diffable_matcher_spec.rb --diff`
+    Then the exit status should not be 0
+
+    And the output should contain "should be just like that"
+    And the output should contain "Diff:\n@@ -1,2 +1,2 @@\n-that\n+this"

data/vendor/bundle/ruby/2.0.0/gems/rspec-expectations-2.14.4/features/custom_matchers/define_matcher.feature

@@ -0,0 +1,368 @@
+Feature: define matcher
+
+  In order to express my domain clearly in my code examples
+  As an RSpec user
+  I want a shortcut to define custom matchers
+
+  Scenario: define a matcher with default messages
+    Given a file named "matcher_with_default_message_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+      end
+
+      describe 9 do
+        it {should be_a_multiple_of(3)}
+      end
+
+      describe 9 do
+        it {should_not be_a_multiple_of(4)}
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should be_a_multiple_of(4)}
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should_not be_a_multiple_of(3)}
+      end
+
+      """
+    When I run `rspec ./matcher_with_default_message_spec.rb --format documentation`
+    Then the exit status should not be 0
+
+    And the output should contain "should be a multiple of 3"
+    And the output should contain "should not be a multiple of 4"
+    And the output should contain "Failure/Error: it {should be_a_multiple_of(4)}"
+    And the output should contain "Failure/Error: it {should_not be_a_multiple_of(3)}"
+
+    And the output should contain "4 examples, 2 failures"
+    And the output should contain "expected 9 to be a multiple of 4"
+    And the output should contain "expected 9 not to be a multiple of 3"
+
+  Scenario: overriding the failure_message_for_should
+    Given a file named "matcher_with_failure_message_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        failure_message_for_should do |actual|
+          "expected that #{actual} would be a multiple of #{expected}"
+        end
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should be_a_multiple_of(4)}
+      end
+      """
+    When I run `rspec ./matcher_with_failure_message_spec.rb`
+    Then the exit status should not be 0
+    And the stdout should contain "1 example, 1 failure"
+    And the stdout should contain "expected that 9 would be a multiple of 4"
+
+  Scenario: overriding the failure_message_for_should_not
+    Given a file named "matcher_with_failure_for_message_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        failure_message_for_should_not do |actual|
+          "expected that #{actual} would not be a multiple of #{expected}"
+        end
+      end
+
+      # fail intentionally to generate expected output
+      describe 9 do
+        it {should_not be_a_multiple_of(3)}
+      end
+      """
+    When I run `rspec ./matcher_with_failure_for_message_spec.rb`
+    Then the exit status should not be 0
+    And the stdout should contain "1 example, 1 failure"
+    And the stdout should contain "expected that 9 would not be a multiple of 3"
+
+  Scenario: overriding the description
+    Given a file named "matcher_overriding_description_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        match do |actual|
+          actual % expected == 0
+        end
+        description do
+          "be multiple of #{expected}"
+        end
+      end
+
+      describe 9 do
+        it {should be_a_multiple_of(3)}
+      end
+
+      describe 9 do
+        it {should_not be_a_multiple_of(4)}
+      end
+      """
+    When I run `rspec ./matcher_overriding_description_spec.rb --format documentation`
+    Then the exit status should be 0
+    And the stdout should contain "2 examples, 0 failures"
+    And the stdout should contain "should be multiple of 3"
+    And the stdout should contain "should not be multiple of 4"
+
+  Scenario: with no args
+    Given a file named "matcher_with_no_args_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :have_7_fingers do
+        match do |thing|
+          thing.fingers.length == 7
+        end
+      end
+
+      class Thing
+        def fingers; (1..7).collect {"finger"}; end
+      end
+
+      describe Thing do
+        it {should have_7_fingers}
+      end
+      """
+    When I run `rspec ./matcher_with_no_args_spec.rb --format documentation`
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+    And the stdout should contain "should have 7 fingers"
+
+  Scenario: with multiple args
+    Given a file named "matcher_with_multiple_args_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :be_the_sum_of do |a,b,c,d|
+        match do |sum|
+          a + b + c + d == sum
+        end
+      end
+
+      describe 10 do
+        it {should be_the_sum_of(1,2,3,4)}
+      end
+      """
+    When I run `rspec ./matcher_with_multiple_args_spec.rb --format documentation`
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+    And the stdout should contain "should be the sum of 1, 2, 3, and 4"
+
+  Scenario: with helper methods
+    Given a file named "matcher_with_internal_helper_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      RSpec::Matchers.define :have_same_elements_as do |sample|
+        match do |actual|
+          similar?(sample, actual)
+        end
+
+        def similar?(a, b)
+          a.sort == b.sort
+        end
+      end
+
+      describe "these two arrays" do
+        specify "should be similar" do
+          [1,2,3].should have_same_elements_as([2,3,1])
+        end
+      end
+      """
+    When I run `rspec ./matcher_with_internal_helper_spec.rb`
+    Then the exit status should be 0
+    And the stdout should contain "1 example, 0 failures"
+
+  Scenario: scoped in a module
+    Given a file named "scoped_matcher_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      module MyHelpers
+        extend RSpec::Matchers::DSL
+
+        matcher :be_just_like do |expected|
+          match {|actual| actual == expected}
+        end
+      end
+
+      describe "group with MyHelpers" do
+        include MyHelpers
+        it "has access to the defined matcher" do
+          5.should be_just_like(5)
+        end
+      end
+
+      describe "group without MyHelpers" do
+        it "does not have access to the defined matcher" do
+          expect do
+            5.should be_just_like(5)
+          end.to raise_exception
+        end
+      end
+      """
+
+    When I run `rspec ./scoped_matcher_spec.rb`
+    Then the stdout should contain "2 examples, 0 failures"
+
+  Scenario: scoped in an example group
+    Given a file named "scoped_matcher_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+
+      describe "group with matcher" do
+        matcher :be_just_like do |expected|
+          match {|actual| actual == expected}
+        end
+
+        it "has access to the defined matcher" do
+          5.should be_just_like(5)
+        end
+
+        describe "nested group" do
+          it "has access to the defined matcher" do
+            5.should be_just_like(5)
+          end
+        end
+
+      end
+
+      describe "group without matcher" do
+        it "does not have access to the defined matcher" do
+          expect do
+            5.should be_just_like(5)
+          end.to raise_exception
+        end
+      end
+      """
+
+    When I run `rspec scoped_matcher_spec.rb`
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: matcher with separate logic for should and should_not
+    Given a file named "matcher_with_separate_should_not_logic_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :contain do |*expected|
+        match_for_should do |actual|
+          expected.all? { |e| actual.include?(e) }
+        end
+
+        match_for_should_not do |actual|
+          expected.none? { |e| actual.include?(e) }
+        end
+      end
+
+      describe [1, 2, 3] do
+        it { should contain(1, 2) }
+        it { should_not contain(4, 5, 6) }
+
+        # deliberate failures
+        it { should contain(1, 4) }
+        it { should_not contain(1, 4) }
+      end
+      """
+    When I run `rspec matcher_with_separate_should_not_logic_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures                    |
+      | expected [1, 2, 3] to contain 1 and 4     |
+      | expected [1, 2, 3] not to contain 1 and 4 |
+
+  Scenario: use define_method to create a helper method with access to matcher params
+    Given a file named "define_method_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        define_method :is_multiple? do |actual|
+          actual % expected == 0
+        end
+        match { |actual| is_multiple?(actual) }
+      end
+
+      describe 9 do
+        it { should be_a_multiple_of(3) }
+        it { should_not be_a_multiple_of(4) }
+
+        # deliberate failures
+        it { should be_a_multiple_of(2) }
+        it { should_not be_a_multiple_of(3) }
+      end
+      """
+    When I run `rspec define_method_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures               |
+      | expected 9 to be a multiple of 2     |
+      | expected 9 not to be a multiple of 3 |
+
+  Scenario: include a module with helper methods in the matcher
+    Given a file named "include_module_spec.rb" with:
+      """ruby
+      module MatcherHelpers
+        def is_multiple?(actual, expected)
+          actual % expected == 0
+        end
+      end
+
+      RSpec::Matchers.define :be_a_multiple_of do |expected|
+        include MatcherHelpers
+        match { |actual| is_multiple?(actual, expected) }
+      end
+
+      describe 9 do
+        it { should be_a_multiple_of(3) }
+        it { should_not be_a_multiple_of(4) }
+
+        # deliberate failures
+        it { should be_a_multiple_of(2) }
+        it { should_not be_a_multiple_of(3) }
+      end
+      """
+    When I run `rspec include_module_spec.rb`
+    Then the output should contain all of these:
+      | 4 examples, 2 failures               |
+      | expected 9 to be a multiple of 2     |
+      | expected 9 not to be a multiple of 3 |
+
+  Scenario: matching against a regular expression
+    Given a file named "regular_expression_matcher_spec.rb" with:
+      """ruby
+      # Due to Ruby's method dispatch mechanism, use the `#match_regex` alias
+      # rather than the `#match` matcher when defining custom matchers via the
+      # DSL.
+
+      RSpec::Matchers.define :be_valid_us_zipcode do
+        match do |actual|
+          expect(actual).to match_regex(/\A\d{5}(-\d{4})?\z/)
+        end
+      end
+
+      describe "30316" do
+        it { should be_valid_us_zipcode }
+      end
+
+      describe "30316-0001" do
+        it { should be_valid_us_zipcode }
+      end
+
+      describe "1000-61303" do
+        it { should_not be_valid_us_zipcode }
+      end
+      """
+    When I run `rspec regular_expression_matcher_spec.rb`
+    Then the stdout should contain "3 examples, 0 failures"