abstract_mapper 0.0.1

data/spec/integration/faceter.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+shared_context "Faceter" do
+
+  before do
+    module Faceter
+
+      # Transproc functions
+      module Functions
+        extend Transproc::Registry
+
+        uses :map_array,   from: Transproc::ArrayTransformations
+        uses :rename_keys, from: Transproc::HashTransformations
+      end
+
+      # Nodes
+      class List < AbstractMapper::Branch
+        def transproc
+          Functions[:map_array, super]
+        end
+      end
+
+      class Rename < AbstractMapper::Node
+        def initialize(old, options = {})
+          @old = old
+          @new = options.fetch(:to)
+          super
+        end
+
+        def transproc
+          Functions[:rename_keys, @old => @new]
+        end
+      end
+
+      # Rules
+      class CompactLists < AbstractMapper::PairRule
+        def optimize?
+          left.is_a?(List) && right.is_a?(List)
+        end
+
+        def optimize
+          List.new { left.entries + right.entries }
+        end
+      end
+
+      # Registry
+      class Mapper < AbstractMapper
+        configure do
+          command :list,   Faceter::List
+          command :rename, Faceter::Rename
+
+          rule Faceter::CompactLists
+        end
+      end
+
+    end # module Faceter
+
+  end # before
+
+  after { Object.send :remove_const, :Faceter }
+
+end # shared context

data/spec/integration/mapper_definition_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require_relative "faceter"
+
+describe "mapper definition" do
+
+  include_context "Faceter"
+
+  before do
+    class MyMapper < Faceter::Mapper
+      list do
+        rename :foo, to: :baz
+      end
+
+      list do
+        rename :bar, to: :qux
+      end
+    end
+  end
+
+  let(:mapper) { MyMapper.new }
+  let(:input)  { [{ foo: :FOO, bar: :FOO }, { foo: :BAR, bar: :BAR }] }
+  let(:output) { [{ baz: :FOO, qux: :FOO }, { baz: :BAR, qux: :BAR }] }
+
+  it "works" do
+    expect(mapper.tree.inspect)
+      .to eql "<Root [<List [<Rename(:foo, {:to=>:baz})>, <Rename(:bar, {:to=>:qux})>]>]>"
+    expect(mapper.call input).to eql output
+  end
+
+  after { Object.send :remove_const, :MyMapper }
+
+end # describe mapper definition

data/spec/integration/rspec_examples_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require_relative "faceter"
+
+require "abstract_mapper/rspec" # examples under the test
+
+describe "rspec examples" do
+
+  include_context "Faceter"
+
+  describe "Faceter::Functions", "#rename_keys" do
+
+    let(:described_class) { Faceter::Functions }
+
+    it_behaves_like :transforming_immutable_data do
+      let(:arguments) { [:rename_keys, foo: :bar] }
+      let(:input)     { { foo: :FOO, baz: :BAZ }  }
+      let(:output)    { { bar: :FOO, baz: :BAZ }  }
+    end
+
+  end # describe Faceter::Functions
+
+  describe "Faceter::Rename" do
+
+    let(:described_class) { Faceter::Rename }
+
+    it_behaves_like :creating_immutable_node do
+      let(:attributes) { [:foo, to: :bar] }
+    end
+
+    it_behaves_like :mapping_immutable_input do
+      let(:attributes) { [:foo, to: :bar]         }
+      let(:input)      { { foo: :FOO, baz: :BAZ } }
+      let(:output)     { { bar: :FOO, baz: :BAZ } }
+    end
+
+  end # describe Faceter::Rename
+
+  describe "Faceter::List" do
+
+    let(:described_class) { Faceter::List }
+
+    it_behaves_like :creating_immutable_branch
+
+  end # describe Faceter::List
+
+  describe "Faceter::CompactLists" do
+
+    let(:described_class) { Faceter::CompactLists }
+
+    it_behaves_like :skipping_nodes do
+      let(:input) { [Faceter::Rename.new(:foo, to: :bar), Faceter::List.new] }
+    end
+
+    it_behaves_like :optimizing_nodes do
+      let(:input)  { [Faceter::List.new { [1] }, Faceter::List.new { [2] }] }
+      let(:output) { Faceter::List.new { [1, 2] } }
+    end
+
+  end # describe Faceter::CompactLists
+
+  describe "Faceter::Mapper" do
+
+    let(:described_class) { Faceter::Mapper }
+
+    it_behaves_like :defining_command do
+      let(:name) { :list }
+      let(:node) { Faceter::List }
+    end
+
+    it_behaves_like :defining_rule do
+      let(:rule) { Faceter::CompactLists }
+    end
+
+  end # describe Faceter::Mapper
+
+end # describe mapper definition

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# 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 "abstract_mapper"
+
+RSpec.configure do |config|
+  config.around do |example|
+    class AbstractMapper::Test; end
+    example.run
+    AbstractMapper.send :remove_const, :Test
+  end
+end

data/spec/unit/abstract_mapper/branch_spec.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+describe AbstractMapper::Branch do
+
+  let(:branch) { test.new(:foo) { [node1, node2] }              }
+  let(:test)   { AbstractMapper::Test::Foo = Class.new(described_class) }
+  let(:tproc)  { Transproc::Function.new -> v { "#{v}-1" }, {}  }
+  let(:node1)  { instance_double AbstractMapper::Node, transproc: tproc }
+  let(:node2)  { instance_double AbstractMapper::Node, transproc: tproc }
+  let(:node3)  { instance_double AbstractMapper::Node, transproc: tproc }
+
+  describe ".new" do
+
+    subject { branch }
+
+    it { is_expected.to be_kind_of Enumerable }
+    it { is_expected.to be_frozen             }
+
+    context "without a block" do
+
+      subject { test.new(:foo).entries }
+      it { is_expected.to be_empty }
+
+    end # context
+
+    context "with a block" do
+
+      subject { test.new(:foo) { [node1, node2] }.entries }
+      it { is_expected.to eql [node1, node2] }
+
+    end # context
+
+  end # describe .new
+
+  describe "#block" do
+
+    subject { branch.block }
+    it { is_expected.to be_nil }
+
+  end # describe #block
+
+  describe "#rebuild" do
+
+    subject { branch.rebuild { [node2, node3] } }
+
+    it { is_expected.to be_kind_of test }
+
+    it "preserves attributes" do
+      expect(subject.attributes).to eql branch.attributes
+    end
+
+    it "assings new subnodes from a block" do
+      expect(subject.entries).to eql [node2, node3]
+    end
+
+  end # describe #rebuild
+
+  describe "#each" do
+
+    let(:subnodes) { [node1, node2] }
+
+    context "with a block" do
+
+      subject { branch.each { |item| item } }
+
+      it "looks over subnodes" do
+        expect(subject).to eql subnodes
+      end
+
+    end # context
+
+    context "without a block" do
+
+      subject { branch.each }
+
+      it "returns Enumerator for subnodes" do
+        expect(subject).to be_kind_of Enumerator
+        expect(subject.entries).to eql subnodes
+      end
+
+    end # context
+
+  end # describe #each
+
+  describe "#<<" do
+
+    subject { branch << node3 }
+
+    it "returns the branch with updated subnodes and the same attributes" do
+      expect(subject).to be_kind_of test
+      expect(subject.attributes).to eql branch.attributes
+      expect(subject.entries).to eql [node1, node2, node3]
+    end
+
+  end # describe #<<
+
+  describe "#transproc" do
+
+    let(:data) { "baz" }
+
+    subject { branch.transproc[data] }
+    it { is_expected.to eql "baz-1-1" }
+
+  end # describe #transproc
+
+  describe "#to_s" do
+
+    subject { branch.to_s }
+
+    context "of the root" do
+
+      let(:branch) { described_class.new { [node1, node2] } }
+      it { is_expected.to eql "Root [#{node1.inspect}, #{node2.inspect}]" }
+
+    end # context
+
+    context "of the specific node" do
+
+      let(:branch) { test.new(:foo) { [node1, node2] } }
+      it { is_expected.to eql "Foo(:foo) [#{node1.inspect}, #{node2.inspect}]" }
+
+    end # context
+
+  end # describe #to_s
+
+end # describe Branch

data/spec/unit/abstract_mapper/builder_spec.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+describe AbstractMapper::Builder do
+
+  before do
+    AbstractMapper::Test::Builder = Class.new(described_class)
+    AbstractMapper::Test::Foo     = Class.new(AbstractMapper::Node)
+    AbstractMapper::Test::Bar     = Class.new(AbstractMapper::Branch)
+  end
+
+  let(:builder)  { test.new tree                          }
+  let(:test)     { AbstractMapper::Test::Builder          }
+  let(:commands) { AbstractMapper::Commands.new(registry) }
+  let(:tree)     { AbstractMapper::Test::Foo.new          }
+  let(:registry) do
+    { foo: AbstractMapper::Test::Foo, bar: AbstractMapper::Test::Bar }
+  end
+
+  describe ".commands=" do
+
+    subject { test.commands = commands }
+
+    it "sets the commands" do
+      expect { subject }.to change { test.commands }.to commands
+    end
+
+  end # describe .commands=
+
+  describe ".update" do
+
+    before { test.commands = commands }
+
+    context "by default" do
+
+      subject { test.update }
+
+      it "is an empty branch" do
+        expect(subject).to be_instance_of AbstractMapper::Branch
+        expect(subject.entries).to be_empty
+      end
+
+    end # context
+
+    context "initialized" do
+
+      subject { test.update(tree) }
+      it { is_expected.to eql tree }
+
+    end # context
+
+    context "with a block" do
+
+      subject { test.update { bar { foo(:foo) { fail } } } }
+
+      it "is built" do
+        expect(subject.inspect).to eql "<Root [<Bar [<Foo(:foo)>]>]>"
+        expect(subject.first.first.block).not_to be_nil
+      end
+
+    end # context
+
+  end # describe .update
+
+  describe ".new" do
+
+    subject { builder }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#respond_to?" do
+
+    subject { builder.respond_to? :arbitrary_method }
+    it { is_expected.to eql true }
+
+  end # describe #respond_to?
+
+end # describe AbstractMapper::Builder

data/spec/unit/abstract_mapper/commands_spec.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+describe AbstractMapper::Commands do
+
+  let(:commands) { test.new                   }
+  let(:test)     { Class.new(described_class) }
+  let(:branch)   { Class.new(AbstractMapper::Branch)  }
+
+  describe ".new" do
+
+    subject { commands }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#registry" do
+
+    subject { commands.registry }
+
+    context "with a hash" do
+
+      let(:commands) { test.new(registry) }
+      let(:registry) { { foo: branch }    }
+
+      it { is_expected.to eql registry }
+      it { is_expected.to be_frozen    }
+
+      it "doesn't freeze the source" do
+        expect { subject }.not_to change { registry.frozen? }
+      end
+
+    end # context
+
+    context "without a hash" do
+
+      let(:commands) { test.new }
+
+      it { is_expected.to eql({})   }
+      it { is_expected.to be_frozen }
+
+    end # context
+
+  end # describe #builder
+
+  describe "#<<" do
+
+    let(:commands) { test.new(foo: branch) }
+
+    subject { commands << ["bar", branch] }
+
+    it "registers a command" do
+      expect(subject).to be_kind_of test
+      expect(subject.registry).to eql(foo: branch, bar: branch)
+    end
+
+  end # describe #<<
+
+  describe "#[]" do
+
+    let(:block) { proc { [:foo] }   }
+    let(:args)  { [:baz, qux: :QUX] }
+    let(:commands) do
+      test.new(foo: AbstractMapper::Node, bar: AbstractMapper::Branch)
+    end
+
+    context "simple node" do
+
+      subject { commands["foo", *args, &block] }
+
+      it "builds a node with a block" do
+        expect(subject).to be_kind_of AbstractMapper::Node
+        expect(subject.attributes).to eql args
+        expect(subject.block).to eql block
+      end
+
+    end # context
+
+    context "branch command" do
+
+      subject { commands["bar", *args, &block] }
+
+      it "builds a branch" do
+        expect(subject).to be_kind_of AbstractMapper::Node
+        expect(subject.attributes).to eql args
+        expect(subject.entries).to eql []
+      end
+
+    end # context
+
+    context "unknown command" do
+
+      subject { commands["baz"] }
+
+      it "fails" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of AbstractMapper::Errors::UnknownCommand
+          expect(error.message).to include "baz"
+        end
+      end
+
+    end # context
+
+  end # describe #build
+
+end # describe AbstractMapper::Commands

data/spec/unit/abstract_mapper/dsl_spec.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+describe AbstractMapper::DSL do
+
+  let!(:bar) { AbstractMapper::Test::Bar = Class.new(AbstractMapper::Branch) }
+  let!(:foo) { AbstractMapper::Test::Foo = Class.new(AbstractMapper::Node)   }
+  let!(:rule) do
+    AbstractMapper::Test::Rule = Class.new(AbstractMapper::PairRule) do
+      def optimize?
+        left.instance_of?(AbstractMapper::Test::Foo)
+      end
+
+      def optimize
+        AbstractMapper::Test::Foo.new(nodes.flat_map(&:attributes))
+      end
+    end
+  end
+  let!(:dsl) { Class.new { extend AbstractMapper::DSL } }
+
+  let!(:config) do
+    dsl.configure do
+      command :foo, AbstractMapper::Test::Foo
+      command :bar, AbstractMapper::Test::Bar
+      rule AbstractMapper::Test::Rule
+    end
+  end
+
+  describe "#configure" do
+
+    subject { config }
+
+    it { is_expected.to eql dsl }
+
+    it "configures settings" do
+      subject
+      expect(dsl.settings).to be_kind_of AbstractMapper::Settings
+      expect(dsl.settings.rules.registry).to eql [rule]
+      expect(dsl.settings.commands.registry).to eql(foo: foo, bar: bar)
+    end
+
+  end # describe #configure
+
+  describe "#finalize" do
+
+    before do
+      dsl.instance_eval do
+        bar :baz do
+          foo :qux
+          foo :quxx
+        end
+        foo :foo
+      end
+    end
+
+    subject { dsl.finalize }
+
+    it { is_expected.to be_kind_of AbstractMapper::Branch }
+
+    it "is optimized" do
+      expect(subject.inspect)
+        .to eql "<Root [<Bar(:baz) [<Foo([:qux, :quxx])>]>, <Foo(:foo)>]>"
+    end
+
+  end # describe #finalize
+
+  describe "#respond_to?" do
+
+    subject { dsl.respond_to? :anything }
+    it { is_expected.to eql true }
+
+  end # describe #respond_to?
+
+  describe ".inherited" do
+
+    let(:subklass) { Class.new(dsl) }
+    subject { subklass.settings }
+
+    it { is_expected.to eql dsl.settings }
+
+  end # describe .inherited
+
+end # describe AbstractMapper::DSL

data/spec/unit/abstract_mapper/errors/unknown_command_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+describe AbstractMapper::Errors::UnknownCommand do
+
+  subject(:error) { described_class.new :foo }
+
+  describe ".new" do
+
+    it { is_expected.to be_kind_of NameError }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#message" do
+
+    subject { error.message }
+    it { is_expected.to eql "'foo' is not a registered DSL command" }
+
+  end # describe #message
+
+end # describe AbstractMapper::Errors::UnknownCommand

data/spec/unit/abstract_mapper/errors/wrong_node_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+describe AbstractMapper::Errors::WrongNode do
+
+  subject(:error) { described_class.new Symbol }
+
+  describe ".new" do
+
+    it { is_expected.to be_kind_of TypeError }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#message" do
+
+    subject { error.message }
+    it { is_expected.to eql "Symbol is not a subclass of AbstractMapper::Node" }
+
+  end # describe #message
+
+end # describe AbstractMapper::Errors::WrongNode

data/spec/unit/abstract_mapper/errors/wrong_rule_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+describe AbstractMapper::Errors::WrongRule do
+
+  subject(:error) { described_class.new Symbol }
+
+  describe ".new" do
+
+    it { is_expected.to be_kind_of TypeError }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#message" do
+
+    subject { error.message }
+    it do
+      is_expected.to eql "Symbol is not a subclass of AbstractMapper::SoleRule"
+    end
+
+  end # describe #message
+
+end # describe AbstractMapper::Errors::WrongRule

data/spec/unit/abstract_mapper/functions/compact_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require "abstract_mapper/rspec"
+
+describe AbstractMapper::Functions, "#compact" do
+
+  let(:function)  { -> a, b { (a == b) ? [a + b] : [a, b] } }
+  let(:arguments) { [:compact, function] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { [] }
+    let(:output) { [] }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { [1] }
+    let(:output) { [1] }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { [1, 1, 2, 3, 3] }
+    let(:output) { [4, 6]          }
+  end
+
+end # describe AbstractMapper::Functions#compact

data/spec/unit/abstract_mapper/functions/filter_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require "abstract_mapper/rspec"
+
+describe AbstractMapper::Functions, "#filter" do
+
+  let(:arguments) { [:filter, -> v { v - 1 if v > 3 }] }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { [] }
+    let(:output) { [] }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:input)  { [1, 4, 9, 7, 2, 5] }
+    let(:output) { [3, 8, 6, 4]       }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:filter, -> v { [v - 1] if v > 3 }] }
+
+    let(:input)  { [1, 4, 9, 7, 2, 5] }
+    let(:output) { [3, 8, 6, 4]       }
+  end
+
+end # describe AbstractMapper::Functions#filter