rspec-given 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51d4d0b65e5c61f3e4477ba071cbb662baf9a641
-  data.tar.gz: 025e3eca40c723c210f09afa21a05a5bc36af8a2
+  metadata.gz: 1d5e73181cf61bc93071d7161a925ed327343dc9
+  data.tar.gz: 608ea8d31f28616d28f82724eb687c67b0f31d88
 SHA512:
-  metadata.gz: 4a72c0d1a81c7a4c232ff99ba00409fd5511a9b43522292b62c3c891075592e21323083db75312c0ebd05ef11409f172b76af0e69245b984baae2c77d8e3fdf0
-  data.tar.gz: fd9dfa5be45391c50a84b6ddccc3d9455a15f312dbe3733a4731d12164e3ae0cceeea0184803eb6134056a5076e1f80e26f41911394ceccdce85b1b1e701c46e
+  metadata.gz: 91305932206df20bc225b9e4c81ba5147c24ba288b687055bdc2265a7e8eba4e4085c39e37e0fb326b98274ceb6cb5ae69446bae063201dca032fe9fb5761749
+  data.tar.gz: 111ba753e7988ba157c844da3d3628713b3b13ec2567c25089bc890946c8eb91b90c35b3c505dbe9c8177f7484dc6783502b4ffef7e270217c854f158a09f6e0

data/Gemfile.lock

@@ -1,21 +1,24 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.2.4)
-    minitest (5.0.6)
-    rake (10.0.4)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.1)
-    rspec-expectations (2.14.0)
+    diff-lcs (1.2.5)
+    minitest (4.3.2)
+    rake (0.9.6)
+    rspec (3.0.0.beta1)
+      rspec-core (= 3.0.0.beta1)
+      rspec-expectations (= 3.0.0.beta1)
+      rspec-mocks (= 3.0.0.beta1)
+    rspec-core (3.0.0.beta1)
+      rspec-support (= 3.0.0.beta1)
+    rspec-expectations (3.0.0.beta1)
       diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.1)
-    sorcerer (0.3.10)
+      rspec-support (= 3.0.0.beta1)
+    rspec-mocks (3.0.0.beta1)
+      rspec-support (= 3.0.0.beta1)
+    rspec-support (3.0.0.beta1)
+    sorcerer (1.0.2)
 
 PLATFORMS
-  java
   ruby
 
 DEPENDENCIES

data/README.md

@@ -4,7 +4,7 @@
 | :----: |
 | [![Master Build Status](https://secure.travis-ci.org/jimweirich/rspec-given.png?branch=master)](https://travis-ci.org/jimweirich/rspec-given) |
 
-Covering rspec-given, minitest-given, and given-core, version 3.1.1.
+Covering rspec-given, minitest-given, and given-core, version 3.2.0.
 
 rspec-given and minitest-given are extensions to your favorite testing
 framework to allow Given/When/Then notation when writing specs.
@@ -19,8 +19,7 @@ structure RSpec specifications.
 
 ## Status
 
-* rspec-given is ready for production use.
-* minitest-given is experimental.
+* rspec-given and minitest-given are ready for production use.
 
 ### RSpec/Given
 
@@ -267,8 +266,10 @@ E.g.
 
       context "inner context" do
 
-        # At this point, the _When_ of the outer context
-        # should be treated as a _Given_ of the inner context
+        # At this point, the _When_ of the outer context will be run
+        # before the _When_ of then inner context (but after all the
+        # _Givens_ of all the contexts).  You can think of the outer
+        # _When_ as a special given for the inner scope.
 
         When { code specified in the inner context }
         Then { assert something about the inner context }
@@ -309,12 +310,16 @@ specify that behavior:
 
 ```ruby
     When(:result) { stack.pop }
-    Then { result.should have_failed(UnderflowError, /empty/) }
+    Then { expect(result).to have_failed(UnderflowError, /empty/) }
 ```
 
-Note that the arguments to the 'have_failed' matcher are the same as
+The arguments to the 'have_failed' matcher are the same as
 those given to the standard RSpec matcher 'raise_error'.
 
+*NOTE:* Prior to RSpec 3, the .should method worked with the failed
+result. In RSpec 3 the <code>.should</code> method is deprecated and
+should not be used with the failed result.
+
 ### Then
 
 The _Then_ clauses are the postconditions of the specification. These
@@ -625,7 +630,7 @@ context.
   context "Outer" do
     context "Inner" do
       Then { a == b }               # Natural Assertions
-      Then { a.should == b }        # RSpec style
+      Then { a.should == b }        # Deprecated RSpec style
       Then { expect(a).to eq(b) }   # RSpec style
       Then { assert_equal b, a }    # Minitest style
       Then { a.must_equal b }       # Minitest style
@@ -709,7 +714,7 @@ For example, the following two Then clauses are equivalent:
 
 ```ruby
     # Using an RSpec matcher
-    Then { result.should have_failed(StandardError, /message/) }
+    Then { expect(result).to have_failed(StandardError, /message/) }
 
     # Using natural assertions
     Then { result == Failure(StandardError, /message/) }
@@ -844,6 +849,10 @@ License. See the MIT-LICENSE file in the source distribution.
 
 # History
 
+* Version 3.2.0
+
+  * Add support for RSpec 3 beta
+
 * Version 3.1.0
 
   * Add support for Precondition/Postcondition/Assert in non-spec

data/examples/failing/natural_failing_spec.rb

@@ -11,10 +11,10 @@ describe "Natural Assertions" do
   Given(:null) { nil }
   Then { foo+foo+2*foo == expected }
   Then { nil == "HI" && true && :symbol  && 1}
-  Then { foo.should == 2 }
+  Then { expect(foo).to eq(2) }
   Then { foo != 1 }
-  Then { foo.should_not == 1 }
-  Then { foo.should be_nil }
+  Then { expect(foo).to_not == 1 }
+  Then { expect(foo).to be_nil }
   Then { ary.empty? }
   Then { !null.nil? }
   Then { fail "OUCH" }

data/examples/integration/and_spec.rb

@@ -35,7 +35,7 @@ describe "And" do
       @message = ex.message
     end
 
-    it "should define a message" do
+    it "defines a message" do
       message = self.class.instance_eval { @message }
       given_assert_match(/and.*without.*then/i, message)
     end

data/spec/lib/given/binary_operation_spec.rb

@@ -5,23 +5,23 @@ describe Given::BinaryOperation do
 
   context "with a valid binary sexp" do
     Given(:sexp) { [:binary,  [:@ident, "a"], :==, [:@ident, "b"]] }
-    Then { binary.left.should == [:@ident, "a"] }
-    Then { binary.operator.should == :== }
-    Then { binary.right.should == [:@ident, "b"] }
-    Then { binary.explain.should == "to equal" }
+    Then { expect(binary.left).to eq([:@ident, "a"]) }
+    Then { expect(binary.operator).to eq(:==) }
+    Then { expect(binary.right).to eq([:@ident, "b"]) }
+    Then { expect(binary.explain).to eq("to equal") }
   end
 
   context "with a valid binary sexp using ===" do
     Given(:sexp) { [:binary,  [:@ident, "a"], :===, [:@ident, "b"]] }
-    Then { binary.left.should == [:@ident, "a"] }
-    Then { binary.operator.should == :=== }
-    Then { binary.right.should == [:@ident, "b"] }
-    Then { binary.explain.should == "to be matched by" }
+    Then { expect(binary.left).to eq([:@ident, "a"]) }
+    Then { expect(binary.operator).to eq(:===) }
+    Then { expect(binary.right).to eq([:@ident, "b"]) }
+    Then { expect(binary.explain).to eq("to be matched by") }
   end
 
   context "with a non-binary sexp" do
     Given(:sexp) { [:something_else] }
-    Then { binary.should be_nil }
+    Then { expect(binary).to be_nil }
   end
 
 end

data/spec/lib/given/evaluator_spec.rb

@@ -6,10 +6,10 @@ describe "Environmental Access" do
   Given(:a) { 2 }
   FauxThen { X + a }
 
-  Then { block_result.should == 3 }
-  Then { ev.eval_string("X").should == "1" }
-  Then { ev.eval_string("a").should == "2" }
-  Then { ev.eval_string("X+a").should == "3" }
+  Then { expect(block_result).to eq(3) }
+  Then { expect(ev.eval_string("X")).to eq("1") }
+  Then { expect(ev.eval_string("a")).to eq("2") }
+  Then { expect(ev.eval_string("X+a")).to eq("3") }
 end
 
 module Nested
@@ -18,10 +18,10 @@ module Nested
     use_natural_assertions false
     Given(:a) { 2 }
     FauxThen { X + a }
-    Then { block_result.should == 3 }
-    Then { ev.eval_string("a").should == "2" }
-    Then { ev.eval_string("X").should == "1" }
-    Then { ev.eval_string("a+X").should == "3" }
+    Then { expect(block_result).to eq(3) }
+    Then { expect(ev.eval_string("a")).to eq("2") }
+    Then { expect(ev.eval_string("X")).to eq("1") }
+    Then { expect(ev.eval_string("a+X")).to eq("3") }
   end
 end
 
@@ -29,6 +29,6 @@ describe "Evaluator with error object" do
   use_natural_assertions false
   FauxThen { 1 }
   When(:result) { ev.eval_string("fail 'XYZ'") }
-  Then { result.class.should == Given::EvalErr }
-  Then { result.inspect.should == "RuntimeError: XYZ" }
+  Then { expect(result.class).to eq(Given::EvalErr) }
+  Then { expect(result.inspect).to eq("RuntimeError: XYZ") }
 end

data/spec/lib/given/extensions_spec.rb

@@ -6,20 +6,20 @@ describe Given::ClassExtensions do
   describe "Given with var" do
     context "with simple given" do
       Given(:a) { 1 }
-      Then { a.should == 1 }
+      Then { expect(a).to eq(1) }
     end
 
     context "is lazy" do
       Given(:a) { trace << :given; 1 }
-      Then { a.should == 1 }
-      Then { trace.should == [] }
-      Then { a; trace.should == [:given] }
+      Then { expect(a).to eq(1) }
+      Then { expect(trace).to eq([]) }
+      Then { a; expect(trace).to eq([:given]) }
 
       context "when nested" do
         Given(:a) { trace << :nested; 2 }
-        Then { a.should == 2 }
-        Then { trace.should == [] }
-        Then { a; trace.should == [:nested] }
+        Then { expect(a).to eq(2) }
+        Then { expect(trace).to eq([]) }
+        Then { a; expect(trace).to eq([:nested]) }
       end
     end
   end
@@ -27,11 +27,11 @@ describe Given::ClassExtensions do
   describe "Given without var" do
     context "is lazy" do
       Given { trace << :given }
-      Then { trace.should == [:given] }
+      Then { expect(trace).to eq([:given]) }
 
       context "when nested" do
         Given { trace << :nested }
-        Then { trace.should == [:given, :nested] }
+        Then { expect(trace).to eq([:given, :nested]) }
       end
     end
   end
@@ -39,20 +39,20 @@ describe Given::ClassExtensions do
   describe "Given!" do
     context "with simple given" do
       Given!(:a) { 1 }
-      Then { a.should == 1 }
+      Then { expect(a).to eq(1) }
     end
 
     context "is not lazy" do
       Given!(:a) { trace << :given; 1 }
-      Then { a.should == 1 }
-      Then { trace.should == [:given] }
-      Then { a; trace.should == [:given] }
+      Then { expect(a).to eq(1) }
+      Then { expect(trace).to eq([:given]) }
+      Then { a; expect(trace).to eq([:given]) }
     end
 
     context "when preceeded by a Given block" do
       Given { trace << :given }
       Given!(:other) { trace << :given_bang }
-      Then { trace.should == [:given, :given_bang] }
+      Then { expect(trace).to eq([:given, :given_bang]) }
     end
   end
 
@@ -65,12 +65,12 @@ describe Given::ClassExtensions do
     When(:result_outer) { trace << :when_result_outer }
 
     Then {
-      trace.should == [
-        :before_outer, :before2_outer,
-        :given_outer, :given_bang_outer,
-        :when_outer,
-        :when_result_outer,
-      ]
+      expect(trace).to eq([
+          :before_outer, :before2_outer,
+          :given_outer, :given_bang_outer,
+          :when_outer,
+          :when_result_outer,
+        ])
     }
 
     context "with a nested When" do
@@ -81,14 +81,14 @@ describe Given::ClassExtensions do
       When { trace << :when_inner }
 
       Then {
-        trace.should == [
-          :before_outer, :before2_outer,
-          :given_outer, :given_bang_outer,
-          :given_inner, :given_bang_inner,
-          :when_outer, :when_result_outer,
-          :before_inner,
-          :when_result_inner, :when_inner,
-        ]
+        expect(trace).to eq([
+            :before_outer, :before2_outer,
+            :given_outer, :given_bang_outer,
+            :given_inner, :given_bang_inner,
+            :when_outer, :when_result_outer,
+            :before_inner,
+            :when_result_inner, :when_inner,
+          ])
       }
     end
 
@@ -98,13 +98,13 @@ describe Given::ClassExtensions do
       Given!(:x_inner) { trace << :given_bang_inner }
 
       Then {
-        trace.should == [
-          :before_outer, :before2_outer,
-          :given_outer, :given_bang_outer,
-          :given_inner, :given_bang_inner,
-          :when_outer, :when_result_outer,
-          :before_inner,
-        ]
+        expect(trace).to eq([
+            :before_outer, :before2_outer,
+            :given_outer, :given_bang_outer,
+            :given_inner, :given_bang_inner,
+            :when_outer, :when_result_outer,
+            :before_inner,
+          ])
       }
     end
   end
@@ -112,62 +112,62 @@ describe Given::ClassExtensions do
   describe "When without result" do
     Given { trace << :given }
     When { trace << :when }
-    Then { trace.should == [:given, :when] }
+    Then { expect(trace).to eq([:given, :when]) }
 
     context "with nesting" do
       Given { trace << :nested }
-      Then { trace.should == [:given, :nested, :when] }
+      Then { expect(trace).to eq([:given, :nested, :when]) }
     end
 
     context "with nesting of When" do
       Given { trace << :nested }
       When { trace << :when_nested }
-      Then { trace.should == [:given, :nested, :when, :when_nested] }
+      Then { expect(trace).to eq([:given, :nested, :when, :when_nested]) }
     end
   end
 
   describe "When with result" do
     Given { trace << :given }
     When(:result) { trace << :when; :result }
-    Invariant { result.should == :result }
+    Invariant { expect(result).to eq(:result) }
 
-    Then { trace.should == [:given, :when] }
+    Then { expect(trace).to eq([:given, :when]) }
 
     context "with nesting" do
       Given { trace << :nested }
-      Then { trace.should == [:given, :nested, :when] }
+      Then { expect(trace).to eq([:given, :nested, :when]) }
     end
 
     context "with nesting of When" do
       Given { trace << :nested }
       When { trace << :when_nested }
-      Then { trace.should == [:given, :nested, :when, :when_nested] }
+      Then { expect(trace).to eq([:given, :nested, :when, :when_nested]) }
     end
   end
 
   describe "When with unreferenced result" do
     Given { trace << :given }
     When(:result) { trace << :when; :result }
-    Then { trace.should == [:given, :when] }
+    Then { expect(trace).to eq([:given, :when]) }
   end
 
   describe "Invariant with When" do
     Given { trace << :given }
     Invariant { trace << :invariant }
     When { trace << :when }
-    Then { trace.should == [:given, :when, :invariant] }
+    Then { expect(trace).to eq([:given, :when, :invariant]) }
   end
 
   describe "Invariant without When" do
     Given { trace << :given }
     Invariant { trace << :invariant }
-    Then { trace.should == [:given, :invariant] }
+    Then { expect(trace).to eq([:given, :invariant]) }
   end
 
   describe "Then" do
     Given { trace << :given }
     Then { trace << :then }
-    And { trace.should == [:given, :then] }
+    And { expect(trace).to eq([:given, :then]) }
   end
 
   describe "Then referencing givens" do
@@ -184,7 +184,7 @@ describe Given::ClassExtensions do
     Given { trace << :given }
     Then { trace << :then }
     And { trace << :and}
-    And { trace.should == [:given, :then, :and] }
+    And { expect(trace).to eq([:given, :then, :and]) }
   end
 
 end
@@ -196,9 +196,9 @@ describe "use_natural_assertions" do
     When(:result) { CONTEXT.use_natural_assertions }
 
     if ::Given::NATURAL_ASSERTIONS_SUPPORTED
-      Then { result.should_not have_failed }
+      Then { expect(result).to_not have_failed }
     else
-      Then { result.should have_failed(ArgumentError) }
+      Then { expect(result).to have_failed(ArgumentError) }
     end
   end
 end

data/spec/lib/given/failure_spec.rb

@@ -8,7 +8,7 @@ describe Given::Failure do
   Given(:exception) { StandardError.new("Oops") }
   Given(:failure) { Given::Failure.new(exception) }
 
-  Then { failure.is_a?(Given::Failure).should be_true }
+  Then { expect(failure.is_a?(Given::Failure)).to eq(true) }
 
   describe "general operations" do
     Then { expect { failure.to_s }.to raise_error(StandardError, "Oops") }
@@ -20,10 +20,10 @@ describe Given::Failure do
     Then { expect { ! failure }.to raise_error(StandardError, "Oops") }
   end
 
-  describe "should raise error" do
-    Then { failure.should raise_error(StandardError, "Oops") }
-    Then { failure.should raise_error(StandardError) }
-    Then { failure.should raise_error }
+  describe "raising error" do
+    Then { expect(failure).to raise_error(StandardError, "Oops") }
+    Then { expect(failure).to raise_error(StandardError) }
+    Then { expect(failure).to raise_error }
   end
 
   describe "== have_failed" do