abstract_mapper 0.0.1 → 0.0.2

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

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require "abstract_mapper/rspec"
+require "transproc/rspec"
 
 describe AbstractMapper::Functions, "#subclass?" do
 

data/spec/unit/abstract_mapper/node_spec.rb

@@ -1,84 +1,155 @@
 # encoding: utf-8
 
-describe AbstractMapper::Node do
+class AbstractMapper # namespace
 
-  let(:test)       { AbstractMapper::Test::Node = Class.new(described_class) }
-  let(:node)       { test.new(*attributes)                           }
-  let(:attributes) { [:foo, :bar]                                    }
+  describe AbstractMapper::Node do
 
-  describe ".new" do
+    let(:test) do
+      Test::Node = Class.new(described_class) do
+        attribute "foo"
+        attribute :bar, default: :BAR
+      end
+    end
 
-    subject { node }
-    it { is_expected.to be_frozen }
+    let(:node)       { test.new(attributes, &block) }
+    let(:attributes) { { foo: :FOO }                }
+    let(:block)      { nil                          }
 
-  end # describe .new
+    describe ".new" do
 
-  describe "#attributes" do
+      subject { node }
 
-    subject { node.attributes }
+      it "initializes attributes" do
+        expect(subject.foo).to eql :FOO
+        expect(subject.bar).to eql :BAR
+      end
 
-    it { is_expected.to eql attributes }
-    it { is_expected.to be_frozen      }
+      it { is_expected.to be_frozen }
 
-    it "doesn't freeze the source" do
-      expect { subject }.not_to change { attributes.frozen? }
-    end
+      it "doesn't freeze the source" do
+        expect { subject }.not_to change { attributes.frozen? }
+      end
+
+    end # describe .new
+
+    describe ".attributes" do
+
+      it "is declared via DSL" do
+        expect(test.attributes).to eql(foo: nil, bar: :BAR)
+      end
+
+      it "is inheritable" do
+        subklass = Class.new(test)
+        expect(subklass.attributes).to eql(test.attributes)
+      end
+
+    end # describe .attributes
+
+    describe "#attributes" do
+
+      subject { node.attributes }
+
+      it { is_expected.to eql({ foo: nil, bar: :BAR }.merge(attributes)) }
+
+      context "by default" do
+
+        let(:node) { test.new }
+        it { is_expected.to eql(foo: nil, bar: :BAR) }
+
+      end # context
+
+    end # describe #attributes
+
+    describe "#block" do
+
+      subject { node.block }
+
+      context "when block is absent" do
+
+        it { is_expected.to eql nil }
+
+      end # context
+
+      context "when block is present" do
+
+        let(:block) { proc { :foo }                }
+        it { is_expected.to eql block }
+
+      end # context
+
+    end # describe #block
+
+    describe "#to_s" do
+
+      subject { node.to_s }
+
+      context "with uninitialized attributes" do
+
+        let(:node) { test.new }
+        it { is_expected.to eql "Node(foo: nil, bar: :BAR)" }
+
+      end # context
+
+      context "with initialized attributes" do
+
+        let(:node) { test.new(attributes) }
+        it { is_expected.to eql "Node(foo: :FOO, bar: :BAR)" }
 
-  end # describe #attributes
+      end # context
 
-  describe "#block" do
+      context "without attributes" do
 
-    subject { node.block }
+        let(:node) { described_class.new }
+        it { is_expected.to eql "Node" }
 
-    context "when block is absent" do
+      end # context
 
-      let(:node) { test.new(*attributes) }
-      it { is_expected.to eql nil }
+    end # describe #to_s
 
-    end # context
+    describe "#==" do
 
-    context "when block is present" do
+      subject { node == other }
 
-      let(:block) { proc { :foo }                 }
-      let(:node)  { test.new(*attributes, &block) }
-      it { is_expected.to eql block }
+      context "node with the same type and attributes" do
 
-    end # context
+        let(:other) { test.new(attributes) }
+        it { is_expected.to eql true }
 
-  end # describe #block
+      end # context
 
-  describe "#to_s" do
+      context "node with other type" do
 
-    subject { node.to_s }
+        let(:other) { Class.new(test).new(attributes) }
+        it { is_expected.to eql false }
 
-    context "without attributes" do
+      end # context
 
-      let(:node) { test.new }
-      it { is_expected.to eql "Node" }
+      context "node with other attributes" do
 
-    end # context
+        let(:other) { test.new }
+        it { is_expected.to eql false }
 
-    context "with attributes" do
+      end # context
 
-      let(:node) { test.new(*attributes) }
-      it { is_expected.to eql "Node(:foo, :bar)" }
+    end # describe #==
 
-    end # context
+    describe "#inspect" do
 
-  end # describe #to_s
+      subject { node.inspect }
+      it { is_expected.to eql "<Node(foo: :FOO, bar: :BAR)>" }
 
-  describe "#inspect" do
+    end # describe #inspect
 
-    subject { node.inspect }
-    it { is_expected.to eql "<Node(:foo, :bar)>" }
+    describe "#transproc" do
 
-  end # describe #inspect
+      subject { node.transproc }
 
-  describe "#transproc" do
+      it "returns the identity function" do
+        expect(subject[:foo]).to eql :foo
+      end
 
-    subject { node.transproc[:foo] }
-    it { is_expected.to eql :foo }
+    end # describe #transproc
 
-  end # describe #transproc
+  end # describe AbstractMapper::Node
 
-end # describe AbstractMapper::Node
+end # class AbstractMapper

data/spec/unit/abstract_mapper/optimizer_spec.rb

@@ -1,48 +1,54 @@
 # encoding: utf-8
 
-describe AbstractMapper::Optimizer do
+class AbstractMapper # namespace
 
-  let(:optimizer) { test.new rules             }
-  let(:test)      { Class.new(described_class) }
-  let(:rules)     { AbstractMapper::Rules.new          }
+  describe AbstractMapper::Optimizer do
 
-  describe ".new" do
+    let(:optimizer) { test.new rules             }
+    let(:test)      { Class.new(described_class) }
+    let(:rules)     { Rules.new                  }
 
-    subject { optimizer }
-    it { is_expected.to be_frozen }
+    describe ".new" do
 
-  end # describe .new
+      subject { optimizer }
+      it { is_expected.to be_frozen }
 
-  describe "#rules" do
+    end # describe .new
 
-    subject { optimizer.rules }
-    it { is_expected.to eql rules }
+    describe "#rules" do
 
-  end # describe #rules
+      subject { optimizer.rules }
+      it { is_expected.to eql rules }
 
-  describe "#update" do
+    end # describe #rules
 
-    subject { optimizer.update(tree) }
+    describe "#update" do
 
-    let(:rules) { AbstractMapper::Rules.new([rule])                   }
-    let(:rule)  { Class.new(AbstractMapper::PairRule)                 }
-    let(:tree)  { AbstractMapper::Branch.new { [node3, node4] }       }
-    let(:node1) { AbstractMapper::Node.new(1)                         }
-    let(:node2) { AbstractMapper::Node.new(2)                         }
-    let(:node3) { AbstractMapper::Node.new(3)                         }
-    let(:node4) { AbstractMapper::Test::Foo.new(4) { [node1, node2] } }
+      subject { optimizer.update(tree) }
 
-    before { AbstractMapper::Test::Foo = Class.new(AbstractMapper::Branch) }
-    before { rule.send(:define_method, :optimize?) { true }                }
-    before { rule.send(:define_method, :optimize)  { nodes.reverse }       }
+      let(:rules) { Rules.new([rule])           }
+      let(:rule)  { Class.new(PairRule)         }
+      let(:tree)  { Branch.new { [foo3, bar1] } }
 
-    it "optimizes the tree deeply" do
-      expect(tree.inspect)
-        .to eql "<Root [<Node(3)>, <Foo(4) [<Node(1)>, <Node(2)>]>]>"
-      expect(subject.inspect)
-        .to eql "<Root [<Foo(4) [<Node(2)>, <Node(1)>]>, <Node(3)>]>"
-    end
+      let(:foo1) { Test::Foo.new(n: 1)                  }
+      let(:foo2) { Test::Foo.new(n: 2)                  }
+      let(:foo3) { Test::Foo.new(n: 3)                  }
+      let(:bar1) { Test::Bar.new(n: 4) { [foo1, foo2] } }
 
-  end # describe #update
+      before { Test::Foo = Class.new(Node) { attribute :n }            }
+      before { Test::Bar = Class.new(Branch)                           }
+      before { rule.send(:define_method, :optimize?) { true }          }
+      before { rule.send(:define_method, :optimize)  { nodes.reverse } }
 
-end # describe AbstractMapper::Optimize
+      it "optimizes the tree deeply" do
+        expect(tree.inspect)
+          .to eql "<Root [<Foo(n: 3)>, <Bar [<Foo(n: 1)>, <Foo(n: 2)>]>]>"
+        expect(subject.inspect)
+          .to eql "<Root [<Bar [<Foo(n: 2)>, <Foo(n: 1)>]>, <Foo(n: 3)>]>"
+      end
+
+    end # describe #update
+
+  end # describe AbstractMapper::Optimize
+
+end # class AbstractMapper

data/spec/unit/abstract_mapper/pair_rule_spec.rb

@@ -5,15 +5,8 @@ describe AbstractMapper::PairRule do
   let(:rule)  { test.new(left, right)                           }
   let(:test)  { AbstractMapper::Test::Rule = Class.new(described_class) }
   let(:nodes) { [left, right]                                   }
-  let(:left)  { double                                          }
-  let(:right) { double                                          }
-
-  describe ".composer" do
-
-    subject { test.composer }
-    it { is_expected.to eql :compact }
-
-  end # describe .pair?
+  let(:left)  { AbstractMapper::Node.new                        }
+  let(:right) { AbstractMapper::Node.new                        }
 
   describe ".new" do
 
@@ -49,9 +42,9 @@ describe AbstractMapper::PairRule do
       test.send(:define_method, :optimize)  { left + right  }
     end
 
-    subject { test.transproc[array] }
-
     let(:array) { [1, 1, 2, 5] }
+
+    subject { test.transproc[array] }
     it { is_expected.to eql [4, 5] }
 
   end # describe #transproc

data/spec/unit/abstract_mapper/rule_spec.rb

@@ -5,7 +5,7 @@ describe AbstractMapper::Rule do
   let(:rule)  { test.new(*nodes) }
   let(:test)  { AbstractMapper::Test::Rule = Class.new(described_class) }
   let(:nodes) { [node] }
-  let(:node)  { double }
+  let(:node)  { AbstractMapper::Node.new }
 
   describe ".new" do
 
@@ -31,36 +31,41 @@ describe AbstractMapper::Rule do
 
     subject { rule.call }
 
-    before { test.send(:define_method, :optimize?) { true }  }
-    before { test.send(:define_method, :optimize) { [:foo] } }
+    context "by default" do
+
+      it { is_expected.to eql nodes }
+
+    end # context
 
     context "when #optimize? returns true" do
 
       before { test.send(:define_method, :optimize?) { true } }
-      it { is_expected.to eql [:foo] }
+      it { is_expected.to eql nodes }
 
     end # context
 
-    context "when #optimize? returns false" do
+    context "when #optimize is defined" do
 
-      before { test.send(:define_method, :optimize?) { false } }
-      it { is_expected.to eql [node] }
+      before { test.send(:define_method, :optimize) { :foo } }
+      it { is_expected.to eql nodes }
 
     end # context
 
-    context "when #optimize returns non-array" do
+    context "when #optimize? returns true and #optimize is defined" do
 
-      before { test.send(:define_method, :optimize) { :foo } }
+      before { test.send(:define_method, :optimize?) { true } }
+      before { test.send(:define_method, :optimize)  { :foo } }
       it { is_expected.to eql [:foo] }
 
-    end # contex
+    end # context
 
     context "when #optimize returns nils" do
 
+      before { test.send(:define_method, :optimize?) { true } }
       before { test.send(:define_method, :optimize) { [nil, nil] } }
       it { is_expected.to eql [] }
 
-    end # contex
+    end # context
 
   end # describe #call
 
@@ -69,14 +74,25 @@ describe AbstractMapper::Rule do
     before do
       test.send(:define_method, :optimize?) { true          }
       test.send(:define_method, :optimize)  { nodes.reverse }
-      allow(test).to receive(:composer)     { :compact      }
     end
 
-    subject { test.transproc[array] }
-
     let(:array) { [1, 2, 3] }
 
-    it { is_expected.to eql [2, 3, 1] }
+    context "with default composer" do
+
+      subject { test.transproc[array] }
+      it { is_expected.to eql array }
+
+    end # context
+
+    context "with another composer" do
+
+      before { allow(test).to receive(:composer) { :compact } }
+
+      subject { test.transproc[array] }
+      it { is_expected.to eql [2, 3, 1] }
+
+    end # context
 
   end # describe .transproc
 

data/spec/unit/abstract_mapper/rules_spec.rb

@@ -78,8 +78,8 @@ describe AbstractMapper::Rules do
       let(:nodes) { [1, 1, 2] }
 
       subject { rules[nodes] }
-      it { is_expected.to eql [6, 4] }
-      # [1, 1, 2] -foo-> [2, 2, 3] -foo-> [3, 3, 4] -bar-> [6, 4]
+      it { is_expected.to eql [5, 4] }
+      # [1, 1, 2] -foo-> [2, 2, 3] -bar-> [4, 3] -foo-> [5, 4]
 
     end # context
 

data/spec/unit/abstract_mapper/settings_spec.rb

@@ -1,113 +1,120 @@
 # encoding: utf-8
 
-describe AbstractMapper::Settings do
-
-  let!(:rule) do
-    AbstractMapper::Test::Rule = Class.new(AbstractMapper::SoleRule)
-  end
-  let!(:node) do
-    AbstractMapper::Test::Node = Class.new(AbstractMapper::Node)
-  end
-
-  let(:settings) do
-    described_class.new do
-      command :foo, AbstractMapper::Test::Node
-      rule AbstractMapper::Test::Rule
+class AbstractMapper
+
+  describe AbstractMapper::Settings do
+
+    let!(:rule) { Test::Rule = Class.new(SoleRule) }
+    let!(:node) { Test::Node = Class.new(Node) { attribute :foo } }
+
+    let(:settings) do
+      described_class.new do
+        command :foo, Test::Node do |value|
+          { foo: value }
+        end
+
+        rule Test::Rule
+      end
     end
-  end
 
-  describe ".new" do
+    describe ".new" do
 
-    context "with a valid block" do
+      context "with a valid block" do
 
-      subject { settings }
-      it { is_expected.to be_frozen }
+        subject { settings }
+        it { is_expected.to be_frozen }
 
-    end # context
+      end # context
 
-    context "with invalid command" do
+      context "with invalid command" do
 
-      subject { described_class.new { command :foo, String } }
-      it "fails" do
-        expect { subject }.to raise_error do |error|
-          expect(error).to be_kind_of AbstractMapper::Errors::WrongNode
-          expect(error.message).to include "String"
+        subject { described_class.new { command :foo, String } }
+
+        it "fails" do
+          expect { subject }.to raise_error do |error|
+            expect(error).to be_kind_of Errors::WrongNode
+            expect(error.message).to include "String"
+          end
         end
-      end
 
-    end # context
+      end # context
+
+      context "with invalid rule" do
 
-    context "with invalid rule" do
+        subject { described_class.new { rule String } }
 
-      subject { described_class.new { rule String } }
-      it "fails" do
-        expect { subject }.to raise_error do |error|
-          expect(error).to be_kind_of AbstractMapper::Errors::WrongRule
-          expect(error.message).to include "String"
+        it "fails" do
+          expect { subject }.to raise_error do |error|
+            expect(error).to be_kind_of Errors::WrongRule
+            expect(error.message).to include "String"
+          end
         end
-      end
 
-    end # context
+      end # context
 
-    context "without a block" do
+      context "without a block" do
 
-      subject { described_class.new }
-      it "doesn't fail" do
-        expect { subject }.not_to raise_error
-      end
+        subject { described_class.new }
+
+        it "doesn't fail" do
+          expect { subject }.not_to raise_error
+        end
 
-    end # context
+      end # context
 
-  end # describe .new
+    end # describe .new
 
-  describe "#commands" do
+    describe "#commands" do
 
-    subject { settings.commands }
+      subject { settings.commands }
 
-    it { is_expected.to be_kind_of AbstractMapper::Commands }
+      it { is_expected.to be_kind_of Commands }
 
-    it "contains registered commands" do
-      expect(subject.registry).to eql(foo: node)
-    end
+      it "contains registered commands" do
+        node = subject[:foo].call(:bar)
+        expect(node.inspect).to eql "<Node(foo: :bar)>"
+      end
 
-  end # describe #commands
+    end # describe #commands
 
-  describe "#rules" do
+    describe "#rules" do
 
-    subject { settings.rules }
+      subject { settings.rules }
 
-    it { is_expected.to be_kind_of AbstractMapper::Rules }
+      it { is_expected.to be_kind_of Rules }
 
-    it "contains registered rules" do
-      expect(subject.registry).to eql [rule]
-    end
+      it "contains registered rules" do
+        expect(subject.registry).to eql [rule]
+      end
 
-  end # describe #rules
+    end # describe #rules
 
-  describe "#builder" do
+    describe "#builder" do
 
-    subject { settings.builder }
+      subject { settings.builder }
 
-    it "subclasses AbstractMapper::Builder" do
-      expect(subject.superclass).to eql AbstractMapper::Builder
-    end
+      it "subclasses Builder" do
+        expect(subject.superclass).to eql Builder
+      end
 
-    it "uses registered commands" do
-      expect(subject.commands).to eql settings.commands
-    end
+      it "uses registered commands" do
+        expect(subject.commands).to eql settings.commands
+      end
 
-  end # describe #builder
+    end # describe #builder
 
-  describe "#optimizer" do
+    describe "#optimizer" do
 
-    subject { settings.optimizer }
+      subject { settings.optimizer }
 
-    it { is_expected.to be_kind_of AbstractMapper::Optimizer }
+      it { is_expected.to be_kind_of Optimizer }
 
-    it "uses registered rules" do
-      expect(subject.rules).to eql settings.rules
-    end
+      it "uses registered rules" do
+        expect(subject.rules).to eql settings.rules
+      end
+
+    end # describe #optimizer
 
-  end # describe #optimizer
+  end # describe Settings
 
-end # describe AbstractMapper::Settings
+end # class AbstractMapper