abstract_mapper 0.0.1 → 0.0.2

data/lib/abstract_mapper/version.rb

@@ -4,6 +4,6 @@ class AbstractMapper
 
   # The semantic version of the module.
   # @see http://semver.org/ Semantic versioning 2.0
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2".freeze
 
 end # class AbstractMapper

data/lib/rspec/doubles.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+# ==============================================================================
+# Doubles for values to be frozen
+# ==============================================================================
+
+# Returns the double that can be freezed
+#
+# @param [Object, Array<Object>] args
+#
+# @return [Double]
+#
+def ice_double(*args)
+  options = args.last.is_a?(Hash) ? args.pop : {}
+  double(*args, options.merge(freeze: nil, frozen?: true))
+end

data/lib/rspec/nodes.rb

@@ -7,9 +7,9 @@
 shared_context :node do
 
   def node
-    attrs__ = defined?(attributes) ? attributes : []
-    block__ = defined?(block) ? block : nil
-    described_class.new(*attrs__, &block__)
+    attributes__ = defined?(attributes) ? attributes : {}
+    block__      = defined?(block) ? block : nil
+    described_class.new(attributes__, &block__)
   end
 
 end # shared context
@@ -40,19 +40,32 @@ shared_examples :mapping_immutable_input do
 
   include_context :node
 
-  subject { node.transproc.call(input.dup.freeze) }
-
-  it do
-    is_expected.to eql(output), <<-REPORT.gsub(/.+\|/, "")
-      |
-      |#{node}
-      |
-      |Input: #{input}
-      |
-      |Output:
-      |  expected: #{output}
-      |       got: #{subject}
-    REPORT
+  let(:immutable_input) do
+    begin
+      input.dup.freeze
+    rescue TypeError # in case input is a singleton that cannot be duplicated
+      input
+    end
+  end
+
+  subject(:transproc) { node.transproc }
+
+  it "[creates a composable transproc]" do
+    expect(transproc).to be_kind_of Transproc::Function
+  end
+
+  it "[maps the input]" do
+    expect(transproc[immutable_input])
+      .to eql(output), <<-REPORT.gsub(/.+\|/, "")
+        |
+        |#{node}
+        |
+        |Input: #{input}
+        |
+        |Output:
+        |  expected: #{output}
+        |       got: #{transproc[immutable_input]}
+      REPORT
   end
 
 end # shared examples

data/lib/rspec/rules.rb

@@ -16,7 +16,7 @@ shared_context :rule do
 
   let(:rule) { described_class }
 
-  subject { rule.new(*nodes).call.inspect }
+  subject { rule.new(*nodes).call }
 
 end # shared context
 
@@ -25,7 +25,7 @@ shared_examples :skipping_nodes do
   include_context :rule
 
   it do
-    is_expected.to eql(nodes.inspect), <<-REPORT.gsub(/.+\|/, "")
+    is_expected.to eql(nodes), <<-REPORT.gsub(/.+\|/, "")
       |
       |#{rule}
       |
@@ -44,7 +44,7 @@ shared_examples :optimizing_nodes do
   include_context :rule
 
   it do
-    is_expected.to eql(optimized.inspect), <<-REPORT.gsub(/.+\|/, "")
+    is_expected.to eql(optimized), <<-REPORT.gsub(/.+\|/, "")
       |
       |#{rule}
       |

data/spec/integration/faceter.rb

@@ -21,14 +21,10 @@ shared_context "Faceter" do
       end
 
       class Rename < AbstractMapper::Node
-        def initialize(old, options = {})
-          @old = old
-          @new = options.fetch(:to)
-          super
-        end
+        attribute :keys
 
         def transproc
-          Functions[:rename_keys, @old => @new]
+          Functions[:rename_keys, keys]
         end
       end
 
@@ -43,13 +39,26 @@ shared_context "Faceter" do
         end
       end
 
+      class CompactRenames < AbstractMapper::PairRule
+        def optimize?
+          left.is_a?(Rename) && right.is_a?(Rename)
+        end
+
+        def optimize
+          Rename.new keys: nodes.map(&:keys).reduce(:merge)
+        end
+      end
+
       # Registry
       class Mapper < AbstractMapper
         configure do
           command :list,   Faceter::List
-          command :rename, Faceter::Rename
+          command :rename, Faceter::Rename do |name, options|
+            { keys: { name => options.fetch(:to) } }
+          end
 
           rule Faceter::CompactLists
+          rule Faceter::CompactRenames
         end
       end
 

data/spec/integration/mapper_definition_spec.rb

@@ -24,7 +24,7 @@ describe "mapper definition" do
 
   it "works" do
     expect(mapper.tree.inspect)
-      .to eql "<Root [<List [<Rename(:foo, {:to=>:baz})>, <Rename(:bar, {:to=>:qux})>]>]>"
+      .to eql "<Root [<List [<Rename(keys: {:foo=>:baz, :bar=>:qux})>]>]>"
     expect(mapper.call input).to eql output
   end
 

data/spec/integration/rspec_examples_spec.rb

@@ -8,28 +8,17 @@ 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] }
+      let(:attributes) { { keys: {} } }
     end
 
     it_behaves_like :mapping_immutable_input do
-      let(:attributes) { [:foo, to: :bar]         }
+      let(:attributes) { { keys: { foo: :bar } } }
+
       let(:input)      { { foo: :FOO, baz: :BAZ } }
       let(:output)     { { bar: :FOO, baz: :BAZ } }
     end
@@ -49,7 +38,7 @@ describe "rspec examples" do
     let(:described_class) { Faceter::CompactLists }
 
     it_behaves_like :skipping_nodes do
-      let(:input) { [Faceter::Rename.new(:foo, to: :bar), Faceter::List.new] }
+      let(:input) { [Faceter::Rename.new(keys: {}), Faceter::List.new] }
     end
 
     it_behaves_like :optimizing_nodes do
@@ -59,19 +48,4 @@ describe "rspec examples" do
 
   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

@@ -13,7 +13,7 @@ require "abstract_mapper"
 
 RSpec.configure do |config|
   config.around do |example|
-    class AbstractMapper::Test; end
+    module AbstractMapper::Test; end
     example.run
     AbstractMapper.send :remove_const, :Test
   end

data/spec/unit/abstract_mapper/branch_spec.rb

@@ -2,12 +2,26 @@
 
 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 }
+  let(:foo) do
+    class Foo < AbstractMapper::Node
+      attribute :foo
+
+      def transproc
+        AbstractMapper::Functions[-> v { "#{v}-1" }]
+      end
+    end
+    Foo
+  end
+
+  let(:node1)  { foo.new foo: :FOO }
+  let(:node2)  { foo.new foo: :BAR }
+  let(:node3)  { foo.new foo: :BAZ }
+  let(:branch) { test.new(foo: :FOO) { [node1, node2] } }
+  let(:test) do
+    AbstractMapper::Test::Foo = Class.new(described_class) do
+      attribute :foo
+    end
+  end
 
   describe ".new" do
 
@@ -18,20 +32,46 @@ describe AbstractMapper::Branch do
 
     context "without a block" do
 
-      subject { test.new(:foo).entries }
+      subject { test.new(foo: :FOO).entries }
       it { is_expected.to be_empty }
 
     end # context
 
     context "with a block" do
 
-      subject { test.new(:foo) { [node1, node2] }.entries }
+      subject { test.new(foo: :FOO) { [node1, node2] }.entries }
       it { is_expected.to eql [node1, node2] }
 
     end # context
 
   end # describe .new
 
+  describe "#attributes" do
+
+    subject { branch.attributes }
+
+    context "initialized" do
+
+      it { is_expected.to eql(foo: :FOO) }
+
+    end # context
+
+    context "not initialized" do
+
+      let(:branch) { test.new }
+      it { is_expected.to eql(foo: nil) }
+
+    end # context
+
+    context "not defined" do
+
+      let(:branch) { described_class.new }
+      it { is_expected.to eql({}) }
+
+    end # context
+
+  end # describe #attributes
+
   describe "#block" do
 
     subject { branch.block }
@@ -39,21 +79,21 @@ describe AbstractMapper::Branch do
 
   end # describe #block
 
-  describe "#rebuild" do
+  describe "#update" do
 
-    subject { branch.rebuild { [node2, node3] } }
+    subject { branch.update { [node2, node3] } }
 
     it { is_expected.to be_kind_of test }
 
     it "preserves attributes" do
-      expect(subject.attributes).to eql branch.attributes
+      expect(subject.attributes).to eql(foo: :FOO)
     end
 
     it "assings new subnodes from a block" do
       expect(subject.entries).to eql [node2, node3]
     end
 
-  end # describe #rebuild
+  end # describe #update
 
   describe "#each" do
 
@@ -116,11 +156,48 @@ describe AbstractMapper::Branch do
 
     context "of the specific node" do
 
-      let(:branch) { test.new(:foo) { [node1, node2] } }
-      it { is_expected.to eql "Foo(:foo) [#{node1.inspect}, #{node2.inspect}]" }
+      let(:branch) { test.new(foo: :FOO) { [node1, node2] } }
+      it do
+        is_expected
+          .to eql "Foo(foo: :FOO) [#{node1.inspect}, #{node2.inspect}]"
+      end
 
     end # context
 
   end # describe #to_s
 
+  describe "#eql?" do
+
+    subject { branch.eql? other }
+
+    context "with the same type, attributes and subnodes" do
+
+      let(:other) { test.new(foo: :FOO) { [node1, node2] } }
+      it { is_expected.to eql true }
+
+    end # context
+
+    context "with another type" do
+
+      let(:other) { Class.new(test).new(foo: :FOO) { [node1, node2] } }
+      it { is_expected.to eql false }
+
+    end # context
+
+    context "with other attributes" do
+
+      let(:other) { test.new(foo: :BAR) { [node1, node2] } }
+      it { is_expected.to eql false }
+
+    end # context
+
+    context "with other subnodes" do
+
+      let(:other) { test.new(foo: :FOO) { [node1, node3] } }
+      it { is_expected.to eql false }
+
+    end # context
+
+  end # describe #eql?
+
 end # describe Branch

data/spec/unit/abstract_mapper/builder_spec.rb

@@ -1,78 +1,96 @@
 # encoding: utf-8
 
-describe AbstractMapper::Builder do
+class AbstractMapper
 
-  before do
-    AbstractMapper::Test::Builder = Class.new(described_class)
-    AbstractMapper::Test::Foo     = Class.new(AbstractMapper::Node)
-    AbstractMapper::Test::Bar     = Class.new(AbstractMapper::Branch)
-  end
+  describe AbstractMapper::Builder do
 
-  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
+    let!(:test) { Class.new(described_class)                     }
+    let!(:foo)  { Test::Foo = Class.new(Node) { attribute :foo } }
+    let!(:bar)  { Test::Bar = Class.new(Branch)                  }
 
-  describe ".commands=" do
+    let(:builder)  { test.new tree }
+    let(:tree)     { Test::Foo.new }
+    let(:commands) { Commands.new << [:foo, Test::Foo] << [:bar, Test::Bar] }
 
-    subject { test.commands = commands }
+    describe ".commands=" do
 
-    it "sets the commands" do
-      expect { subject }.to change { test.commands }.to commands
-    end
+      subject { test.commands = commands }
 
-  end # describe .commands=
+      it "sets the commands" do
+        expect { subject }.to change { test.commands }.to commands
+      end
 
-  describe ".update" do
+    end # describe .commands=
 
-    before { test.commands = commands }
+    describe ".update" do
 
-    context "by default" do
+      before { test.commands = commands }
 
-      subject { test.update }
+      context "by default" do
 
-      it "is an empty branch" do
-        expect(subject).to be_instance_of AbstractMapper::Branch
-        expect(subject.entries).to be_empty
-      end
+        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 "returns exactly the same tree" do
+          expect(subject.inspect).to eql(tree.inspect)
+        end
 
-    end # context
+      end # context
 
-    context "initialized" do
+      context "with a block" do
 
-      subject { test.update(tree) }
-      it { is_expected.to eql tree }
+        subject { test.update { bar { foo(foo: :FOO) { fail } } } }
 
-    end # context
+        it "is built" do
+          expect(subject.inspect).to eql "<Root [<Bar [<Foo(foo: :FOO)>]>]>"
+          expect(subject.first.first.block).not_to be_nil
+        end
 
-    context "with a block" do
+      end # context
 
-      subject { test.update { bar { foo(:foo) { fail } } } }
+    end # describe .update
 
-      it "is built" do
-        expect(subject.inspect).to eql "<Root [<Bar [<Foo(:foo)>]>]>"
-        expect(subject.first.first.block).not_to be_nil
+    describe ".new" do
+
+      subject { builder }
+
+      it { is_expected.to be_frozen }
+
+      it "doesn't freezes the tree" do
+        expect { subject }.not_to change { tree.frozen? }
       end
 
-    end # context
+    end # describe .new
 
-  end # describe .update
+    describe "#tree" do
+
+      subject { builder.tree }
+
+      it "returns exactly the same tree as initialized" do
+        expect(subject.inspect).to eql tree.inspect
+      end
 
-  describe ".new" do
+      it { is_expected.to be_frozen }
 
-    subject { builder }
-    it { is_expected.to be_frozen }
+    end # describe #tree
 
-  end # describe .new
+    describe "#respond_to?" do
 
-  describe "#respond_to?" do
+      subject { builder.respond_to? :arbitrary_method }
+      it { is_expected.to eql true }
 
-    subject { builder.respond_to? :arbitrary_method }
-    it { is_expected.to eql true }
+    end # describe #respond_to?
 
-  end # describe #respond_to?
+  end # describe AbstractMapper::Builder
 
-end # describe AbstractMapper::Builder
+end