nudge 0.0.2 → 0.1.0

data/spec/instructions/code/code_stack_spec.rb

@@ -0,0 +1,386 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+theseInstructions = [
+  CodePopInstruction,
+  CodeSwapInstruction,
+  CodeDuplicateInstruction,
+  CodeRotateInstruction
+  ]
+  
+namesTheyNeed = {
+  CodePopInstruction => 1,
+  CodeSwapInstruction => 2,
+  CodeDuplicateInstruction => 1,
+  CodeRotateInstruction => 3
+  }
+  
+resultTuples = {
+  CodePopInstruction => {["block {}", "do int_add"]=>["block {}"]},
+  CodeSwapInstruction => {["block {}", "do int_add"]=>["do int_add", "block {}"]},
+  CodeDuplicateInstruction => {["block {}"] => ["block {}", "block {}"]},
+  CodeRotateInstruction => {["block {}", "do int_add", "sample int(2)"] => ["do int_add", "sample int(2)", "block {}"]}
+  }
+  
+    
+theseInstructions.each do |instName|
+  describe instName do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = instName.new(@context)
+    end
+    
+    it "should have its context right" do
+      @i1.context.should == @context
+    end
+    
+    [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
+      it "should respond to \##{methodName}" do
+        @i1 = instName.new(@context)
+        @i1.should respond_to(methodName)
+      end   
+    end
+    
+    describe "\#go" do
+      before(:each) do
+        @i1 = instName.new(@context)
+        @context.clear_stacks
+        @empty_block_code_value = ValuePoint.new("code", "block {}")
+      end
+    
+      describe "\#preconditions?" do
+        it "should check that there are enough parameters" do
+          8.times {@context.stacks[:code].push(@empty_block_code_value)}
+          @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
+          7.times {@context.stacks[:code].push(@empty_block_code_value)}
+          @i1.should_receive(:cleanup)
+          @i1.go
+        end
+      end
+      
+      describe "\#cleanup" do
+        describe "should restructure the stack" do
+          examples = resultTuples[instName]
+          examples.each do |inputs, finalStackState|
+            params = inputs.inspect
+            expected = finalStackState.inspect
+            it "should end up with #{expected} on the \:code stack, starting with #{params}" do
+              inputs.each {|i| @context.stacks[:code].push(ValuePoint.new("code",i))}
+              @i1.go
+              finalStackState.reverse.each {|i| @context.stacks[:code].pop.raw.should == i}
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+
+describe CodeDepthInstruction do
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeDepthInstruction.new(@context)
+  end
+  
+  it "should have its context set" do
+    @i1.context.should == @context
+  end
+  
+  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
+    it "should respond to \##{methodName}" do
+      @i1.should respond_to(methodName)
+    end   
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = CodeDepthInstruction.new(@context)
+      @context.clear_stacks
+      @empty_block_code_value = ValuePoint.new("code", "block {}")
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that the :int stack responds to #depth" do
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should count the items on the stack and push it onto the :int stack" do
+        @context.stacks[:int].depth.should == 0
+        @i1.go # there are no code literals
+        @context.stacks[:int].peek.value.should == 0
+        7.times {@context.stacks[:code].push @empty_block_code_value}
+        @i1.go
+        @context.stacks[:int].peek.value.should == 7
+      end
+    end
+  end
+end
+
+
+describe CodeFlushInstruction do
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeFlushInstruction.new(@context)
+  end
+  
+  it "should have its context set right" do
+    @i1.context.should == @context
+  end
+  
+  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
+    it "should respond to \##{methodName}" do
+      @i1.should respond_to(methodName)
+    end   
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = CodeFlushInstruction.new(@context)
+      @context.clear_stacks
+      @empty_block_code_value = ValuePoint.new("code", "block {}")
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that the :int stack responds to #depth" do
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should remove all items on the stack" do
+        11.times {@context.stacks[:code].push(@empty_block_code_value)}
+        @context.stacks[:code].depth.should == 11
+        @i1.go
+        @context.stacks[:code].depth.should == 0
+      end
+    end
+  end
+end
+
+
+describe CodeShoveInstruction do
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeShoveInstruction.new(@context)
+  end
+  
+  it "should check its context is set" do
+    @i1.context.should == @context
+  end
+  
+  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
+    it "should respond to \##{methodName}" do
+      @i1.should respond_to(methodName)
+    end   
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = CodeShoveInstruction.new(@context)
+      @context.clear_stacks
+      @empty_block_code_value = ValuePoint.new("code", "block {}")
+      
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there is one :int and at least one :code" do
+        @context.stacks[:int].push(ValuePoint.new("int", 4))
+        @context.stacks[:code].push(@empty_block_code_value)
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.clear_stacks
+        11.times {@context.stacks[:code].push(@empty_block_code_value)}
+        @context.stacks[:code].push(ValuePoint.new("code","do int_add")) # making it 12 deep
+      end
+      
+      it "should not move the top item if the integer is negative" do
+        @context.stacks[:int].push(ValuePoint.new("int", -99))
+        @i1.go
+        @context.stacks[:code].depth.should == 12
+        @context.stacks[:code].peek.value.should == "do int_add"
+      end
+      
+      it "should not move the top item if the integer is zero" do
+        @context.stacks[:int].push(ValuePoint.new("int", 0))
+        @i1.go
+        @context.stacks[:code].depth.should == 12
+        @context.stacks[:code].peek.value.should == "do int_add"
+      end
+      
+      it "should move the top item farther down if the value is less than the depth" do
+        @context.stacks[:int].push(ValuePoint.new("int", 1000))
+        @i1.go
+        @context.stacks[:code].depth.should == 12
+        @context.stacks[:code].entries[0].value.should == "do int_add"
+      end
+      
+      it "should move the top item to the bottom if the value is more than the depth" do
+        @context.stacks[:int].push(ValuePoint.new("int", 4))
+        @i1.go
+        @context.stacks[:code].depth.should == 12
+        @context.stacks[:code].entries[11].value.should == "block {}"
+        @context.stacks[:code].entries[7].value.should == "do int_add"
+      end
+    end
+  end
+end
+
+
+describe CodeYankInstruction do
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeYankInstruction.new(@context)
+  end
+  
+  it "should check its context is set" do
+    @i1.context.should == @context
+  end
+  
+  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
+    it "should respond to \##{methodName}" do
+      @i1.should respond_to(methodName)
+    end   
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = CodeYankInstruction.new(@context)
+      @context.clear_stacks
+      @int1 = ValuePoint.new("int", 3)
+      @empty_block_code_value = ValuePoint.new("code", "block {}")
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there is one :name and at least one :int" do
+        @context.stacks[:code].push(@empty_block_code_value)
+        @context.stacks[:int].push(@int1)
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.clear_stacks
+        (4..6).each {|i| @context.stacks[:code].push(ValuePoint.new("code","ref a_#{i}"))}
+      end
+      
+      it "should not change anything if the position integer is negative" do
+        @context.stacks[:int].push(ValuePoint.new("int", -99))
+        @i1.go
+        and_now = @context.stacks[:code].entries.collect {|i| i.value}
+        and_now.should == ["ref a_4", "ref a_5", "ref a_6"]
+      end
+      
+      it "should not change anything if the position integer is zero" do
+        @context.stacks[:int].push(ValuePoint.new("int", 0))
+        @i1.go
+        and_now = @context.stacks[:code].entries.collect {|i| i.value}
+        and_now.should == ["ref a_4", "ref a_5", "ref a_6"]
+      end
+      
+      it "should pull the last item on the stack to the top if the position is more than the stackdepth" do
+        @context.stacks[:int].push(ValuePoint.new("int", 1000))
+        @i1.go
+        and_now = @context.stacks[:code].entries.collect {|i| i.value}
+        and_now.should == ["ref a_5", "ref a_6", "ref a_4"]
+      end
+      
+      it "should yank the indicated item to the top of the stack, counting from the 'top' 'down'" do
+        @context.stacks[:int].push(ValuePoint.new("int", 1))
+        @i1.go
+        and_now = @context.stacks[:code].entries.collect {|i| i.value}
+        and_now.should == ["ref a_4", "ref a_6", "ref a_5"]
+      end
+    end
+  end
+end
+
+
+describe CodeYankdupInstruction do
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = CodeYankdupInstruction.new(@context)
+  end
+  
+  it "should check its context is set" do
+    @i1.context.should == @context
+  end
+  
+  [:preconditions?, :setup, :derive, :cleanup].each do |methodName|
+    it "should respond to \##{methodName}" do
+      @i1.should respond_to(methodName)
+    end   
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = CodeYankdupInstruction.new(@context)
+      @context.clear_stacks
+      @int1 = ValuePoint.new("int", 3)
+      @empty_block_code_value = ValuePoint.new("code", "block {}")
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there is one :int and at least one :code" do
+        @context.stacks[:code].push(@empty_block_code_value)
+        @context.stacks[:int].push(@int1)
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.clear_stacks
+        (1..5).each {|i| @context.stacks[:code].push(ValuePoint.new("int", i))}
+      end
+      
+      it "should duplicate the top item if the position integer is negative" do
+        @context.stacks[:int].push(ValuePoint.new("int", -99))
+        @i1.go
+        and_now = @context.stacks[:code].entries.collect {|i| i.value}
+        and_now.should == [1,2,3,4,5, 5]
+      end
+      
+      it "should duplicate the top item if the position integer is zero" do
+        @context.stacks[:int].push(ValuePoint.new("int", 0))
+        @i1.go
+        and_now = @context.stacks[:code].entries.collect {|i| i.value}
+        and_now.should == [1,2,3,4,5, 5]
+      end
+      
+      it "should clone the bottom item and push it if the position is more than the stackdepth" do
+        @context.stacks[:int].push(ValuePoint.new("int", 1000))
+        @i1.go
+        and_now = @context.stacks[:code].entries.collect {|i| i.value}
+        and_now.should == [1,2,3,4,5, 1]
+      end
+      
+      it "should push a copy of the indicated item to the top of the stack, counting from the 'top down'" do
+        @context.stacks[:int].push(ValuePoint.new("int", 2))
+        @i1.go
+        and_now = @context.stacks[:code].entries.collect {|i| i.value}
+        and_now.should == [1,2,3,4,5, 3]
+        
+        @context.stacks[:int].push(ValuePoint.new("int", 4))
+        @i1.go
+        and_now = @context.stacks[:code].entries.collect {|i| i.value}
+        and_now.should == [1,2,3,4,5, 3,2]
+      end
+    end
+  end
+end

data/spec/instructions/exec/exec_define_spec.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe ExecDefineInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = ExecDefineInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = ExecDefineInstruction.new(@context)
+      @context.clear_stacks
+      @name1 = ReferencePoint.new("xyz")
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there is one :name and one :exec item" do
+        @context.stacks[:name].push(@name1)
+        @context.stacks[:exec].push(CodeblockPoint.new([]))
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.clear_stacks
+        @context.reset_names
+      end
+      
+      it "should bind the top :exec item to the top :name" do
+        @context.stacks[:name].push(@name1)
+        @context.stacks[:exec].push(CodeblockPoint.new([]))
+        @i1.go
+        @context.stacks[:name].depth.should == 0
+        @context.stacks[:exec].depth.should == 0
+        @context.names.length.should_not == 0        
+        @context.names["xyz"].blueprint.should == "block {}"
+        @context.names["xyz"].should be_a_kind_of(CodeblockPoint)
+        
+      end
+      
+      it "should overwrite the binding if it already exists" do
+        @context.bind_name("xyz", ValuePoint.new("int", 999))
+        @context.names["xyz"].value.should == 999
+        
+        @context.stacks[:name].push(@name1)
+        @context.stacks[:exec].push(ValuePoint.new("int", 22))
+        @i1.go
+        @context.stacks[:name].depth.should == 0
+        @context.stacks[:exec].depth.should == 0
+        @context.names.length.should_not == 0        
+        @context.names["xyz"].value.should == 22
+      end
+      
+      it "should not re-bind a name that is a variable, though" do
+        @context.bind_variable("xyz", ValuePoint.new("bool", false))
+        @context.stacks[:exec].push(ValuePoint.new("int", 456))
+        @context.stacks[:name].push(ReferencePoint.new("xyz"))
+        @i1.go
+        @context.stacks[:error].depth.should == 1
+      end
+    end
+  end
+end

data/spec/instructions/exec/exec_depth_spec.rb

@@ -0,0 +1,39 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe ExecDepthInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = ExecDepthInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = ExecDepthInstruction.new(@context)
+      @context.reset("block{value «bool» value «int» block {}}\n«bool»false\n«int»88")
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that the :bool stack responds to #depth" do
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      it "should count the items on the stack and push it onto the :int stack" do
+        @context.stacks[:int].depth.should == 0
+        @i1.go
+        @context.stacks[:int].peek.value.should == 1
+        @context.step # unpacking the three points onto :exec
+        @i1.go
+        @context.stacks[:int].peek.value.should == 3
+      end
+    end
+  end
+end

data/spec/instructions/exec/exec_do_count_spec.rb

@@ -0,0 +1,79 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+# EXEC.DO*COUNT: An iteration instruction that performs a loop (the body of which is taken from the EXEC stack) the number of times indicated by the INTEGER argument, pushing an index (which runs from zero to one less than the number of iterations) onto the INTEGER stack prior to each execution of the loop body. This is similar to CODE.DO*COUNT except that it takes its code argument from the EXEC stack. This should be implemented as a macro that expands into a call to EXEC.DO*RANGE. EXEC.DO*COUNT takes a single INTEGER argument (the number of times that the loop will be executed) and a single EXEC argument (the body of the loop). If the provided INTEGER argument is negative or zero then this becomes a NOOP. Otherwise it expands into: ( 0 <1 - IntegerArg> EXEC.DO*RANGE <ExecArg> )
+
+
+describe ExecDoCountInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = ExecDoCountInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = ExecDoCountInstruction.new(@context)
+      @context.reset("block {}")
+      @context.enable(ExecDoCountInstruction)
+      @context.enable(ExecDoRangeInstruction)
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there are two :ints, 1+ :exec item, and knows ExecDoRangeInstruction" do
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 4))
+        @context.stacks[:exec].push(ReferencePoint.new("x"))
+        @i1.preconditions?.should == true
+      end
+      
+      it "should check that the @context knows about exec_do_range" do
+        @context.disable(ExecDoRangeInstruction)
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        lambda{@i1.go}.should_not raise_error
+        @context.stacks[:error].peek.blueprint.should include(
+          "ExecDoCountInstruction needs ExecDoRangeInstruction")
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.reset("block {}")
+        @context.enable(ExecDoRangeInstruction)
+      end
+      
+      it "should create an :error entry if the int is negative or zero" do
+        @context.stacks[:int].push(ValuePoint.new("int", -213))
+        @i1.go
+        @context.stacks[:exec].depth.should == 0
+        
+        @context.reset("block {}")
+        @context.stacks[:int].push(ValuePoint.new("int", 0))
+        @i1.go
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 0
+      end
+      
+      it "should push a 0 onto :int, and an exec_do_range block onto :exec" do
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @i1.go
+        
+        @context.stacks[:int].depth.should == 0
+        @context.stacks[:exec].depth.should == 1
+        @context.stacks[:exec].entries[0].blueprint_parts.should ==
+          ["block {\n  value «int»\n  value «int»\n  do exec_do_range\n  block {}}",
+            "«int» 0\n«int» 2"]
+            
+        @context.run
+        @context.stacks[:int].depth.should == 3
+        @context.stacks[:exec].depth.should == 0
+      end
+    end
+  end
+end

data/spec/instructions/exec/exec_do_range_spec.rb

@@ -0,0 +1,98 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe ExecDoRangeInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = ExecDoRangeInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = ExecDoRangeInstruction.new(@context)
+      @context.reset("block {}")
+      @context.enable(ExecDoRangeInstruction)
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there are two :ints and at least one :exec item" do
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.reset("block {}")
+      end
+      
+      it "should finish if the :ints are identical, pushing an :int and a copy of the codeblock" do
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @i1.go
+        @context.stacks[:int].depth.should == 1
+        @context.stacks[:int].peek.value.should == 3
+        @context.stacks[:exec].depth.should == 1
+        @context.stacks[:exec].peek.tidy.should == "block {}"
+      end
+      
+      it "should increment the counter if the counter < destination, and push a bunch of stuff" do
+        @context.stacks[:int].push(ValuePoint.new("int", 1))
+        @context.stacks[:int].push(ValuePoint.new("int", 3))
+        @i1.go
+        
+        @context.stacks[:int].depth.should == 1
+        @context.stacks[:int].peek.value.should == 1
+        @context.stacks[:exec].depth.should == 2
+        @context.stacks[:exec].entries[1].blueprint_parts.should == ["block {}",""]
+        @context.stacks[:exec].entries[0].blueprint_parts.should == ["block {\n  value «int»\n  value «int»\n  do exec_do_range\n  block {}}","«int» 2\n«int» 3"]
+        
+        5.times {@context.step} # block {}; unwrap; push counter; push dest; run exec_do_range
+        
+        @context.stacks[:int].depth.should == 2
+        @context.stacks[:int].peek.value.should == 2
+        
+        @context.stacks[:exec].depth.should == 2
+        @context.stacks[:exec].entries[1].blueprint_parts.should == ["block {}",""]
+        @context.stacks[:exec].entries[0].blueprint_parts.should == ["block {\n  value «int»\n  value «int»\n  do exec_do_range\n  block {}}","«int» 3\n«int» 3"]
+      end
+      
+      it "should decrement the counter if the counter > destination, and push a bunch of stuff" do
+        @context.stacks[:int].push(ValuePoint.new("int", -2))
+        @context.stacks[:int].push(ValuePoint.new("int", -19))
+        @i1.go
+        
+        @context.stacks[:int].depth.should == 1
+        @context.stacks[:int].peek.value.should == -2
+        @context.stacks[:exec].depth.should == 2
+        @context.stacks[:exec].entries[1].blueprint_parts.should == ["block {}",""]
+        @context.stacks[:exec].entries[0].blueprint_parts.should == ["block {\n  value «int»\n  value «int»\n  do exec_do_range\n  block {}}","«int» -3\n«int» -19"]
+        
+        5.times {@context.step} # block {}; unwrap; push counter; push dest; run exec_do_range
+        
+        @context.stacks[:int].depth.should == 2
+        @context.stacks[:int].peek.value.should == -3
+        
+        @context.stacks[:exec].depth.should == 2
+        @context.stacks[:exec].entries[1].blueprint_parts.should == ["block {}",""]
+        @context.stacks[:exec].entries[0].blueprint_parts.should == ["block {\n  value «int»\n  value «int»\n  do exec_do_range\n  block {}}","«int» -4\n«int» -19"]
+      end
+      
+      it "should 'continue' until counter and destination are the same value" do
+        @context.stacks[:int].push(ValuePoint.new("int", 1))
+        @context.stacks[:int].push(ValuePoint.new("int", 100))
+        @i1.go
+        @context.run # finish it off
+        @context.stacks[:int].depth.should == 100
+        @context.stacks[:exec].depth.should == 0
+      end
+    end
+  end
+end