nudge 0.0.2 → 0.1.0

data/spec/instructions/float/float_yank_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe FloatYankInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = FloatYankInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = FloatYankInstruction.new(@context)
+      @context.clear_stacks
+      @int1 = ValuePoint.new("int", 3)
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there is one :float and at least one :int" do
+        @context.stacks[:float].push(ValuePoint.new("float", -99.99))
+        @context.stacks[:int].push(@int1)
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.clear_stacks
+        (1..3).each {|i| @context.stacks[:float].push(ValuePoint.new("float",i*0.5))}
+      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[:float].entries.collect {|i| i.value}
+        and_now.should == [0.5,1.0,1.5]
+      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[:float].entries.collect {|i| i.value}
+        and_now.should == [0.5,1.0,1.5]
+      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[:float].entries.collect {|i| i.value}
+        and_now.should == [1.0,1.5, 0.5]
+      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[:float].entries.collect {|i| i.value}
+        and_now.should == [0.5,1.5, 1.0]
+      end
+    end
+  end
+end

data/spec/instructions/float/float_yankdup_spec.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe FloatYankdupInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = FloatYankdupInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = FloatYankdupInstruction.new(@context)
+      @context.clear_stacks
+      @int1 = ValuePoint.new("int", 3)
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there is one :int and at least one :float" do
+        @context.stacks[:float].push(ValuePoint.new("float", 1.1))
+        @context.stacks[:int].push(@int1)
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.clear_stacks
+        (1..3).each {|i| @context.stacks[:float].push(ValuePoint.new("float",i*1.0))}
+      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[:float].entries.collect {|i| i.value}
+        and_now.should == [1.0,2.0,3.0, 3.0]
+      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[:float].entries.collect {|i| i.value}
+        and_now.should == [1.0,2.0,3.0, 3.0]
+      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[:float].entries.collect {|i| i.value}
+        and_now.should == [1.0,2.0,3.0, 1.0]
+      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[:float].entries.collect {|i| i.value}
+        and_now.should == [1.0,2.0,3.0, 1.0]
+        
+        @context.stacks[:int].push(ValuePoint.new("int", 2))
+        @i1.go
+        and_now = @context.stacks[:float].entries.collect {|i| i.value}
+        and_now.should == [1.0,2.0,3.0, 1.0, 2.0]
+      end
+    end
+  end
+end

data/spec/instructions/instruction_class_spec.rb

@@ -1,9 +1,40 @@
 require File.join(File.dirname(__FILE__), "/../spec_helper")
 include Nudge
 
+
+class TestingInterdependencyInstruction < Instruction
+  def preconditions?
+    needs IntAddInstruction
+  end
+end
+
 describe "Instruction has a master list" do
   it "should have an #all_instructions [getter] method to return a list of every defined instruction" do
     # will be a list of every type subclassed from Instruction
     Instruction.all_instructions.should include(IntAddInstruction)
   end
+end
+
+describe "capturing errors" do
+  describe "NotEnoughStackItems" do
+    describe "#preconditions?" do
+      it "should push an :error ValuePoint onto the :error stacks when NotEnoughStackItems is raised" do
+        context = Interpreter.new
+        i1 = IntAddInstruction.new(context)
+        lambda{i1.go}.should_not raise_error
+        context.stacks[:error].peek.blueprint.should include "int too small"
+      end
+    end
+  end
+  
+  describe "MissingInstructionError" do
+    it "should push an error if missing interdependent Instruction is identified" do
+      context = Interpreter.new
+      context.disable(IntAddInstruction)
+      i1 = TestingInterdependencyInstruction.new(context)
+      lambda{i1.go}.should_not raise_error
+      context.stacks[:error].peek.blueprint.should include "needs IntAddInstruction"
+    end
+  end
+  
 end

data/spec/instructions/int/int_abs_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe IntAbsInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = IntAbsInstruction.new(@context)
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = IntAbsInstruction.new(@context)
+      @context.clear_stacks
+      @int1 = ValuePoint.new("int", 1)
+    end
+
+    describe "\#preconditions?" do
+      it "should check that there are enough parameters" do
+        10.times {@context.stacks[:int].push(@int1)}
+        @i1.preconditions?.should == true
+      end
+      
+      it "should raise an error if the preconditions aren't met" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error(Instruction::NotEnoughStackItems)
+      end
+      
+      it "should successfully run #go only if all preconditions are met" do
+        5.times {@context.stacks[:int].push(@int1)}
+        @i1.should_receive(:cleanup)
+        @i1.go
+      end
+    end
+    
+    describe "\#derive" do
+      it "should pop all the arguments" do
+        1.times {@context.stacks[:int].push(@int1)}
+        @i1.stub!(:cleanup) # and do nothing
+        @i1.go
+        @context.stacks[:int].depth.should == 0
+      end
+    end
+    
+    describe "\#cleanup" do
+      describe "should push the result" do
+        {[-3] => 3,[-0] => 0 }.each do |inputs, expected|
+          params = inputs.inspect
+          it "should produce #{expected} given #{params}" do
+            inputs.each {|i| @context.stacks[:int].push(ValuePoint.new("int", i))}
+            @i1.go
+            @context.stacks[:int].peek.value.should == expected
+          end
+        end
+      end
+    end
+  end
+end

data/spec/instructions/int/int_add_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+describe IntAddInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = IntAddInstruction.new(@context)
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = IntAddInstruction.new(@context)
+      @context.clear_stacks
+      @int1 = ValuePoint.new("int", 1)
+    end
+
+    describe "\#preconditions?" do
+      it "should check that there are enough parameters" do
+        10.times {@context.stacks[:int].push(@int1)}
+        @i1.preconditions?.should == true
+      end
+      
+      it "should raise an error if the preconditions aren't met" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error(Instruction::NotEnoughStackItems)
+      end
+      
+      it "should successfully run #go only if all preconditions are met" do
+        5.times {@context.stacks[:int].push(@int1)}
+        @i1.should_receive(:cleanup)
+        @i1.go
+      end
+    end
+    
+    describe "\#derive" do
+      it "should pop all the arguments" do
+        2.times {@context.stacks[:int].push(@int1)}
+        @i1.stub!(:cleanup) # and do nothing
+        @i1.go
+        @context.stacks[:int].depth.should == 0
+      end
+    end
+    
+    describe "\#cleanup" do
+      describe "should push the result" do
+        {[1,3] => 4, [-3,-4] => -7}.each do |inputs, expected|
+          params = inputs.inspect
+          it "should produce #{expected} given #{params}" do
+            inputs.each {|i| @context.stacks[:int].push(ValuePoint.new("int", i))}
+            @i1.go
+            @context.stacks[:int].peek.value.should == expected
+          end
+        end
+      end
+    end
+  end
+end

data/spec/instructions/int/int_define_spec.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+describe IntDefineInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = IntDefineInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = IntDefineInstruction.new(@context)
+      @context.clear_stacks
+      @name1 = ReferencePoint.new("xyz")
+    end
+    
+    describe "\#preconditions?" do
+      it "should check that there is one :name and one :int" do
+        @context.stacks[:name].push(@name1)
+        @context.stacks[:int].push(ValuePoint.new("int", 123))
+        @i1.preconditions?.should == true
+      end
+    end
+    
+    describe "\#cleanup" do
+      before(:each) do
+        @context.clear_stacks
+        @context.reset_names
+      end
+      
+      it "should bind the top :int to the top :name" do
+        @context.stacks[:name].push(@name1)
+        @context.stacks[:int].push(ValuePoint.new("int", 123))
+        @i1.go
+        @context.stacks[:name].depth.should == 0
+        @context.stacks[:int].depth.should == 0
+        @context.names.length.should_not == 0        
+        @context.names["xyz"].value.should == 123
+      end
+      
+      it "should overwrite the binding if it already exists" do
+        @context.bind_name("xyz", ValuePoint.new("bool", false))
+        @context.names["xyz"].value.should == false
+        
+        @context.stacks[:name].push(@name1)
+        @context.stacks[:int].push(ValuePoint.new("int", 123))
+        @i1.go
+        @context.stacks[:name].depth.should == 0
+        @context.stacks[:int].depth.should == 0
+        @context.names.length.should_not == 0        
+        @context.names["xyz"].value.should == 123
+      end
+      
+      it "should not re-bind a name that is a variable, though" do
+        @context.bind_variable("xyz", ValuePoint.new("bool", false))
+        @context.stacks[:int].push(ValuePoint.new("int", 456))
+        @context.stacks[:name].push(ReferencePoint.new("xyz"))
+        @i1.go
+        @context.stacks[:error].peek.blueprint.should include("cannot redefine a variable")
+      end
+      
+      it "should raise an exception if it's binding the name to anything but a ValuePoint" do
+        @context.stacks[:int].push(9912) #the actual number
+        @context.stacks[:name].push(@name1)
+        lambda{@i1.go}.should raise_error
+      end
+    end
+  end
+end

data/spec/instructions/int/int_depth_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe IntDepthInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = IntDepthInstruction.new(@context)
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = IntDepthInstruction.new(@context)
+      @context.clear_stacks
+      @int1 = ValuePoint.new("int", 1)
+    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" do
+        @i1.go
+        @context.stacks[:int].peek.value.should == 0
+        7.times {@context.stacks[:int].push @int1}
+        @i1.go
+        @context.stacks[:int].peek.value.should == 8
+      end
+    end
+  end
+end

data/spec/instructions/int/int_divide_spec.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe IntDivideInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = IntDivideInstruction.new(@context)
+  end
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = IntDivideInstruction.new(@context)
+      @context.clear_stacks
+      @int1 = ValuePoint.new("int", 1)
+    end
+
+    describe "\#preconditions?" do
+      it "should check that there are enough parameters" do
+        10.times {@context.stacks[:int].push(@int1)}
+        @i1.preconditions?.should == true
+      end
+      
+      it "should raise an error if the preconditions aren't met" do
+        @context.clear_stacks
+        lambda{@i1.preconditions?}.should raise_error(Instruction::NotEnoughStackItems)
+      end
+      
+      it "should successfully run #go only if all preconditions are met" do
+        5.times {@context.stacks[:int].push(@int1)}
+        @i1.should_receive(:cleanup)
+        @i1.go
+      end
+    end
+    
+    describe "\#derive" do
+      it "should pop all the arguments" do
+        2.times {@context.stacks[:int].push(@int1)}
+        @i1.stub!(:cleanup) # and do nothing
+        @i1.go
+        @context.stacks[:int].depth.should == 0
+      end
+      
+      it "should raise the right exceptions if it tries to divide by zero" do
+        @context.clear_stacks
+        @context.stacks[:int].push(ValuePoint.new("int", 10))
+        @context.stacks[:int].push(ValuePoint.new("int", 0))
+        @i1.go
+        @context.stacks[:error].depth.should == 1
+      end
+    end
+    
+    describe "\#cleanup" do
+      describe "should push the result" do
+        {[9,3] => 3, [3,9] => 0, [-9,-3] => 3}.each do |inputs, expected|
+          params = inputs.inspect
+          it "should produce #{expected} given #{params}" do
+            inputs.each {|i| @context.stacks[:int].push(ValuePoint.new("int", i))}
+            @i1.go
+            @context.stacks[:int].peek.value.should == expected
+          end
+        end
+      end
+    end
+  end
+end

data/spec/instructions/int/int_equal_q_spec.rb

@@ -0,0 +1,52 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+describe "IntEqualQInstruction" do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new    
+    @i1 = IntEqualQInstruction.new(@context)
+    @int1 = ValuePoint.new("int", 1)
+    @int2 = ValuePoint.new("int", 2)
+  end
+  
+  
+  it "should check that there are enough parameters" do
+    6.times {@context.stacks[:int].push(@int1)}
+    @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
+    5.times {@context.stacks[:int].push(@int1)}
+    @i1.should_receive(:cleanup)
+    @i1.go
+  end
+  
+  it "should pop all the arguments" do
+    @context.clear_stacks
+    5.times {@context.stacks[:int].push(@int1)}
+    @i1.stub!(:cleanup) # and do nothing
+    @i1.go
+    @context.stacks[:int].depth.should == 3
+  end
+  
+  it "should push the result" do
+    @context.clear_stacks
+    @context.stacks[:int].push(@int1)
+    @context.stacks[:int].push(@int1)
+    @context.stacks[:int].push(@int1)
+    @context.stacks[:int].push(@int2)
+    @i1.go
+    @context.stacks[:bool].peek.value.should == false
+    @i1.go
+    @context.stacks[:bool].peek.value.should == true
+  end
+end

data/spec/instructions/int/int_flush_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe IntFlushInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = IntFlushInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @i1 = IntFlushInstruction.new(@context)
+      @context.clear_stacks
+      @int1 = ValuePoint.new("int", 1)
+    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[:int].push(@int1)}
+        @context.stacks[:int].depth.should == 11
+        @i1.go
+        @context.stacks[:int].depth.should == 0
+      end
+    end
+  end
+end

data/spec/instructions/int/int_greater_than_q_spec.rb

@@ -0,0 +1,59 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+
+describe "IntGreaterThanQInstruction" do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = IntGreaterThanQInstruction.new(@context)
+    @int1 = ValuePoint.new("int", 1)
+    @int2 = ValuePoint.new("int", 2)
+  end
+  
+  
+  it "should check that there are enough parameters" do
+    6.times {@context.stacks[:int].push(@int1)}
+    @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
+    5.times {@context.stacks[:int].push(@int1)}
+    @i1.should_receive(:cleanup)
+    @i1.go
+  end
+  
+  it "should pop all the arguments" do
+    @context.clear_stacks
+    5.times {@context.stacks[:int].push(@int1)}
+    @i1.stub!(:cleanup) # and do nothing
+    @i1.go
+    @context.stacks[:int].depth.should == 3
+  end
+  
+  it "should push the result" do
+    @context.clear_stacks
+    @context.stacks[:int].push(@int1)
+    @context.stacks[:int].push(@int1)
+    @i1.go
+    @context.stacks[:bool].peek.value.should == false
+    
+    @context.stacks[:int].push(@int1)
+    @context.stacks[:int].push(@int2)
+    @i1.go
+    @context.stacks[:bool].peek.value.should == false
+    
+    @context.stacks[:int].push(@int2)
+    @context.stacks[:int].push(@int1)
+    @i1.go
+    @context.stacks[:bool].peek.value.should == true
+  end
+end

data/spec/instructions/int/int_if_spec.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+describe IntIfInstruction do
+  
+  it_should_behave_like "every Nudge Instruction"
+  
+  before(:each) do
+    @context = Interpreter.new
+    @i1 = IntIfInstruction.new(@context)
+  end
+  
+  
+  describe "\#go" do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = IntIfInstruction.new(@context)
+      @v1 = ValuePoint.new("int",  1)
+      @v2 = ValuePoint.new("int", -100)
+    end
+
+    describe "\#preconditions?" do
+      it "should check that there are two items on the target stack and at least one :bool" do
+        @context.stacks[:int].push(@v1)
+        @context.stacks[:int].push(@v2)
+        @context.stacks[:bool].push(ValuePoint.new("bool", true))
+        @i1.preconditions?.should == true
+      end
+    end
+
+    describe "\#cleanup" do
+      it "should keep the SECOND :int if the :bool is true, otherwise the top one" do
+        @context.stacks[:int].push(@v1)
+        @context.stacks[:int].push(@v2)
+        @context.stacks[:bool].push(ValuePoint.new("bool", true))
+        @i1.go
+        @context.stacks[:int].depth.should == 1
+        @context.stacks[:int].peek.value.should == 1
+        
+        @context.stacks[:int].push(@v1)
+        @context.stacks[:int].push(@v2)
+        @context.stacks[:bool].push(ValuePoint.new("bool", false))
+        @i1.go
+        @context.stacks[:int].peek.value.should == -100
+      end
+    end
+  end
+end