faceter 0.0.1

data/spec/integration/commands/symbolize_keys_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+describe "symbolize_keys" do
+
+  subject { mapper.new.call input }
+
+  let(:input) do
+    [
+      {
+        "id" => 1,
+        "user" => {
+          "name" => "joe",
+          emails: [{ "address" => "joe@doe.com" }]
+        },
+        "roles" => [{ "name" => "admin" }]
+      }
+    ]
+  end
+
+  let(:output) do
+    [
+      {
+        id: 1,
+        user:  {
+          name: "joe",
+          emails: [{ address: "joe@doe.com" }]
+        },
+        roles: [{ "name" => "admin" }]
+      }
+    ]
+  end
+
+  let(:mapper) do
+    Class.new(Faceter::Mapper) do
+      list do
+        symbolize_keys nested: false
+
+        field :user do
+          symbolize_keys
+        end
+      end
+    end
+  end
+
+  it "works" do
+    expect(subject).to eql output
+  end
+
+end # describe symbolize_keys

data/spec/integration/commands/unfold_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+describe "fold" do
+
+  subject { mapper.new.call input }
+
+  let(:input) do
+    [
+      {
+        name: "Joe",
+        emails: [{ address: "joe@doe.com" }, { address: "joe@doe.org" }]
+      },
+      {
+        name: "Jane",
+        emails: [{ address: "jane@doe.com" }]
+      }
+    ]
+  end
+
+  let(:output) do
+    [
+      { name: "Joe",  emails: ["joe@doe.com", "joe@doe.org"] },
+      { name: "Jane", emails: ["jane@doe.com"] }
+    ]
+  end
+
+  let(:mapper) do
+    Class.new(Faceter::Mapper) do
+      list do
+        field :emails do
+          list { unfold from: :address }
+        end
+      end
+    end
+  end
+
+  it "works" do
+    expect(subject).to eql output
+  end
+
+end # describe fold

data/spec/integration/commands/ungroup_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+describe "ungroup" do
+
+  subject { mapper.new.call input }
+
+  let(:input) do
+    [
+      {
+        role: "admin",
+        users: [
+          {
+            name: "Joe",
+            contacts: [
+              { email: "joe@doe.com", type: "job" },
+              { email: "joe@doe.org", type: "job" }
+            ]
+          },
+          {
+            name: "Ian",
+            contacts: [
+              { email: "ian@doe.com", type: "job" },
+              { email: "ian@doe.org", type: "job" }
+            ]
+          }
+        ]
+      }
+    ]
+  end
+
+  let(:output) do
+    [
+      {
+        name: "Joe",
+        role: "admin",
+        type: "job",
+        contacts: [{ email: "joe@doe.com" }, { email: "joe@doe.org" }]
+      },
+      {
+        name: "Ian",
+        role: "admin",
+        type: "job",
+        contacts: [{ email: "ian@doe.com" }, { email: "ian@doe.org" }]
+      }
+    ]
+  end
+
+  let(:mapper) do
+    Class.new(Faceter::Mapper) do
+      list do
+        field :users do
+          ungroup :type, from: :contacts
+        end
+      end
+
+      ungroup :name, :contacts, :type, from: :users
+    end
+  end
+
+  it "works" do
+    expect(subject).to eql output
+  end
+
+end # describe ungroup

data/spec/integration/commands/unwrap_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+describe "unwrap" do
+
+  subject { mapper.new.call input }
+
+  let(:input) do
+    [
+      {
+        user: { id: 1, name: "joe" },
+        contacts: [{ email: { address: "joe@doe.com", type: "job" } }]
+      },
+      {
+        user: { id: 2, name: "jane" },
+        contacts: [{ email: { address: "jane@doe.com", type: "job" } }]
+      }
+    ]
+  end
+
+  let(:output) do
+    [
+      {
+        id: 1, name: "joe",
+        contacts: [{ email: { address: "joe@doe.com" }, type: "job" }]
+      },
+      {
+        id: 2, name: "jane",
+        contacts: [{ email: { address: "jane@doe.com" }, type: "job" }]
+      }
+    ]
+  end
+
+  let(:mapper) do
+    Class.new(Faceter::Mapper) do
+      list do
+        unwrap from: :user, only: :id
+
+        unwrap :name, from: :user # alternative syntax
+
+        field :contacts do
+          list { unwrap from: :email, except: :address }
+        end
+      end
+    end
+  end
+
+  it "works" do
+    expect(subject).to eql output
+  end
+
+end # describe unwrap

data/spec/integration/commands/wrap_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+describe "wrap" do
+
+  subject { mapper.new.call input }
+
+  let(:input) do
+    [
+      {
+        id: 1, name: "joe",
+        contacts: [{ email: { address: "joe@doe.com" }, type: "job" }]
+      },
+      {
+        id: 2, name: "jane",
+        contacts: [{ email: { address: "jane@doe.com" }, type: "job" }]
+      }
+    ]
+  end
+
+  let(:output) do
+    [
+      {
+        user: { id: 1, name: "joe" },
+        contacts: [{ email: { address: "joe@doe.com", type: "job" } }]
+      },
+      {
+        user: { id: 2, name: "jane" },
+        contacts: [{ email: { address: "jane@doe.com", type: "job" } }]
+      }
+    ]
+  end
+
+  let(:mapper) do
+    Class.new(Faceter::Mapper) do
+      list do
+        wrap to: :user, only: :id
+
+        wrap :name, to: :user # alternative syntax
+
+        field :contacts do
+          list { wrap to: :email, except: :email }
+        end
+      end
+    end
+  end
+
+  it "works" do
+    expect(subject).to eql output
+  end
+
+end # describe wrap

data/spec/integration/rom_spec.rb

@@ -0,0 +1,39 @@
+require "rom"
+require "rom/memory"
+
+describe "ROM integration" do
+
+  let(:setup) { ROM.setup :memory }
+  let(:rom)   { ROM.finalize.env  }
+
+  before do
+    class UserMapper < Faceter::Mapper
+      group :email, to: :emails
+
+      list do
+        field :emails do
+          list { unfold from: :email }
+        end
+      end
+    end
+
+    setup.relation(:users)
+
+    setup.mappers do
+      register(:users, mapped: UserMapper.new)
+    end
+
+    users = setup.default.dataset(:users)
+    users.insert(id: 1, name: "Joe", email: "joe@doe.com")
+    users.insert(id: 1, name: "Joe", email: "joe@doe.org")
+  end
+
+  it "works" do
+    expect(rom.relation(:users).as(:mapped).to_a).to eql [
+      { id: 1, name: "Joe", emails: ["joe@doe.com", "joe@doe.org"] }
+    ]
+  end
+
+  after { Object.send :remove_const, :UserMapper }
+
+end # describe "ROM integration"

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+begin
+  require "hexx-suit"
+  Hexx::Suit.load_metrics_for(self)
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.load_metrics_for(self)
+end
+
+# Loads the code under test
+require "faceter"
+
+# Loads shared examples
+require "abstract_mapper/rspec"
+require "transproc/rspec"
+
+# Creates the temporary Test module for test-specific constants
+RSpec.configure do |config|
+  config.around do |example|
+    class Faceter::Test; end
+    example.run
+    Faceter.send :remove_const, :Test
+  end
+end

data/spec/unit/coercers/create_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+describe Faceter::Coercers, ".create" do
+
+  subject { described_class[:create] }
+
+  it "coerces arguments" do
+    expect(subject[:foo, from: :bar]).to eq(name: :foo, keys: :bar)
+  end
+
+  it "coerces arguments" do
+    expect(subject[:foo, from: [:bar, :baz]])
+      .to eq(name: :foo, keys: [:bar, :baz])
+  end
+
+end # describe Faceter::Coercers.create

data/spec/unit/coercers/exclude_spec.rb

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

data/spec/unit/coercers/field_spec.rb

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

data/spec/unit/coercers/fold_spec.rb

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

data/spec/unit/coercers/prefix_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+describe Faceter::Coercers, ".prefix" do
+
+  subject { described_class[:prefix] }
+
+  it "coerces arguments" do
+    expect(subject[:foo]).to eql(
+      prefix: :foo,
+      separator: "_",
+      nested: false,
+      selector: nil
+    )
+  end
+
+  it "coerces arguments" do
+    attributes = subject[:foo, separator: ".", nested: true, only: /foo/]
+
+    expect(attributes).to eq(
+      prefix: :foo,
+      separator: ".",
+      nested: true,
+      selector: Selector.new(only: /foo/)
+    )
+  end
+
+  it "coerces arguments" do
+    attributes = subject[:foo, separator: ".", nested: true, except: /foo/]
+
+    expect(attributes).to eq(
+      prefix: :foo,
+      separator: ".",
+      nested: true,
+      selector: Selector.new(except: /foo/)
+    )
+  end
+
+end # describe Faceter::Coercers.prefix

data/spec/unit/coercers/rename_spec.rb

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