ducktrap 0.0.1

data/spec/unit/ducktrap/formatter/body_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Ducktrap::Formatter, '#body' do
+  let(:object) { described_class.new(output) }
+
+  let(:output) { StringIO.new }
+
+  subject { object.body(node) }
+
+  let(:node) { [Ducktrap::Node::Noop.instance, Ducktrap::Node::Noop.instance] }
+
+  it 'should print node with members' do
+    subject
+    output.rewind
+    output.read.should eql("  body:\n    Ducktrap::Node::Noop\n    Ducktrap::Node::Noop\n")
+  end
+
+  it_should_behave_like 'a command method'
+end

data/spec/unit/ducktrap/formatter/class_methods/new_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ducktrap::Formatter, '.new' do
+  subject { object.new(*arguments) }
+  let(:object) { described_class }
+
+  context 'with defaults' do
+    let(:arguments) { [] }
+    it 'should write to stderr' do
+      $stderr.should_receive(:puts).with('Class').and_return($stderr)
+      subject.name(described_class)
+    end
+  end
+end

data/spec/unit/ducktrap/formatter/initialize_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ducktrap::Formatter, '.new' do
+  subject { object.new(*arguments) }
+  let(:object) { described_class }
+
+  context 'with defaults' do
+    let(:arguments) { [] }
+    it 'should write to stderr' do
+      $stderr.should_receive(:puts).with('Class').and_return($stderr)
+      subject.name(described_class)
+    end
+  end
+end

data/spec/unit/ducktrap/formatter/name_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Ducktrap::Formatter, '#name' do
+  subject { object.name(target) }
+
+  let(:object) { described_class.new(io) }
+  let(:io)     { StringIO.new }
+
+  def output
+    io.rewind
+    io.read
+  end
+
+  before { subject }
+
+  let(:target) do
+    mock(:class => mock(:name => 'Target'))
+  end
+
+  it 'should print name of targets class' do
+    output.should eql("Target\n")
+  end
+
+  it_should_behave_like 'a command method'
+end

data/spec/unit/ducktrap/formatter/nest_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Ducktrap::Formatter, '#nest' do
+  subject { object.nest(label, nested) }
+
+  let(:label)  { 'the-label' }
+  let(:nested) { mock }
+
+  let(:object) { described_class.new(io) }
+  let(:io)     { StringIO.new            }
+
+  before do
+    nested.should_receive(:pretty_dump).with(indented).and_return(nested)
+  end
+
+  def output
+    io.rewind
+    io.read
+  end
+  
+  let(:string) { 'the-string' }
+
+  before { subject }
+
+  let(:indented) do
+    object.indent.indent
+  end
+
+  context 'unindented' do
+    it 'should write the string to io' do
+      output.should eql("  the-label:\n")
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+  context 'indented' do
+
+    let(:object) { super().indent }
+
+    it 'should write the indeted string to io' do
+      output.should eql("    the-label:\n")
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+end

data/spec/unit/ducktrap/formatter/puts_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Ducktrap::Formatter, '#puts' do
+  subject { object.puts(string) }
+
+  let(:object) { described_class.new(io) }
+  let(:io)     { StringIO.new }
+
+  def output
+    io.rewind
+    io.read
+  end
+  
+  let(:string) { 'the-string' }
+
+  before { subject }
+
+  context 'unindented' do
+    it 'should write the string to io' do
+      output.should eql("the-string\n")
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+  context 'indented' do
+    let(:object) { super().indent }
+
+    it 'should write the indeted string to io' do
+      output.should eql("  the-string\n")
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+end

data/spec/unit/ducktrap/mapper/builder/dumper_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Ducktrap::Mapper::Builder, '#dumper' do
+  subject do 
+    block = self.block
+    described_class.new(Ducktrap::Mapper) do |mapper|
+      mapper.dumper(&block).should be(mapper)
+    end
+  end
+
+  let(:block)  { dumper = self.dumper; proc { add(dumper) }           }
+  let(:dumper) { mock('Dumper', :inverse => loader, :frozen? => true) }
+  let(:loader) { mock('Loader')                                       }
+
+  its(:object) do 
+    loader = Ducktrap::Node::Block.new([self.loader])
+    dumper = Ducktrap::Node::Block.new([self.dumper])
+    should eql(Ducktrap::Mapper.new(loader, dumper))
+  end
+end

data/spec/unit/ducktrap/mapper/builder/loader_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Ducktrap::Mapper::Builder, '#loader' do
+  subject do 
+    block = self.block
+    described_class.new(Ducktrap::Mapper) do |mapper|
+      mapper.loader(&block).should be(mapper)
+    end
+  end
+
+  let(:block)  { loader = self.loader; proc { add(loader) } }
+  let(:loader) { mock('Loader', :inverse => dumper, :frozen? => true) }
+  let(:dumper) { mock('Dumper')                                       }
+
+  its(:object) do 
+    loader = Ducktrap::Node::Block.new([self.loader])
+    dumper = Ducktrap::Node::Block.new([self.dumper])
+    should eql(Ducktrap::Mapper.new(loader, dumper))
+  end
+end

data/spec/unit/ducktrap/mapper/builder/object_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Ducktrap::Mapper::Builder, '#object' do
+  let(:object) do
+    described_class.new(Ducktrap::Mapper, &block)
+  end
+
+  subject { object.object }
+
+  let(:loader) { mock('Loader', :frozen? => true) }
+  let(:dumper) { mock('Dumper', :frozen? => true) }
+
+  context 'with loader' do
+    let(:block) do
+      node = self.loader
+      proc do
+        loader do
+          add(node)
+        end
+      end
+    end
+
+    before do
+      loader.stub(:inverse => dumper)
+    end
+
+    specify do 
+      loader = Ducktrap::Node::Block.new([self.loader])
+      dumper = Ducktrap::Node::Block.new([self.dumper])
+      should eql(Ducktrap::Mapper.new(loader, dumper))
+    end
+  end
+
+  context 'with dumper' do
+    let(:block) do
+      node = self.dumper
+      proc do
+        dumper do
+          add(node)
+        end
+      end
+    end
+
+    before do
+      dumper.stub(:inverse => loader)
+    end
+
+    specify do 
+      loader = Ducktrap::Node::Block.new([self.loader])
+      dumper = Ducktrap::Node::Block.new([self.dumper])
+      should eql(Ducktrap::Mapper.new(loader, dumper))
+    end
+  end
+
+  context 'with loader and dumper' do
+    let(:block) do
+      dumper = self.dumper
+      loader = self.loader
+      proc do
+        dumper do
+          add(dumper)
+        end
+
+        loader do
+          add(loader)
+        end
+      end
+    end
+
+    before do
+      dumper.stub(:inverse => loader)
+      loader.stub(:inverse => dumper)
+    end
+
+    specify do 
+      loader = Ducktrap::Node::Block.new([self.loader])
+      dumper = Ducktrap::Node::Block.new([self.dumper])
+      should eql(Ducktrap::Mapper.new(loader, dumper))
+    end
+  end
+
+  context 'without loader or dumper' do
+    let(:block) do
+    end
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(RuntimeError, 'Did not specify loader or dumper or both')
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Ducktrap::Mapper do
+
+  let(:object) { described_class }
+  
+  subject { described_class.build(&block) }
+
+  let(:block)   { proc {}                            }
+  let(:builder) { mock('Builder', :object => mapper) }
+  let(:mapper)  { mock('Mapper')                     }
+
+  it 'should call Ducktrap::Mapper::Builder' do
+    Ducktrap::Mapper::Builder.should_receive(:new).with(described_class) do |&block|
+      block.should be(self.block)
+      builder
+    end
+    subject.should be(mapper)
+  end
+end

data/spec/unit/ducktrap/nary/builder/add_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Ducktrap::Nary::Builder, '#add' do
+  let(:object) { described_class.new(klass) }
+  let(:klass)  { Ducktrap::Node::Block      }
+
+  let(:node)  { Ducktrap::Node::Noop.instance }
+
+  subject { object.add(node) }
+
+  it 'should add node to body' do
+    expect { subject }.to change { object.body }.from([]).to([node])
+  end
+
+  it_should_behave_like 'a command method'
+end

data/spec/unit/ducktrap/nary/builder/method_missing_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Ducktrap::Nary::Builder, '#method_missing' do
+  let(:object) { described_class.new(klass)    }
+  let(:klass)  { Ducktrap::Node::Block         }
+
+  context 'known nullary DSL method' do
+    subject { object.noop }
+    it 'should add node to body' do
+      node = Ducktrap::Node::Noop.instance
+      expect { subject }.to change { object.body }.from([]).to([node])
+    end
+  end
+
+  context 'known unary DSL method' do
+    subject { object.guard_nil { noop } }
+    it 'should add node to body' do
+      node = Ducktrap::Node::GuardNil.new(
+        Ducktrap::Node::Block.new(
+          [Ducktrap::Node::Noop.instance]
+        )
+      )
+      expect { subject }.to change { object.body }.from([]).to([node])
+    end
+  end
+
+  context 'unknown DSL method' do
+    subject { object.unknown }
+
+    it 'should raise error' do
+      message = 
+        if Devtools.rbx? 
+          %q(undefined method `unknown' on an instance of Ducktrap::Nary::Builder.)
+        else
+          %q(undefined method `unknown' for #<Ducktrap::Nary::Builder klass=Ducktrap::Node::Block>)
+        end
+
+      expect { subject }.to raise_error(
+        NoMethodError, 
+        message
+      )
+    end
+  end
+end

data/spec/unit/ducktrap/nary/builder/output_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Ducktrap::Nary::Builder, '#output' do
+  let(:object) { described_class.new(klass)    }
+  let(:klass)  { Ducktrap::Node::Block         }
+  let(:node)   { Ducktrap::Node::Noop.instance }
+
+  subject { object.object }
+
+  it 'should add node to body' do
+    object.add(node)
+    should eql(Ducktrap::Node::Block.new([node]))
+  end
+
+  it_should_behave_like 'an idempotent method'
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Ducktrap::Nary::ClassMethods, '#build' do
+  let(:object) { Object.new.extend(described_class) }
+
+  subject { object.build(:foo, :bar, &block) }
+
+  let(:block) { proc {} }
+
+  let(:output) { mock('Output') }
+
+  it 'should delegate to nary builder' do
+    Ducktrap::Nary::Builder.should_receive(:new) do |first, second, third, &block|
+      first.should be(object)
+      second.should be(:foo)
+      third.should be(:bar)
+      block.should be(self.block)
+      mock(:object => output)
+    end
+    subject.should be(output)
+  end
+end

data/spec/unit/ducktrap/nary/class_methods/included_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Ducktrap::Nary, '.included' do
+  subject { described_class = self.described_class; Class.new { include described_class } }
+
+  its(:ancestors) { should include(Ducktrap::Nary::InstanceMethods) }
+  it              { should respond_to(:build) }
+
+  specify do
+    subject.new(:foo).should eql(subject.new(:foo))
+    subject.new(:foo).should_not eql(subject.new(:bar))
+  end
+end

data/spec/unit/ducktrap/nary/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