abstractivator 0.0.22 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed70b3e745e17ec7a24ef81a0f8734a88408f6ee
-  data.tar.gz: 7f463093462a219c2f055da69e14f867ad45d5cd
+  metadata.gz: 5cf5eda70ec67c313b2df05ad3280682c8785f40
+  data.tar.gz: 9a0d1adaf5762a97cbf854086bb09edff5577169
 SHA512:
-  metadata.gz: 36cc3d351e63c62cb1a84cd073747a734a145b1712111fad30431df3f82c59b5eb7cf4eca6c096d8eb824131c2b953a28eedcf0b83cc8ba1bc327ff8260aa1f2
-  data.tar.gz: aabc33b65cd3f7133f78828e2f14e379c360f64accbccd2df9d6f399594d88730b8ccfd1d29904ec763f83a12f212435fd74d5873889e56606088174dccc8e9d
+  metadata.gz: b04ee0b54f862440283a251cb940d05c55412d6dd9312286935302c9d26b9aeeeb892e3632cfdb433f3d7b9c65c7c804ca9a78e3080039d3cd19b709d928b4e3
+  data.tar.gz: 6d3f90b0717a52ef4ef069dea162070b3b0cf4bd7e96d36911475afeec513ef79a3b933152bcc3f488a300cf7caa4b1f46ec3b8858755b7e814bf2a18d20f7f5

data/lib/abstractivator/trees.rb

@@ -1,220 +1,3 @@
-require 'active_support/core_ext/object/deep_dup'
-require 'abstractivator/trees/block_collector'
-require 'sourcify'
-require 'delegate'
-require 'set'
-
-module Abstractivator
-  module Trees
-
-    SetMask = Struct.new(:items, :get_key)
-    def set_mask(items, get_key)
-      SetMask.new(items, get_key)
-    end
-
-    def tree_compare(tree, mask, path=[], index=nil)
-      if mask == [:*] && tree.is_a?(Enumerable)
-        []
-      elsif mask == :+ && tree != :__missing__
-        []
-      elsif mask == :- && tree != :__missing__
-        [diff(path, tree, :__absent__)]
-      elsif mask.respond_to?(:call)
-        comparable = mask.call(tree)
-        comparable ? [] : [diff(path, tree, mask)]
-      else
-        case mask
-          when Hash
-            if tree.is_a?(Hash)
-              mask.each_pair.flat_map do |k, v|
-                tree_compare(tree.fetch(k, :__missing__), v, push_path(path, k))
-              end
-            else
-              [diff(path, tree, mask)]
-            end
-          when SetMask # must check this before Enumerable because Structs are enumerable
-            if tree.is_a?(Enumerable)
-              # convert the enumerables to hashes, then compare those hashes
-              tree_items = tree
-              mask_items = mask.items.dup
-              get_key = mask.get_key
-
-              be_strict = !mask_items.delete(:*)
-              new_tree = hashify_set(tree_items, get_key)
-              new_mask = hashify_set(mask_items, get_key)
-              tree_keys = Set.new(new_tree.keys)
-              mask_keys = Set.new(new_mask.keys)
-              tree_only = tree_keys - mask_keys
-
-              # report duplicate keys
-              if new_tree.size < tree_items.size
-                diff(path, [:__duplicate_keys__, duplicates(tree_items.map(&get_key))], nil)
-              elsif new_mask.size < mask_items.size
-                diff(path, nil, [:__duplicate_keys__, duplicates(mask_items.map(&get_key))])
-              # hash comparison allows extra values in the tree.
-              # report extra values in the tree unless there was a :* in the mask
-              elsif be_strict && tree_only.any?
-                tree_only.map{|k| diff(push_path(path, k), new_tree[k], :__absent__)}
-              else # compare as hashes
-                tree_compare(new_tree, new_mask, path, index)
-              end
-            else
-              [diff(path, tree, mask.items)]
-            end
-          when Enumerable
-            if tree.is_a?(Enumerable)
-              index ||= 0
-              if !tree.any? && !mask.any?
-                []
-              elsif !tree.any?
-                [diff(push_path(path, index.to_s), :__missing__, mask)]
-              elsif !mask.any?
-                [diff(push_path(path, index.to_s), tree, :__absent__)]
-              else
-                # if the mask is programmatically generated (unlikely), then
-                # the mask might be really big and this could blow the stack.
-                # don't support this case for now.
-                tree_compare(tree.first, mask.first, push_path(path, index.to_s)) +
-                    tree_compare(tree.drop(1), mask.drop(1), path, index + 1)
-              end
-            else
-              [diff(path, tree, mask)]
-            end
-          else
-            tree == mask ? [] : [diff(path, tree, mask)]
-        end
-      end
-    end
-
-    private
-
-    def hashify_set(items, get_key)
-      Hash[items.map{|x| [get_key.call(x), x] }]
-    end
-
-    def duplicates(xs)
-      xs.group_by{|x| x}.each_pair.select{|_k, v| v.size > 1}.map(&:first)
-    end
-
-    def push_path(path, name)
-      path + [name]
-    end
-
-    def path_string(path)
-      path.join('/')
-    end
-
-    def diff(path, tree, mask)
-      {path: path_string(path), tree: tree, mask: massage_mask_for_diff(mask)}
-    end
-
-    def massage_mask_for_diff(mask)
-      if mask.respond_to?(:call)
-        massaged = :__predicate__
-        begin
-          massaged = mask.to_source
-        rescue Exception => e
-          raise unless e.class.name.start_with?('Sourcify')
-        end
-        massaged
-      else
-        mask
-      end
-    end
-
-    public
-
-    def tree_map(h)
-      raise ArgumentError.new('Must provide a transformer block') unless block_given?
-      config = BlockCollector.new
-      yield(config)
-      TransformTreeClosure.new.do_obj(h, config.get_path_tree)
-    end
-
-    class TransformTreeClosure
-      def initialize
-        @bias = 0 # symbol = +, string = -
-      end
-
-      def do_obj(obj, path_tree)
-        case obj
-          when nil; nil
-          when Array; do_array(obj, path_tree)
-          else; do_hash(obj, path_tree)
-        end
-      end
-
-      private
-
-      def do_hash(h, path_tree)
-        h = h.dup
-        path_tree.each_pair do |name, path_tree|
-          if path_tree.respond_to?(:call)
-            if (hash_name = try_get_hash_name(name))
-              hash_name, old_fh = get_key_and_value(h, hash_name)
-              unless old_fh.nil?
-                h[hash_name] = old_fh.each_with_object(old_fh.dup) do |(key, value), fh|
-                  fh[key] = path_tree.call(value.deep_dup)
-                end
-              end
-            elsif (array_name = try_get_array_name(name))
-              array_name, value = get_key_and_value(h, array_name)
-              unless value.nil?
-                h[array_name] = value.map(&:deep_dup).map(&path_tree)
-              end
-            else
-              name, value = get_key_and_value(h, name)
-              h[name] = path_tree.call(value.deep_dup)
-            end
-          else
-            name, value = get_key_and_value(h, name)
-            h[name] = do_obj(value, path_tree)
-          end
-        end
-        h
-      end
-
-      def get_key_and_value(h, string_key)
-        tried_symbol = @bias >= 0
-        trial_key = tried_symbol ? string_key.to_sym : string_key
-        value = h[trial_key]
-
-        if value.nil? # failed
-          @bias += (tried_symbol ? -1 : 1)
-          key = tried_symbol ? string_key : string_key.to_sym
-          [key, h[key]]
-        else
-          @bias += (tried_symbol ? 1 : -1)
-          [trial_key, value]
-        end
-      end
-
-      def do_array(a, path_tree)
-        a.map{|x| do_obj(x, path_tree)}
-      end
-
-      def try_get_hash_name(p)
-        p =~ /(.+)\{\}$/ ? $1 : nil
-      end
-
-      def try_get_array_name(p)
-        p =~ /(.+)\[\]$/ ? $1 : nil
-      end
-    end
-
-    public
-
-    def recursive_delete!(hash, keys)
-      x = hash # hash is named 'hash' for documentation purposes but may be anything
-      case x
-        when Hash
-          keys.each{|k| x.delete(k)}
-          x.each_value{|v| recursive_delete!(v, keys)}
-        when Array
-          x.each{|v| recursive_delete!(v, keys)}
-      end
-      x
-    end
-
-  end
-end
+require 'abstractivator/trees/tree_map'
+require 'abstractivator/trees/tree_compare'
+require 'abstractivator/trees/recursive_delete'

data/lib/abstractivator/trees/block_collector.rb

@@ -18,6 +18,10 @@ module Abstractivator
         path_tree
       end
 
+      def delete
+        @delete ||= Object.new
+      end
+
       private
 
       def set_hash_path(h, names, block)
@@ -31,4 +35,4 @@ module Abstractivator
     end
 
   end
-end
+end

data/lib/abstractivator/trees/recursive_delete.rb

@@ -0,0 +1,21 @@
+require 'active_support/core_ext/object/deep_dup'
+require 'abstractivator/trees/block_collector'
+require 'sourcify'
+require 'delegate'
+require 'set'
+
+module Abstractivator
+  module Trees
+    def recursive_delete!(hash, keys)
+      x = hash # hash is named 'hash' for documentation purposes but may be anything
+      case x
+        when Hash
+          keys.each{|k| x.delete(k)}
+          x.each_value{|v| recursive_delete!(v, keys)}
+        when Array
+          x.each{|v| recursive_delete!(v, keys)}
+      end
+      x
+    end
+  end
+end

data/lib/abstractivator/trees/tree_compare.rb

@@ -0,0 +1,125 @@
+require 'active_support/core_ext/object/deep_dup'
+require 'abstractivator/trees/block_collector'
+require 'sourcify'
+require 'delegate'
+require 'set'
+
+module Abstractivator
+  module Trees
+
+    SetMask = Struct.new(:items, :get_key)
+    def set_mask(items, get_key)
+      SetMask.new(items, get_key)
+    end
+
+    def tree_compare(tree, mask, path=[], index=nil)
+      if mask == [:*] && tree.is_a?(Enumerable)
+        []
+      elsif mask == :+ && tree != :__missing__
+        []
+      elsif mask == :- && tree != :__missing__
+        [diff(path, tree, :__absent__)]
+      elsif mask.respond_to?(:call)
+        are_equivalent = mask.call(tree)
+        are_equivalent ? [] : [diff(path, tree, mask)]
+      else
+        case mask
+          when Hash
+            if tree.is_a?(Hash)
+              mask.each_pair.flat_map do |k, v|
+                tree_compare(tree.fetch(k, :__missing__), v, push_path(path, k))
+              end
+            else
+              [diff(path, tree, mask)]
+            end
+          when SetMask # must check this before Enumerable because Structs are enumerable
+            if tree.is_a?(Enumerable)
+              # convert the enumerables to hashes, then compare those hashes
+              tree_items = tree
+              mask_items = mask.items.dup
+              get_key = mask.get_key
+
+              be_strict = !mask_items.delete(:*)
+              new_tree = hashify_set(tree_items, get_key)
+              new_mask = hashify_set(mask_items, get_key)
+              tree_keys = Set.new(new_tree.keys)
+              mask_keys = Set.new(new_mask.keys)
+              tree_only = tree_keys - mask_keys
+
+              # report duplicate keys
+              if new_tree.size < tree_items.size
+                diff(path, [:__duplicate_keys__, duplicates(tree_items.map(&get_key))], nil)
+              elsif new_mask.size < mask_items.size
+                diff(path, nil, [:__duplicate_keys__, duplicates(mask_items.map(&get_key))])
+                # hash comparison allows extra values in the tree.
+                # report extra values in the tree unless there was a :* in the mask
+              elsif be_strict && tree_only.any?
+                tree_only.map{|k| diff(push_path(path, k), new_tree[k], :__absent__)}
+              else # compare as hashes
+                tree_compare(new_tree, new_mask, path, index)
+              end
+            else
+              [diff(path, tree, mask.items)]
+            end
+          when Enumerable
+            if tree.is_a?(Enumerable)
+              index ||= 0
+              if !tree.any? && !mask.any?
+                []
+              elsif !tree.any?
+                [diff(push_path(path, index.to_s), :__missing__, mask)]
+              elsif !mask.any?
+                [diff(push_path(path, index.to_s), tree, :__absent__)]
+              else
+                # if the mask is programmatically generated (unlikely), then
+                # the mask might be really big and this could blow the stack.
+                # don't support this case for now.
+                tree_compare(tree.first, mask.first, push_path(path, index.to_s)) +
+                    tree_compare(tree.drop(1), mask.drop(1), path, index + 1)
+              end
+            else
+              [diff(path, tree, mask)]
+            end
+          else
+            tree == mask ? [] : [diff(path, tree, mask)]
+        end
+      end
+    end
+
+    private
+
+    def hashify_set(items, get_key)
+      Hash[items.map{|x| [get_key.call(x), x] }]
+    end
+
+    def duplicates(xs)
+      xs.group_by{|x| x}.each_pair.select{|_k, v| v.size > 1}.map(&:first)
+    end
+
+    def push_path(path, name)
+      path + [name]
+    end
+
+    def path_string(path)
+      path.join('/')
+    end
+
+    def diff(path, tree, mask)
+      {path: path_string(path), tree: tree, mask: massage_mask_for_diff(mask)}
+    end
+
+    def massage_mask_for_diff(mask)
+      if mask.respond_to?(:call)
+        massaged = :__predicate__
+        begin
+          massaged = mask.to_source
+        rescue Exception => e
+          raise unless e.class.name.start_with?('Sourcify')
+        end
+        massaged
+      else
+        mask
+      end
+    end
+  end
+end

data/lib/abstractivator/trees/tree_map.rb

@@ -0,0 +1,121 @@
+require 'active_support/core_ext/object/deep_dup'
+require 'abstractivator/trees/block_collector'
+require 'sourcify'
+require 'delegate'
+require 'set'
+
+module Abstractivator
+  module Trees
+
+    # Transforms a tree at certain paths.
+    # The transform is non-destructive and reuses untouched substructure.
+    # For efficiency, it first builds a "path_tree" that describes
+    # which paths to transform. This path_tree is then used as input
+    # for a data-driven algorithm.
+    def tree_map(h)
+      raise ArgumentError.new('Must provide a transformer block') unless block_given?
+      config = BlockCollector.new
+      yield(config)
+      TransformTreeClosure.new(config).do_obj(h, config.get_path_tree)
+    end
+
+    class TransformTreeClosure
+      def initialize(config)
+        @config = config
+        @bias = 0 # symbol = +, string = -
+        @no_value = Object.new
+      end
+
+      def do_obj(obj, path_tree)
+        case obj
+          when nil; nil
+          when Array; do_array(obj, path_tree)
+          else; do_hash(obj, path_tree)
+        end
+      end
+
+      private
+
+      def do_hash(h, path_tree)
+        h = h.dup
+        path_tree.each_pair do |name, path_tree|
+          if leaf?(path_tree)
+            if hash_name = try_get_hash_name(name)
+              hash_name, old_fh = get_key_and_value(h, hash_name)
+              unless old_fh == @no_value || old_fh.nil?
+                old_fh.is_a?(Hash) or raise "Expected a hash but got #{old_fh.class.name}: #{old_fh.inspect}"
+                h[hash_name] = old_fh.each_with_object(old_fh.dup) do |(key, value), fh|
+                  replacement = path_tree.call(value.deep_dup, key)
+                  if deleted?(replacement)
+                    fh.delete(key)
+                  else
+                    fh[key] = replacement
+                  end
+                end
+              end
+            elsif array_name = try_get_array_name(name)
+              array_name, value = get_key_and_value(h, array_name)
+              unless value == @no_value || value.nil?
+                value.is_a?(Array) or raise "Expected an array but got #{value.class.name}: #{value.inspect}"
+                h[array_name] = value.map(&:deep_dup).each_with_index.map(&path_tree).reject(&method(:deleted?))
+              end
+            else
+              name, value = get_key_and_value(h, name)
+              unless value == @no_value
+                replacement = path_tree.call(value.deep_dup)
+                if deleted?(replacement)
+                  h.delete(name)
+                else
+                  h[name] = replacement
+                end
+              end
+            end
+          else # not leaf
+            name, value = get_key_and_value(h, name)
+            h[name] = do_obj(value, path_tree) unless value == @no_value
+          end
+        end
+        h
+      end
+
+      def leaf?(path_tree)
+        path_tree.respond_to?(:call)
+      end
+
+      def deleted?(value)
+        value == @config.delete
+      end
+
+      def get_key_and_value(h, string_key)
+        tried_symbol = @bias >= 0
+        trial_key = tried_symbol ? string_key.to_sym : string_key
+        value = try_fetch(h, trial_key)
+
+        if value == @no_value # failed
+          @bias += (tried_symbol ? -1 : 1)
+          key = tried_symbol ? string_key : string_key.to_sym
+          [key, try_fetch(h, key)]
+        else
+          @bias += (tried_symbol ? 1 : -1)
+          [trial_key, value]
+        end
+      end
+
+      def try_fetch(h, trial_key)
+        h.fetch(trial_key, @no_value)
+      end
+
+      def do_array(a, path_tree)
+        a.map{|x| do_obj(x, path_tree)}
+      end
+
+      def try_get_hash_name(p)
+        p =~ /(.+)\{\}$/ ? $1 : nil
+      end
+
+      def try_get_array_name(p)
+        p =~ /(.+)\[\]$/ ? $1 : nil
+      end
+    end
+  end
+end

data/lib/abstractivator/version.rb

@@ -1,3 +1,3 @@
 module Abstractivator
-  VERSION = '0.0.22'
+  VERSION = '0.0.23'
 end

data/spec/lib/abstractivator/trees/recursive_delete_spec.rb

@@ -0,0 +1,28 @@
+require 'rspec'
+require 'abstractivator/trees/recursive_delete'
+require 'json'
+require 'rails'
+require 'pp'
+
+describe Abstractivator::Trees do
+
+  include Abstractivator::Trees
+
+  describe '#recursive_delete!' do
+    it 'deletes keys in the root hash' do
+      h = {a: 1, b: 2}
+      recursive_delete!(h, [:a])
+      expect(h).to eql({b: 2})
+    end
+    it 'deletes keys in sub hashes' do
+      h = {a: 1, b: {c: 3, d: 4}}
+      recursive_delete!(h, [:c])
+      expect(h).to eql({a: 1, b: {d: 4}})
+    end
+    it 'deletes keys in hashes inside arrays' do
+      h = {a: [{b: 1, c: 2}, {b: 3, c: 4}]}
+      recursive_delete!(h, [:b])
+      expect(h).to eql({a: [{c: 2}, {c: 4}]})
+    end
+  end
+end

data/spec/lib/abstractivator/{tree_visitor_spec.rb → trees/tree_compare_spec.rb}

@@ -1,5 +1,5 @@
 require 'rspec'
-require 'abstractivator/trees'
+require 'abstractivator/trees/tree_compare'
 require 'json'
 require 'rails'
 require 'pp'
@@ -8,161 +8,6 @@ describe Abstractivator::Trees do
 
   include Abstractivator::Trees
 
-  describe '#tree_map' do
-
-    context 'when no block is provided' do
-      it 'raises an exception' do
-        expect{ tree_map(hash) }.to raise_error ArgumentError, 'Must provide a transformer block'
-      end
-    end
-
-    it 'handles both string and symbol keys' do
-      h = {:a => 1, 'b' => 2}
-      result = tree_map(h) do |t|
-        t.when('a') {|v| v + 10}
-        t.when('b') {|v| v + 10}
-      end
-      expect(result).to eql({:a => 11, 'b' => 12})
-    end
-
-    it 'replaces primitive-type hash fields' do
-      h = {'a' => 1}
-      result = transform_one_path(h, 'a') { 2 }
-      expect(result).to eql({'a' => 2})
-    end
-
-    it 'replaces nil hash fields' do
-      h = {'a' => nil}
-      result = transform_one_path(h, 'a') {|v| v.to_s}
-      expect(result).to eql({'a' => ''})
-    end
-
-    it 'replaces hash-type hash fields' do
-      h = {'a' => {'b' => 1}}
-      result = transform_one_path(h, 'a') { {'z' => 99} }
-      expect(result).to eql({'a' => {'z' => 99}})
-    end
-
-    it 'replaces array-type hash fields' do
-      h = {'a' => [1,2,3]}
-      result = transform_one_path(h, 'a') {|v| v.reverse}
-      expect(result).to eql({'a' => [3,2,1]})
-    end
-
-    it 'replaces primitive-type hash members' do
-      h = {'a' => {'b' => 'foo', 'c' => 'bar'}}
-      result = transform_one_path(h, 'a{}') {|v| v.reverse}
-      expect(result).to eql({'a' => {'b' => 'oof', 'c' => 'rab'}})
-    end
-
-    it 'replaces hash-type hash members' do
-      h = {'a' => {'b' => {'x' => 88}, 'c' => {'x' => 88}}}
-      result = transform_one_path(h, 'a{}') {|v| {'y' => 99}}
-      expect(result).to eql({'a' => {'b' => {'y' => 99}, 'c' => {'y' => 99}}})
-    end
-
-    it 'replaces array-type hash members' do
-      h = {'a' => {'b' => [1,2,3], 'c' => [4,5,6]}}
-      result = transform_one_path(h, 'a{}') {|v| v.reverse}
-      expect(result).to eql({'a' => {'b' => [3,2,1], 'c' => [6,5,4]}})
-    end
-
-    it 'replaces primitive-type array members' do
-      h = {'a' => [1, 2]}
-      result = transform_one_path(h, 'a[]') {|v| v + 10}
-      expect(result).to eql({'a' => [11, 12]})
-    end
-
-    it 'replaces hash-type array members' do
-      h = {'a' => [{'b' => 1}, {'c' => 2}]}
-      result = transform_one_path(h, 'a[]') { {'z' => 99} }
-      expect(result).to eql({'a' => [{'z' => 99}, {'z' => 99}]})
-    end
-
-    it 'replaces array-type array members' do
-      h = {'a' => [[1,2,3], [4,5,6]]}
-      result = transform_one_path(h, 'a[]') {|v| v.reverse}
-      expect(result).to eql({'a' => [[3,2,1], [6,5,4]]})
-    end
-
-    context 'when replacing array members' do
-      it 'allows the array to be nil' do
-        h = {'a' => nil}
-        result = transform_one_path(h, 'a[]') {|v| v + 1}
-        expect(result).to eql({'a' => nil})
-      end
-    end
-
-    context 'when replacing hash members' do
-      it 'allows the hash to be nil' do
-        h = {'a' => nil}
-        result = transform_one_path(h, 'a{}') {|v| v + 1}
-        expect(result).to eql({'a' => nil})
-      end
-    end
-
-    context 'mutation' do
-      before(:each) do
-        @old = {'a' => {'x' => 1, 'y' => 2}, 'b' => {'x' => 17, 'y' => 23}}
-        @new = transform_one_path(@old,'a') {|v|
-          v['z'] = v['x'] + v['y']
-          v
-        }
-      end
-      it 'does not mutate the input' do
-        expect(@old).to eql({'a' => {'x' => 1, 'y' => 2}, 'b' => {'x' => 17, 'y' => 23}})
-        expect(@new).to eql({'a' => {'x' => 1, 'y' => 2, 'z' => 3}, 'b' => {'x' => 17, 'y' => 23}})
-      end
-      it 'preserves unmodified substructure' do
-        expect(@old['a'].equal?(@new['a'])).to be_falsey
-        expect(@old['b'].equal?(@new['b'])).to be_truthy
-      end
-
-      #TODO: create a generic json file to use for this test
-      # it 'really does not mutate the input' do
-      #   old = JSON.parse(File.read('assay.json'))
-      #   old2 = old.deep_dup
-      #   tree_map(old) do |t|
-      #     t.when('compound_methods/calibration/normalizers[]') {|v| v.to_s.reverse}
-      #     t.when('compound_methods/calibration/responses[]') {|v| v.to_s.reverse}
-      #     t.when('compound_methods/rule_settings{}') {|v| v.to_s.reverse}
-      #     t.when('compound_methods/chromatogram_methods/rule_settings{}') {|v| v.to_s.reverse}
-      #     t.when('compound_methods/chromatogram_methods/peak_integration/retention_time') do |ret_time|
-      #       if ret_time['reference_type_source'] == 'chromatogram'
-      #         ret_time['reference'] = ret_time['reference'].to_s.reverse
-      #       end
-      #       ret_time
-      #     end
-      #   end
-      #   expect(old).to eql old2
-      # end
-    end
-
-    def transform_one_path(h, path, &block)
-      tree_map(h) do |t|
-        t.when(path, &block)
-      end
-    end
-  end
-
-  describe '#recursive_delete!' do
-    it 'deletes keys in the root hash' do
-      h = {a: 1, b: 2}
-      recursive_delete!(h, [:a])
-      expect(h).to eql({b: 2})
-    end
-    it 'deletes keys in sub hashes' do
-      h = {a: 1, b: {c: 3, d: 4}}
-      recursive_delete!(h, [:c])
-      expect(h).to eql({a: 1, b: {d: 4}})
-    end
-    it 'deletes keys in hashes inside arrays' do
-      h = {a: [{b: 1, c: 2}, {b: 3, c: 4}]}
-      recursive_delete!(h, [:b])
-      expect(h).to eql({a: [{c: 2}, {c: 4}]})
-    end
-  end
-
   describe '#tree_compare' do
 
     extend Abstractivator::Trees

data/spec/lib/abstractivator/trees/tree_map_spec.rb

@@ -0,0 +1,201 @@
+require 'rspec'
+require 'abstractivator/trees/tree_map'
+require 'json'
+require 'rails'
+require 'pp'
+
+describe Abstractivator::Trees do
+
+  include Abstractivator::Trees
+
+  describe '#tree_map' do
+
+    context 'when no block is provided' do
+      it 'raises an exception' do
+        expect{ tree_map(hash) }.to raise_error ArgumentError, 'Must provide a transformer block'
+      end
+    end
+
+    it 'handles both string and symbol keys' do
+      h = {:a => 1, 'b' => 2}
+      result = tree_map(h) do |t|
+        t.when('a') {|v| v + 10}
+        t.when('b') {|v| v + 10}
+      end
+      expect(result).to eql({:a => 11, 'b' => 12})
+    end
+
+    it 'replaces primitive-type hash fields' do
+      h = {'a' => 1}
+      result = transform_one_path(h, 'a') { 2 }
+      expect(result).to eql({'a' => 2})
+    end
+
+    it 'replaces nil hash fields' do
+      h = {'a' => nil}
+      result = transform_one_path(h, 'a') {|v| v.to_s}
+      expect(result).to eql({'a' => ''})
+    end
+
+    it 'replaces hash-type hash fields' do
+      h = {'a' => {'b' => 1}}
+      result = transform_one_path(h, 'a') { {'z' => 99} }
+      expect(result).to eql({'a' => {'z' => 99}})
+    end
+
+    it 'replaces array-type hash fields' do
+      h = {'a' => [1,2,3]}
+      result = transform_one_path(h, 'a') {|v| v.reverse}
+      expect(result).to eql({'a' => [3,2,1]})
+    end
+
+    it 'replaces primitive-type hash members' do
+      h = {'a' => {'b' => 'foo', 'c' => 'bar'}}
+      result = transform_one_path(h, 'a{}') {|v| v.reverse}
+      expect(result).to eql({'a' => {'b' => 'oof', 'c' => 'rab'}})
+    end
+
+    it 'replaces hash-type hash members' do
+      h = {'a' => {'b' => {'x' => 88}, 'c' => {'x' => 88}}}
+      result = transform_one_path(h, 'a{}') {|v| {'y' => 99}}
+      expect(result).to eql({'a' => {'b' => {'y' => 99}, 'c' => {'y' => 99}}})
+    end
+
+    it 'replaces array-type hash members' do
+      h = {'a' => {'b' => [1,2,3], 'c' => [4,5,6]}}
+      result = transform_one_path(h, 'a{}') {|v| v.reverse}
+      expect(result).to eql({'a' => {'b' => [3,2,1], 'c' => [6,5,4]}})
+    end
+
+    it 'replaces primitive-type array members' do
+      h = {'a' => [1, 2]}
+      result = transform_one_path(h, 'a[]') {|v| v + 10}
+      expect(result).to eql({'a' => [11, 12]})
+    end
+
+    it 'replaces hash-type array members' do
+      h = {'a' => [{'b' => 1}, {'c' => 2}]}
+      result = transform_one_path(h, 'a[]') { {'z' => 99} }
+      expect(result).to eql({'a' => [{'z' => 99}, {'z' => 99}]})
+    end
+
+    it 'replaces array-type array members' do
+      h = {'a' => [[1,2,3], [4,5,6]]}
+      result = transform_one_path(h, 'a[]') {|v| v.reverse}
+      expect(result).to eql({'a' => [[3,2,1], [6,5,4]]})
+    end
+
+    it 'deletes values' do
+      h = {
+          a: 1,
+          b: [4, 5, 6],
+          c: { d: 9, e: 10 },
+          f: { g: 101, h: 102, i: 103 }
+      }
+      result = tree_map(h) do |t|
+        t.when('a') { t.delete }
+        t.when('c/d') { t.delete }
+        t.when('b[]') { |x| x.even? ? t.delete : x }
+        t.when('f{}') { |x| x.even? ? t.delete : x }
+      end
+      expect(result).to eql({b: [5], c: {e: 10}, f: {g: 101, i: 103}})
+    end
+
+    context 'when replacing array members' do
+      it 'allows the array to be nil' do
+        h = {'a' => nil}
+        result = transform_one_path(h, 'a[]') {|v| v + 1}
+        expect(result).to eql({'a' => nil})
+      end
+      it 'passes the index as the second argument' do
+        h = {a: %w(one two)}
+        call_count = 0
+        transform_one_path(h, 'a[]') do |v, i|
+          expect(i).to eql 0 if v == 'one'
+          expect(i).to eql 1 if v == 'two'
+          call_count += 1
+        end
+        expect(call_count).to eql 2
+      end
+      it 'raises an error is the value is not an array' do
+        expect{transform_one_path({a: 1}, 'a[]') { |x| x }}.to raise_error 'Expected an array but got Fixnum: 1'
+        expect{transform_one_path({a: {b: 1}}, 'a[]') { |x| x }}.to raise_error 'Expected an array but got Hash: {:b=>1}'
+      end
+    end
+
+    context 'when replacing hash members' do
+      it 'allows the hash to be nil' do
+        h = {'a' => nil}
+        result = transform_one_path(h, 'a{}') {|v| v + 1}
+        expect(result).to eql({'a' => nil})
+      end
+      it 'passes the key as the second argument' do
+        h = {a: {b: 1, c: 2}}
+        call_count = 0
+        transform_one_path(h, 'a{}') do |v, k|
+          expect(k).to eql :b if v == 1
+          expect(k).to eql :c if v == 2
+          call_count += 1
+        end
+        expect(call_count).to eql 2
+      end
+      it 'raises an error is the value is not a hash' do
+        expect{transform_one_path({a: 1}, 'a{}') { |x| x }}.to raise_error 'Expected a hash but got Fixnum: 1'
+        expect{transform_one_path({a: [1, 2]}, 'a{}') { |x| x }}.to raise_error 'Expected a hash but got Array: [1, 2]'
+      end
+    end
+
+    it 'it does not add missing keys' do # regression test
+      result = tree_map({}) do |t|
+        t.when('foo') { |x| x }
+        t.when('bars[]') { |x| x }
+        t.when('others/baz') { |x| x }
+      end
+      expect(result).to eql({})
+    end
+
+    context 'mutation' do
+      before(:each) do
+        @old = {'a' => {'x' => 1, 'y' => 2}, 'b' => {'x' => 17, 'y' => 23}}
+        @new = transform_one_path(@old,'a') {|v|
+          v['z'] = v['x'] + v['y']
+          v
+        }
+      end
+      it 'does not mutate the input' do
+        expect(@old).to eql({'a' => {'x' => 1, 'y' => 2}, 'b' => {'x' => 17, 'y' => 23}})
+        expect(@new).to eql({'a' => {'x' => 1, 'y' => 2, 'z' => 3}, 'b' => {'x' => 17, 'y' => 23}})
+      end
+      it 'preserves unmodified substructure' do
+        expect(@old['a'].equal?(@new['a'])).to be_falsey
+        expect(@old['b'].equal?(@new['b'])).to be_truthy
+      end
+
+      #TODO: create a generic json file to use for this test
+      # it 'really does not mutate the input' do
+      #   old = JSON.parse(File.read('assay.json'))
+      #   old2 = old.deep_dup
+      #   tree_map(old) do |t|
+      #     t.when('compound_methods/calibration/normalizers[]') {|v| v.to_s.reverse}
+      #     t.when('compound_methods/calibration/responses[]') {|v| v.to_s.reverse}
+      #     t.when('compound_methods/rule_settings{}') {|v| v.to_s.reverse}
+      #     t.when('compound_methods/chromatogram_methods/rule_settings{}') {|v| v.to_s.reverse}
+      #     t.when('compound_methods/chromatogram_methods/peak_integration/retention_time') do |ret_time|
+      #       if ret_time['reference_type_source'] == 'chromatogram'
+      #         ret_time['reference'] = ret_time['reference'].to_s.reverse
+      #       end
+      #       ret_time
+      #     end
+      #   end
+      #   expect(old).to eql old2
+      # end
+    end
+
+    def transform_one_path(h, path, &block)
+      tree_map(h) do |t|
+        t.when(path, &block)
+      end
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstractivator
 version: !ruby/object:Gem::Version
-  version: 0.0.22
+  version: 0.0.23
 platform: ruby
 authors:
 - Peter Winton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-13 00:00:00.000000000 Z
+date: 2015-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -89,6 +89,9 @@ files:
 - lib/abstractivator/proc_ext.rb
 - lib/abstractivator/trees.rb
 - lib/abstractivator/trees/block_collector.rb
+- lib/abstractivator/trees/recursive_delete.rb
+- lib/abstractivator/trees/tree_compare.rb
+- lib/abstractivator/trees/tree_map.rb
 - lib/abstractivator/version.rb
 - lib/enumerable_ext.rb
 - spec/lib/abstractivator/array_ext_spec.rb
@@ -97,7 +100,9 @@ files:
 - spec/lib/abstractivator/enum_spec.rb
 - spec/lib/abstractivator/enumerable_ext_spec.rb
 - spec/lib/abstractivator/proc_ext_spec.rb
-- spec/lib/abstractivator/tree_visitor_spec.rb
+- spec/lib/abstractivator/trees/recursive_delete_spec.rb
+- spec/lib/abstractivator/trees/tree_compare_spec.rb
+- spec/lib/abstractivator/trees/tree_map_spec.rb
 - spec/lib/enumerable_ext_spec.rb
 homepage: ''
 licenses:
@@ -130,6 +135,8 @@ test_files:
 - spec/lib/abstractivator/enum_spec.rb
 - spec/lib/abstractivator/enumerable_ext_spec.rb
 - spec/lib/abstractivator/proc_ext_spec.rb
-- spec/lib/abstractivator/tree_visitor_spec.rb
+- spec/lib/abstractivator/trees/recursive_delete_spec.rb
+- spec/lib/abstractivator/trees/tree_compare_spec.rb
+- spec/lib/abstractivator/trees/tree_map_spec.rb
 - spec/lib/enumerable_ext_spec.rb
 has_rdoc: