faceter 0.0.1

data/spec/unit/functions/ungroup_spec.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+describe Faceter::Functions, ".ungroup" do
+
+  let(:arguments) { [:ungroup, :baz, Selector.new(options)] }
+
+  it_behaves_like :transforming_immutable_data 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 :transforming_immutable_data 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 :transforming_immutable_data 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 :transforming_immutable_data 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 :transforming_immutable_data 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
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { {} }
+
+    let(:input) do
+      [{ qux: :QUX, baz: [] }]
+    end
+
+    let(:output) do
+      [{ qux: :QUX }]
+    end
+  end
+
+end # describe Faceter::Functions.ungroup

data/spec/unit/functions/unwrap_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+describe Faceter::Functions, ".unwrap" do
+
+  let(:arguments) { [:unwrap, :foo, Selector.new(options)] }
+  let(:input)     { { foo: { foo: :FOO, bar: :BAR, baz: :BAZ }, qux: {} } }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { {} }
+    let(:output)  { { foo: :FOO, bar: :BAR, baz: :BAZ, qux: {} } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { except: :foo } }
+    let(:output)  { { foo: { foo: :FOO }, bar: :BAR, baz: :BAZ, qux: {} } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { except: :bar } }
+    let(:output)  { { foo: :FOO, baz: :BAZ, qux: {} } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { except: [:foo, :bar] } }
+    let(:output)  { { foo: { foo: :FOO, bar: :BAR }, baz: :BAZ, qux: {} } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { only: [] } }
+    let(:output)  { { foo: { foo: :FOO, bar: :BAR, baz: :BAZ }, qux: {} } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { only: :foo } }
+    let(:output)  { { foo: :FOO, qux: {} } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { {} }
+    let(:input)   { { foo: { bar: :BAR }, qux: {} } }
+    let(:output)  { { bar: :BAR, qux: {} } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { only: :bar } }
+    let(:output)  { { foo: { foo: :FOO, baz: :BAZ }, bar: :BAR, qux: {} } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { only: [:foo, :bar] } }
+    let(:output)  { { foo: :FOO, bar: :BAR, qux: {} } }
+  end
+
+end # describe Faceter::Functions.unwrap

data/spec/unit/functions/wrap_spec.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+describe Faceter::Functions, ".wrap" do
+
+  let(:arguments) { [:wrap, :foo, Selector.new(options)] }
+  let(:input)  { { foo: :FOO, bar: :BAR, baz: :BAZ, qux: :QUX } }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { {} }
+    let(:output) { { foo: { foo: :FOO, bar: :BAR, baz: :BAZ, qux: :QUX } } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { except: [] } }
+    let(:output) { { foo: { foo: :FOO, bar: :BAR, baz: :BAZ, qux: :QUX } } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { except: :foo } }
+    let(:output) { { foo: { bar: :BAR, baz: :BAZ, qux: :QUX } }   }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { except: :bar } }
+    let(:output) { { bar: :BAR, foo: { foo: :FOO, baz: :BAZ, qux: :QUX } } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { except: [:foo, :bar] } }
+    let(:output) { { bar: :BAR, foo: { baz: :BAZ, qux: :QUX } }   }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { only: [] } }
+    let(:output) { { foo: {}, bar: :BAR, baz: :BAZ, qux: :QUX }   }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { only: :foo } }
+    let(:output) { { foo: { foo: :FOO }, bar: :BAR, baz: :BAZ, qux: :QUX } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { only: :bar } }
+    let(:output) { { foo: { bar: :BAR }, baz: :BAZ, qux: :QUX }   }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { only: [:foo, :bar] } }
+    let(:output) { { foo: { foo: :FOO, bar: :BAR }, baz: :BAZ, qux: :QUX } }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { only: [:bar] } }
+
+    let(:input)  { { foo: { foo: :FOO, bar: :FOO }, bar: :BAR, baz: :BAZ } }
+    let(:output) { { foo: { foo: :FOO, bar: :BAR }, baz: :BAZ }            }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:options) { { except: :foo } }
+
+    let(:input)  { { foo: { foo: :FOO, bar: :FOO }, bar: :BAR, baz: :BAZ } }
+    let(:output) { { foo: { foo: :FOO, bar: :BAR, baz: :BAZ } }            }
+  end
+
+end # describe Faceter::Functions.wrap

data/spec/unit/nodes/add_prefix_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::AddPrefix 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)  { { bar: "BAR", "baz" => { qux: :QUX } }         }
+    let(:output) { { foo_bar: "BAR", "foo_baz" => { qux: :QUX } } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { prefix: "foo", separator: "." } }
+
+    let(:input)  { { bar: "BAR", "baz" => { qux: :QUX } }              }
+    let(:output) { { :"foo.bar" => "BAR", "foo.baz" => { qux: :QUX } } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:selector)   { Selector.new(only: /bar/) }
+    let(:attributes) { { prefix: "foo", selector: selector } }
+
+    let(:input)  { { bar: "BAR", "baz" => { qux: :QUX } }     }
+    let(:output) { { foo_bar: "BAR", "baz" => { qux: :QUX } } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:selector)   { Selector.new(except: "baz") }
+    let(:attributes) { { prefix: "foo", selector: selector } }
+
+    let(:input)  { { bar: "BAR", "baz" => { qux: :QUX } }     }
+    let(:output) { { foo_bar: "BAR", "baz" => { qux: :QUX } } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { prefix: "foo", nested: true } }
+
+    let(:input)  { { bar: "BAR", "baz" => { qux: :QUX } }             }
+    let(:output) { { foo_bar: "BAR", "foo_baz" => { foo_qux: :QUX } } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:selector)   { Selector.new(except: /b/) }
+    let(:attributes) { { prefix: "foo", nested: true, selector: selector } }
+
+    let(:input)  { { bar: "BAR", "baz" => { qux: :QUX } }     }
+    let(:output) { { bar: "BAR", "baz" => { foo_qux: :QUX } } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:selector)   { Selector.new(only: /q/) }
+    let(:attributes) { { prefix: "foo", nested: true, selector: selector } }
+
+    let(:input)  { { bar: "BAR", "baz" => { qux: :QUX } }     }
+    let(:output) { { bar: "BAR", "baz" => { foo_qux: :QUX } } }
+  end
+
+end # describe Faceter::Nodes::AddPrefix

data/spec/unit/nodes/create_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::Create do
+
+  it_behaves_like :creating_immutable_node do
+    let(:attributes) { { keys: [] } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { keys: :bar } }
+
+    let(:input)  { { bar: :BAR, baz: :BAZ } }
+    let(:output) { :BAR                     }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { keys: [:bar] } }
+
+    let(:input)  { { bar: :BAR, baz: :BAZ } }
+    let(:output) { [:BAR]                   }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { name: :foo, keys: :bar } }
+
+    let(:input)  { { bar: :BAR, baz: :BAZ }            }
+    let(:output) { { bar: :BAR, baz: :BAZ, foo: :BAR } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { name: :foo, keys: [:bar, :baz] } }
+
+    let(:input)  { { bar: :BAR, baz: :BAZ }                    }
+    let(:output) { { bar: :BAR, baz: :BAZ, foo: [:BAR, :BAZ] } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:block)    { proc { |bar| bar.to_s } }
+    let(:attributes) { { name: :foo, keys: :bar } }
+
+    let(:input)  { { bar: :BAR, baz: :BAZ }             }
+    let(:output) { { bar: :BAR, baz: :BAZ, foo: "BAR" } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:block)      { proc { |*args| args.map(&:to_s) } }
+    let(:attributes) { { name: :foo, keys: [:bar, :baz] } }
+
+    let(:input)  { { bar: :BAR, baz: :BAZ }                   }
+    let(:output) { { bar: :BAR, baz: :BAZ, foo: %w(BAR BAZ) } }
+  end
+
+end # describe Faceter::Nodes::Create

data/spec/unit/nodes/exclude_spec.rb

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

data/spec/unit/nodes/field_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::Field 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 do
+    let(:attributes) { { key: :foo } }
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:attributes) { { key: :baz }       }
+    let(:block)      { proc { [foo, bar] } }
+
+    let(:input)  { { baz: { foo: :FOO, bar: :BAR } } }
+    let(:output) { { baz: { baz: :FOO, qux: :BAR } } }
+  end
+
+end # describe Faceter::Nodes::Field

data/spec/unit/nodes/fold_spec.rb

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

data/spec/unit/nodes/group_spec.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+
+describe Faceter::Nodes::Group 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) { { only: [:foo, :bar] } }
+
+    let(:input) do
+      [
+        { foo: :FOO, bar: :FOO, qux: :QUX },
+        { foo: :BAR, bar: :BAR, qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        {
+          qux: :QUX,
+          baz: [{ foo: :FOO, bar: :FOO }, { foo: :BAR, bar: :BAR }]
+        }
+      ]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: [:foo, :bar] } }
+
+    let(:input) do
+      [
+        { foo: :FOO, bar: :FOO, baz: :BAZ, qux: :QUX },
+        { foo: :BAR, bar: :BAR, baz: :BAZ, qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        {
+          qux: :QUX,
+          baz: [{ foo: :FOO, bar: :FOO }, { foo: :BAR, bar: :BAR }]
+        }
+      ]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: [:foo, :bar] } }
+
+    let(:input) do
+      [
+        { foo: :FOO, bar: :FOO, baz: { bar: :BAZ }, qux: :QUX },
+        { foo: :BAR, bar: :BAR, baz: { bar: :BAZ }, qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        {
+          qux: :QUX,
+          baz: [{ foo: :FOO, bar: :FOO }, { foo: :BAR, bar: :BAR }]
+        }
+      ]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: [:foo, :bar] } }
+
+    let(:input) do
+      [
+        { foo: :FOO, bar: :FOO, baz: [{ baz: :BAZ  }], qux: :QUX },
+        { foo: :BAR, bar: :BAR, baz: [{ baz: :BAZZ }], qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        {
+          qux: :QUX,
+          baz: [
+            { foo: :FOO, bar: :FOO, baz: :BAZ },
+            { foo: :BAR, bar: :BAR, baz: :BAZZ }
+          ]
+        }
+      ]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: :foo } }
+
+    let(:input) do
+      [
+        { foo: :FOO, baz: [{ baz: :FOO }, { baz: :BAR }], qux: :QUX },
+        { foo: :BAR, baz: [{ baz: :BAZ }, { baz: :QUX }], qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        {
+          qux: :QUX,
+          baz: [
+            { baz: :FOO, foo: :FOO },
+            { baz: :BAR, foo: :FOO },
+            { baz: :BAZ, foo: :BAR },
+            { baz: :QUX, foo: :BAR }
+          ]
+        }
+      ]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: [:foo, :baz] } }
+
+    let(:input) do
+      [
+        { foo: :FOO, baz: :FOO, qux: :QUX },
+        { foo: :BAR, baz: :BAR, qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        {
+          qux: :QUX,
+          baz: [{ foo: :FOO, baz: :FOO }, { foo: :BAR, baz: :BAR }]
+        }
+      ]
+    end
+  end
+
+  it_behaves_like :mapping_immutable_input do
+    let(:options) { { only: :baz } }
+
+    let(:input) do
+      [
+        { baz: [{ bar: :FOO }, { baz: :FOO  }], qux: :QUX },
+        { baz: [{ bar: :BAR }, { baz: :BAR }],  qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        {
+          qux: :QUX,
+          baz: [
+            { baz: [{ bar: :FOO }, { baz: :FOO  }] },
+            { baz: [{ bar: :BAR }, { baz: :BAR }] }
+          ]
+        }
+      ]
+    end
+  end
+
+end # describe Faceter::Nodes::Group