hamstar 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7e20abd0e1bdc5dcacbe0334893f80cac4cc639
-  data.tar.gz: 3385c91113d9d36c1056fed5b1731940b4bc27d4
+  metadata.gz: 10081af52f734deabb468d54970637ad5f591c73
+  data.tar.gz: f17292d002caceba185a55a8b814c42b506f92ea
 SHA512:
-  metadata.gz: 1e20a8a16cecfe4535001bd1043eaf6ab23a64d69bcf3ba3960b44dc7db32381726c0c3a59a944c57c79a3f65f14a67d533cee23af9714592c859c0228ebb471
-  data.tar.gz: 68d4f9fe22a65da1db8dc733768e395e9fbdbd0e521548eb23ae4d835d355c2a989678d944ecc0425d066921e04d60ce3975a90c4448d2286c2f874285f9167f
+  metadata.gz: 38185b986447b91ecfc13ac4cc5f90531b37dd3d8db99830464053a9cc6cd751471090a0dce0b324f7927e1d2e840fdea2855962374cc12a1d5f9ddef6b8b8e8
+  data.tar.gz: c0627954be2535db2d4a15f4d18f426449262938421e9ec469ebc49c95571f4a7e7df38430c5503bb8164f82c4c1e075641dd567e9d8e9ef57bec51355bd3f09

data/README.md

@@ -1,6 +1,10 @@
 # Hamstar
 
+`Hamstar.update_having` is a `module_function` that works just like [Hamster update_in()](https://github.com/hamstergem/hamster#transformations) but with three additional ways to select container elements:
 
+1. the associative selector denoted by an array containing a key and a value e.g. `[:name,'Chris']`
+2. the Kleene star operator denoted by '*'
+3. generalized `Proc`-based matching e.g. you can supply a lambda directly in the path specification
 
 ## Installation
 
@@ -18,11 +22,6 @@ Or install it yourself as:
 
 ## Usage
 
-`Hamstar.update_having` is a `module_function` that works just like [Hamster update_in()](https://github.com/hamstergem/hamster#transformations) but with two additional ways to select container elements:
-
-1. the associative selector denoted by an array containing a key and a value e.g. `[:name,'Chris']`
-2. the Kleen star operator denoted by '*'
-
 With plain old `update_in()` you can:
 
 ```ruby
@@ -54,10 +53,10 @@ Hamstar.update_having( x, [:name,'Pat'],:name){|name| 'Patsy'}
 => Hamster::Vector[Hamster::Hash[:name => "Chris", :hobbies => Hamster::Vector["clarinet"]], Hamster::Hash[:name => "Patsy", :hobbies => Hamster::Vector["bird watching", "rugby"]]]
 ```
 
-Finally, you can use a `Proc` as a matcher e.g.
+Finally, you can use a `Proc` as a matcher. Here's an example that supplies a lambda inline:
 
 ```ruby
-Hamstar.update_having( x, ->(k,v,expr){v[:name] == 'Pat'},:name){|name| 'Patsy'}
+Hamstar.update_having( x, ->(k,v){v[:name] == 'Pat'},:name){|name| 'Patsy'}
  => Hamster::Vector[Hamster::Hash[:name => "Chris", :hobbies => Hamster::Vector["clarinet"]], Hamster::Hash[:name => "Patsy", :hobbies => Hamster::Vector["bird watching", "rugby"]]]
 ```
 

data/hamstar.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Bill Burcham"]
   spec.email         = ["bill.burcham@gmail.com"]
   spec.summary       = %q{Hamstar Transforms Immutable Ruby Collections Better}
-  spec.description   = %q{Hamstar.update_having() lets you transform deep amalgamations of Hamster (immutable) Hash and Vector with all the features of update_in() plus associative selection [key,val] and Kleene star '*'}
+  spec.description   = %q{Hamstar.update_having() lets you transform deep amalgamations of Hamster (immutable) Hash and Vector with all the features of update_in() plus: associative selection [key,val], Kleene star '*', and generalized Proc-based matching}
   spec.homepage      = "https://github.com/Bill/hamstar"
   spec.license       = "MIT"
 

data/lib/hamstar.rb

@@ -5,8 +5,6 @@ require 'hamster'
 module Hamstar
 
   KLEENE_STAR = '*'
-  MATCH_KLEENE_STAR = ->(k,v,expr){true}
-  MATCH_ASSOCIATION = ->(k,v,expr){key,value=expr; v[key] == value}
 
   module_function
 
@@ -16,8 +14,8 @@ module Hamstar
     end
     matcher = match_path[0]
     case matcher
-    when KLEENE_STAR; match MATCH_KLEENE_STAR, c, *match_path, &block
-    when Array, Hamster::Vector; match MATCH_ASSOCIATION, c, *match_path, &block
+    when KLEENE_STAR; match ->(k,v){true}, c, *match_path, &block
+    when Array, Hamster::Vector; match ->(k,v){key,value=matcher; v[key] == value}, c, *match_path, &block
     when Proc; match matcher, c, *match_path, &block
     else
       if match_path.size == 1
@@ -31,10 +29,9 @@ module Hamstar
   end
 
   def match(matcher, c, *match_path, &block)
-    expr = match_path[0]
-    mp_rest = Hamster.from(match_path)[1..-1] # drop expr
+    mp_rest = Hamster.from(match_path)[1..-1] # drop first expr
     c.each_pair do |key,value|
-      if matcher.call key, value, expr
+      if matcher.call key, value
         mp = mp_rest.unshift key # put key where assoc was
         c = update_having c, *mp, &block
       end

data/lib/hamstar/version.rb

@@ -1,3 +1,3 @@
 module Hamstar
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/hamstar_spec.rb

@@ -13,18 +13,20 @@ RSpec.describe Hamstar do
   examples_kleene_star = [
     [ {a:1,b:2},    ['*'],     ->(v){v+1}, {a:2,b:3},     'top level Hash'],
     [ [1,2],        ['*'],     ->(v){v+1}, [2,3],         'top level Vector'],
-    [ {a:[1],b:[2]},[:b, '*'], ->(v){v+1}, {a:[1],b:[3]}, 'Hash containing Vector'],
-    [ [{a:1},{a:2}],[0, '*'],  ->(v){v+1}, [{a:2},{a:2}], 'Vector containing Hash'],
-    [ {a:[1],b:[2]},['*', 0],  ->(v){v+1}, {a:[2],b:[3]}, 'Vector inside Hash'],
-    [ [{a:1},{a:2}],['*', :a], ->(v){v+1}, [{a:2},{a:3}], 'Hash inside Vector']
+    [ {a:[1],b:[2]},[:b,'*'],  ->(v){v+1}, {a:[1],b:[3]}, 'Hash containing Vector'],
+    [ [{a:1},{a:2}],[0,'*'],   ->(v){v+1}, [{a:2},{a:2}], 'Vector containing Hash'],
+    [ {a:[1],b:[2]},['*',0],   ->(v){v+1}, {a:[2],b:[3]}, 'Vector inside Hash'],
+    [ [{a:1},{a:2}],['*',:a],  ->(v){v+1}, [{a:2},{a:3}], 'Hash inside Vector']
   ]
 
   examples_associative = [
-    [ [{name:'Chris'},{name:'Pat'}], [ [:name, 'Pat'], :name ], ->(name){name<<'sy'}, [{name:'Chris'},{name:'Patsy'}], 'modify matching Hash']
+    [ [{name:'Chris'},{name:'Pat'}],  [[:name,'Pat'],:name],->(name){name+'sy'}, [{name:'Chris'},{name:'Patsy'}],  'match a Hash'],
+    [ [[:name,'Chris'],[:name,'Pat']],[[1,'Pat'],1],        ->(name){name+'sy'}, [[:name,'Chris'],[:name,'Patsy']],'match a Vector']
   ]
 
   examples_function_match = [
-    [ [1,2], [->(k,v,expr){v==2}], ->(v){5}, [1,5] ]
+    [ [{a:1},{b:1},{b:2}], ['*',->(k,v){k==:b && v==2}], ->(v){5}, [{a:1},{b:1},{b:5}],'match a Hash'],
+    [ [[1,2],[3,4]],       ['*',->(k,v){k==0&&v==3}],->(v){7}, [[1,2],[7,4]],          'match a Vector']
   ]
 
   def self.write_examples(examples)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hamstar
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Bill Burcham
@@ -80,9 +80,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Hamstar.update_having() lets you transform deep amalgamations of Hamster
-  (immutable) Hash and Vector with all the features of update_in() plus associative
-  selection [key,val] and Kleene star '*'
+description: 'Hamstar.update_having() lets you transform deep amalgamations of Hamster
+  (immutable) Hash and Vector with all the features of update_in() plus: associative
+  selection [key,val], Kleene star ''*'', and generalized Proc-based matching'
 email:
 - bill.burcham@gmail.com
 executables: []