abstract_mapper 0.0.2 → 0.1.0

data/spec/integration/rspec_examples_spec.rb

@@ -9,7 +9,6 @@ describe "rspec examples" do
   include_context "Faceter"
 
   describe "Faceter::Rename" do
-
     let(:described_class) { Faceter::Rename }
 
     it_behaves_like :creating_immutable_node do
@@ -22,19 +21,15 @@ describe "rspec examples" do
       let(:input)      { { foo: :FOO, baz: :BAZ } }
       let(:output)     { { bar: :FOO, baz: :BAZ } }
     end
-
   end # describe Faceter::Rename
 
   describe "Faceter::List" do
-
     let(:described_class) { Faceter::List }
 
     it_behaves_like :creating_immutable_branch
-
   end # describe Faceter::List
 
   describe "Faceter::CompactLists" do
-
     let(:described_class) { Faceter::CompactLists }
 
     it_behaves_like :skipping_nodes do
@@ -45,7 +40,6 @@ describe "rspec examples" do
       let(:input)  { [Faceter::List.new { [1] }, Faceter::List.new { [2] }] }
       let(:output) { Faceter::List.new { [1, 2] } }
     end
-
   end # describe Faceter::CompactLists
 
 end # describe mapper definition

data/spec/unit/abstract_mapper/{branch_spec.rb → ast/branch_spec.rb}

@@ -1,9 +1,9 @@
 # encoding: utf-8
 
-describe AbstractMapper::Branch do
+describe AbstractMapper::AST::Branch do
 
   let(:foo) do
-    class Foo < AbstractMapper::Node
+    class Foo < AbstractMapper::AST::Node
       attribute :foo
 
       def transproc
@@ -12,7 +12,6 @@ describe AbstractMapper::Branch do
     end
     Foo
   end
-
   let(:node1)  { foo.new foo: :FOO }
   let(:node2)  { foo.new foo: :BAR }
   let(:node3)  { foo.new foo: :BAZ }
@@ -24,63 +23,51 @@ describe AbstractMapper::Branch do
   end
 
   describe ".new" do
-
     subject { branch }
 
     it { is_expected.to be_kind_of Enumerable }
     it { is_expected.to be_frozen             }
 
     context "without a block" do
-
       subject { test.new(foo: :FOO).entries }
-      it { is_expected.to be_empty }
 
-    end # context
+      it { is_expected.to be_empty }
+    end
 
     context "with a block" do
-
       subject { test.new(foo: :FOO) { [node1, node2] }.entries }
-      it { is_expected.to eql [node1, node2] }
-
-    end # context
 
+      it { is_expected.to eql [node1, node2] }
+    end
   end # describe .new
 
   describe "#attributes" do
-
     subject { branch.attributes }
 
     context "initialized" do
-
       it { is_expected.to eql(foo: :FOO) }
-
-    end # context
+    end
 
     context "not initialized" do
-
       let(:branch) { test.new }
-      it { is_expected.to eql(foo: nil) }
 
-    end # context
+      it { is_expected.to eql(foo: nil) }
+    end
 
     context "not defined" do
-
       let(:branch) { described_class.new }
-      it { is_expected.to eql({}) }
-
-    end # context
 
+      it { is_expected.to eql({}) }
+    end
   end # describe #attributes
 
   describe "#block" do
-
     subject { branch.block }
-    it { is_expected.to be_nil }
 
+    it { is_expected.to be_nil }
   end # describe #block
 
   describe "#update" do
-
     subject { branch.update { [node2, node3] } }
 
     it { is_expected.to be_kind_of test }
@@ -92,38 +79,30 @@ describe AbstractMapper::Branch do
     it "assings new subnodes from a block" do
       expect(subject.entries).to eql [node2, node3]
     end
-
   end # describe #update
 
   describe "#each" do
-
     let(:subnodes) { [node1, node2] }
 
     context "with a block" do
-
       subject { branch.each { |item| item } }
 
       it "looks over subnodes" do
         expect(subject).to eql subnodes
       end
-
-    end # context
+    end
 
     context "without a block" do
-
       subject { branch.each }
 
       it "returns Enumerator for subnodes" do
         expect(subject).to be_kind_of Enumerator
         expect(subject.entries).to eql subnodes
       end
-
-    end # context
-
+    end
   end # describe #each
 
   describe "#<<" do
-
     subject { branch << node3 }
 
     it "returns the branch with updated subnodes and the same attributes" do
@@ -131,73 +110,61 @@ describe AbstractMapper::Branch do
       expect(subject.attributes).to eql branch.attributes
       expect(subject.entries).to eql [node1, node2, node3]
     end
-
   end # describe #<<
 
   describe "#transproc" do
+    subject { branch.transproc[data] }
 
     let(:data) { "baz" }
 
-    subject { branch.transproc[data] }
     it { is_expected.to eql "baz-1-1" }
-
   end # describe #transproc
 
   describe "#to_s" do
-
     subject { branch.to_s }
 
     context "of the root" do
-
       let(:branch) { described_class.new { [node1, node2] } }
-      it { is_expected.to eql "Root [#{node1.inspect}, #{node2.inspect}]" }
 
-    end # context
+      it { is_expected.to eql "Root [#{node1.inspect}, #{node2.inspect}]" }
+    end
 
     context "of the specific node" do
-
       let(:branch) { test.new(foo: :FOO) { [node1, node2] } }
+
       it do
         is_expected
           .to eql "Foo(foo: :FOO) [#{node1.inspect}, #{node2.inspect}]"
       end
-
-    end # context
-
+    end
   end # describe #to_s
 
   describe "#eql?" do
-
     subject { branch.eql? other }
 
     context "with the same type, attributes and subnodes" do
-
       let(:other) { test.new(foo: :FOO) { [node1, node2] } }
-      it { is_expected.to eql true }
 
-    end # context
+      it { is_expected.to eql true }
+    end
 
     context "with another type" do
-
       let(:other) { Class.new(test).new(foo: :FOO) { [node1, node2] } }
-      it { is_expected.to eql false }
 
-    end # context
+      it { is_expected.to eql false }
+    end
 
     context "with other attributes" do
-
       let(:other) { test.new(foo: :BAR) { [node1, node2] } }
-      it { is_expected.to eql false }
 
-    end # context
+      it { is_expected.to eql false }
+    end
 
     context "with other subnodes" do
-
       let(:other) { test.new(foo: :FOO) { [node1, node3] } }
-      it { is_expected.to eql false }
-
-    end # context
 
+      it { is_expected.to eql false }
+    end
   end # describe #eql?
 
-end # describe Branch
+end # describe AbstractMapper::AST::Branch

data/spec/unit/abstract_mapper/{node_spec.rb → ast/node_spec.rb}

@@ -2,7 +2,7 @@
 
 class AbstractMapper # namespace
 
-  describe AbstractMapper::Node do
+  describe AbstractMapper::AST::Node do
 
     let(:test) do
       Test::Node = Class.new(described_class) do
@@ -16,7 +16,6 @@ class AbstractMapper # namespace
     let(:block)      { nil                          }
 
     describe ".new" do
-
       subject { node }
 
       it "initializes attributes" do
@@ -29,127 +28,91 @@ class AbstractMapper # namespace
       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
 
+        it { is_expected.to eql(foo: nil, bar: :BAR) }
+      end
     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 }                }
+        let(:block) { proc { :foo }   }
         it { is_expected.to eql block }
-
-      end # context
-
+      end
     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
+        it { is_expected.to eql "Node(foo: nil, bar: :BAR)" }
+      end
 
       context "with initialized attributes" do
-
         let(:node) { test.new(attributes) }
-        it { is_expected.to eql "Node(foo: :FOO, bar: :BAR)" }
 
-      end # context
+        it { is_expected.to eql "Node(foo: :FOO, bar: :BAR)" }
+      end
 
       context "without attributes" do
-
         let(:node) { described_class.new }
-        it { is_expected.to eql "Node" }
-
-      end # context
 
+        it { is_expected.to eql "Node" }
+      end
     end # describe #to_s
 
     describe "#==" do
-
       subject { node == other }
 
       context "node with the same type and attributes" do
-
         let(:other) { test.new(attributes) }
-        it { is_expected.to eql true }
 
+        it { is_expected.to eql true }
       end # context
 
       context "node with other type" do
-
         let(:other) { Class.new(test).new(attributes) }
-        it { is_expected.to eql false }
 
+        it { is_expected.to eql false }
       end # context
 
       context "node with other attributes" do
-
         let(:other) { test.new }
-        it { is_expected.to eql false }
 
+        it { is_expected.to eql false }
       end # context
-
     end # describe #==
 
     describe "#inspect" do
-
       subject { node.inspect }
-      it { is_expected.to eql "<Node(foo: :FOO, bar: :BAR)>" }
 
+      it { is_expected.to eql "<Node(foo: :FOO, bar: :BAR)>" }
     end # describe #inspect
 
     describe "#transproc" do
-
       subject { node.transproc }
 
       it "returns the identity function" do
         expect(subject[:foo]).to eql :foo
       end
-
     end # describe #transproc
 
-  end # describe AbstractMapper::Node
+  end # describe AbstractMapper::AST::Node
 
 end # class AbstractMapper

data/spec/unit/abstract_mapper/builder_spec.rb

@@ -4,64 +4,53 @@ class AbstractMapper
 
   describe AbstractMapper::Builder do
 
-    let!(:test) { Class.new(described_class)                     }
-    let!(:foo)  { Test::Foo = Class.new(Node) { attribute :foo } }
-    let!(:bar)  { Test::Bar = Class.new(Branch)                  }
+    let!(:test) { Class.new(described_class)                          }
+    let!(:foo)  { Test::Foo = Class.new(AST::Node) { attribute :foo } }
+    let!(:bar)  { Test::Bar = Class.new(AST::Branch)                  }
 
     let(:builder)  { test.new tree }
     let(:tree)     { Test::Foo.new }
     let(:commands) { Commands.new << [:foo, Test::Foo] << [:bar, Test::Bar] }
 
     describe ".commands=" do
-
       subject { test.commands = commands }
 
       it "sets the commands" do
         expect { subject }.to change { test.commands }.to commands
       end
-
     end # describe .commands=
 
     describe ".update" do
-
       before { test.commands = commands }
 
       context "by default" do
-
         subject { test.update }
 
         it "is an empty branch" do
-          expect(subject).to be_instance_of AbstractMapper::Branch
+          expect(subject).to be_instance_of AST::Branch
           expect(subject.entries).to be_empty
         end
-
-      end # context
+      end
 
       context "initialized" do
-
         subject { test.update(tree) }
 
         it "returns exactly the same tree" do
           expect(subject.inspect).to eql(tree.inspect)
         end
-
-      end # context
+      end
 
       context "with a block" do
-
         subject { test.update { bar { foo(foo: :FOO) { fail } } } }
 
         it "is built" do
           expect(subject.inspect).to eql "<Root [<Bar [<Foo(foo: :FOO)>]>]>"
           expect(subject.first.first.block).not_to be_nil
         end
-
-      end # context
-
+      end
     end # describe .update
 
     describe ".new" do
-
       subject { builder }
 
       it { is_expected.to be_frozen }
@@ -69,11 +58,9 @@ class AbstractMapper
       it "doesn't freezes the tree" do
         expect { subject }.not_to change { tree.frozen? }
       end
-
     end # describe .new
 
     describe "#tree" do
-
       subject { builder.tree }
 
       it "returns exactly the same tree as initialized" do
@@ -81,16 +68,14 @@ class AbstractMapper
       end
 
       it { is_expected.to be_frozen }
-
     end # describe #tree
 
     describe "#respond_to?" do
-
       subject { builder.respond_to? :arbitrary_method }
-      it { is_expected.to eql true }
 
+      it { is_expected.to eql true }
     end # describe #respond_to?
 
   end # describe AbstractMapper::Builder
 
-end
+end # class AbstractMapper