faceter 0.0.1

data/spec/unit/coercers/unfold_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+describe Faceter::Coercers, ".unfold" do
+
+  subject { described_class[:unfold] }
+
+  it "coerces arguments" do
+    expect(subject[from: :baz]).to eq(key: :baz)
+  end
+
+end # describe Faceter::Coercers.unfold

data/spec/unit/coercers/unwrap_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+describe Faceter::Coercers, ".unwrap" do
+
+  subject { described_class[:unwrap] }
+
+  it "coerces arguments" do
+    expect(subject[from: :baz]).to eq(
+      key: :baz,
+      selector: Selector::ANYTHING
+    )
+  end
+
+  it "coerces arguments" do
+    expect(subject[:foo, :bar, from: :baz]).to eq(
+      key: :baz,
+      selector: Selector.new(only: [:foo, :bar])
+    )
+  end
+
+  it "coerces arguments" do
+    expect(subject[from: :baz, only: /foo/]).to eq(
+      key: :baz,
+      selector: Selector.new(only: /foo/)
+    )
+  end
+
+  it "coerces arguments" do
+    expect(subject[from: :baz, except: /foo/]).to eq(
+      key: :baz,
+      selector: Selector.new(except: /foo/)
+    )
+  end
+
+end # describe Faceter::Coercers.unwrap

data/spec/unit/coercers/wrap_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+describe Faceter::Coercers, ".wrap" do
+
+  subject { described_class[:wrap] }
+
+  it "coerces arguments" do
+    expect(subject[to: :baz]).to eq(
+      key: :baz,
+      selector: Selector::ANYTHING
+    )
+  end
+
+  it "coerces arguments" do
+    expect(subject[:foo, :bar, to: :baz]).to eq(
+      key: :baz,
+      selector: Selector.new(only: [:foo, :bar])
+    )
+  end
+
+  it "coerces arguments" do
+    expect(subject[to: :baz, only: /foo/]).to eq(
+      key: :baz,
+      selector: Selector.new(only: /foo/)
+    )
+  end
+
+  it "coerces arguments" do
+    expect(subject[to: :baz, except: /foo/]).to eq(
+      key: :baz,
+      selector: Selector.new(except: /foo/)
+    )
+  end
+
+end # describe Faceter::Coercers.wrap

data/spec/unit/functions/add_prefix_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe Faceter::Functions, ".add_prefix" do
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:add_prefix, "foo", "."] }
+
+    let(:input)  { "bar"     }
+    let(:output) { "foo.bar" }
+  end
+
+end # describe Faceter::Functions.add_prefix

data/spec/unit/functions/claster_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+describe Faceter::Functions, ".claster" do
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:claster, -> v { v.class }] }
+
+    let(:input)  { [:foo, :bar, "foo", :bar, :baz]       }
+    let(:output) { [[:foo, :bar], ["foo"], [:bar, :baz]] }
+  end
+
+end # describe Faceter::Functions.claster

data/spec/unit/functions/clean_spec.rb

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

data/spec/unit/functions/drop_prefix_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+describe Faceter::Functions, ".drop_prefix" do
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:drop_prefix, "foo", "."] }
+
+    let(:input)  { "foo.bar" }
+    let(:output) { "bar"     }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:drop_prefix, "foo", "."] }
+
+    let(:input)  { "foo." }
+    let(:output) { ""     }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:drop_prefix, "foo", "."] }
+
+    let(:input)  { "baz_bar" }
+    let(:output) { "baz_bar" }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:drop_prefix, "foo", "."] }
+
+    let(:input)  { :foo_bar  }
+    let(:output) { "foo_bar" }
+  end
+
+end # describe Faceter::Functions.drop_prefix

data/spec/unit/functions/exclude_spec.rb

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

data/spec/unit/functions/group_spec.rb

@@ -0,0 +1,176 @@
+# encoding: utf-8
+
+describe Faceter::Functions, ".group" do
+
+  it_behaves_like :transforming_immutable_data do
+    let(:selector)  { Selector.new(only: [:foo, :bar]) }
+    let(:arguments) { [:group, :baz, selector] }
+
+    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 :transforming_immutable_data do
+    let(:selector)  { Selector.new(except: :qux) }
+    let(:arguments) { [:group, :baz, selector] }
+
+    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 :transforming_immutable_data do
+    let(:selector)  { Selector.new(only: [:foo, :bar]) }
+    let(:arguments) { [:group, :baz, selector] }
+
+    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 :transforming_immutable_data do
+    let(:selector)  { Selector.new(only: [:foo, :bar]) }
+    let(:arguments) { [:group, :baz, selector] }
+
+    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 :transforming_immutable_data do
+    let(:selector)  { Selector.new(only: [:foo, :bar]) }
+    let(:arguments) { [:group, :baz, selector] }
+
+    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 :transforming_immutable_data do
+    let(:selector)  { Selector.new(only: :foo) }
+    let(:arguments) { [:group, :bar, selector] }
+
+    let(:input) do
+      [
+        { foo: :FOO, bar: [{ baz: :FOO }, { baz: :BAR }], qux: :QUX },
+        { foo: :BAR, bar: [{ baz: :BAZ }, { baz: :QUX }], qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        {
+          qux: :QUX,
+          bar: [
+            { baz: :FOO, foo: :FOO },
+            { baz: :BAR, foo: :FOO },
+            { baz: :BAZ, foo: :BAR },
+            { baz: :QUX, foo: :BAR }
+          ]
+        }
+      ]
+    end
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:selector)  { Selector.new(only: [:foo, :baz]) }
+    let(:arguments) { [:group, :foo, selector] }
+
+    let(:input) do
+      [
+        { foo: :FOO, baz: :FOO, qux: :QUX },
+        { foo: :BAR, baz: :BAR, qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        { qux: :QUX, foo: [{ foo: :FOO, baz: :FOO }, { foo: :BAR, baz: :BAR }] }
+      ]
+    end
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:selector)  { Selector.new(only: :foo) }
+    let(:arguments) { [:group, :foo, selector] }
+
+    let(:input) do
+      [
+        { foo: [{ bar: :FOO }, { baz: :FOO  }], qux: :QUX },
+        { foo: [{ bar: :BAR }, { baz: :BAR }],  qux: :QUX }
+      ]
+    end
+
+    let(:output) do
+      [
+        {
+          qux: :QUX,
+          foo: [
+            { foo: [{ bar: :FOO }, { baz: :FOO  }] },
+            { foo: [{ bar: :BAR }, { baz: :BAR }] }
+          ]
+        }
+      ]
+    end
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:selector)  { Selector.new(only: :quxx) }
+    let(:arguments) { [:group, :baz, selector] }
+
+    let(:input) do
+      [{ foo: :FOO, bar: :FOO, qux: :QUX }, { foo: :BAR, bar: :BAR, qux: :QUX }]
+    end
+
+    let(:output) do
+      [{ foo: :FOO, bar: :FOO, qux: :QUX }, { foo: :BAR, bar: :BAR, qux: :QUX }]
+    end
+  end
+
+end # describe Faceter::Functions.group

data/spec/unit/functions/keep_symbol_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+describe Faceter::Functions, ".keep_symbol" do
+
+  let(:function) { -> value { value.to_s.reverse.to_i } }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:keep_symbol, function] }
+
+    let(:input)  { 123 }
+    let(:output) { 321 }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:keep_symbol, function] }
+
+    let(:input)  { :"123" }
+    let(:output) { :"321" }
+  end
+
+end # describe Faceter::Functions.keep_symbol

data/spec/unit/functions/split_spec.rb

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