nudge 0.0.2 → 0.1.0

data/spec/instructions/split_these/conversions_spec.rb

@@ -0,0 +1,103 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+theseInstructions = [
+  IntFromBoolInstruction,
+  BoolFromIntInstruction,
+  IntFromFloatInstruction,
+  FloatFromIntInstruction,
+  FloatFromBoolInstruction,
+  BoolFromFloatInstruction,
+  CodeFromFloatInstruction,
+  CodeFromIntInstruction,
+  CodeFromBoolInstruction
+]
+
+itNeeds = {
+  IntFromBoolInstruction => {"stack" => :bool, "stackname" => "bool", "becomes" => :int},
+  IntFromFloatInstruction => {"stack" => :float, "stackname" => "float", "becomes" => :int},
+  BoolFromIntInstruction => {"stack" => :int, "stackname" => "int", "becomes" => :bool},
+  BoolFromFloatInstruction => {"stack" => :float, "stackname" => "float", "becomes" => :bool},
+  FloatFromIntInstruction => {"stack" => :int, "stackname" => "int", "becomes" => :float},
+  FloatFromBoolInstruction => {"stack" => :bool, "stackname" => "bool", "becomes" => :float},
+  CodeFromFloatInstruction => {"stack" => :float, "stackname" => "float", "becomes" => :code},
+  CodeFromIntInstruction => {"stack" => :int, "stackname" => "int", "becomes" => :code},
+  CodeFromBoolInstruction => {"stack" => :bool, "stackname" => "bool", "becomes" => :code}}
+  
+whatHappens = {
+  IntFromBoolInstruction => {false => 0, true => 1},
+  IntFromFloatInstruction => {1.1 => 1, -31.71 => -31},
+  BoolFromIntInstruction => {0 => false, -2 => true, 122 => true},
+  BoolFromFloatInstruction => {0.0 => false, -2.2 => true, 122.2 => true},
+  FloatFromIntInstruction => {0 => 0.0, -2 => -2.0, 99 => 99.0},
+  FloatFromBoolInstruction => {false => 0.0, true => 1.0},
+  CodeFromFloatInstruction => {1.3 => "value «float»\n«float» 1.3", -2.8 => "value «float»\n«float» -2.8"},
+  CodeFromIntInstruction => {1882 => "value «int»\n«int» 1882", -9111 => "value «int»\n«int» -9111"},
+  CodeFromBoolInstruction => {false => "value «bool»\n«bool» false", true => "value «bool»\n«bool» true"}}
+
+
+theseInstructions.each do |instName|
+  describe instName do
+    before(:each) do
+      @context = Interpreter.new
+      @i1 = instName.new(@context)
+    end
+    
+    it "should have the right context" 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
+        @stackSymbol = itNeeds[instName]["stack"]
+        @stackName = itNeeds[instName]["stackname"]
+        @someValue = "anything_at_all"
+        @it_becomes = itNeeds[instName]["becomes"]
+        @myStarter = ValuePoint.new(@stackName,@someValue)
+      end
+      
+      describe "\#preconditions?" do
+        it "should check that there are enough parameters" do
+          @context.stacks[@stackSymbol].push(@myStarter)
+          @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[@stackSymbol].push(@myStarter)
+          @i1.should_receive(:cleanup)
+          @i1.go
+        end
+        
+        describe "\#cleanup" do
+          describe "should create and push the new (expected) value to the right place" do
+            before(:each) do
+              @context.clear_stacks
+            end
+            whatHappens[instName].each do |k,v|
+              it "\'#{k}\' becomes #{itNeeds[instName]["becomes"]} \'#{v}\'" do
+                @context.stacks[@stackSymbol].push(ValuePoint.new(@stackName,k))
+                @i1.go
+                @context.stacks[@it_becomes].peek.value.should == v
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/instructions/split_these/float_stack_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+theseInstructions = [
+  FloatPopInstruction,
+  FloatSwapInstruction,
+  FloatDuplicateInstruction,
+  FloatRotateInstruction
+  ]
+  
+floatsTheyNeed = {
+  FloatPopInstruction => 1,
+  FloatSwapInstruction => 2,
+  FloatDuplicateInstruction => 1,
+  FloatRotateInstruction => 3
+  }
+  
+resultTuples = {
+  FloatPopInstruction => {[1.0,2.0]=>[1.0]},
+  FloatSwapInstruction => {[1.1,2.2]=>[2.2,1.1]},
+  FloatDuplicateInstruction => {[33.3] => [33.3,33.3]},
+  FloatRotateInstruction => {[1.1,2.2,3.3] => [2.2,3.3,1.1]}
+  }
+    
+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
+        @float1 = ValuePoint.new("float", 1.0)
+      end
+    
+      describe "\#preconditions?" do
+        it "should check that there are enough parameters" do
+          10.times {@context.stacks[:float].push(@float1)}
+          @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[:float].push(@float1)}
+          @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 \:float stack, starting with #{params}" do
+              inputs.each {|i| @context.stacks[:float].push(ValuePoint.new("float", i))}
+              @i1.go
+              finalStackState.reverse.each {|i| @context.stacks[:float].pop.value.should == i}
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+
+
+
+
+
+
+

data/spec/instructions/split_these/int_stack_spec.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+theseInstructions = [
+  IntPopInstruction,
+  IntSwapInstruction,
+  IntDuplicateInstruction,
+  IntRotateInstruction]
+  
+intsTheyNeed = {
+  IntPopInstruction => 1,
+  IntSwapInstruction => 2,
+  IntDuplicateInstruction => 1,
+  IntRotateInstruction => 3  }
+  
+resultTuples = {
+  IntPopInstruction => {[1,2]=>[1]},
+  IntSwapInstruction => {[1,2]=>[2,1]},
+  IntDuplicateInstruction => {[33] => [33,33]},
+  IntRotateInstruction => {[1,2,3] => [2,3,1]}  }
+    
+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
+        @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 # 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
+      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 \:int stack, starting with #{params}" do
+              inputs.each {|i| @context.stacks[:int].push(ValuePoint.new("int", i))}
+              @i1.go
+              finalStackState.reverse.each {|i| @context.stacks[:int].pop.value.should == i}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/instructions/split_these/name_stack_spec.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), "../../spec_helper")
+include Nudge
+
+theseInstructions = [
+  NamePopInstruction,
+  NameSwapInstruction,
+  NameDuplicateInstruction,
+  NameRotateInstruction
+  ]
+  
+namesTheyNeed = {
+  NamePopInstruction => 1,
+  NameSwapInstruction => 2,
+  NameDuplicateInstruction => 1,
+  NameRotateInstruction => 3
+  }
+  
+resultTuples = {
+  NamePopInstruction => {["a", "b"]=>["a"]},
+  NameSwapInstruction => {["a", "b"]=>["b", "a"]},
+  NameDuplicateInstruction => {["a"] => ["a", "a"]},
+  NameRotateInstruction => {["a", "b", "c"] => ["b", "c", "a"]}
+  }
+    
+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
+        @name1 = ReferencePoint.new("a")
+      end
+    
+      describe "\#preconditions?" do
+        it "should check that there are enough parameters" do
+          8.times {@context.stacks[:name].push(@name1)}
+          @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[:name].push(@name1)}
+          @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 \:name stack, starting with #{params}" do
+              inputs.each {|i| @context.stacks[:name].push(ReferencePoint.new(i))}
+              @i1.go
+              finalStackState.reverse.each {|i| @context.stacks[:name].pop.value.should == i}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/interpreter/codeblock_point_spec.rb

@@ -0,0 +1,164 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+def magicCodeblockPointMaker(program_blueprint)
+  my_kludge = NudgeProgram.new(program_blueprint)
+  return my_kludge.linked_code
+end
+
+
+describe "#initialize" do
+  it "should accept an Array of ProgramPoint objects, defaulting to none" do
+    lambda{CodeblockPoint.new()}.should_not raise_error
+    lambda{CodeblockPoint.new("block {}")}.should raise_error(ArgumentError)
+    lambda{CodeblockPoint.new([ReferencePoint.new("x")])}.should_not raise_error
+    CodeblockPoint.new([ReferencePoint.new("x")]).contents[0].should be_a_kind_of(ReferencePoint)
+  end
+end
+
+describe "tidy" do
+  it "should return the #tidy string of the codeblock, with 0 indent" do
+    CodeblockPoint.new([]).tidy.should == "block {}"
+    CodeblockPoint.new([CodeblockPoint.new([CodeblockPoint.new])]).tidy.should ==
+      "block {\n  block {\n    block {}}}"
+    CodeblockPoint.new([ReferencePoint.new("a"), ValuePoint.new("b")]).tidy.should ==
+      "block {\n  ref a\n  value «b»}"
+  end
+end
+
+
+describe "blueprint_parts" do
+  context "when there are no footnotes" do
+    it "should produce an Array with (1) self.tidy and (2) an empty string" do
+      CodeblockPoint.new([]).blueprint_parts.should == ["block {}",""]
+      CodeblockPoint.new([CodeblockPoint.new([CodeblockPoint.new])]).blueprint_parts.should ==
+        ["block {\n  block {\n    block {}}}",""]        
+      CodeblockPoint.new([ReferencePoint.new("a"), InstructionPoint.new("b")]).blueprint_parts.should ==
+        ["block {\n  ref a\n  do b}",""]
+    end
+  end
+  
+  
+  context "when there need to be footnotes" do
+    it "should work for blocks containing nil-valued ValuePoints" do
+      CodeblockPoint.new([ValuePoint.new("foo")]).blueprint_parts.should ==
+        ["block {\n  value «foo»}",""]
+      annoyinglyWordy = magicCodeblockPointMaker("block { block { block { value «foo»}}}")
+      annoyinglyWordy.blueprint_parts.should ==
+        ["block {\n  block {\n    block {\n      value «foo»}}}",""]
+    end
+    
+    it "should work with footnotes from the root" do
+      simple1 = magicCodeblockPointMaker("block { value «foo»} \n«foo» bar")
+      simple1.blueprint_parts.should ==
+        ["block {\n  value «foo»}","«foo» bar"]
+      nested = magicCodeblockPointMaker("block { block { value «foo»} ref x} \n«foo» bar")
+      nested.blueprint_parts[1].should == "«foo» bar"
+    end
+    
+    it "should return the footnotes in depth-first order" do
+      listed = magicCodeblockPointMaker("block { value «c» value «b» value «a»} \n«a» 1\n«b» 2\n«c» 3")
+      listed.blueprint_parts[1].should == "«c» 3\n«b» 2\n«a» 1"
+    end
+    
+    it "should work with nested «code» footnotes" do
+      simple_tricky = "block { value «code»}\n«code» value «code»\n«int» 123\n«code» value «int»"
+      simple_tricky = magicCodeblockPointMaker(simple_tricky)
+      simple_tricky.blueprint_parts[1].should == "«code» value «code»\n«code» value «int»\n«int» 123"
+    end
+  end
+end
+
+
+describe "#blueprint" do
+  it "should return a single string with the tidied code and footnotes block, surrounding a newline" do
+    simple_tricky = magicCodeblockPointMaker(
+      "block { value «code»}\n«code» value «code»\n«int» 123\n«code» value «int»")
+    simple_tricky.blueprint.should include(simple_tricky.blueprint_parts[0])
+    simple_tricky.blueprint.should include(simple_tricky.blueprint_parts[1])
+  end
+end
+
+
+describe "#go" do
+  describe "should split at the root #contents level and push IN REVERSE ORDER back onto :exec" do
+    before(:each) do
+      @ii=Interpreter.new()
+      @ii.clear_stacks
+    end
+    
+    it " : if it is an empty Codeblock" do
+      @ii.reset("block {}")
+      @ii.step
+      @ii.stacks[:exec].depth.should == 0
+    end
+    
+    it " : if it is a long, flat Codeblock" do
+      @ii.reset("block {\nref a\nref b\nref c\nref d}")
+      @ii.stacks[:exec].depth.should == 1
+      @ii.step
+      @ii.stacks[:exec].depth.should == 4
+      @ii.stacks[:exec].pop.name.should == "a"
+      @ii.stacks[:exec].pop.name.should == "b"
+      @ii.stacks[:exec].pop.name.should == "c"
+      @ii.stacks[:exec].pop.name.should == "d"
+      @ii.stacks[:exec].pop.should == nil
+    end
+    
+    it " : if it is a deeply nested program" do
+      @ii.reset("block {\nblock {\n block {\nvalue «int»}\nvalue «bool»}}")
+      @ii.stacks[:exec].depth.should == 1
+      @ii.step
+      @ii.stacks[:exec].depth.should == 1
+      @ii.step
+      @ii.stacks[:exec].depth.should == 2
+      @ii.step
+      @ii.stacks[:exec].depth.should == 2
+      item = @ii.stacks[:exec].pop
+      item.should be_a_kind_of(ValuePoint)
+      item.type.should == :int
+      item = @ii.stacks[:exec].pop
+      item.should be_a_kind_of(ValuePoint)
+      item.type.should == :bool
+    end
+  end
+end
+
+
+describe "codeblock methods" do
+  describe "#points" do
+    it "should return the number of lines in the block" do
+      myP = CodeblockPoint.new()
+      myP.points.should == 1
+      
+      myQ = CodeblockPoint.new([CodeblockPoint.new([myP])])
+      myQ.points.should == 3
+      
+      myQ = CodeblockPoint.new([CodeblockPoint.new, CodeblockPoint.new])
+      myQ.points.should == 3
+      
+      myQ = CodeblockPoint.new([InstructionPoint.new("int_add")])
+      myQ.points.should == 2
+      
+      myP = CodeblockPoint.new([InstructionPoint.new("a"),ReferencePoint.new("b"),ReferencePoint.new("c")])
+      myP.points.should == 4
+    end
+  end
+  
+  
+  describe "each" do
+    before(:each) do
+      @myQ = CodeblockPoint.new([ReferencePoint.new("a"), InstructionPoint.new("b")])
+    end
+    
+    it "should return an Enumerator object of the right size" do
+      @myQ = CodeblockPoint.new([ReferencePoint.new("a"), InstructionPoint.new("b")])
+      @myQ.collect {|c| c.tidy}.length.should == 3
+    end
+    
+    it "should cycle depth-first through the tree" do
+      @myQ.collect {|c| c.tidy}[2].should == "do b"
+    end
+  end
+end