json_expressions 0.7.2 → 0.8.0

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+### v0.8.0 [view commit logs](https://github.com/chancancode/json_expressions/compare/0.7.3...0.8.0)
+
+* Added Test::Unit support.
+* Added MiniTest::Spec support.
+* BREAKING: Changed internal structure of MiniTest support code. This shouldn't affect you unless you have been manually requiring and including the MiniTest helpers yourself.
+* Use of `WILDCARD_MATCHER` (the constant) inside a `MiniTest::Unit::TestCase` is now discouraged. Instead, you are encouraged to use `wildcard_matcher` (the method) instead. README has been updated.
+
+### v0.7.3 [view commit logs](https://github.com/chancancode/json_expressions/compare/0.7.2...0.7.3)
+
+* Removed WILDCARD_MATCHER#match and the corresponding test. Since support for Object#match has been removed in v0.7.0, this should no longer be necessary.
+
 ### v0.7.2 [view commit logs](https://github.com/chancancode/json_expressions/compare/0.7.1...0.7.2)
 
 * Bugfix: Corrected a misbehaving require statement in minitest helpers (Fixes #2)

data/README.md

@@ -89,8 +89,8 @@ class UsersControllerTest < MiniTest::Unit::TestCase
         type:       'Administrator',
         points:     Fixnum,                      # Any integer value
         homepage:   /\Ahttps?\:\/\/.*\z/i,       # Let's get serious
-        created_at: WILDCARD_MATCHER,            # Don't care as long as it exists
-        updated_at: WILDCARD_MATCHER,
+        created_at: wildcard_matcher,            # Don't care as long as it exists
+        updated_at: wildcard_matcher,
         posts: [
           {
             id:      Fixnum,
@@ -119,21 +119,28 @@ class UsersControllerTest < MiniTest::Unit::TestCase
   end
 end
 
-# RSpec example
+# MiniTest::Spec example
 describe UsersController, "#show" do
   it "returns a user" do
     pattern = # See above...
 
     server_response = get '/users/chancancode.json'
 
-    server_response.body.should match_json_expression(pattern)
+    server_response.body.must_match_json_expression(pattern)
   end
 end
-```
 
-### `RSpec` Integration
+# RSpec example
+describe UsersController, "#show" do
+  it "returns a user" do
+    pattern = # See above...
 
+    server_response = get '/users/chancancode.json'
 
+    server_response.body.should match_json_expression(pattern)
+  end
+end
+```
 
 ### Basic Matching
 
@@ -164,11 +171,11 @@ matches the JSON object
 
 ### Wildcard Matching
 
-You can use the WILDCARD_MATCHER to ignore keys that you don't care about (other than the fact that they exist).
+You can use `wildcard_matcher` to ignore keys that you don't care about (other than the fact that they exist).
 
 This pattern
 ```ruby
-[ WILDCARD_MATCHER, WILDCARD_MATCHER, WILDCARD_MATCHER, WILDCARD_MATCHER, WILDCARD_MATCHER, WILDCARD_MATCHER, WILDCARD_MATCHER ]
+[ wildcard_matcher, wildcard_matcher, wildcard_matcher, wildcard_matcher, wildcard_matcher, wildcard_matcher, wildcard_matcher ]
 ```
 matches the JSON array
 ```json
@@ -177,12 +184,14 @@ matches the JSON array
 
 Furthermore, because the pattern is just plain old Ruby code, you can also write:
 ```ruby
-[ WILDCARD_MATCHER ] * 7
+[ wildcard_matcher ] * 7
 ```
 
+Note: Previously, the examples here uses `WILDCARD_MATCHER` which is a constant defined on `MiniTest::Unit::TestCase`. Since 0.8.0, the use of this constant is discouraged because it doesn't work for `MiniTest::Spec` and `RSpec` due to how Ruby scoping works for blocks. Instead, `wildcard_matcher` (a method) has been added. This is now the preferred way to retrieve the wildcard matcher in order to maintain consistency among the different test frameworks.
+
 ### Object Equality
 
-By default, json_expressions uses `Object#===` to match against the corresponding value in the target JSON. In most cases, this method behaves exactly the same as `Object#==`. However, certain classes override this method to provide specialized behavior (notably `Regexp` and `Module`, see below). If you find this undesirable for certain classes, you can explicitly opt them out and json_expressions will call `Object#==` instead:
+By default, json_expressions uses `Object#===` to match against the corresponding value in the target JSON. In most cases, this method behaves exactly the same as `Object#==`. However, certain classes override this method to provide specialized behavior (notably `Regexp`, `Module` and `Range`, see below). If you find this undesirable for certain classes, you can explicitly opt them out and json_expressions will call `Object#==` instead:
 
 ```ruby
 # This is the default setting
@@ -237,6 +246,21 @@ matches the JSON object
 }
 ```
 
+### Ranges
+
+`Range` overrides `===` to mean `include?`. Therefore,
+```ruby
+{ day: (1..31), month: (1..12) }
+```
+matches the JSON object
+```json
+{ "day": 3, "month": 11 }
+```
+but not
+```json
+{ "day": -1, "month": 13 }
+```
+
 ### Capturing
 
 Similar to how "captures" work in Regexp, you can capture the value of certain keys for later use:
@@ -301,10 +325,10 @@ will match
 You can change this behavior in a case-by-case manner:
 ```ruby
 {
-  "unordered_array" => [1,2,3,4,5].unordered!, # calling unordered! is optional as it's the default
-  "ordered_array"   => [1,2,3,4,5].ordered!,
-  "unordered_hash"  => {'a'=>1, 'b'=>2}.unordered!,
-  "ordered_hash"    => {'a'=>1, 'b'=>2}.ordered!
+  unordered_array: [1,2,3,4,5].unordered!, # calling unordered! is optional as it's the default
+  ordered_array:   [1,2,3,4,5].ordered!,
+  unordered_hash:  {a: 1, b: 2}.unordered!,
+  ordered_hash:    {a: 1, b: 2}.ordered!
 }
 ```
 
@@ -339,8 +363,8 @@ You can change this behavior in a case-by-case manner:
 {
   strict_array:    [1,2,3,4,5].strict!, # calling strict! is optional as it's the default
   forgiving_array: [1,2,3,4,5].forgiving!,
-  strict_hash:     {'a'=>1, 'b'=>2}.strict!,
-  forgiving_hash:  {'a'=>1, 'b'=>2}.forgiving!
+  strict_hash:     {a: 1, b: 2}.strict!,
+  forgiving_hash:  {a: 1, b: 2}.forgiving!
 }
 ```
 
@@ -349,8 +373,8 @@ They also come with some more sensible aliases:
 {
   strict_array:    [1,2,3,4,5].reject_extra_values!,
   forgiving_array: [1,2,3,4,5].ignore_extra_values!,
-  strict_hash:     {'a'=>1, 'b'=>2}.reject_extra_keys!,
-  forgiving_hash:  {'a'=>1, 'b'=>2}.ignore_extra_keys!
+  strict_hash:     {a: 1, b: 2}.reject_extra_keys!,
+  forgiving_hash:  {a: 1, b: 2}.ignore_extra_keys!
 }
 ```
 
@@ -363,7 +387,7 @@ JsonExpressions::Matcher.assume_strict_hashes = false
 
 ## Support for `MiniTest::Spec` (and other testing frameworks)
 
-The `Matcher` class itself is written in a testing-framework-agnostic manner. This allows you to easily write custom helpers/matchers for your favorite testing framework. `MiniTest::Spec` is on my TODO list, but it is not a high priority for me personally, as I currently don't use it. If you need this now, write it yourself and submit a pull request - it's really easy, I promise (see `lib/json_expressions/minitest/unit/helpers.rb` for inspiration).
+The `Matcher` class itself is written in a testing-framework-agnostic manner. This allows you to easily write custom helpers/matchers for your favorite testing framework. `MiniTest::Spec` is on my TODO list, but it is not a high priority for me personally, as I don't use it myself. If you need this now, write it yourself and submit a pull request - it's really easy, I promise (see `lib/json_expressions/minitest/unit/helpers.rb` for inspiration).
 
 ## Contributing
 

data/lib/json_expressions.rb

@@ -15,10 +15,6 @@ module JsonExpressions
     true
   end
 
-  def WILDCARD_MATCHER.match(other)
-    true
-  end
-
   def WILDCARD_MATCHER.to_s
     'WILDCARD_MATCHER'
   end

data/lib/json_expressions/minitest.rb

@@ -1,8 +1,19 @@
 require 'minitest/unit'
+require 'minitest/spec'
 require 'json_expressions'
-require 'json_expressions/minitest/unit/helpers'
+require 'json_expressions/minitest/assertions'
+
+# module MiniTest::Assertions
+#   include JsonExpressions::MiniTest::Assertions
+# end
 
 class MiniTest::Unit::TestCase
-	include JsonExpressions::MiniTest::Unit::Helpers
-	WILDCARD_MATCHER = JsonExpressions::WILDCARD_MATCHER
-end
+  WILDCARD_MATCHER = JsonExpressions::WILDCARD_MATCHER
+
+  def wildcard_matcher
+    ::JsonExpressions::WILDCARD_MATCHER
+  end
+end
+
+Object.infect_an_assertion :assert_json_match, :must_match_json_expression
+Object.infect_an_assertion :refute_json_match, :wont_match_json_expression

data/lib/json_expressions/minitest/assertions.rb

@@ -0,0 +1,35 @@
+require 'json'
+
+module MiniTest
+  module Assertions
+    def assert_json_match(exp, act, msg = nil)
+      unless JsonExpressions::Matcher === exp
+        exp = JsonExpressions::Matcher.new(exp)
+      end
+
+      if String === act
+        assert act = JSON.parse(act), "Expected #{mu_pp(act)} to be valid JSON"
+      end
+
+      assert exp =~ act, ->{ "Expected #{mu_pp(exp)} to match #{mu_pp(act)}\n" + exp.last_error}
+
+      # Return the matcher
+      return exp
+    end
+
+    def refute_json_match(exp, act, msg = nil)
+      unless JsonExpressions::Matcher === exp
+        exp = JsonExpressions::Matcher.new(exp)
+      end
+
+      if String === act
+        assert act = JSON.parse(act), "Expected #{mu_pp(act)} to be valid JSON"
+      end
+
+      refute exp =~ act, "Expected #{mu_pp(exp)} to not match #{mu_pp(act)}"
+
+      # Return the matcher
+      return exp
+    end
+  end
+end

data/lib/json_expressions/rspec.rb

@@ -4,4 +4,14 @@ require 'json_expressions/rspec/matchers'
 
 RSpec::configure do |config|
   config.include(JsonExpressions::RSpec::Matchers)
+end
+
+module RSpec
+  module Core
+    class ExampleGroup
+      def wildcard_matcher
+        ::JsonExpressions::WILDCARD_MATCHER
+      end
+    end
+  end
 end

data/lib/json_expressions/test/unit/helpers.rb

@@ -0,0 +1,31 @@
+require 'json'
+require 'pp'
+
+module JsonExpressions
+  module Test
+    module Unit
+      module Helpers
+        def assert_json_match(exp, act, msg = nil)
+          unless JsonExpressions::Matcher === exp
+            exp = JsonExpressions::Matcher.new(exp)
+          end
+
+          if String === act
+            begin
+              act = JSON.parse(act)
+            rescue
+              assert false, "Expected #{pp(act)} to be valid JSON"
+            end
+          end
+
+          unless exp =~ act
+            assert false, "Expected #{pp(exp)} to match #{pp(act)}\n #{exp.last_error}"
+          end
+
+          # Return the matcher
+          return exp
+        end
+      end
+    end
+  end
+end

data/lib/json_expressions/testunit.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'json_expressions'
+require 'json_expressions/test/unit/helpers'
+
+class Test::Unit::TestCase
+  include JsonExpressions::Test::Unit::Helpers
+  WILDCARD_MATCHER = JsonExpressions::WILDCARD_MATCHER
+
+  def wildcard_matcher
+    ::JsonExpressions::WILDCARD_MATCHER
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json_expressions
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-12 00:00:00.000000000 Z
+date: 2012-08-07 00:00:00.000000000 Z
 dependencies: []
 description: JSON matchmaking for all your API testing needs.
 email:
@@ -20,11 +20,13 @@ extra_rdoc_files: []
 files:
 - lib/json_expressions/core_extensions.rb
 - lib/json_expressions/matcher.rb
-- lib/json_expressions/minitest/unit/helpers.rb
+- lib/json_expressions/minitest/assertions.rb
 - lib/json_expressions/minitest.rb
 - lib/json_expressions/rspec/matchers/match_json_expression.rb
 - lib/json_expressions/rspec/matchers.rb
 - lib/json_expressions/rspec.rb
+- lib/json_expressions/test/unit/helpers.rb
+- lib/json_expressions/testunit.rb
 - lib/json_expressions.rb
 - README.md
 - CHANGELOG.md

data/lib/json_expressions/minitest/unit/helpers.rb

@@ -1,39 +0,0 @@
-require 'json'
-
-module JsonExpressions
-  module MiniTest
-    module Unit
-      module Helpers
-        def assert_json_match(exp, act, msg = nil)
-          unless JsonExpressions::Matcher === exp
-            exp = JsonExpressions::Matcher.new(exp)
-          end
-
-          if String === act
-            assert act = JSON.parse(act), "Expected #{mu_pp(act)} to be valid JSON"
-          end
-
-          assert exp =~ act, ->{ "Expected #{mu_pp(exp)} to match #{mu_pp(act)}\n" + exp.last_error}
-
-          # Return the matcher
-          return exp
-        end
-
-        def refute_json_match(exp, act, msg = nil)
-          unless JsonExpressions::Matcher === exp
-            exp = JsonExpressions::Matcher.new(exp)
-          end
-
-          if String === act
-            assert act = JSON.parse(act), "Expected #{mu_pp(act)} to be valid JSON"
-          end
-
-          refute exp =~ act, "Expected #{mu_pp(exp)} to not match #{mu_pp(act)}"
-
-          # Return the matcher
-          return exp
-        end
-      end
-    end
-  end
-end