faceter 0.0.1

data/spec/unit/nodes/list_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::List do
+
+  before do
+    class Faceter::Test::Foo < AbstractMapper::Node
+      define_method(:transproc) { Faceter::Functions[:rename_keys, foo: :baz] }
+    end
+
+    class Faceter::Test::Bar < AbstractMapper::Node
+      define_method(:transproc) { Faceter::Functions[:rename_keys, bar: :qux] }
+    end
+  end
+
+  let(:foo) { Faceter::Test::Foo.new }
+  let(:bar) { Faceter::Test::Bar.new }
+
+  it_behaves_like :creating_immutable_branch
+
+  it_behaves_like :mapping_immutable_input do
+    let(:block)      { proc { [foo, bar] } }
+
+    let(:input)  { [{ foo: :FOO, bar: :BAR }, { foo: :BAZ, bar: :QUX }] }
+    let(:output) { [{ baz: :FOO, qux: :BAR }, { baz: :BAZ, qux: :QUX }] }
+  end
+
+end # describe Faceter::Nodes::List

data/spec/unit/nodes/remove_prefix_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::RemovePrefix do
+
+  it_behaves_like :creating_immutable_node do
+    let(:attributes) { { prefix: :foo } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { prefix: "foo" } }
+
+    let(:input)  { { foo_bar: { "foo_baz" => :QUX }, "foo.baz" => :BAZ } }
+    let(:output) { { bar: { "foo_baz" => :QUX }, "foo.baz" => :BAZ }     }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:selector)   { Selector.new only: /foo_bar/ }
+    let(:attributes) { { prefix: "foo", selector: selector } }
+
+    let(:input)  { { foo_bar: { "foo_baz" => :QUX }, "foo_baz" => :BAZ } }
+    let(:output) { { bar: { "foo_baz" => :QUX }, "foo_baz" => :BAZ }     }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:selector)   { Selector.new except: "foo_baz" }
+    let(:attributes) { { prefix: "foo", selector: selector } }
+
+    let(:input)  { { foo_bar: { "foo_baz" => :QUX }, "foo_baz" => :BAZ } }
+    let(:output) { { bar: { "foo_baz" => :QUX }, "foo_baz" => :BAZ }     }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { prefix: "foo", separator: "." } }
+
+    let(:input)  { { foo_bar: { "foo_baz" => :QUX }, "foo.baz" => :BAZ } }
+    let(:output) { { foo_bar: { "foo_baz" => :QUX }, "baz" => :BAZ }     }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { prefix: "foo", nested: true } }
+
+    let(:input)  { { foo_bar: { "foo_baz" => :QUX }, "foo.baz" => :BAZ } }
+    let(:output) { { bar: { "baz" => :QUX }, "foo.baz" => :BAZ }         }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:selector)   { Selector.new(except: :foo_bar) }
+    let(:attributes) { { prefix: "foo", selector: selector, nested: true } }
+
+    let(:input)  { { foo_bar: { "foo_baz" => :QUX }, "foo.baz" => :BAZ } }
+    let(:output) { { foo_bar: { "baz" => :QUX }, "foo.baz" => :BAZ }     }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:selector)   { Selector.new(only: "foo_baz") }
+    let(:attributes) { { prefix: "foo", selector: selector, nested: true } }
+
+    let(:input)  { { foo_bar: { "foo_baz" => :QUX }, "foo.baz" => :BAZ } }
+    let(:output) { { foo_bar: { "baz" => :QUX }, "foo.baz" => :BAZ }     }
+  end
+
+end # describe Faceter::Nodes::RemovePrefix

data/spec/unit/nodes/rename_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::Rename do
+
+  it_behaves_like :creating_immutable_node do
+    let(:attributes) { { keys: {} } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { keys: { foo: "bar", baz: "qux" } } }
+
+    let(:input)  { { foo: :FOO, baz: :BAZ }         }
+    let(:output) { { "bar" => :FOO, "qux" => :BAZ } }
+  end
+
+end # describe Faceter::Nodes::Rename

data/spec/unit/nodes/stringify_keys_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::StringifyKeys do
+
+  let(:input) { { foo: [{ 1 => :BAZ }] } }
+
+  it_behaves_like :creating_immutable_node do
+    let(:attributes) { {} }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { {} }
+    let(:output) { { "foo" => [{ "1" => :BAZ }] } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { nested: false } }
+    let(:output) { { "foo" => [{ 1 => :BAZ }] } }
+  end
+
+end # describe Faceter::Nodes::StringifyKeys

data/spec/unit/nodes/symbolize_keys_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::SymbolizeKeys do
+
+  let(:input) { { "foo" => [{ 1 => :BAZ }] } }
+
+  it_behaves_like :creating_immutable_node do
+    let(:attributes) { {} }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { {} }
+    let(:output) { { foo: [{ "1".to_sym => :BAZ }] } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { nested: false } }
+    let(:output) { { foo: [{ 1 => :BAZ }] } }
+  end
+
+end # describe Faceter::Nodes::SymbolizeKeys

data/spec/unit/nodes/unfold_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::Unfold do
+
+  let(:attributes) { { key: :foo } }
+
+  it_behaves_like :creating_immutable_node
+
+  it_behaves_like :mapping_immutable_input do
+    let(:input)  { { foo: :FOO } }
+    let(:output) { :FOO          }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:input)  { {}  }
+    let(:output) { nil }
+  end
+
+end # describe Faceter::Nodes::Unfold

data/spec/unit/nodes/ungroup_spec.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::Ungroup do
+
+  let(:attributes) { { key: :baz, selector: selector } }
+  let(:selector)   { Selector.new(options) }
+
+  it_behaves_like :creating_immutable_node do
+    let(:options) { {} }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { {} }
+
+    let(:input) do
+      [{ qux: :QUX, baz: [] }]
+    end
+
+    let(:output) do
+      [{ qux: :QUX }]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { {} }
+
+    let(:input) do
+      [{ qux: :QUX, baz: [{ foo: :FOO, bar: :FOO }, { foo: :BAR, bar: :BAR }] }]
+    end
+
+    let(:output) do
+      [{ qux: :QUX, foo: :FOO, bar: :FOO }, { qux: :QUX, foo: :BAR, bar: :BAR }]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: [:foo, :bar] } }
+
+    let(:input) do
+      [{ qux: :QUX, baz: [{ foo: :FOO, bar: :FOO }, { foo: :BAR, bar: :BAR }] }]
+    end
+
+    let(:output) do
+      [{ qux: :QUX, foo: :FOO, bar: :FOO }, { qux: :QUX, foo: :BAR, bar: :BAR }]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: :foo } }
+
+    let(:input) do
+      [{ qux: :QUX, baz: [{ foo: :FOO, bar: :FOO }, { foo: :BAR, bar: :BAR }] }]
+    end
+
+    let(:output) do
+      [
+        { qux: :QUX, foo: :FOO, baz: [{ bar: :FOO }] },
+        { qux: :QUX, foo: :BAR, baz: [{ bar: :BAR }] }
+      ]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: :foo } }
+
+    let(:input) do
+      [{ qux: :QUX, baz: [{ foo: :FOO, bar: :FOO }, { foo: :FOO, bar: :BAR }] }]
+    end
+
+    let(:output) do
+      [{ qux: :QUX, foo: :FOO, baz: [{ bar: :FOO }, { bar: :BAR }] }]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: [:foo, :bar] } }
+
+    let(:input) do
+      [
+        {
+          qux: :QUX, foo: :QUX,
+          baz: [{ foo: :FOO, bar: :FOO }, { foo: :BAR, bar: :BAR }]
+        }
+      ]
+    end
+
+    let(:output) do
+      [{ qux: :QUX, foo: :FOO, bar: :FOO }, { qux: :QUX, foo: :BAR, bar: :BAR }]
+    end
+  end
+
+end # describe Faceter::Nodes::Ungroup

data/spec/unit/nodes/unwrap_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::Unwrap do
+
+  let(:attributes) { { key: :baz, selector: selector } }
+  let(:selector)   { Selector.new(options) }
+
+  it_behaves_like :creating_immutable_node do
+    let(:options) { {} }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { {} }
+
+    let(:input)  { { baz: { foo: :FOO, bar: :BAR, baz: :BAZ }, qux: :QUX } }
+    let(:output) { { qux: :QUX, foo: :FOO, bar: :BAR, baz: :BAZ }          }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: [:foo, :bar] } }
+
+    let(:input)  { { baz: { foo: :FOO, bar: :BAR, baz: :BAZ }, qux: :QUX } }
+    let(:output) { { baz: { baz: :BAZ }, qux: :QUX, foo: :FOO, bar: :BAR } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: [:foo, :baz] } }
+
+    let(:input)  { { baz: { foo: :FOO, bar: :BAR, baz: :BAZ }, qux: :QUX } }
+    let(:output) { { qux: :QUX, foo: :FOO, baz: :BAZ }                     }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: [:foo, :baz] } }
+
+    let(:input)  { { baz: { foo: :FOO, baz: { bar: :BAR } }, qux: :QUX } }
+    let(:output) { { qux: :QUX, foo: :FOO, baz: { bar: :BAR } }          }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: :foo } }
+
+    let(:input)  { { foo: { baz: :BAZ }, baz: { foo: { bar: :QUX } } } }
+    let(:output) { { foo: { bar: :QUX } }                              }
+  end
+
+end # describe Faceter::Nodes::Unwrap

data/spec/unit/nodes/wrap_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::Wrap do
+
+  let(:attributes) { { key: key, selector: selector } }
+  let(:selector)   { Selector.new(only: [:foo, :bar]) }
+
+  it_behaves_like :creating_immutable_node do
+    let(:key) { :baz }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:key) { :bar }
+
+    let(:input)  { { foo: :FOO, bar: :BAR, baz: :BAZ }          }
+    let(:output) { { bar: { foo: :FOO, bar: :BAR }, baz: :BAZ } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:key) { :baz }
+
+    let(:input)  { { foo: :FOO, bar: :BAR, baz: { qux: :QUX } } }
+    let(:output) { { baz: { foo: :FOO, bar: :BAR, qux: :QUX } } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:key) { :bar }
+
+    let(:input)  { { foo: :FOO, bar: { qux: :QUX }, baz: :BAZ }          }
+    let(:output) { { bar: { foo: :FOO, bar: { qux: :QUX } }, baz: :BAZ } }
+  end
+
+end # describe Faceter::Nodes::Wrap

data/spec/unit/rules/append_nested_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Faceter::Nodes
+
+  describe Faceter::Rules::AppendNested do
+
+    let(:one)   { ice_double    }
+    let(:input) { [left, right] }
+
+    it_behaves_like :skipping_nodes do
+      let(:left)  { AddPrefix.new(prefix: :bar) }
+      let(:right) { AddPrefix.new(prefix: :foo) }
+    end
+
+    it_behaves_like :skipping_nodes do
+      let(:left)  { Field.new(key: :bar)        }
+      let(:right) { AddPrefix.new(prefix: :foo) }
+    end
+
+    it_behaves_like :skipping_nodes do
+      let(:left)  { List.new          }
+      let(:right) { Exclude.new(prefix: :foo) }
+    end
+
+    it_behaves_like :optimizing_nodes do
+      let(:left)  { List.new { [one] }  }
+      let(:right) { AddPrefix.new(prefix: :foo) }
+
+      let(:output) { left }
+    end
+
+    it_behaves_like :optimizing_nodes do
+      let(:left)  { List.new { [one] }                }
+      let(:right) { AddPrefix.new(prefix: :foo, nested: true) }
+
+      let(:output) { List.new { [one, right] } }
+    end
+
+  end # describe Faceter::Rules::AppendNested
+
+end # module Faceter::Nodes

data/spec/unit/rules/merge_branches_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Faceter::Nodes # namespace for constants
+
+  describe Faceter::Rules::MergeBranches do
+
+    let(:one) { ice_double }
+    let(:two) { ice_double }
+
+    it_behaves_like :skipping_nodes do
+      let(:left)  { AddPrefix.new(prefix: :foo) }
+      let(:right) { AddPrefix.new(prefix: :foo) }
+      let(:input) { [left, right]                  }
+    end
+
+    it_behaves_like :skipping_nodes do
+      let(:left)  { Field.new(key: :foo)        }
+      let(:right) { AddPrefix.new(prefix: :foo) }
+      let(:input) { [left, right]               }
+    end
+
+    it_behaves_like :skipping_nodes do
+      let(:left)  { List.new             }
+      let(:right) { Field.new(key: :foo) }
+      let(:input) { [left, right]        }
+    end
+
+    it_behaves_like :skipping_nodes do
+      let(:left)  { AbstractMapper::Branch.new }
+      let(:right) { List.new                   }
+      let(:input) { [left, right]              }
+    end
+
+    it_behaves_like :skipping_nodes do
+      let(:left)  { Field.new(key: :foo) }
+      let(:right) { Field.new(key: :bar) }
+      let(:input) { [left, right]        }
+    end
+
+    it_behaves_like :optimizing_nodes do
+      let(:left)   { List.new { [one] } }
+      let(:right)  { List.new { [two] } }
+      let(:input)  { [left, right]      }
+
+      let(:output) { List.new { [one, two] } }
+    end
+
+    it_behaves_like :optimizing_nodes do
+      let(:left)   { Field.new(key: :foo) { [one] } }
+      let(:right)  { Field.new(key: :foo) { [two] } }
+      let(:input)  { [left, right]                  }
+
+      let(:output) { Field.new(key: :foo) { [one, two] } }
+    end
+
+  end # describe Faceter::Rules::MergeBranches
+
+end # module Faceter