vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/features/built_in_matchers/have.feature

@@ -1,109 +0,0 @@
-Feature: have(n).items matcher
-
-  RSpec provides several matchers that make it easy to set expectations about the
-  size of a collection.  There are three basic forms:
-
-    ```ruby
-    collection.should have(x).items
-    collection.should have_at_least(x).items
-    collection.should have_at_most(x).items
-    ```
-
-  In addition, #have_exactly is provided as an alias to #have.
-
-  These work on any collection-like object--the object just needs to respond to #size
-  or #length (or both).  When the matcher is called directly on a collection object,
-  the #items call is pure syntactic sugar.  You can use anything you want here.  These
-  are equivalent:
-
-    ```ruby
-    collection.should have(x).items
-    collection.should have(x).things
-    ```
-
-  You can also use this matcher on a non-collection object that returns a collection
-  from one of its methods.  For example, Dir#entries returns an array, so you could
-  set an expectation using the following:
-
-    ```ruby
-    Dir.new("my/directory").should have(7).entries
-    ```
-
-  Scenario: have(x).items on a collection
-    Given a file named "have_items_spec.rb" with:
-      """ruby
-      describe [1, 2, 3] do
-        it { should have(3).items }
-        it { should_not have(2).items }
-        it { should_not have(4).items }
-
-        it { should have_exactly(3).items }
-        it { should_not have_exactly(2).items }
-        it { should_not have_exactly(4).items }
-
-        it { should have_at_least(2).items }
-        it { should have_at_most(4).items }
-
-        # deliberate failures
-        it { should_not have(3).items }
-        it { should have(2).items }
-        it { should have(4).items }
-
-        it { should_not have_exactly(3).items }
-        it { should have_exactly(2).items }
-        it { should have_exactly(4).items }
-
-        it { should have_at_least(4).items }
-        it { should have_at_most(2).items }
-      end
-      """
-     When I run `rspec have_items_spec.rb`
-     Then the output should contain "16 examples, 8 failures"
-      And the output should contain "expected target not to have 3 items, got 3"
-      And the output should contain "expected 2 items, got 3"
-      And the output should contain "expected 4 items, got 3"
-      And the output should contain "expected at least 4 items, got 3"
-      And the output should contain "expected at most 2 items, got 3"
-
-  Scenario: have(x).words on a String when String#words is defined
-    Given a file named "have_words_spec.rb" with:
-      """ruby
-      class String
-        def words
-          split(' ')
-        end
-      end
-
-      describe "a sentence with some words" do
-        it { should have(5).words }
-        it { should_not have(4).words }
-        it { should_not have(6).words }
-
-        it { should have_exactly(5).words }
-        it { should_not have_exactly(4).words }
-        it { should_not have_exactly(6).words }
-
-        it { should have_at_least(4).words }
-        it { should have_at_most(6).words }
-
-        # deliberate failures
-        it { should_not have(5).words }
-        it { should have(4).words }
-        it { should have(6).words }
-
-        it { should_not have_exactly(5).words }
-        it { should have_exactly(4).words }
-        it { should have_exactly(6).words }
-
-        it { should have_at_least(6).words }
-        it { should have_at_most(4).words }
-      end
-      """
-     When I run `rspec have_words_spec.rb`
-     Then the output should contain "16 examples, 8 failures"
-      And the output should contain "expected target not to have 5 words, got 5"
-      And the output should contain "expected 4 words, got 5"
-      And the output should contain "expected 6 words, got 5"
-      And the output should contain "expected at least 6 words, got 5"
-      And the output should contain "expected at most 4 words, got 5"
-

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/features/built_in_matchers/include.feature

@@ -1,174 +0,0 @@
-Feature: include matcher
-
-  Use the include matcher to specify that a collection includes one or more
-  expected objects.  This works on any object that responds to #include?  (such
-  as a string or array):
-
-    ```ruby
-    "a string".should include("a")
-    "a string".should include("str")
-    "a string".should include("str", "g")
-    "a string".should_not include("foo")
-
-    [1, 2].should include(1)
-    [1, 2].should include(1, 2)
-    [1, 2].should_not include(17)
-    ```
-
-  The matcher also provides flexible handling for hashes:
-
-    ```ruby
-    {:a => 1, :b => 2}.should include(:a)
-    {:a => 1, :b => 2}.should include(:a, :b)
-    {:a => 1, :b => 2}.should include(:a => 1)
-    {:a => 1, :b => 2}.should include(:b => 2, :a => 1)
-    {:a => 1, :b => 2}.should_not include(:c)
-    {:a => 1, :b => 2}.should_not include(:a => 2)
-    {:a => 1, :b => 2}.should_not include(:c => 3)
-    ```
-
-  Scenario: array usage
-    Given a file named "array_include_matcher_spec.rb" with:
-      """ruby
-      describe [1, 3, 7] do
-        it { should include(1) }
-        it { should include(3) }
-        it { should include(7) }
-        it { should include(1, 7) }
-        it { should include(1, 3, 7) }
-        it { should_not include(17) }
-        it { should_not include(43, 100) }
-
-        # deliberate failures
-        it { should include(4) }
-        it { should_not include(1) }
-        it { should_not include(3) }
-        it { should_not include(7) }
-        it { should_not include(1, 3, 7) }
-
-        # both of these should fail since it includes 1 but not 9
-        it { should include(1, 9) }
-        it { should_not include(1, 9) }
-      end
-      """
-    When I run `rspec array_include_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 14 examples, 7 failures                       |
-      | expected [1, 3, 7] to include 4               |
-      | expected [1, 3, 7] not to include 1           |
-      | expected [1, 3, 7] not to include 3           |
-      | expected [1, 3, 7] not to include 7           |
-      | expected [1, 3, 7] not to include 1, 3, and 7 |
-      | expected [1, 3, 7] to include 1 and 9         |
-      | expected [1, 3, 7] not to include 1 and 9     |
-
-  Scenario: string usage
-    Given a file named "string_include_matcher_spec.rb" with:
-      """ruby
-      describe "a string" do
-        it { should include("str") }
-        it { should include("a", "str", "ng") }
-        it { should_not include("foo") }
-        it { should_not include("foo", "bar") }
-
-        # deliberate failures
-        it { should include("foo") }
-        it { should_not include("str") }
-        it { should include("str", "foo") }
-        it { should_not include("str", "foo") }
-      end
-      """
-    When I run `rspec string_include_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures                             |
-      | expected "a string" to include "foo"               |
-      | expected "a string" not to include "str"           |
-      | expected "a string" to include "str" and "foo"     |
-      | expected "a string" not to include "str" and "foo" |
-
-  Scenario: hash usage
-    Given a file named "hash_include_matcher_spec.rb" with:
-      """ruby
-      describe Hash do
-        subject { { :a => 7, :b => 5 } }
-
-        it { should include(:a) }
-        it { should include(:b, :a) }
-        it { should include(:a => 7) }
-        it { should include(:b => 5, :a => 7) }
-        it { should_not include(:c) }
-        it { should_not include(:c, :d) }
-        it { should_not include(:d => 2) }
-        it { should_not include(:a => 5) }
-        it { should_not include(:b => 7, :a => 5) }
-
-        # deliberate failures
-        it { should_not include(:a) }
-        it { should_not include(:b, :a) }
-        it { should_not include(:a => 7) }
-        it { should_not include(:a => 7, :b => 5) }
-        it { should include(:c) }
-        it { should include(:c, :d) }
-        it { should include(:d => 2) }
-        it { should include(:a => 5) }
-        it { should include(:a => 5, :b => 7) }
-
-        # Mixed cases--the hash includes one but not the other.
-        # All 4 of these cases should fail.
-        it { should include(:a, :d) }
-        it { should_not include(:a, :d) }
-        it { should include(:a => 7, :d => 3) }
-        it { should_not include(:a => 7, :d => 3) }
-      end
-      """
-    When I run `rspec hash_include_matcher_spec.rb`
-    Then the output should contain "13 failure"
-
-  Scenario: fuzzy usage with matchers
-    Given a file named "fuzzy_include_matcher_spec.rb" with:
-      """
-      require 'ostruct'
-
-      class User < OpenStruct
-        def inspect
-          name
-        end
-      end
-
-      RSpec::Matchers.define :a_user_named do |expected|
-        match do |actual|
-          actual.is_a?(User) && (actual.name == expected)
-        end
-        description do
-          "a user named '#{expected}'"
-        end
-      end
-
-      describe "Collection of users" do
-        subject do
-          [User.new(:name => "Joe"),
-           User.new(:name => "Fred"),
-           User.new(:name => "John"),
-           User.new(:name => "Luke"),
-           User.new(:name => "David")]
-        end
-
-        it { should include( a_user_named "Joe" ) }
-        it { should include( a_user_named "Luke" ) }
-        it { should_not include( a_user_named "Richard" ) }
-        it { should_not include( a_user_named "Hayley" ) }
-
-        # deliberate failures
-        it { should include( a_user_named "Richard" ) }
-        it { should_not include( a_user_named "Fred" ) }
-        it { should include( a_user_named "Sarah" ) }
-        it { should_not include( a_user_named "Luke" ) }
-      end
-      """
-    When I run `rspec fuzzy_include_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures                                                     |
-      | expected [Joe, Fred, John, Luke, David] to include a user named 'Richard'  |
-      | expected [Joe, Fred, John, Luke, David] not to include a user named 'Fred' |
-      | expected [Joe, Fred, John, Luke, David] to include a user named 'Sarah'    |
-      | expected [Joe, Fred, John, Luke, David] not to include a user named 'Luke' |

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/features/built_in_matchers/match.feature

@@ -1,52 +0,0 @@
-Feature: match matcher
-
-  The match matcher calls #match on the object, passing if #match returns a
-  truthy (not false or nil) value.  Regexp and String both provide a #match
-  method.
-
-    ```ruby
-    "a string".should match(/str/) # passes
-    "a string".should match(/foo/) # fails
-    /foo/.should match("food")     # passes
-    /foo/.should match("drinks")   # fails
-    ```
-
-  This is equivalent to using the =~ matcher (see the operator matchers
-  feature for more details).
-
-  Scenario: string usage
-    Given a file named "string_match_spec.rb" with:
-      """ruby
-      describe "a string" do
-        it { should match(/str/) }
-        it { should_not match(/foo/) }
-
-        # deliberate failures
-        it { should_not match(/str/) }
-        it { should match(/foo/) }
-      end
-      """
-    When I run `rspec string_match_spec.rb`
-    Then the output should contain all of these:
-      | 4 examples, 2 failures                 |
-      | expected "a string" not to match /str/ |
-      | expected "a string" to match /foo/     |
-
-  Scenario: regular expression usage
-    Given a file named "regexp_match_spec.rb" with:
-      """ruby
-      describe /foo/ do
-        it { should match("food") }
-        it { should_not match("drinks") }
-
-        # deliberate failures
-        it { should_not match("food") }
-        it { should match("drinks") }
-      end
-      """
-    When I run `rspec regexp_match_spec.rb`
-    Then the output should contain all of these:
-      | 4 examples, 2 failures             |
-      | expected /foo/ not to match "food" |
-      | expected /foo/ to match "drinks"   |
-

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/features/built_in_matchers/operators.feature

@@ -1,227 +0,0 @@
-Feature: operator matchers
-
-  RSpec provides a number of matchers that are based on Ruby's built-in
-  operators. These pretty much work like you expect. For example, each of these
-  pass:
-
-    ```ruby
-    7.should == 7
-    [1, 2, 3].should == [1, 2, 3]
-    "this is a string".should =~ /^this/
-    "this is a string".should_not =~ /^that/
-    String.should === "this is a string"
-    ```
-
-  You can also use comparison operators combined with the "be" matcher like
-  this:
-
-    ```ruby
-    37.should be < 100
-    37.should be <= 38
-    37.should be >= 2
-    37.should be > 7
-    ```
-
-  RSpec also provides a `=~` matcher for arrays that disregards differences in
-  the ording between the actual and expected array.  For example:
-
-    ```ruby
-    [1, 2, 3].should =~ [2, 3, 1] # pass
-    [:a, :c, :b].should =~ [:a, :c] # fail
-    ```
-
-  Scenario: numeric operator matchers
-    Given a file named "numeric_operator_matchers_spec.rb" with:
-      """ruby
-      describe 18 do
-        it { should == 18 }
-        it { should be < 20 }
-        it { should be > 15 }
-        it { should be <= 19 }
-        it { should be >= 17 }
-
-        it { should_not == 28 }
-
-        # deliberate failures
-        it { should == 28 }
-        it { should be < 15 }
-        it { should be > 20 }
-        it { should be <= 17 }
-        it { should be >= 19 }
-
-        it { should_not == 18 }
-      end
-      """
-     When I run `rspec numeric_operator_matchers_spec.rb`
-     Then the output should contain "12 examples, 6 failures"
-      And the output should contain:
-      """
-           Failure/Error: it { should == 28 }
-             expected: 28
-                  got: 18 (using ==)
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be < 15 }
-             expected: < 15
-                  got:   18
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be > 20 }
-             expected: > 20
-                  got:   18
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be <= 17 }
-             expected: <= 17
-                  got:    18
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be >= 19 }
-             expected: >= 19
-                  got:    18
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should_not == 18 }
-             expected not: == 18
-                      got:    18
-      """
-
-  Scenario: string operator matchers
-    Given a file named "string_operator_matchers_spec.rb" with:
-      """ruby
-      describe "Strawberry" do
-        it { should == "Strawberry" }
-        it { should be < "Tomato" }
-        it { should be > "Apple" }
-        it { should be <= "Turnip" }
-        it { should be >= "Banana" }
-        it { should =~ /berry/ }
-
-        it { should_not == "Peach" }
-        it { should_not =~ /apple/ }
-
-        it "reports that it is a string using ===" do
-          String.should === subject
-        end
-
-        # deliberate failures
-        it { should == "Peach" }
-        it { should be < "Cranberry" }
-        it { should be > "Zuchini" }
-        it { should be <= "Potato" }
-        it { should be >= "Tomato" }
-        it { should =~ /apple/ }
-
-        it { should_not == "Strawberry" }
-        it { should_not =~ /berry/ }
-
-        it "fails a spec asserting that it is a symbol" do
-          Symbol.should === subject
-        end
-      end
-      """
-     When I run `rspec string_operator_matchers_spec.rb`
-     Then the output should contain "18 examples, 9 failures"
-      And the output should contain:
-      """
-           Failure/Error: it { should == "Peach" }
-             expected: "Peach"
-                  got: "Strawberry" (using ==)
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be < "Cranberry" }
-             expected: < "Cranberry"
-                  got:   "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be > "Zuchini" }
-             expected: > "Zuchini"
-                  got:   "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be <= "Potato" }
-             expected: <= "Potato"
-                  got:    "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should be >= "Tomato" }
-             expected: >= "Tomato"
-                  got:    "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should =~ /apple/ }
-             expected: /apple/
-                  got: "Strawberry" (using =~)
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should_not == "Strawberry" }
-             expected not: == "Strawberry"
-                      got:    "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should_not =~ /berry/ }
-             expected not: =~ /berry/
-                      got:    "Strawberry"
-      """
-      And the output should contain:
-      """
-           Failure/Error: Symbol.should === subject
-             expected: "Strawberry"
-                  got: Symbol (using ===)
-      """
-
-  Scenario: array operator matchers
-    Given a file named "array_operator_matchers_spec.rb" with:
-      """ruby
-      describe [1, 2, 3] do
-        it { should == [1, 2, 3] }
-        it { should_not == [1, 3, 2] }
-
-        it { should =~ [1, 2, 3] }
-        it { should =~ [1, 3, 2] }
-        it { should =~ [2, 1, 3] }
-        it { should =~ [2, 3, 1] }
-        it { should =~ [3, 1, 2] }
-        it { should =~ [3, 2, 1] }
-
-        # deliberate failures
-        it { should_not == [1, 2, 3] }
-        it { should == [1, 3, 2] }
-        it { should =~ [1, 2, 1] }
-      end
-      """
-     When I run `rspec array_operator_matchers_spec.rb`
-     Then the output should contain "11 examples, 3 failures"
-      And the output should contain:
-      """
-           Failure/Error: it { should_not == [1, 2, 3] }
-             expected not: == [1, 2, 3]
-                      got:    [1, 2, 3]
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should == [1, 3, 2] }
-             expected: [1, 3, 2]
-                  got: [1, 2, 3] (using ==)
-      """
-      And the output should contain:
-      """
-           Failure/Error: it { should =~ [1, 2, 1] }
-             expected collection contained:  [1, 1, 2]
-             actual collection contained:    [1, 2, 3]
-             the missing elements were:      [1]
-             the extra elements were:        [3]
-      """
-