json_expressions 0.6.0 → 0.7.0

data/README.md

@@ -82,20 +82,20 @@ class UsersControllerTest < MiniTest::Unit::TestCase
     # This is what we expect the returned JSON to look like
     pattern = {
       user: {
-        id:         :user_id,                # "Capture" this value for later
-        username:   'chancancode',           # Match this exact string
+        id:         :user_id,                    # "Capture" this value for later
+        username:   'chancancode',               # Match this exact string
         full_name:  'Godfrey Chan',
         email:      'godfrey@example.com',
         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
+        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,
         posts:      [
           {
             id:      Fixnum,
             subject: 'Hello world!',
-            user_id: :user_id,               # Match against the captured value
+            user_id: :user_id,                   # Match against the captured value
             tags:    [
               'announcement',
               'welcome',
@@ -180,10 +180,24 @@ Furthermore, because the pattern is just plain old Ruby code, you can also write
 [ WILDCARD_MATCHER ] * 7
 ```
 
-### Pattern Matching
+### Object Equality
 
-When an object `.respond_to? :match`, `match` will be called to by json_expression to match against the corresponding value in the target JSON. Notably, `Regexp` objects responds to `match`, which means you can use regular expressions in your pattern:
+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:
 
+```ruby
+# This is the default setting
+JsonExpressions::Matcher.skip_triple_equal_on = [ ]
+
+# To add more modules/classes
+# JsonExpressions::Matcher.skip_triple_equal_on << MyClass
+
+# To turn this off completely
+# JsonExpressions::Matcher.skip_triple_equal_on = [ BasicObject ]
+```
+
+### Regular Expressions
+
+Since `Regexp` overrides `Object#===` to mean "matches", you can use them in your patterns and json_expressions will do the right thing:
 ```ruby
 { hex: /\A0x[0-9a-f]+\z/i }
 ```
@@ -196,24 +210,9 @@ but not
 { "hex": "Hello world!" }
 ```
 
-Sometimes this behavior is undesirable. For instance, String#match(other) converts `other` into a `Regexp` and use that to match against itself, which is probably not what you want (`''.match 'Hello world!' # => nil` but `'Hello world!'.match '' # => #<MatchData "">`!).
-
-You can specific a list of classes/modules with undesirable `match` behavior, and json_expression will fall back to calling `===` on these objects instead (see the section below for `===` vs `==`).
-
-```ruby
-# This is the default setting
-JsonExpressions::Matcher.skip_match_on = [ String ]
-
-# To add more modules/classes
-# JsonExpressions::Matcher.skip_match_on << MyClass
-
-# To turn this off completely
-# JsonExpressions::Matcher.skip_match_on = [ BasicObject ]
-```
-
 ### Type Matching
 
-For objects that do not `respond_to? :match` or those you opt-ed out explicitly (such as `String`), `===` will be called instead. For most objects, it behaves identical to `==`. A notable exception would be `Module` (and by inheritance, `Class`) objects, which overrides `===` to mean `instance of`. You can exploit this behavior to do type matching:
+`Module` (and by inheritance, `Class`) overrides `===` to mean `instance of`. You can exploit this behavior to do type matching:
 ```ruby
 {
   integer: Fixnum,
@@ -238,19 +237,6 @@ matches the JSON object
 }
 ```
 
-You can specific a list of classes/modules with undesirable `===` behavior, and json_expression will fall back to calling `==` on them instead.
-
-```ruby
-# This is the default setting
-JsonExpressions::Matcher.skip_triple_equal_on = [ ]
-
-# To add more modules/classes
-# JsonExpressions::Matcher.skip_triple_equal_on << MyClass
-
-# To turn this off completely
-# JsonExpressions::Matcher.skip_triple_equal_on = [ BasicObject ]
-```
-
 ### Capturing
 
 Similar to how "captures" work in Regexp, you can capture the value of certain keys for later use:

data/lib/json_expressions/matcher.rb

@@ -4,12 +4,6 @@ require 'json_expressions/core_extensions'
 module JsonExpressions
   class Matcher
     class << self
-      # JsonExpressions::Matcher.skip_match_on (Array)
-      #   An array of classes and modules with undesirable `match` behavior
-      #   Default: [ String ]
-      attr_accessor :skip_match_on
-      JsonExpressions::Matcher.skip_match_on = [ String ]
-
       # JsonExpressions::Matcher.skip_triple_equal_on (Array)
       #   An array of classes and modules with undesirable `===` behavior
       #   Default: []
@@ -20,7 +14,7 @@ module JsonExpressions
       #   By default, assume arrays are unordered when not specified
       #   Default: true
       attr_accessor :assume_unordered_arrays
-      JsonExpressions::Matcher.assume_unordered_arrays = true
+      JsonExpressions::Matcher.assume_unordered_arrays = false
 
       # JsonExpressions::Matcher.assume_strict_arrays (Boolean)
       #   By default, reject arrays with extra elements when not specified
@@ -78,8 +72,6 @@ module JsonExpressions
         match_array path, matcher, other
       elsif matcher.is_a? Hash
         match_hash path, matcher, other
-      elsif matcher.respond_to?(:match) && matchable?(matcher)
-        match_obj path, matcher, other, :match
       elsif triple_equable?(matcher)
         match_obj path, matcher, other, :===
       else
@@ -204,14 +196,6 @@ module JsonExpressions
       end
     end
 
-    def matchable?(obj)
-      if self.class.skip_match_on.include? obj.class
-        false
-      else
-        self.class.skip_match_on.none? { |klass| obj.is_a? klass }
-      end
-    end
-
     def triple_equable?(obj)
       if self.class.skip_triple_equal_on.include? obj.class
         false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json_expressions
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors: