abstract_mapper 0.0.2 → 0.1.0

data/spec/unit/abstract_mapper/{command_spec.rb → commands/base_spec.rb}

@@ -2,7 +2,7 @@
 
 class AbstractMapper
 
-  describe AbstractMapper::Command do
+  describe AbstractMapper::Commands::Base do
 
     let(:command)   { described_class.new name, klass, converter }
     let(:name)      { "foo"                                      }
@@ -12,55 +12,44 @@ class AbstractMapper
     let(:block)     { proc { :foo }                              }
 
     describe ".new" do
-
       subject { command }
-      it { is_expected.to be_frozen }
 
+      it { is_expected.to be_frozen }
     end # describe .new
 
     describe "#name" do
-
       subject { command.name }
-      it { is_expected.to eql name.to_sym }
 
+      it { is_expected.to eql name.to_sym }
     end # describe #name
 
     describe "#klass" do
-
       subject { command.klass }
-      it { is_expected.to eql klass  }
 
+      it { is_expected.to eql klass }
     end # describe #name
 
     describe "#converter" do
-
       subject { command.converter }
 
       context "by default" do
-
         let(:command) { described_class.new name, klass }
 
         it "returns identity function" do
           expect(subject.call(foo: :BAR)).to eql(foo: :BAR)
           expect(subject.call).to eql({})
         end
-
-      end # context
+      end
 
       context "initialized" do
-
         it { is_expected.to eql converter }
-
-      end # context
-
+      end
     end # describe #name
 
     describe "#call" do
-
       subject { command.call(arguments, &block) }
 
       context "when the klass is not a branch" do
-
         it "builds a node" do
           expect(klass).to receive(:new) do |args, &blk|
             expect(args).to eql(converter.call(arguments))
@@ -68,12 +57,10 @@ class AbstractMapper
           end
           subject
         end
-
-      end # context
+      end
 
       context "when the klass is a branch" do
-
-        let(:klass) { Class.new(Branch) }
+        let(:klass) { Class.new(AST::Branch) }
 
         it "builds a branch" do
           expect(klass).to receive(:new) do |args, &blk|
@@ -82,11 +69,9 @@ class AbstractMapper
           end
           subject
         end
-
-      end # context
-
+      end
     end # describe #call
 
-  end # describe AbstractMapper::Command
+  end # describe AbstractMapper::Commands::Base
 
 end # class AbstractMapper

data/spec/unit/abstract_mapper/commands_spec.rb

@@ -4,31 +4,29 @@ class AbstractMapper
 
   describe AbstractMapper::Commands do
 
-    let(:foo)       { Test::Foo = Class.new(AbstractMapper::Branch) }
-    let(:bar)       { Test::Bar = Class.new(AbstractMapper::Node)   }
-    let(:test)      { Class.new(described_class)                    }
-    let(:commands)  { test.new                                      }
-    let(:converter) { -> v { v.reverse }                            }
+    let(:foo)       { Test::Foo = Class.new(AbstractMapper::AST::Branch) }
+    let(:bar)       { Test::Bar = Class.new(AbstractMapper::AST::Node) }
+    let(:test)      { Class.new(described_class) }
+    let(:commands)  { test.new }
+    let(:converter) { -> v { v.reverse } }
 
     describe ".new" do
+      subject { test.new(registry) }
 
       let(:registry) { { foo: foo, bar: bar } }
-      subject { test.new(registry) }
 
       it { is_expected.to be_frozen }
 
       it "doesn't freeze arguments" do
         expect { subject }.not_to change { registry.frozen? }
       end
-
     end # describe .new
 
     describe "#[]" do
-
       subject { commands << ["foo", foo] }
 
       it "returns registered command" do
-        expect(subject["foo"]).to be_kind_of Command
+        expect(subject["foo"]).to be_kind_of Commands::Base
       end
 
       it "complains about unknown command" do
@@ -37,26 +35,23 @@ class AbstractMapper
           expect(error.message).to include "baz"
         end
       end
-
     end # describe #[]
 
     describe "#<<" do
-
       subject { commands << ["foo", foo] << ["bar", bar, converter] }
 
       it { is_expected.to be_kind_of test }
 
       it "preserves registered commands" do
-        expect(subject[:foo]).to be_kind_of Command
+        expect(subject[:foo]).to be_kind_of Commands::Base
       end
 
       it "registers new command" do
-        expect(subject[:bar]).to be_kind_of Command
+        expect(subject[:bar]).to be_kind_of Commands::Base
         expect(subject[:bar].name).to eql :bar
         expect(subject[:bar].klass).to eql bar
         expect(subject[:bar].converter).to eql converter
       end
-
     end # describe #<<
 
   end # describe AbstractMapper::Commands

data/spec/unit/abstract_mapper/dsl_spec.rb

@@ -5,11 +5,10 @@ class AbstractMapper
   describe AbstractMapper::DSL do
 
     let!(:dsl) { Class.new { extend DSL } }
-    let!(:foo) { Test::Foo = Class.new(Node) { attribute :foo } }
-    let!(:bar) { Test::Bar = Class.new(Branch) { attribute :bar } }
-
+    let!(:foo) { Test::Foo = Class.new(AST::Node) { attribute :foo } }
+    let!(:bar) { Test::Bar = Class.new(AST::Branch) { attribute :bar } }
     let!(:rule) do
-      Test::Rule = Class.new(PairRule) do
+      Test::Rule = Class.new(Rules::Pair) do
         def optimize?
           left.instance_of?(Test::Foo)
         end
@@ -19,7 +18,6 @@ class AbstractMapper
         end
       end
     end
-
     let!(:config) do
       dsl.configure do
         command :foo, Test::Foo
@@ -29,21 +27,36 @@ class AbstractMapper
     end
 
     describe "#configure" do
-
       subject { config }
 
-      it { is_expected.to eql dsl }
+      it "returns self" do
+        expect(subject).to eql dsl
+      end
 
       it "configures settings" do
         subject
+
         expect(dsl.settings).to be_kind_of Settings
         expect(dsl.settings.rules.registry).to eql [rule]
         expect { dsl.settings.commands[:foo] }.not_to raise_error
       end
 
+      it "updates existing settings" do
+        subject
+        dsl.configure do
+          command :baz, Test::Foo
+        end
+
+        expect(dsl.settings).to be_kind_of Settings
+        expect(dsl.settings.rules.registry).to eql [rule]
+        expect { dsl.settings.commands[:foo] }.not_to raise_error
+        expect { dsl.settings.commands[:bar] }.not_to raise_error
+        expect { dsl.settings.commands[:baz] }.not_to raise_error
+      end
     end # describe #configure
 
     describe "#finalize" do
+      subject { dsl.finalize }
 
       before do
         dsl.instance_eval do
@@ -55,31 +68,26 @@ class AbstractMapper
         end
       end
 
-      subject { dsl.finalize }
-
-      it { is_expected.to be_kind_of Branch }
+      it { is_expected.to be_kind_of AST::Branch }
 
       it "is optimized" do
         desc = "<Root [<Bar(bar: :baz) [<Foo(foo: :quxx)>]>, <Foo(foo: :foo)>]>"
         expect(subject.inspect).to eql(desc)
       end
-
     end # describe #finalize
 
     describe "#respond_to?" do
-
       subject { dsl.respond_to? :anything }
-      it { is_expected.to eql true }
 
+      it { is_expected.to eql true }
     end # describe #respond_to?
 
     describe ".inherited" do
+      subject { subklass.settings }
 
       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

@@ -5,17 +5,14 @@ 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" }
 
+    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

@@ -2,20 +2,21 @@
 
 describe AbstractMapper::Errors::WrongNode do
 
-  subject(:error) { described_class.new Symbol }
+  let(:error) { described_class.new Symbol }
 
   describe ".new" do
+    subject { error }
 
     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" }
 
+    it do
+      is_expected.to eql "Symbol is not a subclass of AbstractMapper::AST::Node"
+    end
   end # describe #message
 
 end # describe AbstractMapper::Errors::WrongNode

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

@@ -2,22 +2,22 @@
 
 describe AbstractMapper::Errors::WrongRule do
 
-  subject(:error) { described_class.new Symbol }
+  let(:error) { described_class.new Symbol }
 
   describe ".new" do
+    subject { error }
 
     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::Rule"
+      is_expected
+        .to eql "Symbol is not a subclass of AbstractMapper::Rules::Base"
     end
-
   end # describe #message
 
 end # describe AbstractMapper::Errors::WrongRule

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

@@ -3,7 +3,6 @@
 require "transproc/rspec"
 
 describe AbstractMapper::Functions, "#compact" do
-
   let(:fn) { -> a, b { (a == b) ? [a + b] : [a, b] } }
   let(:arguments) { [:compact, fn] }
 
@@ -21,5 +20,4 @@ describe AbstractMapper::Functions, "#compact" 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

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

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

@@ -3,7 +3,6 @@
 require "transproc/rspec"
 
 describe AbstractMapper::Functions, "#identity" do
-
   it_behaves_like :transforming_immutable_data do
     let(:arguments) { [:identity] }
 
@@ -17,5 +16,4 @@ describe AbstractMapper::Functions, "#identity" do
     let(:input)  { :foo }
     let(:output) { :foo }
   end
-
 end # describe AbstractMapper::Functions#identity

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

@@ -3,14 +3,11 @@
 require "transproc/rspec"
 
 describe AbstractMapper::Functions, "#restrict" do
-
   let(:arguments) { [:restrict, default] }
   let(:default)   { { foo: :FOO, bar: :BAR } }
 
   it_behaves_like :transforming_immutable_data do
-
     let(:input)  { { foo: :BAZ, qux: :QUX } }
     let(:output) { { foo: :BAZ, bar: :BAR } }
   end
-
 end # describe AbstractMapper::Functions#restrict

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

@@ -3,7 +3,6 @@
 require "transproc/rspec"
 
 describe AbstractMapper::Functions, "#subclass?" do
-
   let(:klass) { Class.new  }
   let(:modul) { Module.new }
 
@@ -62,5 +61,4 @@ describe AbstractMapper::Functions, "#subclass?" do
     let(:input)  { Module.new.send :extend, modul }
     let(:output) { false }
   end
-
 end # describe AbstractMapper::Functions#subclass?

data/spec/unit/abstract_mapper/optimizer_spec.rb

@@ -9,44 +9,40 @@ class AbstractMapper # namespace
     let(:rules)     { Rules.new                  }
 
     describe ".new" do
-
       subject { optimizer }
-      it { is_expected.to be_frozen }
 
+      it { is_expected.to be_frozen }
     end # describe .new
 
     describe "#rules" do
-
       subject { optimizer.rules }
-      it { is_expected.to eql rules }
 
+      it { is_expected.to eql rules }
     end # describe #rules
 
     describe "#update" do
+      subject { optimizer.update(input) }
 
-      subject { optimizer.update(tree) }
+      let(:rules) { Rules.new([rule]) }
+      let(:rule)  { Class.new(Rules::Pair) }
+      let(:input) { AST::Branch.new { [foo3, bar1] } }
 
-      let(:rules) { Rules.new([rule])           }
-      let(:rule)  { Class.new(PairRule)         }
-      let(:tree)  { Branch.new { [foo3, bar1] } }
-
-      let(:foo1) { Test::Foo.new(n: 1)                  }
-      let(:foo2) { Test::Foo.new(n: 2)                  }
-      let(:foo3) { Test::Foo.new(n: 3)                  }
+      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] } }
 
-      before { Test::Foo = Class.new(Node) { attribute :n }            }
-      before { Test::Bar = Class.new(Branch)                           }
-      before { rule.send(:define_method, :optimize?) { true }          }
+      before { Test::Foo = Class.new(AST::Node) { attribute :n } }
+      before { Test::Bar = Class.new(AST::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)
+        expect(input.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