abstract_mapper 0.0.1 → 0.0.2

data/spec/unit/abstract_mapper/command_spec.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  describe AbstractMapper::Command do
+
+    let(:command)   { described_class.new name, klass, converter }
+    let(:name)      { "foo"                                      }
+    let(:klass)     { Class.new                                  }
+    let(:converter) { -> *args { args.reverse }                  }
+    let(:arguments) { [baz: :QUX]                                }
+    let(:block)     { proc { :foo }                              }
+
+    describe ".new" do
+
+      subject { command }
+      it { is_expected.to be_frozen }
+
+    end # describe .new
+
+    describe "#name" do
+
+      subject { command.name }
+      it { is_expected.to eql name.to_sym }
+
+    end # describe #name
+
+    describe "#klass" do
+
+      subject { command.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
+
+      context "initialized" do
+
+        it { is_expected.to eql converter }
+
+      end # context
+
+    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))
+            expect(blk).to eql block
+          end
+          subject
+        end
+
+      end # context
+
+      context "when the klass is a branch" do
+
+        let(:klass) { Class.new(Branch) }
+
+        it "builds a branch" do
+          expect(klass).to receive(:new) do |args, &blk|
+            expect(args).to eql(converter.call(arguments))
+            expect(blk).to be_nil
+          end
+          subject
+        end
+
+      end # context
+
+    end # describe #call
+
+  end # describe AbstractMapper::Command
+
+end # class AbstractMapper

data/spec/unit/abstract_mapper/commands_spec.rb

@@ -1,105 +1,64 @@
 # encoding: utf-8
 
-describe AbstractMapper::Commands do
+class AbstractMapper
 
-  let(:commands) { test.new                   }
-  let(:test)     { Class.new(described_class) }
-  let(:branch)   { Class.new(AbstractMapper::Branch)  }
+  describe AbstractMapper::Commands do
 
-  describe ".new" 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 }                            }
 
-    subject { commands }
-    it { is_expected.to be_frozen }
+    describe ".new" do
 
-  end # describe .new
+      let(:registry) { { foo: foo, bar: bar } }
+      subject { test.new(registry) }
 
-  describe "#registry" do
-
-    subject { commands.registry }
-
-    context "with a hash" do
-
-      let(:commands) { test.new(registry) }
-      let(:registry) { { foo: branch }    }
-
-      it { is_expected.to eql registry }
-      it { is_expected.to be_frozen    }
+      it { is_expected.to be_frozen }
 
-      it "doesn't freeze the source" do
+      it "doesn't freeze arguments" do
         expect { subject }.not_to change { registry.frozen? }
       end
 
-    end # context
-
-    context "without a hash" do
-
-      let(:commands) { test.new }
-
-      it { is_expected.to eql({})   }
-      it { is_expected.to be_frozen }
-
-    end # context
-
-  end # describe #builder
-
-  describe "#<<" do
-
-    let(:commands) { test.new(foo: branch) }
-
-    subject { commands << ["bar", branch] }
+    end # describe .new
 
-    it "registers a command" do
-      expect(subject).to be_kind_of test
-      expect(subject.registry).to eql(foo: branch, bar: branch)
-    end
+    describe "#[]" do
 
-  end # describe #<<
+      subject { commands << ["foo", foo] }
 
-  describe "#[]" do
-
-    let(:block) { proc { [:foo] }   }
-    let(:args)  { [:baz, qux: :QUX] }
-    let(:commands) do
-      test.new(foo: AbstractMapper::Node, bar: AbstractMapper::Branch)
-    end
-
-    context "simple node" do
-
-      subject { commands["foo", *args, &block] }
-
-      it "builds a node with a block" do
-        expect(subject).to be_kind_of AbstractMapper::Node
-        expect(subject.attributes).to eql args
-        expect(subject.block).to eql block
+      it "returns registered command" do
+        expect(subject["foo"]).to be_kind_of Command
       end
 
-    end # context
-
-    context "branch command" do
+      it "complains about unknown command" do
+        expect { subject[:baz] }.to raise_error do |error|
+          expect(error).to be_kind_of AbstractMapper::Errors::UnknownCommand
+          expect(error.message).to include "baz"
+        end
+      end
 
-      subject { commands["bar", *args, &block] }
+    end # describe #[]
 
-      it "builds a branch" do
-        expect(subject).to be_kind_of AbstractMapper::Node
-        expect(subject.attributes).to eql args
-        expect(subject.entries).to eql []
-      end
+    describe "#<<" do
 
-    end # context
+      subject { commands << ["foo", foo] << ["bar", bar, converter] }
 
-    context "unknown command" do
+      it { is_expected.to be_kind_of test }
 
-      subject { commands["baz"] }
+      it "preserves registered commands" do
+        expect(subject[:foo]).to be_kind_of Command
+      end
 
-      it "fails" do
-        expect { subject }.to raise_error do |error|
-          expect(error).to be_kind_of AbstractMapper::Errors::UnknownCommand
-          expect(error.message).to include "baz"
-        end
+      it "registers new command" do
+        expect(subject[:bar]).to be_kind_of Command
+        expect(subject[:bar].name).to eql :bar
+        expect(subject[:bar].klass).to eql bar
+        expect(subject[:bar].converter).to eql converter
       end
 
-    end # context
+    end # describe #<<
 
-  end # describe #build
+  end # describe AbstractMapper::Commands
 
-end # describe AbstractMapper::Commands
+end # class AbstractMapper

data/spec/unit/abstract_mapper/dsl_spec.rb

@@ -1,82 +1,87 @@
 # encoding: utf-8
 
-describe AbstractMapper::DSL do
-
-  let!(:bar) { AbstractMapper::Test::Bar = Class.new(AbstractMapper::Branch) }
-  let!(:foo) { AbstractMapper::Test::Foo = Class.new(AbstractMapper::Node)   }
-  let!(:rule) do
-    AbstractMapper::Test::Rule = Class.new(AbstractMapper::PairRule) do
-      def optimize?
-        left.instance_of?(AbstractMapper::Test::Foo)
-      end
+class AbstractMapper
+
+  describe AbstractMapper::DSL do
 
-      def optimize
-        AbstractMapper::Test::Foo.new(nodes.flat_map(&:attributes))
+    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!(:rule) do
+      Test::Rule = Class.new(PairRule) do
+        def optimize?
+          left.instance_of?(Test::Foo)
+        end
+
+        def optimize
+          Test::Foo.new(left.attributes.merge(right.attributes))
+        end
       end
     end
-  end
-  let!(:dsl) { Class.new { extend AbstractMapper::DSL } }
-
-  let!(:config) do
-    dsl.configure do
-      command :foo, AbstractMapper::Test::Foo
-      command :bar, AbstractMapper::Test::Bar
-      rule AbstractMapper::Test::Rule
+
+    let!(:config) do
+      dsl.configure do
+        command :foo, Test::Foo
+        command(:bar, Test::Bar) { |value| { bar: value } }
+        rule Test::Rule
+      end
     end
-  end
 
-  describe "#configure" do
+    describe "#configure" do
 
-    subject { config }
+      subject { config }
 
-    it { is_expected.to eql dsl }
+      it { is_expected.to eql dsl }
 
-    it "configures settings" do
-      subject
-      expect(dsl.settings).to be_kind_of AbstractMapper::Settings
-      expect(dsl.settings.rules.registry).to eql [rule]
-      expect(dsl.settings.commands.registry).to eql(foo: foo, bar: bar)
-    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
 
-  end # describe #configure
+    end # describe #configure
 
-  describe "#finalize" do
+    describe "#finalize" do
 
-    before do
-      dsl.instance_eval do
-        bar :baz do
-          foo :qux
-          foo :quxx
+      before do
+        dsl.instance_eval do
+          bar :baz do
+            foo foo: :qux
+            foo foo: :quxx
+          end
+          foo foo: :foo
         end
-        foo :foo
       end
-    end
 
-    subject { dsl.finalize }
+      subject { dsl.finalize }
 
-    it { is_expected.to be_kind_of AbstractMapper::Branch }
+      it { is_expected.to be_kind_of Branch }
 
-    it "is optimized" do
-      expect(subject.inspect)
-        .to eql "<Root [<Bar(:baz) [<Foo([:qux, :quxx])>]>, <Foo(:foo)>]>"
-    end
+      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
 
-  end # describe #finalize
+    describe "#respond_to?" do
 
-  describe "#respond_to?" do
+      subject { dsl.respond_to? :anything }
+      it { is_expected.to eql true }
 
-    subject { dsl.respond_to? :anything }
-    it { is_expected.to eql true }
+    end # describe #respond_to?
 
-  end # describe #respond_to?
+    describe ".inherited" do
 
-  describe ".inherited" do
+      let(:subklass) { Class.new(dsl) }
+      subject { subklass.settings }
 
-    let(:subklass) { Class.new(dsl) }
-    subject { subklass.settings }
+      it { is_expected.to eql dsl.settings }
 
-    it { is_expected.to eql dsl.settings }
+    end # describe .inherited
 
-  end # describe .inherited
+  end # describe AbstractMapper::DSL
 
-end # describe AbstractMapper::DSL
+end # class AbstractMapper

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

@@ -15,7 +15,7 @@ describe AbstractMapper::Errors::WrongRule do
 
     subject { error.message }
     it do
-      is_expected.to eql "Symbol is not a subclass of AbstractMapper::SoleRule"
+      is_expected.to eql "Symbol is not a subclass of AbstractMapper::Rule"
     end
 
   end # describe #message

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

@@ -1,11 +1,11 @@
 # encoding: utf-8
 
-require "abstract_mapper/rspec"
+require "transproc/rspec"
 
 describe AbstractMapper::Functions, "#compact" do
 
-  let(:function)  { -> a, b { (a == b) ? [a + b] : [a, b] } }
-  let(:arguments) { [:compact, function] }
+  let(:fn) { -> a, b { (a == b) ? [a + b] : [a, b] } }
+  let(:arguments) { [:compact, fn] }
 
   it_behaves_like :transforming_immutable_data do
     let(:input)  { [] }

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

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

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require "transproc/rspec"
+
+describe AbstractMapper::Functions, "#identity" do
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:identity] }
+
+    let(:input)  { :foo }
+    let(:output) { :foo }
+  end
+
+  it_behaves_like :transforming_immutable_data do
+    let(:arguments) { [:identity, :bar, :baz] }
+
+    let(:input)  { :foo }
+    let(:output) { :foo }
+  end
+
+end # describe AbstractMapper::Functions#identity

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+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