abstract_mapper 0.0.1

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

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require "abstract_mapper/rspec"
+
+describe AbstractMapper::Functions, "#subclass?" do
+
+  let(:klass) { Class.new  }
+  let(:modul) { Module.new }
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:subclass?, klass] }
+
+    let(:input)  { Class.new }
+    let(:output) { false     }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:subclass?, klass] }
+
+    let(:input)  { Class.new(Class.new(klass)) }
+    let(:output) { true }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:subclass?, modul] }
+
+    let(:input)  { Class.new }
+    let(:output) { false }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:subclass?, modul] }
+
+    let(:input)  { Class.new.send :include, modul }
+    let(:output) { true }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:subclass?, modul] }
+
+    let(:input)  { Class.new.send :extend, modul }
+    let(:output) { false }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:subclass?, modul] }
+
+    let(:input)  { Module.new }
+    let(:output) { false }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:subclass?, modul] }
+
+    let(:input)  { Module.new.send :include, modul }
+    let(:output) { true }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:subclass?, modul] }
+
+    let(:input)  { Module.new.send :extend, modul }
+    let(:output) { false }
+  end
+
+end # describe AbstractMapper::Functions#subclass?

data/spec/unit/abstract_mapper/node_spec.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+describe AbstractMapper::Node do
+
+  let(:test)       { AbstractMapper::Test::Node = Class.new(described_class) }
+  let(:node)       { test.new(*attributes)                           }
+  let(:attributes) { [:foo, :bar]                                    }
+
+  describe ".new" do
+
+    subject { node }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#attributes" do
+
+    subject { node.attributes }
+
+    it { is_expected.to eql attributes }
+    it { is_expected.to be_frozen      }
+
+    it "doesn't freeze the source" do
+      expect { subject }.not_to change { attributes.frozen? }
+    end
+
+  end # describe #attributes
+
+  describe "#block" do
+
+    subject { node.block }
+
+    context "when block is absent" do
+
+      let(:node) { test.new(*attributes) }
+      it { is_expected.to eql nil }
+
+    end # context
+
+    context "when block is present" do
+
+      let(:block) { proc { :foo }                 }
+      let(:node)  { test.new(*attributes, &block) }
+      it { is_expected.to eql block }
+
+    end # context
+
+  end # describe #block
+
+  describe "#to_s" do
+
+    subject { node.to_s }
+
+    context "without attributes" do
+
+      let(:node) { test.new }
+      it { is_expected.to eql "Node" }
+
+    end # context
+
+    context "with attributes" do
+
+      let(:node) { test.new(*attributes) }
+      it { is_expected.to eql "Node(:foo, :bar)" }
+
+    end # context
+
+  end # describe #to_s
+
+  describe "#inspect" do
+
+    subject { node.inspect }
+    it { is_expected.to eql "<Node(:foo, :bar)>" }
+
+  end # describe #inspect
+
+  describe "#transproc" do
+
+    subject { node.transproc[:foo] }
+    it { is_expected.to eql :foo }
+
+  end # describe #transproc
+
+end # describe AbstractMapper::Node

data/spec/unit/abstract_mapper/optimizer_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+describe AbstractMapper::Optimizer do
+
+  let(:optimizer) { test.new rules             }
+  let(:test)      { Class.new(described_class) }
+  let(:rules)     { AbstractMapper::Rules.new          }
+
+  describe ".new" do
+
+    subject { optimizer }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#rules" do
+
+    subject { optimizer.rules }
+    it { is_expected.to eql rules }
+
+  end # describe #rules
+
+  describe "#update" do
+
+    subject { optimizer.update(tree) }
+
+    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] } }
+
+    before { AbstractMapper::Test::Foo = Class.new(AbstractMapper::Branch) }
+    before { rule.send(:define_method, :optimize?) { true }                }
+    before { rule.send(:define_method, :optimize)  { nodes.reverse }       }
+
+    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
+
+  end # describe #update
+
+end # describe AbstractMapper::Optimize

data/spec/unit/abstract_mapper/pair_rule_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-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?
+
+  describe ".new" do
+
+    subject { rule }
+
+    it { is_expected.to be_kind_of AbstractMapper::Rule }
+    it { is_expected.to be_frozen }
+
+    it "requires second argument" do
+      expect { test.new(left) }.to raise_error(ArgumentError)
+    end
+
+  end # describe .new
+
+  describe "#left" do
+
+    subject { rule.left }
+    it { is_expected.to eql left }
+
+  end # describe #left
+
+  describe "#right" do
+
+    subject { rule.right }
+    it { is_expected.to eql right }
+
+  end # describe #right
+
+  describe "#transproc" do
+
+    before do
+      test.send(:define_method, :optimize?) { left == right }
+      test.send(:define_method, :optimize)  { left + right  }
+    end
+
+    subject { test.transproc[array] }
+
+    let(:array) { [1, 1, 2, 5] }
+    it { is_expected.to eql [4, 5] }
+
+  end # describe #transproc
+
+end # describe AbstractMapper::PairRule

data/spec/unit/abstract_mapper/rule_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+describe AbstractMapper::Rule do
+
+  let(:rule)  { test.new(*nodes) }
+  let(:test)  { AbstractMapper::Test::Rule = Class.new(described_class) }
+  let(:nodes) { [node] }
+  let(:node)  { double }
+
+  describe ".new" do
+
+    subject { rule }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#nodes" do
+
+    subject { rule.nodes }
+
+    it { is_expected.to eql nodes }
+    it { is_expected.to be_frozen }
+
+    it "doesn't freeze the source" do
+      expect { subject }.not_to change { nodes.frozen? }
+    end
+
+  end # describe #nodes
+
+  describe "#call" do
+
+    subject { rule.call }
+
+    before { test.send(:define_method, :optimize?) { true }  }
+    before { test.send(:define_method, :optimize) { [:foo] } }
+
+    context "when #optimize? returns true" do
+
+      before { test.send(:define_method, :optimize?) { true } }
+      it { is_expected.to eql [:foo] }
+
+    end # context
+
+    context "when #optimize? returns false" do
+
+      before { test.send(:define_method, :optimize?) { false } }
+      it { is_expected.to eql [node] }
+
+    end # context
+
+    context "when #optimize returns non-array" do
+
+      before { test.send(:define_method, :optimize) { :foo } }
+      it { is_expected.to eql [:foo] }
+
+    end # contex
+
+    context "when #optimize returns nils" do
+
+      before { test.send(:define_method, :optimize) { [nil, nil] } }
+      it { is_expected.to eql [] }
+
+    end # contex
+
+  end # describe #call
+
+  describe ".transproc" 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] }
+
+  end # describe .transproc
+
+end # describe AbstractMapper::Rule

data/spec/unit/abstract_mapper/rules_spec.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+describe AbstractMapper::Rules do
+
+  let(:rules) { described_class.new }
+  let(:foo) { AbstractMapper::Test::Foo = Class.new(AbstractMapper::SoleRule) }
+  let(:bar) { AbstractMapper::Test::Bar = Class.new(AbstractMapper::PairRule) }
+
+  describe ".new" do
+
+    subject { rules }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#registry" do
+
+    subject { rules.registry }
+
+    context "by default" do
+
+      let(:rules) { described_class.new }
+      it { is_expected.to eql []    }
+      it { is_expected.to be_frozen }
+
+    end # context
+
+    context "initialized" do
+
+      let(:rules)    { described_class.new registry }
+      let(:registry) { [foo, bar]                 }
+
+      it { is_expected.to eql registry }
+      it { is_expected.to be_frozen    }
+
+      it "doesn't freezes the source" do
+        expect { subject }.not_to change { registry.frozen? }
+      end
+
+    end # context
+
+  end # describe #registry
+
+  describe "#<<" do
+
+    subject { rules << bar }
+
+    let(:rules) { described_class.new [foo] }
+
+    it "updates the registry" do
+      expect(subject).to be_kind_of described_class
+      expect(subject.registry).to eql [foo, bar]
+    end
+
+  end # describe #<<
+
+  describe "#[]" do
+
+    before do
+      foo.send(:define_method, :optimize?) { true          }
+      foo.send(:define_method, :optimize)  { node + 1      }
+      bar.send(:define_method, :optimize?) { left == right }
+      bar.send(:define_method, :optimize)  { left + right  }
+    end
+
+    context "when no rule is set" do
+
+      let(:nodes) { [1, 1, 2, 5] }
+
+      subject { rules[nodes] }
+      it { is_expected.to eql nodes }
+
+    end # context
+
+    context "when rules are set" do
+
+      let(:rules) { described_class.new [foo, bar, foo] }
+      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]
+
+    end # context
+
+  end # describe #[]
+
+end # describe AbstractMapper::Rules

data/spec/unit/abstract_mapper/settings_spec.rb

@@ -0,0 +1,113 @@
+# 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
+    end
+  end
+
+  describe ".new" do
+
+    context "with a valid block" do
+
+      subject { settings }
+      it { is_expected.to be_frozen }
+
+    end # context
+
+    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"
+        end
+      end
+
+    end # context
+
+    context "with invalid rule" do
+
+      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"
+        end
+      end
+
+    end # context
+
+    context "without a block" do
+
+      subject { described_class.new }
+      it "doesn't fail" do
+        expect { subject }.not_to raise_error
+      end
+
+    end # context
+
+  end # describe .new
+
+  describe "#commands" do
+
+    subject { settings.commands }
+
+    it { is_expected.to be_kind_of AbstractMapper::Commands }
+
+    it "contains registered commands" do
+      expect(subject.registry).to eql(foo: node)
+    end
+
+  end # describe #commands
+
+  describe "#rules" do
+
+    subject { settings.rules }
+
+    it { is_expected.to be_kind_of AbstractMapper::Rules }
+
+    it "contains registered rules" do
+      expect(subject.registry).to eql [rule]
+    end
+
+  end # describe #rules
+
+  describe "#builder" do
+
+    subject { settings.builder }
+
+    it "subclasses AbstractMapper::Builder" do
+      expect(subject.superclass).to eql AbstractMapper::Builder
+    end
+
+    it "uses registered commands" do
+      expect(subject.commands).to eql settings.commands
+    end
+
+  end # describe #builder
+
+  describe "#optimizer" do
+
+    subject { settings.optimizer }
+
+    it { is_expected.to be_kind_of AbstractMapper::Optimizer }
+
+    it "uses registered rules" do
+      expect(subject.rules).to eql settings.rules
+    end
+
+  end # describe #optimizer
+
+end # describe AbstractMapper::Settings

data/spec/unit/abstract_mapper/sole_rule_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+describe AbstractMapper::SoleRule do
+
+  let(:rule)  { test.new(node) }
+  let(:test)  { AbstractMapper::Test::Rule = Class.new(described_class) }
+  let(:nodes) { [node] }
+  let(:node)  { double }
+
+  describe ".composer" do
+
+    subject { test.composer }
+    it { is_expected.to eql :filter }
+
+  end # describe .pair?
+
+  describe ".new" do
+
+    subject { rule }
+
+    it { is_expected.to be_kind_of AbstractMapper::Rule }
+    it { is_expected.to be_frozen }
+
+    it "denies second argument" do
+      expect { test.new(node, node) }.to raise_error(ArgumentError)
+    end
+
+  end # describe .new
+
+  describe "#node" do
+
+    subject { rule.node }
+    it { is_expected.to eql node }
+
+  end # describe #node
+
+  describe "#transproc" do
+
+    before do
+      test.send(:define_method, :optimize?) { node > 3          }
+      test.send(:define_method, :optimize)  { -node if node < 7 }
+    end
+
+    subject { test.transproc[array] }
+
+    let(:array) { [5, 1, 38, 4] }
+    it { is_expected.to eql [-5, 1, -4] }
+
+  end # describe #transproc
+
+end # describe AbstractMapper::SoleRule

data/spec/unit/abstract_mapper_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+describe AbstractMapper do
+
+  let(:test)      { Class.new(described_class)  }
+  let(:tree)      { double transproc: transproc }
+  let(:transproc) { double                      }
+
+  let(:mapper) do
+    allow(transproc).to receive(:call) { |input| "called: #{input}" }
+    allow(test).to receive(:finalize) { tree }
+    test.new
+  end
+
+  describe ".new" do
+
+    subject { mapper }
+    it { is_expected.to be_frozen }
+
+  end # describe .new
+
+  describe "#tree" do
+
+    subject { mapper.tree }
+    it { is_expected.to eql tree }
+
+  end # describe #tree
+
+  describe "#call" do
+
+    subject { mapper.call :foo }
+    it { is_expected.to eql "called: foo" }
+
+  end # describe #call
+
+end # describe AbstractMapper