abstractivator 0.0.15

data/lib/abstractivator/trees/block_collector.rb

@@ -0,0 +1,34 @@
+module Abstractivator
+  module Trees
+
+    class BlockCollector
+      def initialize
+        @config = {}
+      end
+
+      def when(path, &block)
+        @config[path] = block
+      end
+
+      def get_path_tree
+        path_tree = {}
+        @config.each_pair do |path, block|
+          set_hash_path(path_tree, path.split('/'), block)
+        end
+        path_tree
+      end
+
+      private
+
+      def set_hash_path(h, names, block)
+        orig = h
+        while names.size > 1
+          h = (h[names.shift] ||= {})
+        end
+        h[names.shift] = block
+        orig
+      end
+    end
+
+  end
+end

data/lib/abstractivator/version.rb

@@ -0,0 +1,3 @@
+module Abstractivator
+  VERSION = '0.0.15'
+end

data/lib/enumerable_ext.rb

@@ -0,0 +1,11 @@
+module Enumerable
+  def stable_sort(&compare)
+    compare = compare || ->(a, b){a <=> b}
+    xis = self.each_with_index.map{|x, i| [x, i]}
+    sorted = xis.sort do |(a, ai), (b, bi)|
+      primary = compare.call(a, b)
+      primary != 0 ? primary : (ai <=> bi)
+    end
+    sorted.map(&:first)
+  end
+end

data/spec/lib/abstractivator/collections_spec.rb

@@ -0,0 +1,20 @@
+require 'rspec'
+require 'abstractivator/collections'
+
+describe Abstractivator::Collections do
+
+  include Abstractivator::Collections
+
+  describe '#multizip' do
+    it 'transposes' do
+      xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+      expect(multizip(xs)).to eql [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
+      expect(multizip([])).to eql []
+    end
+    it 'uses a default value past the end of shorter enumerables' do
+      xs = [[1, 2, 3], [4], [7, 8, 9]]
+      expect(multizip(xs)).to eql [[1, 4, 7], [2, nil, 8], [3, nil, 9]]
+      expect(multizip(xs, -1)).to eql [[1, 4, 7], [2, -1, 8], [3, -1, 9]]
+    end
+  end
+end

data/spec/lib/abstractivator/cons_spec.rb

@@ -0,0 +1,48 @@
+require 'rspec'
+require 'abstractivator/cons'
+
+describe Abstractivator::Cons do
+
+  include Abstractivator::Cons
+
+  describe '#empty_list' do
+    it 'is a singleton' do
+      expect(empty_list).to eql empty_list
+    end
+  end
+
+  describe '#cons' do
+    it 'creates a cons cell' do
+      expect(cons(1, 2)).to eql [1,2 ]
+    end
+  end
+
+  describe '#head' do
+    it 'returns the head' do
+      cell = cons(1, 2)
+      expect(cell.head).to eql 1
+    end
+  end
+
+  describe '#tail' do
+    it 'returns the tail' do
+      cell = cons(1, 2)
+      expect(cell.tail).to eql 2
+    end
+  end
+
+  describe '#enum_to_list' do
+    it 'returns the list form of an enumerable' do
+      expect(enum_to_list([])).to eql empty_list
+      expect(enum_to_list([1,2,3])).to eql [1, [2, [3, empty_list]]]
+    end
+  end
+
+  describe '#list_to_enum' do
+    it 'returns the enumerable form of a list' do
+      expect(list_to_enum(empty_list).to_a).to eql []
+      expect(list_to_enum(cons(1, cons(2, cons(3, empty_list)))).to_a).to eql [1, 2, 3]
+    end
+  end
+
+end

data/spec/lib/abstractivator/enumerable_ext_spec.rb

@@ -0,0 +1,144 @@
+require 'abstractivator/enumerable_ext'
+
+describe Enumerable do
+  let!(:x) {[
+      { a: 5, b: 6, c: 'asdf' },
+      { a: 8, b: 5, c: 'ffffsfsf' },
+      { a: 3, b: 2, c: 'rwrwrwr' }
+  ]}
+
+  let!(:y) {[
+      { a: 9, b: 10, c: 'aaaaaarghj' },
+      { a: 3, b: 2, c: 'ggggggg' },
+      { a: 5, b: 6, c: 'rrrrrrrrrr' }
+  ]}
+  let!(:get_key) { ->(z) { [z[:a], z[:b]] } }
+
+  describe '::inner_join' do
+    it 'returns only the matched values' do
+      result = Enumerable.inner_join(x, y, get_key, get_key)
+      expect(result.size).to eql 2
+      expect(result).to include([{ a: 5, b: 6, c: 'asdf' }, { a: 5, b: 6, c: 'rrrrrrrrrr' }])
+      expect(result).to include([{ a: 3, b: 2, c: 'rwrwrwr' }, { a: 3, b: 2, c: 'ggggggg' }])
+    end
+  end
+
+  describe '::outer_join' do
+    it 'matches up elements by key' do
+      result = Enumerable.outer_join(x, y, get_key, get_key, -1, -100)
+      expect(result).to include([{ a: 5, b: 6, c: 'asdf' }, { a: 5, b: 6, c: 'rrrrrrrrrr' }])
+      expect(result).to include([{ a: 3, b: 2, c: 'rwrwrwr' }, { a: 3, b: 2, c: 'ggggggg' }])
+    end
+
+    it 'matches a left value up with the right default when the right is missing' do
+      result = Enumerable.outer_join(x, y, get_key, get_key, -1, -100)
+      expect(result).to include([{ a: 8, b: 5, c: 'ffffsfsf' }, -100])
+    end
+
+    it 'matches a right value up with the left default when the left is missing' do
+      result = Enumerable.outer_join(x, y, get_key, get_key, -1, -100)
+      expect(result).to include([-1, { a: 9, b: 10, c: 'aaaaaarghj' }])
+    end
+
+    it 'invokes default value procs' do
+      result = Enumerable.outer_join(x, y, get_key, get_key, ->(x){x[:c]}, ->(x){x[:c]})
+      expect(result).to include([{ a: 8, b: 5, c: 'ffffsfsf' }, 'ffffsfsf'])
+      expect(result).to include(['aaaaaarghj', { a: 9, b: 10, c: 'aaaaaarghj' }])
+    end
+
+    it 'returns the correct number of pairs' do
+      result = Enumerable.outer_join(x, y, get_key, get_key, -1, -100)
+      expect(result.size).to eql 4
+    end
+
+    it 'works when left is empty' do
+      result = Enumerable.outer_join([], y, get_key, get_key, -1, -100)
+      expect(result.size).to eql 3
+    end
+
+    it 'works when right is empty' do
+      result = Enumerable.outer_join(x, [], get_key, get_key, -1, -100)
+      expect(result.size).to eql 3
+    end
+
+    it 'works when both are empty' do
+      result = Enumerable.outer_join([], [], get_key, get_key, -1, -100)
+      expect(result.size).to eql 0
+    end
+
+    it 'throws an exception when left values have overlapping keys' do
+      x.push({ a: 8, b: 5, c: 'oops' })
+      expect { Enumerable.outer_join(x, y, get_key, get_key, -1, -100) }.to raise_error
+    end
+
+    it 'throws an exception when right values have overlapping keys' do
+      y.push({ a: 5, b: 6, c: 'oops' })
+      expect { Enumerable.outer_join(x, y, get_key, get_key, -1, -100) }.to raise_error
+    end
+  end
+
+  describe '#uniq?' do
+    it 'returns true if the items are unique' do
+      expect([1,2,3].uniq?).to be true
+    end
+    it 'returns false if the items are unique' do
+      expect([1,2,2].uniq?).to be false
+    end
+    it 'accepts a block' do
+      expect([[1, 99], [2, 99]].uniq?(&:first)).to be true
+      expect([[1, 99], [2, 99]].uniq?(&:last)).to be false
+    end
+  end
+
+  describe '#detect' do
+    let!(:xs) { [Array, Hash] }
+    it 'falls back to the default behavior' do
+      expect(xs.detect{|x| x.name == 'Hash'}).to eql Hash
+    end
+    it 'falls back to the default behavior' do
+      expect(xs.detect(proc{'123'}){|x| x.name == 'Object'}).to eql '123'
+    end
+    context 'with attr_name and value' do
+      it 'returns the matching element' do
+        expect(xs.detect(:name, 'Hash')).to eql Hash
+      end
+      it 'returns nil if not found' do
+        expect([].detect(:name, 'Hash')).to be_nil
+      end
+    end
+    context 'with value and block' do
+      it 'returns the matching element' do
+        expect(xs.detect('Hash', &:name)).to eql Hash
+      end
+      it 'returns the matching element' do
+        expect([].detect('Hash', &:name)).to be_nil
+      end
+    end
+  end
+
+  describe '#inject_right' do
+    it 'injects, starting at the right' do
+      expect([1, 2, 3].inject_right([]){|acc, x| acc << x}).to eql [3, 2, 1]
+    end
+  end
+
+  describe '#pad_right' do
+    it 'pads values at the end' do
+      a = [1, 2]
+      expect(a.pad_right(4, :x)).to eql [1, 2, :x, :x]
+      expect(a.pad_right(2, :x)).to eql [1, 2]
+      expect(a.pad_right(1, :x)).to eql [1, 2]
+      expect(a.pad_right(-1, :x)).to eql [1, 2]
+    end
+    it 'does not mutate the receiver' do
+      a = [1, 2]
+      a.pad_right(4, :x)
+      expect(a).to eql [1, 2]
+    end
+    it 'accepts a block to create values' do
+      n = 0
+      result = [:x].pad_right(4) { n += 1 }
+      expect(result).to eql [:x, 1, 2, 3]
+    end
+  end
+end

data/spec/lib/abstractivator/proc_ext_spec.rb

@@ -0,0 +1,76 @@
+require 'abstractivator/proc_ext'
+
+context 'in the world of functional programming' do
+  let!(:double) { proc{|x| x * 2} }
+  let!(:square) { proc{|x| x ** 2} }
+  let!(:negate) { proc{|x| -x} }
+
+  describe 'Proc#compose' do
+    it 'composes procs' do
+      expect(double.compose(square).call(3)).to eql 18
+      expect(square.compose(double).call(3)).to eql 36
+    end
+  end
+
+  describe 'Proc::compose' do
+    it 'composes procs' do
+      expect(Proc.compose.call(3)).to eql 3
+      expect(Proc.compose(double).call(3)).to eql 6
+      expect(Proc.compose(square, double).call(3)).to eql 36
+      expect(Proc.compose(negate, square, double).call(3)).to eql -36
+    end
+  end
+
+  describe 'Proc#reverse_args' do
+    it 'reverse argument order' do
+      divide = proc {|a, b| a / b}
+      expect(divide.reverse_args.call(4.0, 1.0)).to eql 0.25
+    end
+  end
+
+  describe 'Proc::loose_call' do
+    it 'returns the first argument if it is not a proc' do
+      expect(Proc.loose_call(:a, [:b, :c])).to eql :a
+    end
+    it 'calls the proc with an appropriate number of arguments' do
+      events = []
+      args = [:here, :are, :some, :arguments]
+      Proc.loose_call(->{events << 0}, args)
+      Proc.loose_call(->(a){events << 1}, args)
+      Proc.loose_call(->(a, b){events << 2}, args)
+      Proc.loose_call(->(a, b, c){events << 3}, args)
+      expect(events).to eql [0, 1, 2, 3]
+    end
+    it 'pads with nils' do
+      expect(Proc.loose_call(->(a, b) {[a, b]}, [1])).to eql [1, nil]
+    end
+  end
+
+  describe 'Proc#loosen_args' do
+    it 'returns a procedure with loose arity semantics' do
+      p = ->(a, b, c) { [a, b, c] }
+      lp = p.loosen_args
+      expect(lp.call(1, 2)).to eql [1, 2, nil]
+    end
+  end
+end
+
+describe 'UnboundMethod#explicit_receiver' do
+  it 'returns a proc that takes an explicit self to bind to as the first argument' do
+    m = Array.instance_method(:<<)
+    a = []
+    m.explicit_receiver.call(a, 42)
+    expect(a).to eql [42]
+  end
+end
+
+describe 'Array#to_proc' do
+  it 'makes a hash-accessor proc' do
+    expect([{a: 1, b: 2}, {a: 3, b: 3}].map(&[:a])).to eql [1, 3]
+    expect([{'a' => 1, 'b' => 2}, {'a' => 3, 'b' => 3}].map(&['a'])).to eql [1, 3]
+  end
+  it 'raises an error if you use it wrong' do
+    expect{[].to_proc}.to raise_error 'size must be exactly one'
+    expect{[:a, :b].to_proc}.to raise_error 'size must be exactly one'
+  end
+end

data/spec/lib/abstractivator/tree_visitor_spec.rb

@@ -0,0 +1,320 @@
+require 'rspec'
+require 'abstractivator/trees'
+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
+
+    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
+
+    def self.example(description, values)
+      it description do
+        tree, mask, expected = values[:tree], values[:mask], values[:result]
+        expect(tree_compare(tree, mask)).to eql expected
+      end
+    end
+
+    example 'returns an empty list if the tree is comparable to the mask',
+            tree:   {a: 1},
+            mask:   {a: 1},
+            result: []
+
+    example 'only requires the mask to match a subtree',
+            tree:   {a: 1, b: 1},
+            mask:   {a: 1},
+            result: []
+
+    example 'returns a list of differences',
+            tree:   {a: 1, b: {c: [8, 8]}},
+            mask:   {a: 2, b: {c: [8, 9]}},
+            result: [{path: 'a', tree: 1, mask: 2},
+                     {path: 'b/c/1', tree: 8, mask: 9}]
+
+    example 'returns a list of differences for missing values',
+            tree:   {},
+            mask:   {a: 2, b: nil},
+            result: [{path: 'a', tree: :__missing__, mask: 2}, {path: 'b', tree: :__missing__, mask: nil}]
+
+    example 'compares hash values',
+            tree:   {a: 1},
+            mask:   {a: 2},
+            result: [{path: 'a', tree: 1, mask: 2}]
+
+    example 'compares array values',
+            tree:   {a: [1, 2]},
+            mask:   {a: [1, 3]},
+            result: [{path: 'a/1', tree: 2, mask: 3}]
+
+    example 'compares with predicates',
+            tree:   {a: 1},
+            mask:   {a: proc {|x| x.even?}},
+            result: [{path: 'a', tree: 1, mask: 'proc { |x| x.even? }'}]
+
+    example 'compares with predicates (degrades gracefully when source code is unavailable)',
+            tree:   {a: 1},
+            mask:   {a: :even?.to_proc},
+            result: [{path: 'a', tree: 1, mask: :__predicate__}]
+
+    it 'compares with predicates (lets non-sourcify errors through)' do
+      expect{tree_compare({a: 1}, {a: proc { raise 'oops' }})}.to raise_error
+    end
+
+    example 'can ensure values are absent with :-',
+            tree:   {a: 1},
+            mask:   {a: :-},
+            result: [{path: 'a', tree: 1, mask: :__absent__}]
+
+    example 'can check for any value being present with :+',
+            tree:   {a: 1, b: [1, 2, 3]},
+            mask:   {a: :+, b: [1, :+, 3]},
+            result: []
+
+    context 'when comparing arrays' do
+      example 'reports the tree being shorter',
+              tree:   {a: [1]},
+              mask:   {a: [1, 2]},
+              result: [{path: 'a/1', tree: :__missing__, mask: [2]}]
+
+      example 'reports the mask being shorter',
+              tree:   {a: [1, 2]},
+              mask:   {a: [1]},
+              result: [{path: 'a/1', tree: [2], mask: :__absent__}]
+
+      example 'can allow arbitrary tails with :*',
+              tree:   {a: [1, 2, 3], b: [1], c: [2]},
+              mask:   {a: [1, :*], b: [1, :*], c: [1, :*]},
+              result: [{path: 'c/0', tree: 2, mask: 1}]
+    end
+
+    context 'when comparing sets' do
+
+      def self.get_name
+        ->(x){ x[:name] }
+      end
+
+      example 'allows out-of-order arrays',
+              tree:   {set: [{id: 2, name: 'b'}, {id: 1, name: 'a'}]},
+              mask:   {set: set_mask([{id: 1, name: 'a'}, {id: 2, name: 'b'}], get_name)},
+              result: []
+
+      example 'reports missing set attribute in the tree',
+              tree:   {},
+              mask:   {set: set_mask([{id: 1, name: 'a'}], get_name)},
+              result: [{path: 'set', tree: :__missing__, mask: [{id: 1, name: 'a'}]}]
+
+      example 'reports missing items in the tree',
+              tree:   {set: []},
+              mask:   {set: set_mask([{id: 1, name: 'a'}], get_name)},
+              result: [{path: 'set/a', tree: :__missing__, mask: {id: 1, name: 'a'}}]
+
+      example 'reports extra items in the tree',
+              tree:   {set: [{id: 1, name: 'a'}]},
+              mask:   {set: set_mask([], get_name)},
+              result: [{path: 'set/a', tree: {id: 1, name: 'a'}, mask: :__absent__}]
+
+      example 'reports duplicate keys in the tree',
+              tree:   {set: [{id: 1, name: 'a'}, {id: 2, name: 'a'}]},
+              mask:   {set: set_mask([:*], get_name)},
+              result: [{path: 'set', tree: [:__duplicate_keys__, ['a']], mask: nil}]
+
+      example 'reports duplicate keys in the mask',
+              tree:   {set: [{id: 1, name: 'a'}]},
+              mask:   {set: set_mask([{id: 1, name: 'a'}, {id: 2, name: 'a'}], get_name)},
+              result: [{path: 'set', tree: nil, mask: [:__duplicate_keys__, ['a']]}]
+
+      example 'can test for only a subset',
+              tree:   {set: [{id: 1, name: 'a'}, {id: 2, name: 'b'}]},
+              mask:   {set: set_mask([{id: 2, name: 'b'}, :*], get_name)},
+              result: []
+    end
+
+
+
+    context 'reports mismatched types' do
+      example 'hash for primitive',
+              tree:   {a: {b: 1}},
+              mask:   {a: 1},
+              result: [{path: 'a', tree: {b: 1}, mask: 1}]
+
+      example 'primitive for hash',
+              tree:   {a: 1},
+              mask:   {a: {b: 1}},
+              result: [{path: 'a', tree: 1, mask: {b: 1}}]
+
+      example 'array for primitive',
+              tree:   {a: [1, 2]},
+              mask:   {a: 1},
+              result: [{path: 'a', tree: [1, 2], mask: 1}]
+
+      example 'primitive for array',
+              tree:   {a: 1},
+              mask:   {a: [1, 2]},
+              result: [{path: 'a', tree: 1, mask: [1, 2]}]
+
+      example 'primitive for set',
+              tree:   {set: 1},
+              mask:   {set: set_mask([{x: 1}], ->(item) { item[:x] })},
+              result: [{path: 'set', tree: 1, mask: [{x: 1}]}]
+    end
+  end
+end