qo 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9388601df794f4debc0449dad3374eb90247f92
-  data.tar.gz: 3ecd58e702bad3521796dbc945fbd9900997a2c1
+  metadata.gz: 77e3ec860cc023f34436da2fc2177007574673bb
+  data.tar.gz: f7e09d7967b02518f8da0a7176ad655bc35a2395
 SHA512:
-  metadata.gz: 95e58e25e8ff762010714537a6be43a545ac2d98887a669d4cf5ee665996a0d08ff982d57894a9e3f1d9dda05bec4046a6e16b949d5a8d642f9db574e14c205e
-  data.tar.gz: f74cebc9d05612b384080aea19e84e1d3713ed2162734dcb6b875078d57d0058e16a280e5fa35d4a9f1e4ba67438cde13093eae5064d03c9da45e39d92c56b72
+  metadata.gz: 64b6464ddbf2eb4d00ece478673760d9ee33e0d7a6bb5777478756946a6943ea273a9fdb811143e4e960628239eaf381af37c28d5d314d5af90ba64f11fc671a
+  data.tar.gz: 9dc57edb473939227ed4863cbcd8a524e3afc3097186331ced7662792b235ba09df45e6e0322083b2d5131b164a01f47a74ebb4a5c8fae473800ea958a0ecb24

data/.gitignore

@@ -10,3 +10,6 @@
 
 # rspec failure tracking
 .rspec_status
+
+# built gems
+*.gem

data/lib/qo/matcher.rb

@@ -6,35 +6,69 @@ module Qo
       @keyword_matchers = keyword_matchers
     end
 
+    # Converts a Matcher to a proc for use in querying, such as:
+    #
+    #     data.select(&Qo[...])
+    #
+    # @return [Proc]
     def to_proc
       @array_matchers.empty? ?
         match_against_hash(@keyword_matchers) :
         match_against_array(@array_matchers)
     end
 
-    def call(other)
-      self.to_proc.call(other)
+    # You can directly call a matcher as well, much like a Proc,
+    # using one of call, ===, or []
+    #
+    # @param match_target [Any] Object to match against
+    #
+    # @return [type] [description]
+    def call(match_target)
+      self.to_proc.call(match_target)
     end
 
     alias_method :===, :call
     alias_method :[],  :call
 
+    # Used to match against a matcher made from an Array, like:
+    #
+    #     Qo['Foo', 'Bar']
+    #
+    # @param matchers [Array[respond_to?(===)]] indexed tuple to match the target object against
+    #
+    # @return [Proc[Any]]
+    #     Array  -> Bool # Tuple match against targets index
+    #     Object -> Bool # Boolean public send
     private def match_against_array(matchers)
-      -> other_object {
-        other_object.is_a?(::Array) ?
-          matchers.each_with_index.public_send(@match_method, &array_matches_array_fn(other_object)) :
-          matchers.public_send(@match_method, &array_matches_object_fn(other_object))
+      -> match_target {
+        match_target.is_a?(::Array) ?
+          matchers.each_with_index.public_send(@match_method, &array_matches_array_fn(match_target)) :
+          matchers.public_send(@match_method, &array_matches_object_fn(match_target))
       }
     end
 
+    # Used to match against a matcher made from Keyword Arguments (a Hash)
+    #
+    # @param matchers [Hash[Any, respond_to?(===)]]
+    #     Any key mapping to any value that responds to `===`. Notedly more
+    #     satisfying when `===` does something fun.
+    #
+    # @return [Proc[Any]]
+    #     Hash   -> Bool # Value matching against similar keys, will attempt to coerce to_s because JSON
+    #     Object -> Bool # Uses keys as methods with public send to `===` match against the value
     private def match_against_hash(matchers)
-      -> other_object {
-        other_object.is_a?(::Hash) ?
-          matchers.public_send(@match_method, &hash_matches_hash_fn(other_object)) :
-          matchers.public_send(@match_method, &hash_matches_object_fn(other_object))
+      -> match_target {
+        match_target.is_a?(::Hash) ?
+          matchers.public_send(@match_method, &hash_matches_hash_fn(match_target)) :
+          matchers.public_send(@match_method, &hash_matches_object_fn(match_target))
       }
     end
 
+    # Used to map the nicety names against the actual Ruby methods they represent
+    #
+    # @param name [String] Query type name
+    #
+    # @return [Symbol] The method name to use to query with
     private def get_match_method(name)
       case name
       when 'and' then :all?
@@ -44,29 +78,57 @@ module Qo
       end
     end
 
-    private def array_matches_array_fn(other_object)
+    # A function to match against an indexed array tuple
+    #
+    # @param match_target [Array] Target array
+    #
+    # @return [Proc]
+    #     Any -> Int -> Bool # Match against wildcard or same position in target array
+    private def array_matches_array_fn(match_target)
       -> matcher, i {
-        matcher == WILDCARD_MATCH || matcher === other_object[i]
+        matcher == WILDCARD_MATCH || matcher === match_target[i]
       }
     end
 
-    private def array_matches_object_fn(other_object)
+    # A function to match against an object using an array of predicates
+    #
+    # @param match_target [Any] Target object
+    #
+    # @return [Proc]
+    #     String | Symbol -> Bool # Match against wildcard or boolean return of a predicate method
+    private def array_matches_object_fn(match_target)
       -> matcher {
-        matcher == WILDCARD_MATCH || other_object.public_send(matcher)
+        matcher == WILDCARD_MATCH || match_target.public_send(matcher)
       }
     end
 
-    private def hash_matches_hash_fn(other_object)
+    # A function to match against a Hash using a Hash
+    #
+    # @param match_target [Hash[Any, Any]] Target Hash
+    #
+    # @return [Proc]
+    #     Any -> Any -> Bool # Matches against wildcard or a key and value. Coerces key to_s if no matches for JSON.
+    private def hash_matches_hash_fn(match_target)
       -> match_key, match_value {
         match_value == WILDCARD_MATCH ||
-        match_value === other_object[match_key] ||
-        match_value === other_object[match_key.to_s]
+        match_value === match_target[match_key] || (
+          # This is done for JSON responses, but as key can be `Any` we don't want to assume it knows how
+          # to coerce `to_s` either. It's more of a nicety function.
+          match_key.respond_to?(:to_s) &&
+          match_value === match_target[match_key.to_s]
+        )
       }
     end
 
-    private def hash_matches_object_fn(other_object)
+    # A function to match against an Object using a Hash
+    #
+    # @param match_target [Any] Target object
+    #
+    # @return [Proc]
+    #     Any -> Any -> Bool # Matches against wildcard or match value versus the public send return of the target
+    private def hash_matches_object_fn(match_target)
       -> match_key, match_value {
-        match_value == WILDCARD_MATCH || match_value === other_object.public_send(match_key)
+        match_value == WILDCARD_MATCH || match_value === match_target.public_send(match_key)
       }
     end
   end

data/lib/qo/version.rb

@@ -1,3 +1,3 @@
 module Qo
-  VERSION = "0.1.0"
+  VERSION = '0.1.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Brandon Weaver