reduxco 1.0.0

data/spec/callable_table_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe Reduxco::Context::CallableTable do
+
+  let(:identity_dynref) { Reduxco::CallableRef.new(:identity) }
+  let(:identity_callable) { ->(c){c} }
+  let(:app_callable) { ->(c){c[:identity]} }
+
+  it 'should instantiate with an array of maps' do
+    table = Reduxco::Context::CallableTable.new( [{:identity => identity_callable}, {:app => app_callable}] )
+    table.should include(identity_dynref)
+    table.resolve(identity_dynref).should_not be_nil
+  end
+
+  it 'should instantiate with an array of arrays of arrays' do
+    table = Reduxco::Context::CallableTable.new( [[[:identity, identity_callable]], [[:app, app_callable]]] )
+    table.should include(identity_dynref)
+    table.resolve(identity_dynref).should_not be_nil
+  end
+
+  describe 'introspection' do
+
+    let(:example_callable) { ->(c){c} }
+
+    before(:each) do
+      map1 = {:moho => example_callable, :eve => example_callable}
+      map2 = {:eve => example_callable, :kerbin => example_callable}
+      @table = Reduxco::Context::CallableTable.new([map1,map2])
+    end
+
+    it 'should introspect existence of static refs' do
+      @table.should include(Reduxco::CallableRef.new(:moho,1))
+      @table.should include(Reduxco::CallableRef.new(:eve,1))
+      @table.should include(Reduxco::CallableRef.new(:eve,2))
+      @table.should include(Reduxco::CallableRef.new(:kerbin,2))
+    end
+
+    it 'should introspect existence of dynamic refs' do
+      @table.should include(Reduxco::CallableRef.new(:moho))
+      @table.should include(Reduxco::CallableRef.new(:eve))
+      @table.should include(Reduxco::CallableRef.new(:kerbin))
+    end
+
+    it 'should introspect the non-existance of static refs' do
+      @table.should_not include(Reduxco::CallableRef.new(:duna,1))
+      @table.should_not include(Reduxco::CallableRef.new(:moho,2))
+    end
+
+    it 'should introspect the non-existance of dynamic refs' do
+      @table.should_not include(Reduxco::CallableRef.new(:duna))
+    end
+
+  end
+
+  describe 'resolution' do
+
+    before(:each) do
+      @map1 = {moho: ->(c){1}, eve: ->(c){2}, jool: ->(c){5}}
+      @map2 = {eve: ->(c){'second'}, kerbin: ->(c){3}}
+      @map3 = {jool: ->(c){'5th'}}
+      @table = Reduxco::Context::CallableTable.new([@map1,@map2,@map3])
+    end
+
+    let(:context) {double('context')}
+
+    it 'should resolve top level static ref' do
+      @table.resolve(Reduxco::CallableRef.new(:moho,1)).tap do |callref, callable|
+        callref.should == Reduxco::CallableRef.new(:moho,1)
+        callable.call(context).should == 1
+      end
+    end
+
+    it 'should resolve a deeper level static ref' do
+      @table.resolve(Reduxco::CallableRef.new(:kerbin,2)).tap do |callref, callable|
+        callref.should == Reduxco::CallableRef.new(:kerbin,2)
+        callable.call(context).should == 3
+      end
+    end
+
+    it 'should resolve a static ref that shadows higher level one' do
+      @table.resolve(Reduxco::CallableRef.new(:eve,2)).tap do |callref, callable|
+        callref.should == Reduxco::CallableRef.new(:eve,2)
+        callable.call(context).should == 'second'
+      end
+    end
+
+    it 'should resolve a shadowed static ref' do
+      @table.resolve(Reduxco::CallableRef.new(:eve,1)).tap do |callref, callable|
+        callref.should == Reduxco::CallableRef.new(:eve,1)
+        callable.call(context).should == 2
+      end
+    end
+
+    it 'should resolve simple (non-shadowed) dynamic refs to correct level' do
+      @table.resolve(Reduxco::CallableRef.new(:moho)).tap do |callref, callable|
+        callref.should == Reduxco::CallableRef.new(:moho,1)
+        callable.call(context).should == 1
+      end
+
+      @table.resolve(Reduxco::CallableRef.new(:kerbin)).tap do |callref, callable|
+        callref.should == Reduxco::CallableRef.new(:kerbin,2)
+        callable.call(context).should == 3
+      end
+    end
+
+    it 'should resolve a shadowed dynamic ref to the lowest level' do
+      @table.resolve(Reduxco::CallableRef.new(:eve)).tap do |callref, callable|
+        callref.should == Reduxco::CallableRef.new(:eve,2)
+        callable.call(context).should == 'second'
+      end
+    end
+
+
+    it 'should return a callable value of nil if a static ref cannot be resolved' do
+      @table.resolve(Reduxco::CallableRef.new(:eeloo, 1)).tap do |callref, callable|
+        callref.should be_nil
+        callable.should be_nil
+      end
+    end
+
+    it 'should return a callable value of nil if a dynamic ref cannot be resolved' do
+      @table.resolve(Reduxco::CallableRef.new(:eeloo)).tap do |callref, callable|
+        callref.should be_nil
+        callable.should be_nil
+      end
+    end
+
+    it 'should return RESOLUTION_FAILURE on resolution failure' do
+      @table.resolve(Reduxco::CallableRef.new(:eeloo, 1)).should == Reduxco::Context::CallableTable::RESOLUTION_FAILURE
+      @table.resolve(Reduxco::CallableRef.new(:eeloo)).should == Reduxco::Context::CallableTable::RESOLUTION_FAILURE
+    end
+
+    it 'should give nil values for multiple assignment of RESOLUTION_FAILURE' do
+      callref, callable = Reduxco::Context::CallableTable::RESOLUTION_FAILURE
+      callref.should be_nil
+      callable.should be_nil
+    end
+
+    it 'should use :[] as an alias to :resolve' do
+      @table.method(:[]).should == @table.method(:resolve)
+    end
+
+    describe 'super' do
+
+      it 'should resolve super for a static ref' do
+        @table.resolve_super(Reduxco::CallableRef.new(:eve,2)).tap do |callref, callable|
+          callref.should == Reduxco::CallableRef.new(:eve,1)
+          callable.call(context).should == 2
+        end
+      end
+
+      it 'should resolve super across depth gaps' do
+        @table.resolve_super(Reduxco::CallableRef.new(:jool,3)).tap do |callref, callable|
+          callref.should == Reduxco::CallableRef.new(:jool, 1)
+          callable.call(context).should == 5
+        end
+      end
+
+      it 'should return a callable value of nil if a super ref cannot be resolved' do
+        @table.resolve_super(Reduxco::CallableRef.new(:kerbin,2)).tap do |callref, callable|
+          callref.should be_nil
+          callable.should be_nil
+        end
+      end
+
+      it 'should raise an exception with a dynamic ref' do
+        ->{ @table.resolve_super(Reduxco::CallableRef.new(:moho)) }.should raise_error(ArgumentError)
+      end
+
+    end
+
+  end
+
+end

data/spec/callstack_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Reduxco::Context::Callstack do
+
+  before(:each) do
+    @stack = Reduxco::Context::Callstack.new([:top, :middle, :bottom])
+  end
+
+  it 'should return the depth' do
+    @stack.depth.should == 3
+  end
+
+  it 'should get the top frame' do
+    @stack.top.should == :top
+  end
+
+  it 'should initialize as empty' do
+    stack = Reduxco::Context::Callstack.new
+    stack.depth.should == 0
+  end
+
+  it 'should be able to initialize with an array, top elem first' do
+    @stack.depth.should == 3
+    @stack.top.should == :top
+  end
+
+  it 'should pop' do
+    frame = @stack.pop
+
+    @stack.depth.should == 2
+    frame.should == :top
+  end
+
+  it 'should push' do
+    s = @stack.push(:new_top)
+
+    @stack.depth.should == 4
+    @stack.top.should == :new_top
+
+    s.object_id.should == @stack.object_id
+  end
+
+  it 'should check for frame inclusion' do
+    @stack.should include(:middle)
+
+    @stack.should_not include(:eeloo)
+  end
+
+  it 'should return the rest of the stack' do
+    rest = @stack.rest
+
+    rest.depth.should == 2
+    rest.top.should == :middle
+
+    rest.should be_kind_of(@stack.class)
+  end
+
+  it 'should return a properly structured copy of the stack' do
+    dup = @stack.dup
+
+    dup.should be_kind_of(@stack.class)
+    dup.object_id.should_not == @stack.object_id
+
+    dup.top.should == @stack.top
+  end
+
+  it 'should not mutate the copy of the stack out from under it' do
+    dup = @stack.dup
+
+    @stack.push(:moho)
+    dup.should_not include(:moho)
+
+    dup.push(:eve)
+    @stack.should_not include(:eve)
+  end
+
+  describe 'conversion and formatting' do
+
+    let(:frame) do
+      double('frame').tap do |f|
+        f.stub(:to_s) {'frame-string'}
+        f.stub(:inspect) {'frame-inspect'}
+      end
+    end
+
+    it 'should output to_s with the top element first' do
+      str = @stack.to_s
+
+      str.index('top').should < str.index('bottom')
+    end
+
+    it 'should inspect with the top element first' do
+      str = @stack.inspect
+      str.index('top').should < str.index('bottom')
+    end
+
+    it 'should invoke inspect of frames when inspecting' do
+      @stack.push(frame)
+
+      frame.should_receive(:inspect)
+      str = @stack.inspect
+
+      str.should include('frame-inspect')
+    end
+
+    it 'should convert to a caller-style callstack' do
+      cs = @stack.to_caller
+
+      cs.each {|tr| tr.should be_kind_of(String)}
+      cs.first.should include('top')
+      cs.last.should include('bottom')
+    end
+
+    it 'should prepend a callstack line into the caller-style callstack, conterting it to string' do
+      top = Object.new
+      cs = @stack.to_caller(top)
+
+      cs.each {|tr| tr.should be_kind_of(String)}
+
+      head, *tail = cs
+
+      head.should == top.to_s
+      tail.should == @stack.to_caller
+    end
+
+  end
+
+end

data/spec/context_spec.rb

@@ -0,0 +1,619 @@
+require 'spec_helper'
+
+describe Reduxco::Context do
+
+  let(:add_map) do
+    {
+      sum: ->(c){ c[:a]+c[:b] },
+      a: ->(c){3},
+      b: ->(c){5}
+    }
+  end
+
+  let(:cyclical_map) do
+    {
+      a: ->(c){c[:b]},
+      b: ->(c){c[:c]},
+      c: ->(c){c[:a]}
+    }
+  end
+
+  let(:non_callable_map){ {moho:'foo'} }
+
+  let(:handler) do
+    {
+      handler: Proc.new do |c|
+        begin
+          c[:a]
+        rescue => e
+          [e, c.callstack]
+        end
+      end
+    }
+  end
+
+  describe 'call' do
+
+    it 'should alias :[] to call' do
+      context = Reduxco::Context.new
+      context.method(:[]).should == context.method(:call)
+    end
+
+    it 'should invoke the call method of the object it resolves to' do
+      callable = double('callable')
+      context = Reduxco::Context.new(:moho => callable)
+
+      callable.should_receive(:call).with(context)
+
+      context.call(:moho)
+    end
+
+    it 'should resolve a leaf refname to a value' do
+      context = Reduxco::Context.new(add_map)
+      context.call(:a).should == 3
+    end
+
+    it 'should resolve a refname with dependencies to a value via cascading calculation' do
+      context = Reduxco::Context.new(add_map)
+      context.call(:sum).should == 8
+    end
+
+    it 'should resolve a callref' do
+      context = Reduxco::Context.new(add_map)
+      context.call( Reduxco::CallableRef.new(:sum) ).should == 8
+    end
+
+    it 'should resolve a callref to a shadowed value' do
+      context = Reduxco::Context.new(add_map, {sum: ->(c){-101}})
+      context.call( Reduxco::CallableRef.new(:sum, 1) ).should == 8
+      context.call( Reduxco::CallableRef.new(:sum, 2) ).should == -101
+    end
+
+    it 'should cache the results' do
+      context = Reduxco::Context.new(app: ->(c){ Object.new })
+
+      generated_object = context.call(:app)
+      context.call(:app).should == generated_object
+    end
+
+    it 'should allow yielding to a block.' do
+      context = Reduxco::Context.new(
+        app: ->(c){ c.call(:outter){|x| x*x} },
+        outter: ->(c){ c.yield(3) + c.yield(4) }
+      )
+
+      context.call(:app).should == 25
+    end
+
+    describe 'errors' do
+
+      it 'should error if refname resolves to a non-callable' do
+        context = Reduxco::Context.new(non_callable_map)
+
+        ->{ context.call(:moho) }.should raise_error(Reduxco::Context::NotCallableError)
+
+        begin
+          context.call(:moho)
+        rescue => e
+          e.message.should include('moho')
+          e.backtrace.select {|tr| tr.include?('context.rb')}.should == []
+        end
+      end
+
+      it 'should error if refname is non-resolvable' do
+        context = Reduxco::Context.new(add_map)
+
+        ->{ context.call(:eeloo) }.should raise_error(Reduxco::Context::NameError)
+
+        begin
+          context.call(:eeloo)
+        rescue => e
+          e.message.should include('eeloo')
+          e.backtrace.select {|tr| tr =~ /context.rb.+`call'$/}.should == []
+        end
+
+      end
+
+      it 'should error on cyclical dependencies' do
+        context = Reduxco::Context.new(cyclical_map)
+
+        ->{ context.call(:a) }.should raise_error(Reduxco::Context::CyclicalError)
+
+        begin
+          context.call(:a)
+        rescue => e
+          e.message.should include('a:1')
+          e.message.should include('c:1')
+          e.backtrace.select {|tr| tr =~ /context.rb.+`call'$/}.should == []
+        end
+      end
+
+      it 'should not corrupt the callstack when catching a non-resolvalbe name error' do
+        context = Reduxco::Context.new({a:->(c){c[:eeloo]}}, handler)
+
+        error, stack = context.call(:handler)
+
+        stack.top.should == Reduxco::CallableRef.new(:handler, 2)
+        stack.depth.should == 1
+      end
+
+      it 'should not corrupt the callstack when catching a cyclical dependency' do
+        context = Reduxco::Context.new(cyclical_map, handler)
+
+        error, stack = context.call(:handler)
+
+        stack.top.should == Reduxco::CallableRef.new(:handler, 2)
+        stack.depth.should == 1
+      end
+
+    end
+
+  end
+
+  describe 'super' do
+
+    it 'should resolve to the next previous ref of the same name' do
+      context = Reduxco::Context.new({
+        moho: ->(c){ 'top' }
+      },
+      {
+        moho: ->(c){ c.super }
+      })
+
+      context.call(:moho).should == 'top'
+    end
+
+    it 'should chain calls and their results' do
+      context = Reduxco::Context.new({
+        moho: ->(c){ 1 }
+      },
+      {
+        moho: ->(c){ c.super + 2 }
+      },
+      {
+        eve: ->(c){ 1024 }
+      },
+      {
+        moho: ->(c){ c.super + 4 }
+      })
+
+      context.call(:moho).should == 7
+    end
+
+    it 'should throw a NameError if super cannot be resolved' do
+      context = Reduxco::Context.new({
+        eve: ->(c){ 'eve' }
+      },
+      {
+        moho: ->(c){ c.super }
+      })
+
+      ->{ context.call(:moho) }.should raise_error(Reduxco::Context::NameError)
+    end
+
+    it 'should allow super to recieve a block to yield to' do
+
+      context = Reduxco::Context.new({
+        moho: ->(c){ c.yield(3) }
+      },
+      {
+        moho: ->(c){ c.super {|x| x*x} }
+      })
+
+      context.call(:moho).should == 9
+    end
+
+
+    it 'should forward the yield block to super' do
+      context = Reduxco::Context.new({
+        moho: ->(c){ c.yield(3) }
+      },
+      {
+        moho: ->(c){ c.super },
+        app: ->(c){ c.call(:moho){|x| x*x } }
+      })
+
+      context.call(:app).should == 9
+    end
+
+  end
+
+  describe 'callstack interface' do
+
+    it 'should return a copy of the callstack' do
+      context = Reduxco::Context.new
+
+      context.callstack.should be_kind_of(Reduxco::Context::Callstack)
+      context.callstack.should.object_id.should_not == context.callstack
+    end
+
+    it 'should return a copy of the callstack from inside of a call' do
+      context = Reduxco::Context.new({
+        app: ->(c){ c.callstack }
+      })
+
+      stack = context.call(:app)
+
+      stack.depth.should == 1
+      stack.top.name.should == :app
+    end
+
+    it 'should return the current frame' do
+      context = Reduxco::Context.new({
+        app: ->(c){ c.current_frame.should == c.callstac.top }
+      })
+    end
+
+  end
+
+  describe 'introspection interface' do
+
+    let(:map1) do
+      {moho: ->(c){'moho-value'}, eve: ->(c){'eve-value'}}
+    end
+
+    let(:map2) do
+      {kerbin: ->(c){'kerbin-value'}, duna: ->(c){'duna-value'}, app: ->(c){c[:kerbin] + c[:moho]}}
+    end
+
+    let(:context) do
+      Reduxco::Context.new(map1, map2)
+    end
+
+    describe 'include' do
+
+      it 'should introspect which refnames are valid.' do
+        context.include?(:moho).should be_true
+        context.include?(:kerbin).should be_true
+
+        context.include?(:eeloo).should be_false
+      end
+
+      it 'should introspect which dynamic callrefs are valid.' do
+        context.include?( Reduxco::CallableRef.new(:moho) ).should be_true
+        context.include?( Reduxco::CallableRef.new(:kerbin) ).should be_true
+        context.include?( Reduxco::CallableRef.new(:eeloo) ).should be_false
+      end
+
+      it 'should introspect which static callrefs are valid.' do
+        context.include?( Reduxco::CallableRef.new(:moho,1) ).should be_true
+        context.include?( Reduxco::CallableRef.new(:kerbin,2) ).should be_true
+        context.include?( Reduxco::CallableRef.new(:moho,2) ).should be_false
+        context.include?( Reduxco::CallableRef.new(:kerbin,1) ).should be_false
+      end
+
+    end
+
+    describe 'completed' do
+
+      it 'should introspect which refnames have been computed.' do
+        [:moho, :eve, :kerbin, :duna, :app].each do |refname|
+          context.completed?(refname).should be_false
+        end
+
+        context.call(:app)
+
+        [:moho, :kerbin, :app].each do |refname|
+          context.completed?(refname).should be_true
+        end
+
+        [:eve, :duna].each do |refname|
+          context.completed?(refname).should be_false
+        end
+      end
+
+      it 'should introspect which callrefs have been computed.' do
+        all_ref_args = [[:kerbin,1], [:kerbin,2], [:moho,1], [:moho,2], [:duna,1], [:duna,2]]
+
+        all_ref_args.each do |name, depth|
+          callref = Reduxco::CallableRef.new(name, depth)
+          context.completed?(callref).should be_false
+        end
+
+        context.call(:app)
+
+        completed_ref_args = [[:kerbin,2], [:moho,1]]
+        incomplete_ref_args = all_ref_args - completed_ref_args
+
+        completed_ref_args.each do |name, depth|
+          callref = Reduxco::CallableRef.new(name, depth)
+          context.completed?(callref).should be_true
+        end
+
+        incomplete_ref_args.each do |name, depth|
+          callref = Reduxco::CallableRef.new(name, depth)
+          context.completed?(callref).should be_false
+        end
+      end
+
+      it 'should report not-found refs as uncomputed.' do
+        context.completed?(:eeloo).should be_false
+        context.completed?( Reduxco::CallableRef.new(:eloo,1) ).should be_false
+      end
+
+    end
+
+    describe 'assert_completed' do
+
+      it 'should raise an exception if failed' do
+        ->{ context.assert_completed(:app) }.should raise_error(Reduxco::Context::AssertError)
+      end
+
+      it 'should return nil if success' do
+        context[:app]
+
+        context.assert_completed(:app).should be_nil
+      end
+
+    end
+
+  end
+
+  describe 'initialization' do
+
+    let(:map1) { {moho: ->(c){'moho1'}} }
+    let(:map2) { {eve: ->(c){'eve2'}} }
+
+    it 'should initialize with a single callable map' do
+      context = Reduxco::Context.new(map1)
+      context.should include(:moho)
+    end
+
+    it 'should initialize with multiple callable maps' do
+      context = Reduxco::Context.new(map1, map2)
+      context.should include(:moho)
+      context.should include(:eve)
+    end
+
+    it 'should only invoke :each on the map (returning name/callable pairs)' do
+      map = double('map')
+      map.should_receive(:each)
+
+      Reduxco::Context.new(map)
+    end
+
+  end
+
+  describe 'duplication' do
+
+    it 'should instantiate a new Context with the same callables on dup' do
+      map1 = double('map1')
+      map1.stub(:each)
+      map2 = double('map2')
+      map2.stub(:each)
+      context = Reduxco::Context.new(map1, map2)
+
+      dup = context.dup
+
+      dup.instance_variables.each do |ivar|
+        dup.instance_variable_get(ivar).object_id.should_not == context.instance_variable_get(ivar)
+      end
+
+      dup.instance_variable_get(:@callable_maps).tap do |maps|
+        maps.should == [map1, map2]
+      end
+    end
+
+  end
+
+  describe 'reduce' do
+
+    it 'should reduce with a refname and return the result' do
+      context = Reduxco::Context.new(app: ->(c){'app-result'})
+
+      context.reduce(:app).should == 'app-result'
+    end
+
+    it 'should reduce with :app by default' do
+      context = Reduxco::Context.new(app: ->(c){'app-result'})
+
+      context.reduce(:app).should == 'app-result'
+    end
+
+  end
+
+  describe 'flow helpers' do
+
+    describe 'before' do
+
+      it 'should invoke the before helper block before calling the passed refname' do
+        call_order = []
+        context = Reduxco::Context.new({
+          app: ->(c){ c.before(:a) {c[:b]} },
+            a: ->(c){ call_order << :a },
+            b: ->(c){ call_order << :b }
+        })
+
+        context.call(:app)
+
+        call_order.should == [:b, :a]
+      end
+
+      it 'should return the value of the passed refname' do
+        context = Reduxco::Context.new({
+          app: ->(c){ c.before(:a) {c[:b]} },
+            a: ->(c){ 'a-result' },
+            b: ->(c){ 'b-result' }
+        })
+
+        context.call(:app).should == 'a-result'
+      end
+
+      it 'should not yield anything to the block' do
+        block_args = nil
+        context = Reduxco::Context.new({
+          app: Proc.new do |c|
+            c.before(:a) do |*args|
+              block_args = args
+              c[:b]
+            end
+          end,
+          a: ->(c){ 'a-result' },
+          b: ->(c){ 'b-result' }
+        })
+
+        context.call(:app)
+
+        block_args.should == []
+      end
+
+    end
+
+    describe 'after' do
+
+      it 'should invoke the after helper block after calling the passed refname' do
+        call_order = []
+        context = Reduxco::Context.new({
+          app: ->(c){ c.after(:a) {c[:b]} },
+            a: ->(c){ call_order << :a },
+            b: ->(c){ call_order << :b }
+        })
+
+        context.call(:app)
+
+        call_order.should == [:a, :b]
+      end
+
+      it 'should return the value of the passed refname' do
+        context = Reduxco::Context.new({
+          app: ->(c){ c.after(:a) {c[:b]} },
+            a: ->(c){ 'a-result' },
+            b: ->(c){ 'b-result' }
+        })
+
+        context.call(:app).should == 'a-result'
+      end
+
+      it 'should not yield anything' do
+        block_args = nil
+        context = Reduxco::Context.new({
+          app: Proc.new do |c|
+            c.after(:a) do |*args|
+              block_args = args
+              c[:b]
+            end
+          end,
+          a: ->(c){ 'a-result' },
+          b: ->(c){ 'b-result' }
+        })
+
+        context.call(:app)
+
+        block_args.should == []
+      end
+
+    end
+
+    describe 'inside' do
+
+      describe 'client behavior' do
+
+        let(:table){ {} }
+
+        let(:outter) do
+          Proc.new do |c|
+            table[:yeild_result] = c.yield('arg1', 'arg2')
+            'outter_result'
+          end
+        end
+
+        let(:app) do
+          Proc.new do |c|
+            table[:inside_method_result] = c.inside(:outter) do |*args|
+              table[:args] = args
+              'yield_result'
+            end
+            'app_result'
+          end
+        end
+
+        let(:map) do
+          {app:app, outter:outter}
+        end
+
+        let(:context) do
+          context = Reduxco::Context.new(map)
+        end
+
+        it 'should be an alias to call, as it is just call with a block provided.' do
+          context.method(:inside).should == context.method(:call)
+        end
+
+        it 'should return the block\'s value from inside the passed refname' do
+          context.call(:app)
+
+          table[:yeild_result].should == 'yield_result'
+        end
+
+        it 'should return the value of the passed refname' do
+          context.call(:app)
+
+
+          table[:inside_method_result].should == 'outter_result'
+        end
+
+        it 'should allow yielding of args to the block' do
+          context.call(:app)
+
+          table[:args].should == ['arg1', 'arg2']
+        end
+
+        it 'should allow taking no block' do
+          context = Reduxco::Context.new(app: ->(c){ c.inside(:moho) }, moho: ->(c){'moho-result'})
+
+          context.call(:app).should == 'moho-result'
+        end
+
+      end
+
+      describe 'yield failure modes' do
+
+        it 'should give nested insides their correct block handles' do
+          context = Reduxco::Context.new(
+            app: ->(c){ c.inside(:outter){ c.inside(:middle){ c[:inner] } } },
+            outter: ->(c){ c.yield << 'outter' },
+            middle: ->(c){ c.yield << 'middle' },
+            inner: ->(c){ ['inner'] }
+          )
+
+          context.call(:app).should == ['inner', 'middle', 'outter']
+        end
+
+        it 'should not corrupt the handle stack when an exception is thrown and then caught inside of nested insides' do
+          context = Reduxco::Context.new(
+            app: ->(c){ c.inside(:outter){ c.inside(:middle){ c.inside(:inner) {c[:leaf]} } } },
+            outter: ->(c){ c.yield << 'outter' },
+            middle: ->(c){ begin c.yield << 'middle' rescue ['middle-caught'] end },
+            inner: ->(c){ c.yield << 'inner' },
+            leaf: ->(c){ raise RuntimeError }
+          )
+
+          context.call(:app).should == ['middle-caught', 'outter']
+        end
+
+        it 'should not allow yielding from a nested call.' do
+          context = Reduxco::Context.new(
+            app: ->(c){ c.inside(:outter){ 2 } },
+            outter: ->(c){ c[:middle] },
+            middle: ->(c){ c.yield }
+          )
+
+          ->{ context.call(:app) }.should raise_error(Reduxco::Context::LocalJumpError)
+        end
+
+        it 'should allow a double yield.' do
+          context = Reduxco::Context.new(
+            app: ->(c){ c.inside(:outter){|x| x*x} },
+            outter: ->(c){ c.yield(3) + c.yield(4) }
+          )
+
+          context.call(:app).should == 25
+        end
+
+      end
+
+    end
+
+  end
+
+end