ducktrap 0.0.1

data/spec/unit/ducktrap/node/custom/builder/object_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/call_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Custom, '#call' do 
+  let(:object) { described_class.new(forward, inverse) }
+
+  let(:input)  { mock('Input') }
+  let(:output) { mock('Output') }
+
+  let(:arguments) { [] }
+
+  let(:forward) {  lambda { |input| arguments << input; output } }
+  let(:inverse) { mock('Inverse')                                }
+
+  subject { object.call(input) }
+
+  it { should eql(Ducktrap::Evaluator::Static.new(object, input, output)) }
+
+  it 'should call with correct argument' do
+    expect { subject }.to change { arguments }.from([]).to([input])
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Custom, '.build' do
+  let(:object) { described_class }
+
+  subject { object.build(&block) }
+
+  let(:block) { proc {} }
+
+  let(:result) { mock('Result') }
+
+  it 'should call custom builder and return its object' do
+    Ducktrap::Node::Custom::Builder.should_receive(:new) do |&block|
+      block.should be(self.block)
+      mock(:object => result)
+    end
+    should be(result)
+  end
+end
+

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Custom, '#inverse' do
+  let(:object) { described_class.new(:forward, :inverse) }
+
+  subject { object.inverse }
+
+  it { should eql(described_class.new(:inverse, :forward)) }
+
+  it_should_behave_like 'an #inverse method'
+end
+

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

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

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Forward::Evaluator, '#output' do
+  let(:object) { described_class.new(context, input) }
+
+  let(:context) { mock('Context', :operand => operand)           }
+  let(:operand) { Ducktrap::Node::Static.new(:forward, :inverse) }
+  let(:input)   { mock('Input')                                  }
+
+  subject { object.output }
+
+  it { should eql(:forward) }
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Forward, '#inverse' do
+  let(:object) { described_class.new(operand) }
+
+  let(:operand) { Ducktrap::Node::Static.new(:foo, :bar) }
+
+  subject { object.inverse }
+
+  it { should eql(Ducktrap::Node::Inverse.new(operand)) }
+
+  it_should_behave_like 'an #inverse method'
+end
+

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Forward, '#pretty_inspect' do
+  let(:object)    { described_class.new(operand) }
+  let(:primitive) { String }
+
+  let(:operand) { Ducktrap::Node::Noop.instance }
+  let(:key)     { :key                          }
+
+  subject { object.pretty_inspect }
+
+  it 'should return inspected error' do
+    should eql(strip(<<-STR))
+      Ducktrap::Node::Forward
+        operand:
+          Ducktrap::Node::Noop
+    STR
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::GuardNil, '#call' do
+  subject { object.call(input) }
+
+  let(:object)  { described_class.new(operand) }
+
+  let(:operand) { Ducktrap::Node::Noop.instance }
+
+  context 'with nil input' do
+    let(:input)       { nil }
+    its(:output)      { should be(nil) }
+    its(:successful?) { should be(true) }
+  end
+
+  context 'with non nil input' do
+    let(:input)       { :input           }
+    its(:output)      { should be(input) }
+    its(:successful?) { should be(true)  }
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::GuardNil::Evaluator, '#output' do
+  let(:object) { described_class.new(context, input) }
+
+  let(:context) { mock('Context', :operand => operand) }
+
+  subject { object.output }
+
+  context 'when input is nil' do
+    let(:operand) { mock('Operand') }
+    let(:input)   { nil             }
+
+    it { should be(nil) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'when input is not nil' do
+    let(:operand) { Ducktrap::Node::Noop.instance   }
+    let(:input)   { mock('Input', :frozen? => true) }
+
+    it { should be(input) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::GuardNil, '#inverse' do
+  subject { object.inverse }
+
+  let(:object)  { described_class.new(operand)           }
+  let(:operand) { Ducktrap::Node::Static.new(:foo, :bar) }
+
+  it { should eql(described_class.new(operand.inverse)) }
+
+  it_should_behave_like 'an #inverse method'
+end

data/spec/unit/ducktrap/node/hash/transform/evaluator/output_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Hash::Transform::Evaluator, '#output' do
+  let(:object) { described_class.new(context, input) }
+
+  let(:context) { mock('Context', :body => body) }
+
+  let(:noop) { Ducktrap::Node::Noop.instance }
+
+  subject { object.output }
+
+  context 'with empty body' do
+    let(:body) { [] }
+    let(:input) { {} }
+
+    it { should eql({}) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'with filled body' do
+
+    context 'without errors' do
+      let(:body) do
+        [
+          Ducktrap::Node::Key::Fetch.new(Ducktrap::Node::Key::Dump.new(noop, :foo), 'foo')
+        ]
+      end
+
+      let(:input) { { 'foo' => :bar } }
+
+      it { should eql(:foo => :bar) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
+    context 'with error' do
+      let(:body) do
+        [
+          Ducktrap::Node::Key::Fetch.new(Ducktrap::Node::Invalid.instance, :foo)
+        ]
+      end
+
+      let(:input) { { 'foo' => :bar } }
+
+      it { should eql(Ducktrap::Error.new(body.first.call(input), input)) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+  end
+end

data/spec/unit/ducktrap/node/hash/transform/inverse_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Hash::Transform, '#inverse' do
+  let(:object) { described_class.new(body) }
+
+  let(:noop) { Ducktrap::Node::Noop.instance }
+
+  let(:body) do
+    [
+      Ducktrap::Node::Key::Fetch.new(noop, :foo),
+      Ducktrap::Node::Key::Fetch.new(noop, :bar)
+    ]
+  end
+
+  let(:inverse_body) do
+    [
+      Ducktrap::Node::Key::Dump.new(noop, :foo),
+      Ducktrap::Node::Key::Dump.new(noop, :bar)
+    ]
+  end
+
+  subject { object.inverse }
+
+  it { should eql(Ducktrap::Node::Hash::Transform.new(inverse_body)) }
+
+  it_should_behave_like 'an #inverse method'
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Invalid, '#call' do
+  let(:object) { described_class.instance }
+
+  let(:value)         { mock('Value')         }
+  let(:inverse_value) { mock('Inverse Value') }
+  let(:input)         { mock('Input')         }
+
+  subject { object.call(input) }
+
+  it { should eql(Ducktrap::Evaluator::Invalid.new(object, input)) }
+end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Invalid, '#inverse' do
+  let(:object) { described_class.instance }
+
+  subject { object.inverse }
+
+  it { should eql(object) }
+
+  it_should_behave_like 'an #inverse method'
+end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Inverse, '#call' do
+  let(:object)  { described_class.new(operand)    }
+  let(:operand) { Ducktrap::Node::Noop.instance   }
+  let(:input)   { mock('Input', :frozen? => true) }
+
+  subject { object.call(input) }
+
+  it { should eql(Ducktrap::Evaluator::Noop.new(object, input)) }
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Inverse, '#inverse' do
+  let(:object) { described_class.new(operand) }
+
+  let(:operand) { Ducktrap::Node::Static.new(:foo, :bar) }
+
+  subject { object.inverse }
+
+  it { should eql(Ducktrap::Node::Forward.new(operand)) }
+
+  it_should_behave_like 'an #inverse method'
+end
+

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Inverse, '#pretty_inspect' do
+  let(:object)    { described_class.new(operand) }
+  let(:primitive) { String }
+
+  let(:operand) { Ducktrap::Node::Noop.instance }
+  let(:key)     { :key                          }
+
+  subject { object.pretty_inspect }
+
+  it 'should return inspected error' do
+    should eql(strip(<<-STR))
+      Ducktrap::Node::Inverse
+        operand:
+          Ducktrap::Node::Noop
+    STR
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key::Add, '#call' do
+  subject { object.call(input) }
+
+  let(:object)         { described_class.new(operand, key)                                       }
+  let(:key)            { mock('Key')                                                             }
+  let(:operand)        { mock('Operand', :call => operand_evaluator)                                 }
+  let(:operand_evaluator) { mock('Operand Evaluator', :output => operand_output, :successful? => true, :frozen? => true) }
+  let(:operand_output) { mock('Operand Output')                                                  }
+  let(:input)          { { :foo => :bar }.freeze }
+
+
+  its(:output)  { should eql(:foo => :bar, key => operand_output) }
+end

data/spec/unit/ducktrap/node/key/add/evaluator/call_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key::Add, '#call' do
+  subject { object.call(input) }
+
+  let(:object)         { described_class.new(operand, key)                                       }
+  let(:key)            { mock('Key')                                                             }
+  let(:operand)        { mock('Operand', :call => operand_evaluator)                                 }
+  let(:operand_evaluator) { mock('Operand Evaluator', :output => operand_output, :successful? => true, :frozen? => true) }
+  let(:operand_output) { mock('Operand Output')                                                  }
+  let(:input)          { { :foo => :bar }.freeze }
+
+
+  its(:output)  { should eql(:foo => :bar, key => operand_output) }
+end

data/spec/unit/ducktrap/node/key/add/inverse_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key::Add, '#inverse' do
+
+  subject { object.inverse }
+
+  let(:object)  { described_class.new(inverse, key) }
+  let(:key)     { mock('Key')                       }
+  let(:inverse) { mock('Inverse') }
+
+  it { should eql(Ducktrap::Node::Key::Delete.new(inverse, key)) }
+
+  it_should_behave_like 'an #inverse method'
+end