qo 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11b6629bbb972894e4d1ebc01916769e14a70ec4dbc0d197f990d2c6849d3ffa
-  data.tar.gz: d609ce71af4795164999b2219f3e70892c09c0eaca4174d73d79bc3e2d988231
+  metadata.gz: af6c00578bf0fca7464a3823282f8de93e3f5befde82c991e1f4cee97c244c1a
+  data.tar.gz: 9532c9394d8874306487846fe166c11315a5e322af62d58a40ee8f5a59257cf1
 SHA512:
-  metadata.gz: c44fe7b89ec3da320eca4007f0b207da6d2300999c23c167c494e281bbe96c7449f88419d1eec29dcc9f5bc987df3ecea9b1bb0b88afa7968c6e2f3d94b12237
-  data.tar.gz: c4e5e607debf592180547d4f7180251e38cc09958a5a2f4961ebbe91c4a52416fb2a2ceeb26c7ba0076e24999c7333716141649aace38d4152931040d8b1dc7d
+  metadata.gz: 71953edde27da9876463b453c8b8909986ea8f18461fa5c9ae123a15c71fea739276dd768a85487fc51152e6e3d3e0f0c9eecbc09db95eb97fc7433584caa2b0
+  data.tar.gz: 754e7dce63ca7a0e9b641fe45eb2b06feeb3045804f9a3236088c0187781b50de5422eaf506f777cd92f24a674ad1ca8d5dbc2faa6eac4fdfe53cdde9b007314

data/README.md

@@ -43,7 +43,15 @@ end
 
 # Run a select like an AR query, getting the age attribute against a range
 people.select(&Qo[age: 18..30])
+```
+
+How about some pattern matching? There are two styles:
+
+#### Pattern Match
+
+The original style
 
+```
 # How about some "right-hand assignment" pattern matching
 name_longer_than_three      = -> person { person.name.size > 3 }
 people_with_truncated_names = people.map(&Qo.match(
@@ -58,7 +66,25 @@ Qo.match(people.first,
 )
 ```
 
-Get a lot more expressiveness in your queries and transformations. Read on for the full details.
+#### Pattern Match Block
+
+The new style, likely to take over in `v1.0.0` after testing:
+
+```ruby
+name_longer_than_three      = -> person { person.name.size > 3 }
+people_with_truncated_names = people.map(&Qo.match { |m|
+  m.when(name_longer_than_three) { |person| Person.new(person.name[0..2], person.age) }
+  m.else(&:itself)
+})
+
+# And standalone like a case:
+Qo.match(people.first) { |m|
+  m.when(age: 10..19) { |person| "#{person.name} is a teen that's #{person.age} years old" }
+  m.else { |person| "#{person.name} is #{person.age} years old" }
+}
+```
+
+(More details coming on the difference and planned 1.0.0 APIs)
 
 ### Qo'isms
 

data/Rakefile

@@ -44,7 +44,7 @@ def xrun_benchmark(title, **benchmarks) end
 # be readability first with performance coming later. That means that early iterations
 # may well be slower, but the net expressiveness we get is worth it in the short run.
 task :perf do
-  puts "Running on Qo v#{Qo::VERSION} at commit #{`git rev-parse HEAD`}"
+  puts "Running on Qo v#{Qo::VERSION} at rev #{`git rev-parse HEAD`} - Ruby #{`ruby -v`}"
 
   # Compare simple array equality. I almost think this isn't fair to Qo considering
   # no sane dev should use it for literal 1 to 1 matches like this.

data/lib/qo.rb

@@ -8,6 +8,7 @@ require 'qo/matchers/guard_block_matcher'
 
 # Meta Matchers
 require 'qo/matchers/pattern_match'
+require 'qo/matchers/pattern_match_block'
 
 # Helpers
 require 'qo/helpers'

data/lib/qo/exceptions.rb

@@ -39,5 +39,16 @@ module Qo
         "defined with `Qo.matcher` or `Qo.m` instead of regular matchers."
       end
     end
+
+    # In the case of a Pattern Match, we should only have one "else" clause
+    #
+    # @author baweaver
+    # @since 0.3.0
+    #
+    class MultipleElseClauses < ArgumentError
+      def to_s
+        "Cannot have more than one `else` clause in a Pattern Match."
+      end
+    end
   end
 end

data/lib/qo/matchers/pattern_match_block.rb

@@ -0,0 +1,115 @@
+require 'qo/exceptions'
+
+module Qo
+  module Matchers
+    # Creates a PatternMatch in the style of a block.
+    #
+    # This varies from the regular PatternMatch in that all matchers are
+    # provided in a more succinct block format:
+    #
+    # ```ruby
+    # Qo.match(target) { |m|
+    #   m.when(/^F/, 42) { |(name, age)| "#{name} is #{age}" }
+    #   m.else { "We need a default, right?" }
+    # }
+    # ```
+    #
+    # The Public API obscures the fact that the matcher is only called when it
+    # is explicitly given an argument to match against. If it is not, it will
+    # just return a class waiting for a target, as such:
+    #
+    # ```ruby
+    # def get_url(url)
+    #   Net::HTTP.get_response(URI(url)).yield_self(&Qo.match { |m|
+    #     m.when(Net::HTTPSuccess) { |response| response.body.size }
+    #     m.else { |response| raise response.message }
+    #   })
+    # end
+    #
+    # get_url('https://github.com/baweaver/qo')
+    # # => 142387
+    # get_url('https://github.com/baweaver/qo/does_not_exist')
+    # # => RuntimeError: Not Found
+    # ```
+    #
+    # This is intended for flexibility between singular calls and calls as a
+    # paramater to higher order functions like `map` and `yield_self`.
+    #
+    # This variant was inspired by ideas from Scala, Haskell, and various Ruby
+    # libraries dealing with Async and self-yielding blocks. Especially notable
+    # were websocket handlers and dry-ruby implementations.
+    #
+    # @author baweaver
+    # @since 0.3.0
+    #
+    class PatternMatchBlock
+      def initialize
+        @matchers = []
+
+        yield(self)
+      end
+
+      # Creates a match case. This is the exact same as any other `and` style
+      # match reflected in the public API, except that it's a Guard Block
+      # match being performed. That means if the left side matches, the right
+      # side function is invoked and that value is returned.
+      #
+      # @param *array_matchers [Array[Any]]
+      #   Array style matchers
+      #
+      # @param **keyword_matchers [Hash[Any, Any]]
+      #   Hash style matchers
+      #
+      # @param &fn [Proc]
+      #   If matched, this function will be called
+      #
+      # @return [Array[GuardBlockMatcher]]
+      #   The return of this method should not be directly depended on, but will
+      #   provide all matchers currently present. This will likely be left for
+      #   ease of debugging later.
+      def when(*array_matchers, **keyword_matchers, &fn)
+        @matchers << Qo::Matchers::GuardBlockMatcher.new(*array_matchers, **keyword_matchers, &fn)
+      end
+
+      # Else is the last statement that will be evaluated if all other parts
+      # fail. It should be noted that it won't magically appear, you have to
+      # explicitly put an `else` case in for it to catch on no match unless
+      # you want a `nil` return
+      #
+      # @param &fn [Proc]
+      #   Function to call when all other matches have failed
+      #
+      # @return [Proc]
+      def else(&fn)
+        raise Qo::Exceptions::MultipleElseClauses if @else
+        @else = fn
+      end
+
+      # Proc version of a PatternMatchBlock
+      #
+      # @return [Proc]
+      #     Any -> Any | nil
+      def to_proc
+        Proc.new { |target| self.call(target) }
+      end
+
+      # Immediately invokes a PatternMatch
+      #
+      # @param target [Any]
+      #   Target to run against and pipe to the associated block if it
+      #   "matches" any of the GuardBlocks
+      #
+      # @return [Any | nil] Result of the piped block, or nil on a miss
+      def call(target)
+        @matchers.each { |guard_block_matcher|
+          did_match, match_result = guard_block_matcher.call(target)
+          return match_result if did_match
+        }
+
+        return @else.call(target) if @else
+
+        nil
+      end
+    end
+  end
+end

data/lib/qo/public_api.rb

@@ -82,12 +82,32 @@ module Qo
     # it finds one that "matches". Once found, it will pass the target into the
     # associated matcher's block function.
     #
+    # @param fn [Proc]
+    #   If provided, the pattern match will become block-style, utilizing
+    #   PatternMatchBlock instead. If any args are provided, the first
+    #   will be treated as the target.
+    #
     # @param *args [Array[Any, *GuardBlockMatcher]]
     #   Collection of matchers to run, potentially prefixed by a target object
     #
-    # @return [Qo::PatternMatch | Any]
-    #   Returns a PatternMatch waiting for a target, or an evaluated PatternMatch response
-    def match(*args)
+    # @return [Qo::PatternMatchBlock]
+    #   If a value is not provided, a block style pattern match will be returned
+    #   that responds to proc coercion. It can be used for functions like `map`.
+    #
+    # @return [Qo::PatternMatch]
+    #   If a value is not provided and no function is present, a PatternMatch
+    #   will be returned, awaiting a value to match against.
+    #
+    # @return [Any]
+    #   If a value is provided, matchers will attempt to call through on it,
+    #   returning the result of the function.
+    def match(*args, &fn)
+      if block_given?
+        return args.empty? ?
+          Qo::Matchers::PatternMatchBlock.new(&fn) :
+          Qo::Matchers::PatternMatchBlock.new(&fn).call(args.first)
+      end
+
       if args.first.is_a?(Qo::Matchers::GuardBlockMatcher)
         Qo::Matchers::PatternMatch.new(*args)
       else

data/lib/qo/version.rb

@@ -1,3 +1,3 @@
 module Qo
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/performance_report.txt

@@ -1,4 +1,5 @@
-Running on Qo v0.2.0 at commit ba999659acb51beec215fab4240a34298794a5bf
+Running on Qo v0.3.0 at rev 77eb2544c41b33361a561178b145d33fa2409bde
+ - Ruby ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin17]
 
 Array * Array - Literal
 =======================
@@ -7,15 +8,15 @@ Vanilla result: true
 Qo.and result: true
 
 Warming up --------------------------------------
-             Vanilla   278.882k i/100ms
-              Qo.and    83.044k i/100ms
+             Vanilla   275.791k i/100ms
+              Qo.and    77.679k i/100ms
 Calculating -------------------------------------
-             Vanilla      8.950M (± 1.7%) i/s -     44.900M in   5.018406s
-              Qo.and      1.062M (± 1.2%) i/s -      5.315M in   5.003728s
+             Vanilla      8.805M (± 1.6%) i/s -     44.127M in   5.012793s
+              Qo.and    987.041k (± 2.8%) i/s -      4.971M in   5.040741s
 
 Comparison:
-             Vanilla:  8949563.3 i/s
-              Qo.and:  1062331.4 i/s - 8.42x  slower
+             Vanilla:  8805260.8 i/s
+              Qo.and:   987041.0 i/s - 8.92x  slower
 
 
 Array * Array - Index pattern match
@@ -25,15 +26,15 @@ Vanilla result: true
 Qo.and result: true
 
 Warming up --------------------------------------
-             Vanilla    49.757k i/100ms
-              Qo.and    22.362k i/100ms
+             Vanilla    45.347k i/100ms
+              Qo.and    21.225k i/100ms
 Calculating -------------------------------------
-             Vanilla    562.718k (± 4.0%) i/s -      2.836M in   5.048960s
-              Qo.and    238.217k (± 1.7%) i/s -      1.208M in   5.070540s
+             Vanilla    550.096k (± 2.4%) i/s -      2.766M in   5.031463s
+              Qo.and    226.391k (± 4.2%) i/s -      1.146M in   5.072495s
 
 Comparison:
-             Vanilla:   562718.0 i/s
-              Qo.and:   238216.8 i/s - 2.36x  slower
+             Vanilla:   550096.4 i/s
+              Qo.and:   226391.4 i/s - 2.43x  slower
 
 
 Array * Object - Predicate match
@@ -43,15 +44,15 @@ Vanilla result: false
 Qo.and result: false
 
 Warming up --------------------------------------
-             Vanilla   145.056k i/100ms
-              Qo.and    27.888k i/100ms
+             Vanilla   139.508k i/100ms
+              Qo.and    27.451k i/100ms
 Calculating -------------------------------------
-             Vanilla      2.204M (± 4.4%) i/s -     11.024M in   5.011429s
-              Qo.and    323.232k (± 2.4%) i/s -      1.618M in   5.007142s
+             Vanilla      2.148M (± 3.3%) i/s -     10.742M in   5.007009s
+              Qo.and    303.118k (± 2.0%) i/s -      1.537M in   5.073596s
 
 Comparison:
-             Vanilla:  2204056.6 i/s
-              Qo.and:   323232.5 i/s - 6.82x  slower
+             Vanilla:  2147916.4 i/s
+              Qo.and:   303118.1 i/s - 7.09x  slower
 
 
 Array * Array - Select index pattern match
@@ -61,15 +62,15 @@ Vanilla result: [["Robert", 22], ["Roberta", 22]]
 Qo.and result: [["Robert", 22], ["Roberta", 22]]
 
 Warming up --------------------------------------
-             Vanilla    14.343k i/100ms
-              Qo.and     7.454k i/100ms
+             Vanilla    12.651k i/100ms
+              Qo.and     7.024k i/100ms
 Calculating -------------------------------------
-             Vanilla    149.518k (± 2.9%) i/s -    760.179k in   5.088601s
-              Qo.and     77.519k (± 2.8%) i/s -    387.608k in   5.004058s
+             Vanilla    141.337k (± 8.3%) i/s -    708.456k in   5.067441s
+              Qo.and     73.799k (± 2.9%) i/s -    372.272k in   5.048946s
 
 Comparison:
-             Vanilla:   149517.6 i/s
-              Qo.and:    77519.5 i/s - 1.93x  slower
+             Vanilla:   141336.5 i/s
+              Qo.and:    73799.3 i/s - 1.92x  slower
 
 
 Hash * Hash - Hash intersection
@@ -79,15 +80,15 @@ Vanilla result: [{:name=>"Robert", :age=>22}, {:name=>"Roberta", :age=>22}]
 Qo.and result: [{:name=>"Robert", :age=>22}, {:name=>"Roberta", :age=>22}]
 
 Warming up --------------------------------------
-             Vanilla    36.214k i/100ms
-              Qo.and     5.050k i/100ms
+             Vanilla    34.600k i/100ms
+              Qo.and     4.851k i/100ms
 Calculating -------------------------------------
-             Vanilla    411.041k (± 2.3%) i/s -      2.064M in   5.024556s
-              Qo.and     50.029k (± 5.0%) i/s -    252.500k in   5.060014s
+             Vanilla    392.298k (± 2.6%) i/s -      1.972M in   5.030828s
+              Qo.and     48.213k (± 4.8%) i/s -    242.550k in   5.043068s
 
 Comparison:
-             Vanilla:   411041.4 i/s
-              Qo.and:    50028.6 i/s - 8.22x  slower
+             Vanilla:   392298.2 i/s
+              Qo.and:    48213.1 i/s - 8.14x  slower
 
 
 Hash * Object - Property match
@@ -97,13 +98,13 @@ Vanilla result: [#<struct Person name="Robert", age=22>, #<struct Person name="R
 Qo.and result: [#<struct Person name="Robert", age=22>, #<struct Person name="Roberta", age=22>]
 
 Warming up --------------------------------------
-             Vanilla    36.167k i/100ms
-              Qo.and     5.263k i/100ms
+             Vanilla    32.783k i/100ms
+              Qo.and     4.422k i/100ms
 Calculating -------------------------------------
-             Vanilla    411.057k (± 3.4%) i/s -      2.062M in   5.021612s
-              Qo.and     52.776k (± 4.0%) i/s -    268.413k in   5.094233s
+             Vanilla    361.140k (± 9.7%) i/s -      1.803M in   5.053763s
+              Qo.and     46.667k (±10.8%) i/s -    229.944k in   5.002258s
 
 Comparison:
-             Vanilla:   411057.2 i/s
-              Qo.and:    52775.9 i/s - 7.79x  slower
+             Vanilla:   361140.4 i/s
+              Qo.and:    46667.1 i/s - 7.74x  slower
 

data/qo.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["keystonelemur@gmail.com"]
 
   spec.summary       = %q{Qo is a querying library for Ruby pattern matching}
-  spec.homepage      = "https://www.github.com/baweaver/q"
+  spec.homepage      = "https://www.github.com/baweaver/qo"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qo
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Brandon Weaver
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-18 00:00:00.000000000 Z
+date: 2018-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -182,11 +182,12 @@ files:
 - lib/qo/matchers/guard_block_matcher.rb
 - lib/qo/matchers/hash_matcher.rb
 - lib/qo/matchers/pattern_match.rb
+- lib/qo/matchers/pattern_match_block.rb
 - lib/qo/public_api.rb
 - lib/qo/version.rb
 - performance_report.txt
 - qo.gemspec
-homepage: https://www.github.com/baweaver/q
+homepage: https://www.github.com/baweaver/qo
 licenses:
 - MIT
 metadata: {}