abstract_mapper 0.0.2 → 0.1.0

data/spec/unit/abstract_mapper/{rule_spec.rb → rules/base_spec.rb}

@@ -1,21 +1,19 @@
 # encoding: utf-8
 
-describe AbstractMapper::Rule do
+describe AbstractMapper::Rules::Base do
 
   let(:rule)  { test.new(*nodes) }
-  let(:test)  { AbstractMapper::Test::Rule = Class.new(described_class) }
+  let(:test)  { Class.new(described_class) }
   let(:nodes) { [node] }
-  let(:node)  { AbstractMapper::Node.new }
+  let(:node)  { AbstractMapper::AST::Node.new }
 
   describe ".new" do
-
     subject { rule }
-    it { is_expected.to be_frozen }
 
+    it { is_expected.to be_frozen }
   end # describe .new
 
   describe "#nodes" do
-
     subject { rule.nodes }
 
     it { is_expected.to eql nodes }
@@ -24,52 +22,44 @@ describe AbstractMapper::Rule do
     it "doesn't freeze the source" do
       expect { subject }.not_to change { nodes.frozen? }
     end
-
   end # describe #nodes
 
   describe "#call" do
-
     subject { rule.call }
 
     context "by default" do
-
       it { is_expected.to eql nodes }
-
-    end # context
+    end
 
     context "when #optimize? returns true" do
-
       before { test.send(:define_method, :optimize?) { true } }
-      it { is_expected.to eql nodes }
 
-    end # context
+      it { is_expected.to eql nodes }
+    end
 
     context "when #optimize is defined" do
-
       before { test.send(:define_method, :optimize) { :foo } }
-      it { is_expected.to eql nodes }
 
-    end # context
+      it { is_expected.to eql nodes }
+    end
 
     context "when #optimize? returns true and #optimize is defined" do
-
       before { test.send(:define_method, :optimize?) { true } }
       before { test.send(:define_method, :optimize)  { :foo } }
-      it { is_expected.to eql [:foo] }
 
-    end # context
+      it { is_expected.to eql [:foo] }
+    end
 
     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 # context
 
+      it { is_expected.to eql [] }
+    end
   end # describe #call
 
   describe ".transproc" do
+    subject { test.transproc[array] }
 
     before do
       test.send(:define_method, :optimize?) { true          }
@@ -79,21 +69,14 @@ describe AbstractMapper::Rule do
     let(:array) { [1, 2, 3] }
 
     context "with default composer" do
-
-      subject { test.transproc[array] }
       it { is_expected.to eql array }
-
-    end # context
+    end
 
     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
   end # describe .transproc
 
-end # describe AbstractMapper::Rule
+end # describe AbstractMapper::Rules::Base

data/spec/unit/abstract_mapper/{pair_rule_spec.rb → rules/pair_spec.rb}

@@ -1,18 +1,18 @@
 # encoding: utf-8
 
-describe AbstractMapper::PairRule do
+describe AbstractMapper::Rules::Pair do
 
-  let(:rule)  { test.new(left, right)                           }
-  let(:test)  { AbstractMapper::Test::Rule = Class.new(described_class) }
-  let(:nodes) { [left, right]                                   }
-  let(:left)  { AbstractMapper::Node.new                        }
-  let(:right) { AbstractMapper::Node.new                        }
+  let(:rule)  { test.new(left, right) }
+  let(:test)  { Class.new(described_class) }
+  let(:nodes) { [left, right] }
+  let(:left)  { AbstractMapper::AST::Node.new   }
+  let(:right) { AbstractMapper::AST::Node.new   }
 
   describe ".new" do
 
     subject { rule }
 
-    it { is_expected.to be_kind_of AbstractMapper::Rule }
+    it { is_expected.to be_kind_of AbstractMapper::Rules::Base }
     it { is_expected.to be_frozen }
 
     it "requires second argument" do
@@ -49,4 +49,4 @@ describe AbstractMapper::PairRule do
 
   end # describe #transproc
 
-end # describe AbstractMapper::PairRule
+end # describe AbstractMapper::Rules::Pair

data/spec/unit/abstract_mapper/{sole_rule_spec.rb → rules/sole_spec.rb}

@@ -1,17 +1,17 @@
 # encoding: utf-8
 
-describe AbstractMapper::SoleRule do
+describe AbstractMapper::Rules::Sole do
 
   let(:rule)  { test.new(node) }
-  let(:test)  { AbstractMapper::Test::Rule = Class.new(described_class) }
+  let(:test)  { Class.new(described_class) }
   let(:nodes) { [node] }
-  let(:node)  { AbstractMapper::Node.new }
+  let(:node)  { AbstractMapper::AST::Node.new }
 
   describe ".new" do
 
     subject { rule }
 
-    it { is_expected.to be_kind_of AbstractMapper::Rule }
+    it { is_expected.to be_kind_of AbstractMapper::Rules::Base }
     it { is_expected.to be_frozen }
 
     it "denies second argument" do
@@ -41,4 +41,4 @@ describe AbstractMapper::SoleRule do
 
   end # describe #transproc
 
-end # describe AbstractMapper::SoleRule
+end # describe AbstractMapper::Rules::Sole

data/spec/unit/abstract_mapper/rules_spec.rb

@@ -3,86 +3,73 @@
 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) }
+  let(:foo)   { Class.new(AbstractMapper::Rules::Sole) }
+  let(:bar)   { Class.new(AbstractMapper::Rules::Pair) }
 
   describe ".new" do
-
     subject { rules }
-    it { is_expected.to be_frozen }
 
+    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
+    end
 
     context "initialized" do
-
       let(:rules)    { described_class.new registry }
-      let(:registry) { [foo, bar]                 }
+      let(:registry) { [foo, bar] }
 
       it { is_expected.to eql registry }
       it { is_expected.to be_frozen    }
-
-      it "doesn't freezes the source" do
+      it "doesn't freeze a source" do
         expect { subject }.not_to change { registry.frozen? }
       end
-
-    end # context
-
+    end
   end # describe #registry
 
   describe "#<<" do
-
     subject { rules << bar }
 
     let(:rules) { described_class.new [foo] }
 
-    it "updates the registry" do
+    it "returns a collection" do
       expect(subject).to be_kind_of described_class
-      expect(subject.registry).to eql [foo, bar]
     end
 
+    it "updates the registry" do
+      expect(subject.registry).to eql [foo, bar]
+    end
   end # describe #<<
 
   describe "#[]" do
+    subject { rules[nodes] }
 
-    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
+    let(:nodes) { [1, 1, 2, 5] }
 
     context "when no rule is set" do
-
-      let(:nodes) { [1, 1, 2, 5] }
-
-      subject { rules[nodes] }
       it { is_expected.to eql nodes }
-
-    end # context
+    end
 
     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 [5, 4] }
-      # [1, 1, 2] -foo-> [2, 2, 3] -bar-> [4, 3] -foo-> [5, 4]
-
-    end # context
+      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
 
+      it { is_expected.to eql [5, 4, 7] }
+      # [1, 1, 2, 5] -foo-> [2, 2, 3, 6] -bar-> [4, 3, 6] -foo-> [5, 4, 7]
+    end
   end # describe #[]
 
 end # describe AbstractMapper::Rules

data/spec/unit/abstract_mapper/settings_spec.rb

@@ -4,30 +4,27 @@ class AbstractMapper
 
   describe AbstractMapper::Settings do
 
-    let!(:rule) { Test::Rule = Class.new(SoleRule) }
-    let!(:node) { Test::Node = Class.new(Node) { attribute :foo } }
+    let!(:foo) { Test::Foo = Class.new(AST::Node) { attribute :foo } }
+    let!(:bar) { Test::Bar = Class.new(AST::Node) { attribute :bar } }
+
+    let!(:baz) { Test::Baz = Class.new(Rules::Sole) }
+    let!(:qux) { Test::Qux = Class.new(Rules::Sole) }
 
     let(:settings) do
       described_class.new do
-        command :foo, Test::Node do |value|
-          { foo: value }
-        end
-
-        rule Test::Rule
+        command(:foo, Test::Foo) { |value| { foo: value } }
+        rule Test::Baz
       end
     end
 
     describe ".new" do
-
       context "with a valid block" do
-
         subject { settings }
-        it { is_expected.to be_frozen }
 
-      end # context
+        it { is_expected.to be_frozen }
+      end
 
       context "with invalid command" do
-
         subject { described_class.new { command :foo, String } }
 
         it "fails" do
@@ -36,11 +33,9 @@ class AbstractMapper
             expect(error.message).to include "String"
           end
         end
-
-      end # context
+      end
 
       context "with invalid rule" do
-
         subject { described_class.new { rule String } }
 
         it "fails" do
@@ -49,48 +44,39 @@ class AbstractMapper
             expect(error.message).to include "String"
           end
         end
-
-      end # context
+      end
 
       context "without a block" do
-
         subject { described_class.new }
 
         it "doesn't fail" do
           expect { subject }.not_to raise_error
         end
-
-      end # context
-
+      end
     end # describe .new
 
     describe "#commands" do
-
       subject { settings.commands }
 
       it { is_expected.to be_kind_of Commands }
 
       it "contains registered commands" do
-        node = subject[:foo].call(:bar)
-        expect(node.inspect).to eql "<Node(foo: :bar)>"
+        node = subject[:foo].call(:FOO)
+        expect(node.inspect).to eql "<Foo(foo: :FOO)>"
       end
-
     end # describe #commands
 
     describe "#rules" do
-
       subject { settings.rules }
 
       it { is_expected.to be_kind_of Rules }
 
       it "contains registered rules" do
-        expect(subject.registry).to eql [rule]
+        expect(subject.registry).to eql [baz]
       end
-
     end # describe #rules
 
     describe "#builder" do
-
       subject { settings.builder }
 
       it "subclasses Builder" do
@@ -100,11 +86,9 @@ class AbstractMapper
       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 Optimizer }
@@ -112,9 +96,31 @@ class AbstractMapper
       it "uses registered rules" do
         expect(subject.rules).to eql settings.rules
       end
-
     end # describe #optimizer
 
+    describe "#update" do
+      subject do
+        settings.update do
+          command(:bar, Test::Bar) { |value| { bar: value } }
+          rule Test::Qux
+        end
+      end
+
+      it { is_expected.to be_kind_of described_class }
+
+      it "updates commands" do
+        node = subject.commands[:foo].call(:FOO)
+        expect(node.inspect).to eql "<Foo(foo: :FOO)>"
+
+        node = subject.commands[:bar].call(:BAR)
+        expect(node.inspect).to eql "<Bar(bar: :BAR)>"
+      end
+
+      it "updates rules" do
+        expect(subject.rules.registry).to eql [baz, qux]
+      end
+    end # describe #update
+
   end # describe Settings
 
 end # class AbstractMapper

data/spec/unit/abstract_mapper_spec.rb

@@ -2,17 +2,13 @@
 
 describe AbstractMapper do
 
-  let(:mapper) do
-    allow(test).to receive(:finalize) { tree }
-    test.new
-  end
-
-  let(:test) { Class.new(described_class)  }
-
-  let(:tree) { klass.new }
+  before { allow(test).to receive(:finalize) { tree } }
 
-  let(:klass) do
-    Class.new(AbstractMapper::Branch) do
+  let(:test)   { Class.new(described_class) }
+  let(:mapper) { test.new }
+  let(:tree)   { branch.new }
+  let(:branch) do
+    Class.new(AbstractMapper::AST::Branch) do
       def transproc
         -> v { "called: #{v}" }
       end
@@ -20,25 +16,22 @@ describe AbstractMapper do
   end
 
   describe ".new" do
-
     subject { mapper }
-    it { is_expected.to be_frozen }
 
+    it { is_expected.to be_frozen }
   end # describe .new
 
   describe "#tree" do
-
     subject { mapper.tree }
+
     it { is_expected.to eql tree }
     it { is_expected.to be_frozen }
-
   end # describe #tree
 
   describe "#call" do
-
     subject { mapper.call :foo }
-    it { is_expected.to eql "called: foo" }
 
+    it { is_expected.to eql "called: foo" }
   end # describe #call
 
 end # describe AbstractMapper