ducktrap 0.0.1

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key::Delete, '#call' do
+  subject { object.call(input) }
+
+  let(:object)  { described_class.new(inverse, key) }
+  let(:key)     { mock('Key')                       }
+
+  let(:input)   { { key => mock('Value') }.freeze }
+  let(:inverse) { mock('Inverse') }
+
+  its(:output)  { should eql({}) }
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key::Delete, '#call' do
+  subject { object.call(input) }
+
+  let(:object)  { described_class.new(inverse, key) }
+  let(:key)     { mock('Key')                       }
+
+  let(:input)   { { key => mock('Value') }.freeze }
+  let(:inverse) { mock('Inverse') }
+
+  its(:output)  { should eql({}) }
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key::Delete, '#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::Add.new(inverse, key)) }
+
+  it_should_behave_like 'an #inverse method'
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key::Dump::Evaluator, '#output' do
+
+  let(:object)  { described_class.new(context, input)               }
+  let(:context) { mock('Context', :operand => operand, :key => key) }
+  let(:operand) { Ducktrap::Node::Noop.instance }
+
+  subject { object.output }
+
+  let(:key)   { mock('Key', :frozen? => true)   }
+  let(:value) { mock('Value', :frozen? => true) }
+  
+  let(:input) { value }
+
+  context 'when operand does NOT modify value' do
+
+    it { should eql({ key => value}) }
+    it_should_behave_like 'an idempotent method'
+
+  end
+
+  context 'when operand does modify value' do
+    let(:operand) { Ducktrap::Node::Static.new(:forward, :inversE) }
+
+    it { should eql({ key => :forward}) }
+    it_should_behave_like 'an idempotent method'
+
+  end
+
+  context 'when operand fails' do
+
+    let(:operand) { Ducktrap::Node::Invalid.instance }
+
+    it { should eql(Ducktrap::Error.new(operand.call(value), input)) }
+  end
+end

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

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

data/spec/unit/ducktrap/node/key/evaluator/key_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key::Evaluator, '#output' do
+
+  subject { object.key }
+
+  let(:object) { class_under_test.new(context, input) }
+
+  let(:class_under_test) do
+    Class.new(described_class) do
+      public :key
+    end
+  end
+
+  let(:key)     { mock('Key') }
+  let(:value)   { mock('Value') }
+
+  let(:context) { mock('Context', :key => key, :operand => operand) }
+  let(:operand) { Ducktrap::Node::Static.new(:forward, :inverse)    }
+
+    let(:input)   { { key => value } }
+
+  it { should be(key) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/ducktrap/node/key/fetch/evaluator/output_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key::Fetch::Evaluator, '#output' do
+
+  let(:object)  { described_class.new(context, input)               }
+  let(:context) { mock('Context', :operand => operand, :key => key) }
+  let(:operand) { Ducktrap::Node::Noop.instance }
+
+  subject { object.output }
+
+  let(:key)   { mock('Key', :frozen? => true)   }
+  let(:value) { mock('Value', :frozen? => true) }
+
+
+  context 'when key is present' do
+    let(:input) { { key => value } }
+
+    context 'and operand does NOT modify value' do
+
+      it { should be(value) }
+      it_should_behave_like 'an idempotent method'
+
+    end
+
+    context 'and operand does modify value' do
+      let(:operand) { Ducktrap::Node::Static.new(:forward, :inversE) }
+
+      it { should be(:forward) }
+      it_should_behave_like 'an idempotent method'
+
+    end
+
+    context 'and operand fails' do
+
+      let(:operand) { Ducktrap::Node::Invalid.instance }
+
+      it { should eql(Ducktrap::Error.new(operand.call(value), input)) }
+    end
+  end
+
+  context 'when key is NOT present' do
+    let(:input) { {} }
+
+    it { should eql(Ducktrap::Error.new(context, input)) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Key, '#pretty_inspect' do
+  let(:object)    { described_class.new(operand, key) }
+  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::Key
+        key: :key
+        operand:
+          Ducktrap::Node::Noop
+    STR
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Map::Evaluator, '#output' do
+  let(:object) { described_class.new(context, input) }
+
+  let(:context) { mock('Context', :operand => operand) }
+  let(:input)   { [:foo, :bar ] }
+
+  subject { object.output }
+
+  context 'success' do
+    let(:operand) { Ducktrap::Node::Noop.instance }
+
+    it { should eql([:foo, :bar]) }
+  end
+
+  context 'error' do
+    let(:operand) { Ducktrap::Node::Invalid.instance }
+
+    it { should eql(Ducktrap::Error.new(operand.call(:foo), input)) }
+  end
+end

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

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

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

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

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Noop, '#inverse' do
+  let(:object) { described_class.instance }
+
+  subject { object.inverse }
+
+  it { should be(object) }
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Ducktrap::Node, '#pretty_inspect' do
+  let(:object) { class_under_test.new }
+
+  let(:class_under_test) do
+    Class.new(described_class) do
+      def self.name
+        'Test'
+      end
+    end
+  end
+
+  subject { object.pretty_inspect }
+
+  it { should eql("Test\n") }
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Primitive, '#call' do
+  let(:object) { described_class.new(primitive) }
+
+  let(:primitive) { String }
+
+  subject { object.call(input) }
+
+  context 'when input is kind of primitive' do
+    let(:input) { String.new }
+    it { should eql(Ducktrap::Evaluator::Noop.new(object, input)) }
+  end
+
+  context 'when input is NOT kind of primitive' do
+    let(:input) { [] }
+    it { should eql(Ducktrap::Evaluator::Invalid.new(object, input)) }
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Ducktrap::Node::Primitive, '#inverse' do
+  let(:object) { described_class.new(primitive) }
+
+  let(:primitive)     { mock('Primitive')     }
+
+  subject { object.inverse }
+
+  it { should be(object) }
+
+  it_should_behave_like 'an #inverse method'
+end

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

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

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Ducktrap::Node, '#run' do
+  subject { object.run(input) }
+
+  let(:object) { class_under_test.new }
+
+  let(:class_under_test) do
+    evaluator = self.evaluator
+    Class.new(described_class) do
+      define_method :call do |input|
+        evaluator
+      end
+    end
+  end
+
+  class Evaluator
+    attr_reader :output
+
+    def initialize(output, successful)
+      @output, @successful = output, successful
+    end
+
+    def assert_successful
+      raise unless @successful
+    end
+  end
+
+  let(:evaluator) { Evaluator.new(output, successful?) }
+  let(:input)  { mock('Input') }
+  let(:output) { mock('Output') }
+
+  context 'when evaluator is successful' do
+    let(:successful?) { true }
+
+    it { should be(output) }
+  end
+
+  context 'when evaluator is NOT successful' do
+    let(:successful?) { false }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Ducktrap::Nullary::ClassMethods, '#build' do
+  let(:object) do 
+    Class.new do 
+      include Equalizer.new(:arguments)
+      extend Ducktrap::Nullary::ClassMethods
+      attr_reader :arguments
+      def initialize(*arguments)
+        @arguments = arguments
+      end
+
+      def self.name
+        'Test'
+      end
+    end
+  end
+
+  subject { object.build(*arguments, &block) }
+
+  context 'with arguments' do
+    let(:arguments) { [:foo, :bar] }
+    let(:block)     { nil          }
+
+    it { should eql(object.new(:foo, :bar)) }
+  end
+
+  context 'with block' do
+    let(:arguments) { [] }
+    let(:block)     { proc {} }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(RuntimeError, 'Test.build does not take a block')
+    end
+  end
+
+end