ducktrap 0.0.1

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/inverse_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'an #inverse method' do
+  it 'should round trip' do
+    object.inverse.inverse.should eql(object)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'ducktrap'
+require 'devtools'
+Devtools.init_spec_helper
+
+module StripHelper
+  def strip(string)
+    lines = string.lines
+    line = lines.first
+    match = /\A[ ]*/.match(line)
+    length = match[0].length
+    source = lines.map do |line|
+      line[(length..-1)]
+    end.join
+  end
+end
+
+RSpec.configure do |config|
+  config.extend(LetMockHelper)
+  config.include(StripHelper)
+end

data/spec/support/ice_nine_config.rb

@@ -0,0 +1,8 @@
+require 'ice_nine'
+
+module IceNine
+  class Freezer
+    class RSpec < NoFreeze
+    end
+  end
+end

data/spec/support/let_mock_helper.rb

@@ -0,0 +1,13 @@
+module LetMockHelper
+  def let_mock(name,&block)
+    let(name) do 
+      stubs =
+        if block
+          instance_exec(mock,&block) 
+        else
+          {}
+        end
+      mock(name.to_s.capitalize,stubs)
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Ducktrap::Builder, '.new' do
+  let(:object) { class_under_test }
+
+  let(:class_under_test) do
+    Class.new(described_class)
+  end
+
+  let(:klass) { mock('Class') }
+
+  subject { object.new(klass, &block) }
+
+  context 'when called with block argument' do
+    let(:yields) { [] }
+    let(:block) { proc { |argument| yields << argument } }
+
+    it { should eql(class_under_test.new(klass)) }
+
+    it 'should yield builder' do
+      subject
+      yields.should eql([subject])
+    end
+
+    its(:klass) { should be(klass) }
+  end
+
+  context 'when called with block argument' do
+    let(:selfs) { [] }
+    let(:block) { selfs = self.selfs; proc { selfs << self } }
+
+    it { should eql(class_under_test.new(klass)) }
+
+    it 'should execute block within builder' do
+      subject
+      selfs.should eql([subject])
+    end
+
+    its(:klass) { should be(klass) }
+  end
+end

data/spec/unit/ducktrap/builder/new_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Ducktrap::Builder, '.new' do
+  let(:object) { class_under_test }
+
+  let(:class_under_test) do
+    Class.new(described_class)
+  end
+
+  let(:klass) { mock('Class') }
+
+  subject { object.new(klass, &block) }
+
+  context 'when called with block argument' do
+    let(:yields) { [] }
+    let(:block) { proc { |argument| yields << argument } }
+
+    it { should eql(class_under_test.new(klass)) }
+
+    it 'should yield builder' do
+      subject
+      yields.should eql([subject])
+    end
+
+    its(:klass) { should be(klass) }
+  end
+
+  context 'when called with block argument' do
+    let(:selfs) { [] }
+    let(:block) { selfs = self.selfs; proc { selfs << self } }
+
+    it { should eql(class_under_test.new(klass)) }
+
+    it 'should execute block within builder' do
+      subject
+      selfs.should eql([subject])
+    end
+
+    its(:klass) { should be(klass) }
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Ducktrap, '.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/error/exception/pretty_inspect_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Ducktrap::Error::Exception, '#pretty_inspect' do
+  let(:object) { described_class.new(context, input, exception) }
+
+  let(:context)   { Ducktrap::Node::Noop.instance   }
+  let(:input)     { :input                          }
+  let(:exception) { RuntimeError.new('foo-message') }
+
+  subject { object.pretty_inspect }
+
+  it 'should return inspected error' do
+    should eql(strip(<<-STR))
+      Ducktrap::Error::Exception
+        input: :input
+        exception: RuntimeError
+        exception_message: "foo-message"
+        context:
+          Ducktrap::Node::Noop
+    STR
+  end
+end

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

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

data/spec/unit/ducktrap/evaluator/assert_successful_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Ducktrap::Evaluator, '#assert_successful' do
+  let(:object) { class_under_test.new(context, input) }
+  
+  let(:context) { Ducktrap::Node::Noop.instance }
+  let(:input)   { mock('Input')   }
+
+  subject { object.assert_successful }
+
+  context 'when process is not successful' do
+
+    let(:class_under_test) do
+      Class.new(described_class) do
+        def process
+          error
+        end
+      end
+    end
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(Ducktrap::FailedTransformationError)
+    end
+  end
+
+  context 'when process is successful' do
+
+    let(:class_under_test) do
+      Class.new(described_class) do
+        def process
+          :result
+        end
+      end
+    end
+
+    it { should be(object) }
+  end
+end

data/spec/unit/ducktrap/evaluator/invalid/output_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ducktrap::Evaluator::Invalid, '#output' do
+  let(:object) { described_class.new(context, input) }
+
+  let(:context) { mock('Context') }
+  let(:input)   { mock('Input')   }
+
+  subject { object.output }
+
+  it { should eql(Ducktrap::Error.new(context, input)) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/ducktrap/evaluator/noop/output_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ducktrap::Evaluator::Noop, '#output' do
+  let(:object) { described_class.new(context, input) }
+
+  subject { object.output }
+
+  let(:context) { mock('Context') }
+  let(:input)   { mock('Input') }
+
+  it { should be(input) }
+
+  it_should_behave_like 'an idempotent method'
+end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Ducktrap::Evaluator, '#output' do
+  let(:object) { class_under_test.new(context, input) }
+
+  subject { object.output }
+
+  let(:context) { mock('Context') }
+  let(:input)   { mock('Input') }
+
+  context 'when using nested error' do
+
+    let(:inner) { mock('Inner') }
+
+    let(:class_under_test) do
+      inner = self.inner
+      Class.new(described_class) do
+        define_method :process do
+          nested_error(inner)
+        end
+      end
+    end
+
+    let(:exception) do
+      RuntimeError.new('some-message')
+    end
+
+    it { should eql(Ducktrap::Error.new(inner, input)) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  context 'when using exception macro' do
+
+    let(:class_under_test) do
+      exception = self.exception
+      Class.new(described_class) do
+        define_method :process do
+          exception(exception)
+        end
+      end
+    end
+
+    let(:exception) do
+      RuntimeError.new('some-message')
+    end
+
+    it { should eql(Ducktrap::Error::Exception.new(context, input, exception)) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Ducktrap::Evaluator, '#pretty_inspect' do
+  let(:object)  { class_under_test.new(context, input) }
+  let(:context) { Ducktrap::Node::Noop.instance        }
+  let(:input)   { :input                               }
+
+  subject { object.pretty_inspect }
+
+  context 'successful' do 
+
+    let(:class_under_test) do
+      Class.new(described_class) do
+        def process
+          :output
+        end
+
+        def self.name
+          'TestEvaluator'
+        end
+      end
+    end
+
+    it 'should return inspected error' do
+      should eql(strip(<<-STR))
+        TestEvaluator
+          input: :input
+          output: :output
+          context:
+            Ducktrap::Node::Noop
+      STR
+    end
+  end
+
+  context 'error' do 
+
+    let(:class_under_test) do
+      Class.new(described_class) do
+        def process
+          error
+        end
+
+        def self.name
+          'TestEvaluator'
+        end
+      end
+    end
+
+    it 'should return inspected error' do
+      should eql(strip(<<-STR))
+        TestEvaluator
+          input: :input
+          error:
+            Ducktrap::Error
+              input: :input
+              context:
+                Ducktrap::Node::Noop
+          context:
+            Ducktrap::Node::Noop
+      STR
+    end
+  end
+end

data/spec/unit/ducktrap/evaluator/successful_predicate_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Ducktrap::Evaluator, '#successful?' do
+  let(:object) { class_under_test.new(context, input) }
+  
+  let(:context) { mock('Context') }
+  let(:input)   { mock('Input')   }
+
+  subject { object.successful? }
+
+  context 'when process is not successful' do
+
+    let(:class_under_test) do
+      Class.new(described_class) do
+        def process
+          error
+        end
+      end
+    end
+
+    it { should be(false) }
+  end
+
+  context 'when process is successful' do
+
+    let(:class_under_test) do
+      Class.new(described_class) do
+        def process
+          :result
+        end
+      end
+    end
+
+    it { should be(true) }
+  end
+end

data/spec/unit/ducktrap/failed_transformation_error/message_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Ducktrap::FailedTransformationError, '#message' do
+  subject { object.message }
+
+  let(:evaluator) { mock('Evaluator', :pretty_inspect => 'blah') }
+  let(:object) { described_class.new(evaluator)               }
+
+  it { should eql('blah') }
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Ducktrap::Formatter, '#attribute' do
+  subject { object.attribute(label, value) }
+
+  let(:object) { described_class.new(io) }
+  let(:io)     { StringIO.new }
+
+  def output
+    io.rewind
+    io.read
+  end
+
+  before { subject }
+
+  let(:label) { 'label' }
+  let(:value) { 'value' }
+
+  it 'should print indented labeled value' do
+    output.should eql(%Q(  label: "value"\n))
+  end
+
+  it_should_behave_like 'a command method'
+end