ducktrap 0.0.1

data/spec/unit/ducktrap/nary/instance_methods/inverse_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Block, '#inverse' do
+  let(:object) { described_class.new(body) }
+
+  subject { object.inverse }
+
+  let(:body) do
+    [
+      Ducktrap::Node::Static.new(:forward, :inverse),
+      Ducktrap::Node::Noop.instance
+    ]
+  end
+
+  it 'should return inverse' do
+    inverse_body = [
+      Ducktrap::Node::Noop.instance,
+      Ducktrap::Node::Static.new(:inverse, :forward) 
+    ]
+    should eql(described_class.new(inverse_body))
+  end
+
+  it_should_behave_like 'an #inverse method'
+end

data/spec/unit/ducktrap/nary/instance_methods/pretty_inspect_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Ducktrap::Nary::InstanceMethods, '#pretty_inspect' do
+  let(:object)    { class_under_test.new(body) }
+
+  let(:class_under_test) do
+    Class.new(Ducktrap::Node) do
+      include Ducktrap::Nary
+
+      def self.name
+        'Test'
+      end
+    end
+  end
+
+  let(:body) { [node_a, node_b] }
+
+  let(:node_a) { Ducktrap::Node::Static.new(:a, :b) }
+  let(:node_b) { Ducktrap::Node::Noop.instance      }
+
+  subject { object.pretty_inspect }
+
+  it 'should return inspected error' do
+    should eql(strip(<<-STR))
+      Test
+        body:
+          Ducktrap::Node::Static
+          Ducktrap::Node::Noop
+    STR
+  end
+end

data/spec/unit/ducktrap/node/anima/dump/evaluator/output_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Anima::Dump::Evaluator, '#output' do
+  let(:object)  { described_class.new(context, input) }
+  let(:model) do
+    Class.new do
+      include Anima.new(:foo)
+    end
+  end
+  let(:context) { mock('Context', :model => model)    }
+  let(:input) { model.new(:foo => :bar) }
+
+  subject { object.output }
+
+  it { should eql(:foo => :bar) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/ducktrap/node/anima/dump/inverse_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Anima::Dump, '#inverse' do
+  let(:object) { described_class.new(model) }
+  let(:model)  { mock('Model') }
+
+  subject { object.inverse }
+
+  it { should eql(Ducktrap::Node::Anima::Load.new(model)) }
+end

data/spec/unit/ducktrap/node/anima/dump/pretty_inspect_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Anima::Dump, '#pretty_inspect' do
+  let(:object) { described_class.new(model) }
+  let(:model)  { :model }
+
+  subject { object.pretty_inspect }
+
+  it 'should return inspected error' do
+    should eql(strip(<<-STR))
+      Ducktrap::Node::Anima::Dump
+        model: :model
+    STR
+  end
+end

data/spec/unit/ducktrap/node/anima/evaluator/output_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Anima::Dump::Evaluator, '#output' do
+  let(:object)  { described_class.new(context, input) }
+  let(:model) do
+    Class.new do
+      include Anima.new(:foo)
+    end
+  end
+  let(:context) { mock('Context', :model => model)    }
+  let(:input) { model.new(:foo => :bar) }
+
+  subject { object.output }
+
+  it { should eql(:foo => :bar) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/ducktrap/node/anima/load/evaluator/output_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Anima::Load::Evaluator, '#output' do
+
+  let(:object)  { described_class.new(context, input) }
+
+  let(:model) do
+    Class.new do
+      include Anima.new(:foo)
+    end
+  end
+
+  let(:context) { mock('Context', :model => model) }
+
+  subject { object.output }
+
+  context 'with compatible input' do
+    let(:input) { { :foo => :bar} }
+
+    it { should eql(model.new(:foo => :bar)) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'with incompatible input' do
+    let(:input) { {} }
+
+    specify do
+      error = subject
+      should eql(Ducktrap::Error::Exception.new(context, input, error.exception))
+    end
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/ducktrap/node/anima/load/inverse_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Anima::Load, '#inverse' do
+  let(:object) { described_class.new(model) }
+  let(:model)  { mock('Model') }
+
+  subject { object.inverse }
+
+  it { should eql(Ducktrap::Node::Anima::Dump.new(model)) }
+end

data/spec/unit/ducktrap/node/anima/load/pretty_inspect_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Anima::Load, '#pretty_inspect' do
+  let(:object) { described_class.new(model) }
+  let(:model)  { :model }
+
+  subject { object.pretty_inspect }
+
+  it 'should return inspected error' do
+    should eql(strip(<<-STR))
+      Ducktrap::Node::Anima::Load
+        model: :model
+    STR
+  end
+end

data/spec/unit/ducktrap/node/anima/pretty_inspect_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Anima::Dump, '#pretty_inspect' do
+  let(:object) { described_class.new(model) }
+  let(:model)  { :model }
+
+  subject { object.pretty_inspect }
+
+  it 'should return inspected error' do
+    should eql(strip(<<-STR))
+      Ducktrap::Node::Anima::Dump
+        model: :model
+    STR
+  end
+end

data/spec/unit/ducktrap/node/block/evaluator/output_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Block::Evaluator, '#output' do
+  subject { object.output }
+
+  let(:object)  { described_class.new(context, input) }
+  let(:context) { mymock('Context', :body => body)    }
+  let(:input)   { :input                              }
+
+  def mymock(name, attributes={})
+    mock(name, attributes.merge(:frozen? => true))
+  end
+
+  context 'without elements in block' do
+    let(:body) { [] }
+
+    it { should be(input) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'with elements in block' do
+    let(:body) { [trap_a, trap_b] }
+
+    context 'without failures' do
+      let(:trap_a) { Ducktrap::Node::Noop.instance }
+      let(:trap_b) { Ducktrap::Node::Noop.instance }
+
+      it { should be(input) }
+      
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'with late failure' do
+      let(:trap_a) { Ducktrap::Node::Static.new(:forward, :inverse) }
+      let(:trap_b) { Ducktrap::Node::Invalid.instance }
+
+      its(:pretty_inspect) do 
+        should eql(strip(<<-STR))
+          Ducktrap::Error
+            input: :input
+            context:
+              Ducktrap::Evaluator::Invalid
+                input: :forward
+                error:
+                  Ducktrap::Error
+                    input: :forward
+                    context:
+                      Ducktrap::Node::Invalid
+                context:
+                  Ducktrap::Node::Invalid
+        STR
+      end
+    end
+
+    context 'with early failure' do
+      let(:trap_a) { Ducktrap::Node::Invalid.instance }
+      let(:trap_b) { mock('Late Node')                }
+
+      its(:pretty_inspect) do 
+        should eql(strip(<<-STR))
+          Ducktrap::Error
+            input: :input
+            context:
+              Ducktrap::Evaluator::Invalid
+                input: :input
+                error:
+                  Ducktrap::Error
+                    input: :input
+                    context:
+                      Ducktrap::Node::Invalid
+                context:
+                  Ducktrap::Node::Invalid
+        STR
+      end
+    end
+
+  end
+end

data/spec/unit/ducktrap/node/block/inverse_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Block, '#inverse' do
+  let(:object) { described_class.new(body) }
+
+  subject { object.inverse }
+
+  let(:body) do
+    [
+      Ducktrap::Node::Static.new(:forward, :inverse),
+      Ducktrap::Node::Noop.instance
+    ]
+  end
+
+  it 'should return inverse' do
+    inverse_body = [
+      Ducktrap::Node::Noop.instance,
+      Ducktrap::Node::Static.new(:inverse, :forward) 
+    ]
+    should eql(described_class.new(inverse_body))
+  end
+
+  it_should_behave_like 'an #inverse method'
+end

data/spec/unit/ducktrap/node/call_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Ducktrap::Node, '#call' do
+  subject { object.call(input) }
+
+  let(:object) { class_under_test.new }
+  let(:class_under_test) do
+    Class.new(described_class) do
+      evaluator = Class.new(Ducktrap::Evaluator) do
+        def output
+          :foo
+        end
+      end
+      const_set(:Evaluator, evaluator)
+    end
+  end
+
+  let(:input) { mock('Input') }
+
+  it { should eql(class_under_test::Evaluator.new(object, input)) }
+end

data/spec/unit/ducktrap/node/class_methods/build_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Ducktrap::Node, '.build' do
+  let(:object) { described_class }
+
+  subject { object.build(&block) }
+
+  let(:block) { proc { noop } }
+
+  it { should eql(Ducktrap::Node::Block.new([Ducktrap::Node::Noop.instance])) }
+end

data/spec/unit/ducktrap/node/class_methods/register_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Ducktrap::Node, '.register' do
+  subject do
+    Class.new(described_class) do
+      include Ducktrap::Nullary
+      register :foo
+    end
+  end
+
+  it 'should register class' do
+    subject
+    node = Ducktrap.build { foo }.body.first
+    node.class.should be(subject)
+  end
+end

data/spec/unit/ducktrap/node/custom/builder/forward_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Custom::Builder, '#output' do 
+  let(:object) { described_class.new(klass, &block) }
+
+  let(:klass) { Ducktrap::Node::Custom }
+
+  subject { object.object }
+
+  context 'without directions' do
+    let(:block) { proc {} }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(RuntimeError, 'No forward block specified!')
+    end
+
+  end
+
+  context 'with forward direction' do
+    let(:block) { proc { forward { |input| input } } }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(RuntimeError, 'No inverse block specified!')
+    end
+  end
+
+  context 'with forward and inverse direction' do
+    let(:block) { forward, inverse = self.forward, self.inverse; proc { forward(&forward); inverse(&inverse) } }
+
+    let(:forward) { proc {} }
+    let(:inverse) { proc {} }
+
+    it { should eql(klass.new(forward, inverse)) }
+  end
+
+  # kill some mutations
+  context 'with forward and inverse direction chained' do
+    let(:block) { forward, inverse = self.forward, self.inverse; proc { forward(&forward).inverse(&inverse) } }
+
+    let(:forward) { proc {} }
+    let(:inverse) { proc {} }
+
+    it { should eql(klass.new(forward, inverse)) }
+  end
+
+  context 'with forward and inverse direction chained #2' do
+    let(:block) { forward, inverse = self.forward, self.inverse; proc { inverse(&inverse).forward(&forward) } }
+
+    let(:forward) { proc {} }
+    let(:inverse) { proc {} }
+
+    it { should eql(klass.new(forward, inverse)) }
+  end
+end

data/spec/unit/ducktrap/node/custom/builder/inverse_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Custom::Builder, '#output' do 
+  let(:object) { described_class.new(klass, &block) }
+
+  let(:klass) { Ducktrap::Node::Custom }
+
+  subject { object.object }
+
+  context 'without directions' do
+    let(:block) { proc {} }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(RuntimeError, 'No forward block specified!')
+    end
+
+  end
+
+  context 'with forward direction' do
+    let(:block) { proc { forward { |input| input } } }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(RuntimeError, 'No inverse block specified!')
+    end
+  end
+
+  context 'with forward and inverse direction' do
+    let(:block) { forward, inverse = self.forward, self.inverse; proc { forward(&forward); inverse(&inverse) } }
+
+    let(:forward) { proc {} }
+    let(:inverse) { proc {} }
+
+    it { should eql(klass.new(forward, inverse)) }
+  end
+
+  # kill some mutations
+  context 'with forward and inverse direction chained' do
+    let(:block) { forward, inverse = self.forward, self.inverse; proc { forward(&forward).inverse(&inverse) } }
+
+    let(:forward) { proc {} }
+    let(:inverse) { proc {} }
+
+    it { should eql(klass.new(forward, inverse)) }
+  end
+
+  context 'with forward and inverse direction chained #2' do
+    let(:block) { forward, inverse = self.forward, self.inverse; proc { inverse(&inverse).forward(&forward) } }
+
+    let(:forward) { proc {} }
+    let(:inverse) { proc {} }
+
+    it { should eql(klass.new(forward, inverse)) }
+  end
+end