qo 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4df3208a180d13d368677f8fe821106fe073a992
-  data.tar.gz: 5cb7a3d0157be3e78ef5b3eec297886fbf914188
+  metadata.gz: a106b00677e65b0d1bc7f87678d234aaba4a7580
+  data.tar.gz: 56745cdd7c92b3504434209bf269851e95bf6a6a
 SHA512:
-  metadata.gz: 8ab4868303500073f978e621d268f74537eb4d8e48139bd8ab9aab82effe3fe7c835c431058bf214ce5ddd4878337a4c937303e66ad13f6433fa72640039fb05
-  data.tar.gz: 28ab8ae79d276a5ce96a8c05eb4fd2edc8febe460bd7b65d0ed4acbea96b1b647ddf9b21eea5bcd41a2be1417cb9ae032b6a4f54d5b6e4edd77876cf63059a71
+  metadata.gz: c74eee58565ad19a3cd268e3f3a704d8c861f8c978f314ab830d011a46b67bd8a4031730a6a178514b0cf749e03b10643d129bc6fac7c12644520c6d3edacfd9
+  data.tar.gz: 7f976433977c10a5655313e4aacf155cfb5c6c4a4517ea9abfa8f6ce1c048381656f593661047e9d30524918f616c59bcc72c84449d8c55edadd7de057cd0425

data/README.md

@@ -61,6 +61,31 @@ else 'who knows'
 end
 ```
 
+It's even nice enough to work on types, as they respond to `===` too:
+
+```ruby
+case ['Robert', 22]
+when Qo[String, Integer] then 'normal person'
+when Qo[String, Float] then 'probably a kid'
+else 'who knows'
+end
+```
+
+Predicate methods given as symbols will also call through:
+
+```ruby
+case [1, 2]
+when Qo[:even?, :odd?], Qo[:odd?, :even?]
+  'balanced'
+when Qo[:even?, :even?]
+  'even better'
+when Qo[:odd?, :odd?]
+  'odd pair, them'
+else
+  'what did ya do!?'
+end
+```
+
 Though chances are you don't have tuple-like code, you have objects. How about we play with those:
 
 ```ruby
@@ -103,7 +128,7 @@ people = [
 people.select(&Qo[name: /Rob/]) # => [Person('Robert', 22), Person('Roberta', 22)]
 ```
 
-Qo tries to be clever though, it assumes Symbol keys first and then String keys:
+Qo tries to be clever though, it assumes Symbol keys first and then String keys, so how about some JSON?:
 
 ```ruby
 require 'json'
@@ -117,6 +142,17 @@ posts.select(&Qo[userId: 1])
 
 Nifty!
 
+What about NMap for our Opsy friends? Well, simulated, but still fun.
+
+```ruby
+hosts = (`nmap -oG - -sP 192.168.1.* 10.0.0.* | grep Host`).lines.map { |v| v.split[1..2] }
+=> [["192.168.1.1", "(Linksys03384)"], ["192.168.1.2", "(My Computer)"], ["10.0.0.1", "(Gateway)"]]
+
+hosts.select(&Qo[IPAddr.new('192.168.1.1/8')])
+=> [["192.168.1.1", "(Linksys03384)"], ["192.168.1.2", "(My Computer)"]]
+[13] pry(main)>
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/qo/matcher.rb

@@ -44,8 +44,8 @@ module Qo
     private def match_against_array(matchers)
       -> 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))
+          match_with(matchers.each_with_index, array_against_array_matcher(match_target)) :
+          match_with(matchers, array_against_object_matcher(match_target))
       }
     end
 
@@ -61,8 +61,8 @@ module Qo
     private def match_against_hash(matchers)
       -> 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))
+          match_with(matchers, hash_against_hash_matcher(match_target)) :
+          match_with(matchers, hash_against_object_matcher(match_target))
       }
     end
 
@@ -86,9 +86,11 @@ module Qo
     #
     # @return [Proc]
     #     Any -> Int -> Bool # Match against wildcard or same position in target array
-    private def array_matches_array_fn(match_target)
+    private def array_against_array_matcher(match_target)
       -> matcher, i {
-        matcher == WILDCARD_MATCH || matcher === match_target[i]
+        wildcard_match(matcher) ||
+        case_match(match_target[i], matcher) ||
+        method_matches?(match_target[i], matcher)
       }
     end
 
@@ -98,17 +100,11 @@ module Qo
     #
     # @return [Proc]
     #     String | Symbol -> Bool # Match against wildcard or boolean return of a predicate method
-    private def array_matches_object_fn(match_target)
+    private def array_against_object_matcher(match_target)
       -> matcher {
-        matcher == WILDCARD_MATCH ||
-        matcher === match_target || (
-          # Check if the matcher is a symbol / symbolizeable and
-          # if it's on the public interface. This is to give
-          # the ability to avoid using :sym.to_proc for method calls.
-          matcher.respond_to?(:to_sym) &&
-          match_target.respond_to?(matcher.to_sym) &&
-          match_target.public_send(matcher)
-        )
+        wildcard_match(matcher) ||
+        case_match(match_target, matcher) ||
+        method_matches?(match_target, matcher)
       }
     end
 
@@ -118,14 +114,14 @@ module Qo
     #
     # @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)
+    private def hash_against_hash_matcher(match_target)
       -> match_key, match_value {
-        match_value == WILDCARD_MATCH ||
-        match_value === match_target[match_key] || (
+        wildcard_match(match_value) ||
+        case_match(match_target[match_key], match_value) || (
           # 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]
+          case_match(match_target[match_key.to_s], match_value)
         )
       }
     end
@@ -136,10 +132,69 @@ module Qo
     #
     # @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)
+    private def hash_against_object_matcher(match_target)
       -> match_key, match_value {
-        match_value == WILDCARD_MATCH || match_value === match_target.public_send(match_key)
+        wildcard_match(match_value) ||
+        case_match(method_send(match_target, match_key), match_value)
       }
     end
+
+    # Wrapper around public send to encapsulate the matching method (any, all, none)
+    #
+    # @param collection [Enumerable] Any collection that can be enumerated over
+    # @param fn         [Proc] Function to match with
+    #
+    # @return [Enumerable] Resulting collection
+    private def match_with(collection, fn)
+      collection.public_send(@match_method, &fn)
+    end
+
+    # Predicate variant of `method_send` with the same guard concerns
+    #
+    # @param target  [Any] Object to send to
+    # @param matcher [respond_to?(:to_sym)] Anything that can be coerced into a method name
+    #
+    # @return [Boolean] Success status of predicate
+    private def method_matches?(target, matcher)
+      !!method_send(target, matcher)
+    end
+
+    # Guarded version of `public_send` meant to stamp out more
+    # obscure errors when running against non-matching types.
+    #
+    # @param target  [Any] Object to send to
+    # @param matcher [respond_to?(:to_sym)] Anything that can be coerced into a method name
+    #
+    # @return [Any] Response of sending to the method, or false if failed
+    private def method_send(target, matcher)
+      matcher.respond_to?(:to_sym) &&
+      target.respond_to?(matcher.to_sym) &&
+      target.public_send(matcher)
+    end
+
+    # Wraps wildcard in case we want to do anything fun with it later
+    #
+    # @param value [Any] Value to test against the wild card
+    #
+    # @note The rescue is because some classes override `==` to do silly things,
+    #       like IPAddr, and I kinda want to use that.
+    #
+    # @return [Boolean]
+    private def wildcard_match(value)
+      value == WILDCARD_MATCH rescue false
+    end
+
+    # Wraps a case equality statement to make it a bit easier to read. The
+    # typical left bias of `===` can be confusing reading down a page, so
+    # more of a clarity thing than anything.
+    #
+    # @param target [Any] Target to match against
+    # @param value [respond_to?(:===)]
+    #   Anything that responds to ===, preferably in a unique and entertaining way.
+    #
+    # @return [Boolean]
+    private def case_match(target, value)
+      value === target
+    end
   end
 end

data/lib/qo/version.rb

@@ -1,3 +1,3 @@
 module Qo
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qo
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Brandon Weaver
@@ -122,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Qo is a querying library for Ruby pattern matching