hamstar 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8ac2cc619b90cd952f777392b2b5eeee655de44
-  data.tar.gz: 00805291596cc8e7522c106b6bd02aeb7f399ed4
+  metadata.gz: f7e20abd0e1bdc5dcacbe0334893f80cac4cc639
+  data.tar.gz: 3385c91113d9d36c1056fed5b1731940b4bc27d4
 SHA512:
-  metadata.gz: ead258d56878dfbcaa20955b918b6bfa380a3f0e17b2280e628e612ede29564f34b8057f20543f2089f2b149542edba85bba1e01e0c9c94348d728f1a731164c
-  data.tar.gz: 184f0adbfa8877e65be6ad7f35d60e009bb50c7baefe7d20abdbf9830a7971c81d22d11bb458b88e63713c2228abc053f80a2aaaa2fd2f40488de8bcc97e017a
+  metadata.gz: 1e20a8a16cecfe4535001bd1043eaf6ab23a64d69bcf3ba3960b44dc7db32381726c0c3a59a944c57c79a3f65f14a67d533cee23af9714592c859c0228ebb471
+  data.tar.gz: 68d4f9fe22a65da1db8dc733768e395e9fbdbd0e521548eb23ae4d835d355c2a989678d944ecc0425d066921e04d60ce3975a90c4448d2286c2f874285f9167f

data/README.md

@@ -27,24 +27,38 @@ With plain old `update_in()` you can:
 
 ```ruby
 require 'hamster'
-x = [{name:'Chris', hobbies:['clarinet']},{name:'Pat',hobbies:['bird watching','rugby']}]
-Hamster.from(x).update_in(1,:name){|name| 'Patsy'}
+x = Hamster.from([{name:'Chris', hobbies:['clarinet']},{name:'Pat',hobbies:['bird watching','rugby']}])
+x.update_in(1,:name){|name| 'Patsy'}
 => Hamster::Vector[Hamster::Hash[:hobbies => Hamster::Vector["clarinet"], :name => "Chris"], Hamster::Hash[:hobbies => Hamster::Vector["bird watching", "rugby"], :name => "Patsy"]]
 ```
 
-With Hamstar you can write code that is a little more flexibly:
+You can do the exact same thing with Hamstar's `update_having()`:
 
 ```ruby
 require 'hamstar'
-Hamstar.update_having( Hamster.from(x), 1,:name){|name| 'Patsy'}
+Hamstar.update_having( x, 1,:name){|name| 'Patsy'}
 => (same result as before)
 ```
 
 And you can go further, and replace the vector offset `1` with the Kleene star `'*'` to operate on all elements of the vector:
 
 ```ruby
-Hamstar.update_having( Hamster.from(x), '*',:name){|name| 'Patsy'}
-=> (same result as before)
+Hamstar.update_having( x, '*',:name){|name| name + 'sy'}
+=> Hamster::Vector[Hamster::Hash[:name => "Chrissy", :hobbies => Hamster::Vector["clarinet"]], Hamster::Hash[:name => "Patsy", :hobbies => Hamster::Vector["bird watching", "rugby"]]]
+```
+
+And what if you wanted to efficiently replace every 'Pat' with 'Patsy', without having to add conditional code to your block? Hamstar let's you use a key/value pair as part of your path specification:
+
+```ruby
+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.
+
+```ruby
+Hamstar.update_having( x, ->(k,v,expr){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"]]]
 ```
 
 See [`hamstar_spec.rb`](file://spec/hamstar_spec.rb) for more examples.

data/lib/hamstar.rb

@@ -5,44 +5,38 @@ 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
 
-  def update_having(c, *key_path, &block)
-    if key_path.empty?
-      raise ArgumentError, "must have at least one key in path"
+  def update_having(c, *match_path, &block)
+    if match_path.empty?
+      raise ArgumentError, "must have at least one matcher in path"
     end
-    key = key_path[0]
-    case key
-    when KLEENE_STAR; kleene_star c, *key_path, &block
-    when Array, Hamster::Vector; association c, *key_path, &block
+    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 Proc; match matcher, c, *match_path, &block
     else
-      if key_path.size == 1
-        new_value = block.call c.fetch(key,nil)
+      if match_path.size == 1
+        new_value = block.call c.fetch(matcher,nil)
       else
-        value = c.fetch key, Hamster::EmptyHash
-        new_value = update_having value, *key_path[1..-1], &block
+        value = c.fetch matcher, Hamster::EmptyHash
+        new_value = update_having value, *match_path[1..-1], &block
       end
-      c.put key, new_value
+      c.put matcher, new_value
     end
   end
 
-  def kleene_star(c, *key_path, &block)
-    kp_rest = Hamster.from(key_path)[1..-1] # drop kleene star
-    c.keys.each do |key|
-      kp = kp_rest.unshift key # put key where kleene star was
-      c = update_having c, *kp, &block
-    end
-    c
-  end
-
-  def association(c, *key_path, &block)
-    key,value = key_path[0]
-    kp_rest = Hamster.from(key_path)[1..-1] # drop assoc
-    c.each_pair do |k,v|
-      if v[key] == value
-        kp = kp_rest.unshift k # put key where assoc was
-        c = update_having c, *kp, &block
+  def match(matcher, c, *match_path, &block)
+    expr = match_path[0]
+    mp_rest = Hamster.from(match_path)[1..-1] # drop expr
+    c.each_pair do |key,value|
+      if matcher.call key, value, expr
+        mp = mp_rest.unshift key # put key where assoc was
+        c = update_having c, *mp, &block
       end
     end
     c

data/lib/hamstar/version.rb

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

data/spec/hamstar_spec.rb

@@ -13,14 +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]},['*', 0],  ->(v){v+1}, {a:[2],b:[3]}, 'Vector underneath Hash'],
-    [ [{a:1},{a:2}],['*', :a], ->(v){v+1}, [{a:2},{a:3}], 'Hash underneath 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']
   ]
 
+  examples_function_match = [
+    [ [1,2], [->(k,v,expr){v==2}], ->(v){5}, [1,5] ]
+  ]
+
   def self.write_examples(examples)
     examples.each do |e|
       it e[4] do
@@ -40,5 +46,8 @@ RSpec.describe Hamstar do
   describe 'New association matching' do
     write_examples examples_associative
   end
+  describe 'New functional matching' do
+    write_examples examples_function_match
+  end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hamstar
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Bill Burcham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-01 00:00:00.000000000 Z
+date: 2015-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hamster