qo 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 19be813c32add1fbe376c08a27533e43ca87254aca1b5bd73f146df70408d833
-  data.tar.gz: 7876f56688b5a11d0821f368bfbd612c56ecb5e08fdf2dccca6e030d56449a2c
+SHA1:
+  metadata.gz: 1af9159c107b7761e1b30c7062b108e692403067
+  data.tar.gz: 483b4e35c8c9bba6a7e84c7516ea3e8a1de6e5b2
 SHA512:
-  metadata.gz: a13e4be4641782a63e1208053c7e35ee77c665ee5eff80b78af54a43f7e4254bd808a4dc6420c9c7e8bdb8c1070c36134f7192934c8c43c7169be0db81c051c8
-  data.tar.gz: 2098317ea5c317a86107902504787a4d47aec8e69e204490bbf72438d2f210a9bd86377b0895672e33bdf4ab8700fc5f26fade3e871d31bd329e0e86050f6711
+  metadata.gz: 3db647525ff5685025108dacbe62b7945f135399d56c8a68eb9f39eb63dda3704614da143608a97d66251754c7d57c97d69d5e1a0d73f0c56e5d256cf813acdf
+  data.tar.gz: 72582ba2f1d0f81d149e2f0b9e3d35d10dcb929418c2cde4f88d3773a734f93c7e78594dc59689058f8de0d2cf3edfbc9dc7bb448ec7cfe9bda237fe101a07d0

data/.travis.yml

@@ -1,5 +1,7 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.3.3
+  - 2.3.7
+  - 2.4.4
+  - 2.5.1
 before_install: gem install bundler -v 1.15.4

data/README.md

@@ -1,5 +1,9 @@
 # Qo
 
+[![Build Status](https://travis-ci.org/baweaver/qo.svg?branch=master)](https://travis-ci.org/baweaver/qo)
+[![Maintainability](https://api.codeclimate.com/v1/badges/186e9cbb7003842acaf0/maintainability)](https://codeclimate.com/github/baweaver/qo/maintainability)
+[![Gem Version](https://badge.fury.io/rb/qo.svg)](https://badge.fury.io/rb/qo)
+
 Short for Query Object, my play at Ruby pattern matching and fluent querying
 
 ![Qo Lemur logo](img/qo_logo.png)

data/lib/qo/guard_block_matcher.rb

@@ -9,8 +9,8 @@ module Qo
     end
 
     def to_proc
-      -> match_target {
-        return [false, false] unless super[match_target]
+      Proc.new { |match_target|
+        next [false, false] unless super[match_target]
 
         [true, @fn.call(match_target)]
       }

data/lib/qo/matcher.rb

@@ -45,9 +45,15 @@ module Qo
       Proc.new { |match_target|
         next true if matchers == match_target
 
-        match_target.is_a?(::Array) ?
-          match_with(matchers.each_with_index, array_against_array_matcher(match_target)) :
-          match_with(matchers, array_against_object_matcher(match_target))
+        if match_target.is_a?(::Array)
+          match_collection = matchers.each_with_index
+          match_fn         = array_against_array_matcher(match_target)
+        else
+          match_collection = matchers
+          match_fn         = array_against_object_matcher(match_target)
+        end
+
+        match_with(match_collection, match_fn)
       }
     end
 
@@ -64,9 +70,11 @@ module Qo
       Proc.new { |match_target|
         next true if matchers == match_target
 
-        match_target.is_a?(::Hash) ?
-          match_with(matchers, hash_against_hash_matcher(match_target)) :
-          match_with(matchers, hash_against_object_matcher(match_target))
+        match_fn = match_target.is_a?(::Hash) ?
+          hash_against_hash_matcher(match_target) :
+          hash_against_object_matcher(match_target)
+
+        match_with(matchers, match_fn)
       }
     end
 
@@ -92,8 +100,8 @@ module Qo
     #     Any -> Int -> Bool # Match against wildcard or same position in target array
     private def array_against_array_matcher(match_target)
       Proc.new { |matcher, i|
-        wildcard_match(matcher) ||
-        case_match(match_target[i], matcher) ||
+        wildcard_match?(matcher) ||
+        case_match?(match_target[i], matcher) ||
         method_matches?(match_target[i], matcher)
       }
     end
@@ -106,8 +114,8 @@ module Qo
     #     String | Symbol -> Bool # Match against wildcard or boolean return of a predicate method
     private def array_against_object_matcher(match_target)
       Proc.new { |matcher|
-        wildcard_match(matcher) ||
-        case_match(match_target, matcher) ||
+        wildcard_match?(matcher) ||
+        case_match?(match_target, matcher) ||
         method_matches?(match_target, matcher)
       }
     end
@@ -120,22 +128,12 @@ module Qo
     #     Any -> Any -> Bool # Matches against wildcard or a key and value. Coerces key to_s if no matches for JSON.
     private def hash_against_hash_matcher(match_target)
       Proc.new { |(match_key, match_value)|
-        next false unless match_target.key?(match_key)
+        next true if hash_wildcard_match?(match_target, match_key, match_value)
 
-        # If both the match value and target are hashes, descend if the key exists
-        if match_value.is_a?(Hash) && match_target.is_a?(Hash)
-          next match_against_hash(match_value)[match_target[match_key]]
-        end
+        next hash_recurse(match_target[match_key], match_value) if hash_should_recurse?(match_target, match_value)
 
-        wildcard_match(match_value) ||
-        case_match(match_target[match_key], match_value)  ||
-        method_matches?(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_target.key?(match_key.to_s) &&
-          case_match(match_target[match_key.to_s], match_value)
-        )
+        hash_case_match?(match_target, match_key, match_value) ||
+        hash_method_case_match?(match_target, match_key, match_value)
       }
     end
 
@@ -147,11 +145,8 @@ module Qo
     #     Any -> Any -> Bool # Matches against wildcard or match value versus the public send return of the target
     private def hash_against_object_matcher(match_target)
       Proc.new { |(match_key, match_value)|
-        next false unless match_target.respond_to?(match_key)
-
-        wildcard_match(match_value) ||
-        case_match(method_send(match_target, match_key), match_value) ||
-        method_matches?(method_send(match_target, match_key), match_value)
+        object_wildcard_match?(match_target, match_key, match_value) ||
+        hash_method_case_match?(match_target, match_key, match_value)
       }
     end
 
@@ -196,21 +191,96 @@ module Qo
     #       like IPAddr, and I kinda want to use that.
     #
     # @return [Boolean]
-    private def wildcard_match(value)
+    private def wildcard_match?(value)
       value == WILDCARD_MATCH rescue false
     end
 
+    # Wraps strict checks on keys with a wildcard match
+    #
+    # @param match_target [Hash]
+    # @param match_key    [Symbol]
+    # @param match_value  [Any]
+    #
+    # @return [Boolean]
+    private def hash_wildcard_match?(match_target, match_key, match_value)
+      return false unless match_target.key?(match_key)
+
+      wildcard_match?(match_value)
+    end
+
+    # Wraps strict checks for methods existing on objects with a wildcard match
+    #
+    # @param match_target [Hash]
+    # @param match_key    [Symbol]
+    # @param match_value  [Any]
+    #
+    # @return [Boolean]
+    private def object_wildcard_match?(match_target, match_key, match_value)
+      return false unless match_target.respond_to?(match_key)
+
+      wildcard_match?(match_value)
+    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. Also makes for nicer stack traces.
     #
-    # @param target [Any] Target to match against
-    # @param value [respond_to?(:===)]
+    # @param match_target [Any] Target to match against
+    # @param match_value  [respond_to?(:===)]
     #   Anything that responds to ===, preferably in a unique and entertaining way.
     #
     # @return [Boolean]
-    private def case_match(target, value)
-      value === target
+    private def case_match?(match_target, match_value)
+      match_value === match_target
+    end
+
+    # Double wraps case match in order to ensure that we try against both Symbol
+    # and String variants of the keys, as this is a very common mixup in Ruby.
+    #
+    # @param match_target [Hash]              Target of the match
+    # @param match_key    [Symbol]            Key to match against
+    # @param match_value  [respond_to?(:===)] Matcher
+    #
+    # @return [Boolean]
+    private def hash_case_match?(match_target, match_key, match_value)
+      return true if case_match?(match_target[match_key], match_value)
+
+      match_key.respond_to?(:to_s) &&
+      match_target.key?(match_key.to_s) &&
+      case_match?(match_target[match_key.to_s], match_value)
+    end
+
+    # Attempts to run a case match against a method call derived from a hash
+    # key, and checks the result.
+    #
+    # @param match_target [Hash]              Target of the match
+    # @param match_key    [Symbol]            Method to call
+    # @param match_value  [respond_to?(:===)] Matcher
+    #
+    # @return [Boolean]
+    private def hash_method_case_match?(match_target, match_key, match_value)
+      case_match?(method_send(match_target, match_key), match_value)
+    end
+
+    # Defines preconditions for Hash recursion in matching. Currently it's
+    # only Hash and Hash, but may expand later to Arrays and other Enums.
+    #
+    # @param match_target [Any]
+    # @param match_value  [Any]
+    #
+    # @return [Boolean]
+    private def hash_should_recurse?(match_target, match_value)
+      match_target.is_a?(Hash) && match_value.is_a?(Hash)
+    end
+
+    # Recurses on nested hashes.
+    #
+    # @param match_target [Hash]
+    # @param match_value  [Hash]
+    #
+    # @return [Boolean]
+    private def hash_recurse(match_target, match_value)
+      match_against_hash(match_value).call(match_target)
     end
   end
 end

data/lib/qo/version.rb

@@ -1,3 +1,3 @@
 module Qo
-  VERSION = '0.1.9'
+  VERSION = '0.1.10'
 end

data/performance_report.txt

@@ -3,58 +3,58 @@ Array * Array - Literal
 =======================
 
 Warming up --------------------------------------
-             Vanilla   255.131k i/100ms
-              Qo.and    36.805k i/100ms
+             Vanilla   290.029k i/100ms
+              Qo.and    37.778k i/100ms
 Calculating -------------------------------------
-             Vanilla      8.462M (± 2.6%) i/s -     42.352M in   5.008310s
-              Qo.and    454.565k (± 1.8%) i/s -      2.282M in   5.021661s
+             Vanilla      9.559M (± 2.3%) i/s -     47.855M in   5.009272s
+              Qo.and    468.514k (± 2.5%) i/s -      2.342M in   5.002419s
 
 Comparison:
-             Vanilla:  8462330.9 i/s
-              Qo.and:   454565.2 i/s - 18.62x  slower
+             Vanilla:  9558516.6 i/s
+              Qo.and:   468514.2 i/s - 20.40x  slower
 
 
 Array * Array - Index pattern match
 ===================================
 
 Warming up --------------------------------------
-             Vanilla    46.834k i/100ms
-              Qo.and    13.827k i/100ms
+             Vanilla    47.088k i/100ms
+              Qo.and    14.227k i/100ms
 Calculating -------------------------------------
-             Vanilla    551.426k (± 1.6%) i/s -      2.763M in   5.012355s
-              Qo.and    146.762k (± 2.3%) i/s -    746.658k in   5.090187s
+             Vanilla    540.415k (± 3.3%) i/s -      2.731M in   5.059509s
+              Qo.and    149.040k (± 4.2%) i/s -    754.031k in   5.068772s
 
 Comparison:
-             Vanilla:   551426.2 i/s
-              Qo.and:   146762.1 i/s - 3.76x  slower
+             Vanilla:   540414.9 i/s
+              Qo.and:   149040.0 i/s - 3.63x  slower
 
 
 Array * Object - Predicate match
 ================================
 
 Warming up --------------------------------------
-             Vanilla   133.668k i/100ms
-              Qo.and    18.746k i/100ms
+             Vanilla   139.244k i/100ms
+              Qo.and    20.096k i/100ms
 Calculating -------------------------------------
-             Vanilla      2.198M (± 3.1%) i/s -     11.094M in   5.053049s
-              Qo.and    208.117k (± 5.4%) i/s -      1.050M in   5.059694s
+             Vanilla      2.356M (± 3.4%) i/s -     11.836M in   5.030228s
+              Qo.and    218.039k (± 2.9%) i/s -      1.105M in   5.073725s
 
 Comparison:
-             Vanilla:  2197719.6 i/s
-              Qo.and:   208116.8 i/s - 10.56x  slower
+             Vanilla:  2355717.5 i/s
+              Qo.and:   218038.9 i/s - 10.80x  slower
 
 
 Array * Array - Select index pattern match
 ==========================================
 
 Warming up --------------------------------------
-             Vanilla    13.222k i/100ms
-              Qo.and    20.029k i/100ms
+             Vanilla    14.015k i/100ms
+              Qo.and    20.325k i/100ms
 Calculating -------------------------------------
-             Vanilla    140.225k (± 3.0%) i/s -    700.766k in   5.002204s
-              Qo.and    217.401k (± 8.2%) i/s -      1.082M in   5.036013s
+             Vanilla    140.673k (± 3.6%) i/s -    714.765k in   5.087715s
+              Qo.and    219.533k (± 3.8%) i/s -      1.098M in   5.006844s
 
 Comparison:
-              Qo.and:   217401.0 i/s
-             Vanilla:   140224.8 i/s - 1.55x  slower
+              Qo.and:   219533.2 i/s
+             Vanilla:   140672.7 i/s - 1.56x  slower
 

metadata

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