nudge 0.0.2 → 0.1.0

data/spec/instructions/code/code_execute_then_pop_spec.rb

@@ -0,0 +1,61 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeExecuteThenPopInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeExecuteThenPopInstruction.new(@context)
+  end
+    
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @context.enable(CodePopInstruction)
+      @i1 = CodeExecuteThenPopInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least one item on the :code stack" do
+        @context.enable(CodePopInstruction)
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+      
+      it "should need CodePopInstruction to be enabled" do
+        @context.disable(CodePopInstruction)
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        lambda{@i1.preconditions?}.should raise_error
+        @context.enable(CodePopInstruction)
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+      
+    end
+    
+    describe "\#cleanup" do
+      it "should push a new block based on the code from the top of the :code stack" do
+        @context.stacks[:code].push(ValuePoint.new("code", "do foo_bar"))
+        @i1.go
+        @context.stacks[:exec].peek.blueprint.should == "block {\n  do foo_bar\n  do code_pop}"
+        @context.stacks[:exec].peek.should be_a_kind_of(CodeblockPoint)
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref x}"))
+        @i1.go
+        @context.stacks[:exec].peek.blueprint.should == "block {\n  block {\n    ref x}\n  do code_pop}"
+        @context.stacks[:exec].peek.should be_a_kind_of(CodeblockPoint)
+      end
+      
+      it "push a block containing 'do code_pop' if the code point can't be parsed" do
+        @context.stacks[:code].push(ValuePoint.new("code", "whatever you say boss"))
+        @i1.go
+        @context.stacks[:exec].peek.blueprint.should == "block {\n  do code_pop}"
+      end
+    end
+  end
+end

data/spec/instructions/code/code_fromname_spec.rb

@@ -0,0 +1,37 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+describe CodeFromNameInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeFromNameInstruction.new(@context)
+    @context.clear_stacks
+  end
+  
+  it "should check that there are enough parameters" do
+    @context.stacks[:name].push(ReferencePoint.new("foo"))
+    @i1.preconditions?.should == true
+  end
+  
+  it "should raise an error if the preconditions aren't met" do
+    @context.clear_stacks # there are no params at all
+    lambda{@i1.preconditions?}.should raise_error(Instruction::NotEnoughStackItems)
+  end
+  
+  it "should successfully run #go only if all preconditions are met" do
+    @context.stacks[:name].push(ReferencePoint.new("foo"))
+    @i1.should_receive(:cleanup)
+    @i1.go
+  end
+  
+  it "should create and push the new (expected) value to the right place" do
+    @context.stacks[:name].push(ReferencePoint.new("foo"))
+    @i1.go
+    @context.stacks[:name].depth.should == 0
+    @context.stacks[:code].peek.value.should == "ref foo"
+  end
+end

data/spec/instructions/code/code_gsub_spec.rb

@@ -0,0 +1,112 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeGsubInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeGsubInstruction.new(@context)
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeGsubInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least three items on the :code stack" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:code].push(ValuePoint.new("code", "something"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b ref c}"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a_1 ref b_1 ref c_1}"))
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.clear_stacks
+      end
+      
+      it "should substitute the third item on the code stack for the second item in the first item" do
+        @context.stacks[:code].push(ValuePoint.new("code", "do x"))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref b"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b ref c}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  ref a\n  do x\n  ref c}"
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do x"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref c ref d}"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {do a do b block {ref c ref d}}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  do a\n  do b\n  do x}"
+      end
+      
+      it "should replace every occurrence in the tree" do
+        @context.stacks[:code].push(ValuePoint.new("code", "do x"))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref a"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a block {ref a} block { block {ref a}}}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should ==
+          "block {\n  do x\n  block {\n    do x}\n  block {\n    block {\n      do x}}}"
+      end
+      
+      it "should cause an :error if any of the strings can't be parsed" do
+        @context.stacks[:code].push(ValuePoint.new("code", "some junk"))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref a"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {}"))
+        @i1.go
+        @context.stacks[:error].peek.value.should == "code_gsub cannot work with unparseable code"
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "ref a"))
+        @context.stacks[:code].push(ValuePoint.new("code", "some junk"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {}"))
+        @i1.go
+        @context.stacks[:error].peek.value.should == "code_gsub cannot work with unparseable code"
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "ref a"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {}"))
+        @context.stacks[:code].push(ValuePoint.new("code", "some junk"))
+        @i1.go
+        @context.stacks[:error].peek.value.should == "code_gsub cannot work with unparseable code"
+      end
+      
+      it "should work with footnotes correctly" do
+        @context.stacks[:code].push(ValuePoint.new("code", "value «int»\n«int» 81"))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref g"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref g ref g}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should ==
+          "block {\n  value «int»\n  value «int»} \n«int» 81\n«int» 81"
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "value «int»\n«int» 81"))
+        @context.stacks[:code].push(ValuePoint.new("code", "value «foo»\n«foo» bar"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {value «foo»}\n«foo» bar"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  value «int»} \n«int» 81"
+      end
+      
+      it "should return the original code if the substitution isn't found" do
+        @context.stacks[:code].push(ValuePoint.new("code", "ref a"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do x"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  ref a\n  ref b}"
+      end
+      
+      it "should not recurse!" do
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a}"))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref a"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  block {\n    ref a}\n  ref b}"
+      end
+    end
+  end
+end

data/spec/instructions/code/code_if_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeIfInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeIfInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @context.reset
+      @context.enable(CodeIfInstruction)
+      @i1 = CodeIfInstruction.new(@context)
+      @v1 = ValuePoint.new("code", "do my_thing")
+      @v2 = ValuePoint.new("code", "ref some_x")
+    end
+
+    describe "\#preconditions?" do
+      it "should check that there are two items on the target stack and at least one :bool" do
+        @context.stacks[:code].push(@v1)
+        @context.stacks[:code].push(@v2)
+        @context.stacks[:bool].push(ValuePoint.new("bool", true))
+        @i1.preconditions?.should == true
+      end
+    end
+
+    describe "\#cleanup" do
+      it "should move the SECOND :code item to :exec if the :bool is true, otherwise the top one" do
+        @context.stacks[:code].push(@v1)
+        @context.stacks[:code].push(@v2)
+        @context.stacks[:bool].push(ValuePoint.new("bool", true))
+        @i1.go
+        @context.stacks[:exec].depth.should == 1
+        @context.stacks[:exec].peek.should be_a_kind_of(InstructionPoint)
+        @context.stacks[:code].depth.should == 0
+        
+        @context.stacks[:code].push(@v1)
+        @context.stacks[:code].push(@v2)
+        @context.stacks[:bool].push(ValuePoint.new("bool", false))
+        @i1.go
+        @context.stacks[:exec].peek.should be_a_kind_of(ReferencePoint)
+      end
+    end
+  end
+end
+

data/spec/instructions/code/code_instructions_spec.rb

@@ -0,0 +1,42 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeInstructionsInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeInstructionsInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeInstructionsInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "doesn't need any preconditions to be met, actually" do
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should push a block containing every active instruction" do
+        @context.disable_all_instructions
+        @context.enable(CodeInstructionsInstruction)
+        @context.enable(IntAddInstruction)
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block { do code_instructions do int_add}"
+        
+        @context.enable(ExecPopInstruction)
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block { do code_instructions do int_add do exec_pop}"
+      end
+    end
+  end
+end

data/spec/instructions/code/code_list_spec.rb

@@ -0,0 +1,49 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeListInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeListInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeListInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least one item on the :code stack" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:code].push(ValuePoint.new("code", "ref b"))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref a"))
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should push a new block containing the two :code items' code, in order" do
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_wha"))
+        @context.stacks[:code].push(ValuePoint.new("code", "ref huh"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  do int_wha\n  ref huh}"
+      end
+      
+      it "should work with footnotes correctly" do
+        @context.stacks[:code].push(ValuePoint.new("code", "value «foo»\n«foo» bar"))
+        @context.stacks[:code].push(ValuePoint.new("code",
+          "block{value «foo» value «bun»}\n«foo» baz\n«bun» qux"))
+        @i1.go
+        @context.stacks[:code].peek.value.should include("\n«foo» bar\n«foo» baz\n«bun» qux")
+      end
+    end
+  end
+end

data/spec/instructions/code/code_member_q_spec.rb

@@ -0,0 +1,77 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeMemberQInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeMemberQInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeMemberQInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least two items on the :code stack" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should check to see if the second :code value is inside the [backbone of] the top item" do
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {do int_multiply}"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == true
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {do something_else}"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == false
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref x do int_multiply}"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == true
+        
+      end
+      
+      it "should compare the two :code values for equality if the top one isn't a list" do
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == true
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do nothing"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == false
+      end
+      
+      it "should return false if either item isn't parseable" do
+        @context.stacks[:code].push(ValuePoint.new("code", "some crap"))
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == false
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "do int_multiply"))
+        @context.stacks[:code].push(ValuePoint.new("code", "some other crap"))
+        @i1.go
+        @context.stacks[:bool].peek.value.should == false
+        
+      end
+    end
+  end
+end

data/spec/instructions/code/code_name_lookup_spec.rb

@@ -0,0 +1,65 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeNameLookupInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeNameLookupInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeNameLookupInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least one item on the :name stack" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:name].push(ReferencePoint.new("a"))
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should get the top :name item & push its bound value onto the code stack as a new ValuePoint" do
+        @context.stacks[:name].push(ReferencePoint.new("foo"))
+        @context.names["foo"].should == nil
+        @context.bind_name("foo", ValuePoint.new("int",1987))
+        @context.names["foo"].blueprint.should == "value «int» \n«int» 1987"
+        @i1.go
+        @context.stacks[:code].depth.should == 1
+        @context.stacks[:code].peek.blueprint.should == "value «code» \n«code» value «int» \n«int» 1987"
+        @context.stacks[:name].depth.should == 0
+      end
+      
+      it "should work for bindings to other ProgramPoint subclasses" do
+        @context.stacks[:name].push(ReferencePoint.new("vja"))
+        @context.names["vja"].should == nil
+        @context.bind_name("vja", NudgeProgram.new("block {ref x do int_add block {ref y}}").linked_code)
+        @context.names["vja"].blueprint.should == "block {\n  ref x\n  do int_add\n  block {\n    ref y}}"
+        @i1.go
+        @context.stacks[:code].depth.should == 1
+        @context.stacks[:code].peek.blueprint.should ==
+          "value «code» \n«code» block {\n  ref x\n  do int_add\n  block {\n    ref y}}"
+        @context.stacks[:code].peek.should be_a_kind_of(ValuePoint)
+        @context.stacks[:name].depth.should == 0
+        
+      end
+      
+      it "should return an empty «code» ValuePoint if there is no binding" do
+        @context.stacks[:name].push(ReferencePoint.new("b2"))
+        @i1.go
+        @context.stacks[:code].depth.should == 1
+        @context.stacks[:code].peek.blueprint.should == "value «code» \n«code»"
+      end
+    end
+  end
+end

data/spec/instructions/code/code_noop_spec.rb

@@ -0,0 +1,38 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+describe CodeNoopInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeNoopInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeNoopInstruction.new(@context)
+    end
+
+    describe "\#preconditions?" do
+      it "should not need any items on any stacks" do
+        @i1.preconditions?.should == true
+      end
+    end
+
+    describe "\#cleanup" do
+      it "should change nothing about the interpreter except the step count" do
+        @context = Interpreter.new(program:"do code_noop")
+        @context.enable(CodeNoopInstruction)
+        earlier = @context.steps
+        @context.run
+        @context.steps.should == (earlier+1)
+        @context.stacks.each {|k,v| v.depth.should == 0}
+      end
+    end
+  end
+end

data/spec/instructions/code/code_nth_cdr_spec.rb

@@ -0,0 +1,77 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+describe CodeNthCdrInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeNthCdrInstruction.new(@context)
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeNthCdrInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least one item on the :code stack and one on :int" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:int].push(ValuePoint.new("int", 2))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b ref c}"))
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should return the code item with the first n backbone items removed (if 0 < n < length)" do
+        @context.stacks[:int].push(ValuePoint.new("int", 2))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b ref c}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  ref c}"
+        
+        @context.stacks[:int].push(ValuePoint.new("int", 1))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b ref c}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  ref b\n  ref c}"
+      end
+      
+      it "should take n % length of code backbone for other integer values" do
+        @context.stacks[:int].push(ValuePoint.new("int", 11)) # => 2
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b ref c}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  ref c}"
+        
+        @context.stacks[:int].push(ValuePoint.new("int", -921232)) # => 2
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b ref c}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  ref c}"
+      end
+      
+      it "should return an empty codeblock unchanged" do
+        @context.stacks[:int].push(ValuePoint.new("int", 11)) # => 2
+        @context.stacks[:code].push(ValuePoint.new("code", "block {}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {}"
+      end
+      
+      it "should wrap a non-codeblock point and just return it" do
+        @context.stacks[:int].push(ValuePoint.new("int", 12))
+        @context.stacks[:code].push(ValuePoint.new("code", "do x1"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  do x1}"
+      end
+      
+      it "should not remove anything if the int % length == 0" do
+        @context.stacks[:int].push(ValuePoint.new("int", -921231)) # => 0
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b ref c}"))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  ref a\n  ref b\n  ref c}"
+      end
+    end
+  end
+end

data/spec/instructions/code/code_nth_point_spec.rb

@@ -0,0 +1,67 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe CodeNthPointInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeNthPointInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = CodeNthPointInstruction.new(@context)
+    end
+    
+    describe "\#preconditions?" do
+      it "should need at least one item on the :int stack and :code stacks" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error
+        @context.stacks[:int].push(ValuePoint.new("int", 2))
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a ref b ref c}"))
+        lambda{@i1.preconditions?}.should_not raise_error
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a block {ref b ref c}}"))
+      end
+      
+      it "should get the Nth point of the top :code value" do
+        @context.stacks[:int].push(ValuePoint.new("int", 1))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  ref a\n  block {\n    ref b\n    ref c}}"
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a block {ref b ref c}}"))
+        @context.stacks[:int].push(ValuePoint.new("int", 2))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "ref a"
+        
+        @context.stacks[:code].push(ValuePoint.new("code", "block {ref a block {ref b ref c}}"))
+        @context.stacks[:int].push(ValuePoint.new("int", 4))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "ref b"
+        
+      end
+      
+      it "should use the top :int modulo the length of the backbone" do
+        @context.stacks[:int].push(ValuePoint.new("int", 12))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "ref a"        
+      end
+      
+      it "should work for negative values too" do
+        @context.stacks[:int].push(ValuePoint.new("int", -6612))
+        @i1.go
+        @context.stacks[:code].peek.value.should == "block {\n  ref b\n  ref c}"
+      end
+    end
+  end
+end