nudge 0.1.2 → 0.1.3

data/spec/interpreter/nudge_program_spec.rb

@@ -5,9 +5,6 @@ include Nudge
 
 
 describe "Nudge Program parsing" do
-  before(:each) do
-    @parser = NudgeCodeblockParser.new()
-  end
   
   describe ": initializing a new NudgeProgram from a string" do
     it "should check that it's been given a string" do
@@ -46,50 +43,25 @@ describe "Nudge Program parsing" do
         NudgeProgram.new("value «int» \n«int» 8 \n«code» value «bool»").footnote_section.should ==
           "«int» 8 \n«code» value «bool»"
       end
-      
-      it "should capture each individual footnote into #footnotes" do
-        NudgeProgram.new("do int_add").footnotes.should == {}
-        NudgeProgram.new("value «int» \n«bool» false").footnotes[:bool].should include("false")
-        
-        tricky = NudgeProgram.new("value «int» \n«int» 8 \n«code» value «bool»").footnotes
-        tricky.keys.length.should == 2
-        tricky[:code].should == ["value «bool»"]
-      end
     end
   
     describe ": trimming whitespace from footnote values" do
-      it "should ignore leading whitespace" do
-        NudgeProgram.new("value «baz» \n«baz»\t\t8").tokenized_footnote_section[:baz][0].should == "8"
-        NudgeProgram.new("value «baz» \n«baz»\n\n\n\n8").tokenized_footnote_section[:baz][0].should == "8"
-        NudgeProgram.new("value «baz» \n«baz»      8").tokenized_footnote_section[:baz][0].should == "8"
-        NudgeProgram.new("value «baz» \n«baz»8").tokenized_footnote_section[:baz][0].should == "8"
+      it "should ignore (and not need) leading whitespace" do
+        NudgeProgram.new("value «x»\n«x» \t\n \f\n 111").linked_code.value.should == "111"
+        NudgeProgram.new("value «x»\n«x»111").linked_code.value.should == "111"
       end
       
-      it "should should ignore trailing whitespace" do
-        NudgeProgram.new("value «foo» \n«foo» 9\t\t").tokenized_footnote_section[:foo][0].should == "9"
-        NudgeProgram.new("value «foo» \n«foo» 9\n\n\n\n").tokenized_footnote_section[:foo][0].should == "9"
-        NudgeProgram.new("value «foo» \n«foo» 9     ").tokenized_footnote_section[:foo][0].should == "9"
+      it "should should ignore (and not need) trailing whitespace" do
+        NudgeProgram.new("value «y»\n«y» 111\t\n \f\n ").linked_code.value.should == "111"
+        NudgeProgram.new("value «y»\n«y» 111\n«y» something").linked_code.value.should == "111"
       end
       
       it "should capture whitespace inside values" do
-        NudgeProgram.new("value «bar» \n«bar» 9\t\t9").tokenized_footnote_section[:bar][0].should == "9\t\t9"
-        NudgeProgram.new("value «bar» \n«bar» 9\n\n\n\n9").tokenized_footnote_section[:bar][0].
-          should == "9\n\n\n\n9"
-        NudgeProgram.new("value «bar» \n«bar» 9     9").tokenized_footnote_section[:bar][0].should == "9     9"
+        NudgeProgram.new("value «y»\n«y» 1\t\n1\t\n1 ").linked_code.value.should == "1\t\n1\t\n1"
       end
       
       it "should trim whitespace between footnotes" do
-        NudgeProgram.new("value «bar» \n«bar» 9\n  \n\t\n«baz»9").
-          tokenized_footnote_section.keys.length.should == 2
-        NudgeProgram.new("value «bar» \n«bar» 9\n  \n\t\n«baz»9").
-          tokenized_footnote_section.keys.should include(:bar)
-        NudgeProgram.new("value «bar» \n«bar» 9\n  \n\t\n«baz»9").
-          tokenized_footnote_section.keys.should include(:baz)
-      end
-      
-      it "should avoid capturing newlines between footnotes" do
-        known_risk = NudgeProgram.new("block {value «mya»\nvalue «myb»}\n«myb» this is a b\n«mya» a")
-        known_risk.tokenized_footnote_section[:myb][0].should == "this is a b"
+        NudgeProgram.new("block {value «y» value «z»}\n«y» 111\f\t\n\t\t  \n«z» something").linked_code.contents[0].value.should == "111"
       end
     end
   end
@@ -133,6 +105,16 @@ describe "Nudge Program parsing" do
         jeez = "block {" + ("block { " * 20 + "block {}" + "}" * 20) * 3 + "}"
         NudgeProgram.new(jeez).tidy.split(/\n/).length.should == 64
       end
+      
+      it "should not produce footnotes" do
+        wordy = "block {value «code»}\n«code» value «int»\n«int» 9"
+        NudgeProgram.new(wordy).tidy.should == "block {\n  value «code»}"
+      end
+      
+      it "should not produce footnotes even when there are unassigned ones" do
+        forgetful = "block {value «a» value «b» value «c»}"
+        NudgeProgram.new(forgetful).tidy.should == "block {\n  value «a»\n  value «b»\n  value «c»}"
+      end
     end
   end
   
@@ -165,15 +147,6 @@ describe "Nudge Program parsing" do
   end
   
   
-  describe "#contains_codevalues? method" do
-    it "should return true iff the raw code (including footnote_section) includes 'value «code»" do
-      NudgeProgram.new("do int_add").contains_codevalues?.should == false
-      NudgeProgram.new("value \t\t«code»").contains_codevalues?.should == true
-      NudgeProgram.new("block {block {value \n «code»}}").contains_codevalues?.should == true
-    end
-  end
-  
-  
   # some examples worked by hand to test the
   #   depth-first association of values to footnotes
   #
@@ -260,9 +233,10 @@ describe "Nudge Program parsing" do
         tree2.blueprint.should == tree2.tidy
       end
       
-      it "should produce the same thing as #tidy for a CodeblockPoint program with unassigned footnotes" do
+      it "should NOT produce self#tidy for a CodeblockPoint program with unassigned footnotes" do
         dangling = NudgeProgram.new("block {\t\t value «a»\nvalue «b»\n \n value «c»}")
-        dangling.blueprint.should == dangling.tidy
+        dangling.blueprint.should ==
+          "block {\n  value «a»\n  value «b»\n  value «c»} \n«a»\n«b»\n«c»"
       end
       
       it "should put out the tidy form AND the footnotes in the right order" do
@@ -303,6 +277,7 @@ block { value «int» value «code» value «int»}
     
   end
   
+  
   describe "contains_valuepoints?" do
     it "should accept a string and return true if it contains any «» markup AT ALL" do
       np = NudgeProgram.new("")
@@ -316,50 +291,6 @@ block { value «int» value «code» value «int»}
   end
   
   
-  describe "pursue_more_footnotes method" do
-    before(:each) do
-      @nasty = "block {value «code» \nvalue «code» \nvalue «foo»}\n«code» value «foo»\n«code» block {value «code»}\n«foo» 1\n«foo» 2\n«code» value «foo»\n«foo» 3"
-      @simple = "block {value «code»}\n«code» value «int»\n«int» 2"
-      @boring = "value «code»\n«code» block {}"
-      @stringy = "value «code»\n«code» value «code»\n«code» value «code»\n«code» do X"
-      @filler = '['+ (" \n "*100) + ']'
-      @spacey = "value «code»\n«code» value «spacer»\n«spacer»#{@filler}"
-      @staged_program = NudgeProgram.new("")
-      
-      def reprocess_using(new_code)
-        @staged_program.instance_variable_set(:@raw_code,new_code)
-        @staged_program.program_split!
-        @staged_program.relink_code!
-      end
-    end
-    
-    it "should determine if the blueprint contains any ValuePoints if it is type code" do
-      @staged_program.should_receive(:contains_valuepoints?).with("block {}")
-      reprocess_using(@boring)
-    end
-    
-    it "should (in the end) return the collected_footnotes string for this depth-first traversal" do
-      reprocess_using(@nasty)
-      @staged_program.linked_code.contents[0].raw.should == "value «foo»\n«foo» 1"
-      @staged_program.linked_code.contents[1].raw.should ==
-        "block {value «code»}\n«code» value «foo»\n«foo» 2"
-      @staged_program.linked_code.contents[2].raw.should == "3"
-      
-      reprocess_using(@simple)
-      @staged_program.linked_code.contents[0].raw.should == "value «int»\n«int» 2"
-      
-      reprocess_using(@boring)
-      @staged_program.linked_code.raw.should == "block {}"
-      
-      reprocess_using(@stringy)
-      @staged_program.linked_code.raw.should == "value «code»\n«code» value «code»\n«code» do X"
-      
-      reprocess_using(@spacey)
-      @staged_program.linked_code.raw.should == "value «spacer»\n«spacer» #{@filler}"
-    end
-  end
-  
-  
   describe "preserving unused footnotes" do
     before(:each) do
       @all_extras = "value «foo»\n«bar» baz\n«qux» nothing"
@@ -389,55 +320,40 @@ block { value «int» value «code» value «int»}
       huh.footnotes.should == {} # they didn't get used
     end
     
-    it "should interpret an unparseable codesection as no code at all, but keep the footnotes" do
+    it "should interpret an unparseable codesection as no code at all, and drop footnotes" do
       got_nuthin = NudgeProgram.new("block { hunh \n«int» 2")
       got_nuthin.code_section.should == "block { hunh"
       got_nuthin.linked_code.should be_a_kind_of(NilPoint)
       got_nuthin.footnote_section.should == "«int» 2"
-      got_nuthin.footnotes.should == {:int => ["2"]} # it's not been used
+      got_nuthin.footnotes.should == {} # it's not been used
     end
     
     
-    it "should read values linking to missing footnotes as linked to 'nil'" do
-      # nasty_shorter:     |  associated values:
-      # -------------       |  ------------------
-      # block {             |
-      #   value «code»      |  <- "value «foo»\n«foo» 1"
-      #   value «code»      |  <- "block {value «code»}"
-      #   value «foo»}      |  <- nil
-      # «code» value «foo»  |
-      # «code» block {value «code»}
-      # «foo» 1             |
+    it "should include a footnote for every reference, even if it has to create an empty one" do
+      nasty =
+        "block {value «code»\nvalue «code» \nvalue «foo»}\n«code» value «foo»\n«code» block {value «code»}\n«foo» 1"
+        
+      shortstop = NudgeProgram.new(nasty)
+      r0 = "value «code» \n«code» value «foo»\n«foo» 1"
+      r1 = "value «code» \n«code» block {value «code»}\n«code»"
+      r2 = "value «foo» \n«foo»"
+      shortstop.linked_code.contents[0].blueprint.should == r0
+      shortstop.linked_code.contents[1].blueprint.should == r1
       
-      nasty_shorter = "block {value «code» \nvalue «code» \nvalue «foo»}\n«code» value «foo»\n«code» block {value «code»}\n«foo» 1"
-      shortstop = NudgeProgram.new(nasty_shorter)
-      shortstop.linked_code.contents[0].raw.should == "value «foo»\n«foo» 1"
-      shortstop.linked_code.contents[1].raw.should == "block {value «code»}"
-      shortstop.linked_code.contents[2].raw.should == nil
     end
     
     it "should collect unused footnotes" do
       hmm = NudgeProgram.new("do int_add\n«nob» nothing")
-      hmm.footnotes[:nob].should include("nothing")
+      hmm.footnotes["nob"].should include("nothing")
     end
     
     it "should act as specified above when one or more footnote is unparseable" do
-      # stupid_shorter:    |  associated values:
-      # -------------       |  ------------------
-      # block {             |
-      #   value «code»      |  <- "value «foo»\n«foo» 1"
-      #   value «code»      |  <- "some junk"
-      #   value «foo»}      |  <- nil
-      # «code» value «foo»  |
-      # «code» some junk    |
-      # «foo» 1             |
       
       stupid_shorter = "block {value «code» \nvalue «code» \nvalue «foo»}\n«code» value «foo»\n«code» some junk\n«foo» 1"
       busted = NudgeProgram.new(stupid_shorter)
       busted.linked_code.contents[0].raw.should == "value «foo»\n«foo» 1"
       busted.linked_code.contents[1].raw.should == "some junk"
       busted.linked_code.contents[2].raw.should == nil
-      
     end
   end
   
@@ -589,7 +505,7 @@ block { value «int» value «code» value «int»}
         "value «foo» \n«foo» •••"
         
       valueful.replace_point(2,addedvalue).blueprint.should ==
-        "block {\n  value «foo»\n  value «code»} \n«foo» •••\n«code» value «bool»"
+        "block {\n  value «foo»\n  value «code»} \n«foo» •••\n«code» value «bool»\n«bool»"
       
       valueful.replace_point(3,addedvalue).blueprint.should ==
         "block {\n  value «code»\n  value «foo»} \n«code» block {value «int»}\n«int» 7\n«foo» •••"
@@ -652,7 +568,6 @@ block { value «int» value «code» value «int»}
     end
     
     it "should return a new NudgeProgram with the right ProgramPoint deleted" do
-      # "block {\n  block {\n    block {\n      block {\n        block {\n          block {\n            ref a}}}}}}"
       result = @lodgepole_tree.delete_point(1)
       result.blueprint.should == "block {}"
       
@@ -674,7 +589,7 @@ block { value «int» value «code» value «int»}
         "block {}"
         
       valueful.delete_point(2).blueprint.should ==
-        "block {\n  value «code»} \n«code» value «bool»"
+        "block {\n  value «code»} \n«code» value «bool»\n«bool»"
         
       valueful.delete_point(3).blueprint.should ==
         "block {\n  value «code»} \n«code» block {value «int»}\n«int» 7"

data/spec/interpreter/value_point_spec.rb

@@ -69,7 +69,7 @@ describe "ValuePoint" do
   
   
   it "should move to the appropriate stack when removed from the exec stack" do
-    ii = Interpreter.new(program:"value «bool»\n«bool»true")
+    ii = Interpreter.new("value «bool»\n«bool»true")
     ii.step
     ii.stacks[:bool].peek.raw.should == "true"
     
@@ -147,14 +147,14 @@ describe "ValuePoint" do
   
   
   describe "#blueprint_parts" do
-    it "should description return an Array with two parts: (1) self#tidy (2) the footnotes as a string" do
+    it "should return an Array with two parts: (1) self#tidy (2) the footnotes as a string" do
       myL = ValuePoint.new("float", "-99.121001")
       myL.blueprint_parts.should == ["value «float»","«float» -99.121001"]
       myURI = ValuePoint.new("uri", "http://googol.com")
       myURI.blueprint_parts.should == ["value «uri»","«uri» http://googol.com"]
-      
+
       myHuh = ValuePoint.new("missing")
-      myHuh.blueprint_parts.should == ["value «missing»",""]
+      myHuh.blueprint_parts.should == ["value «missing»","«missing»"]
       
       myFUcode = ValuePoint.new("code", "block { value «code»}\n«code» value «int»\n«int» 8")
       myFUcode.blueprint_parts.should == ["value «code»","«code» block { value «code»}\n«code» value «int»\n«int» 8"]
@@ -169,5 +169,10 @@ describe "ValuePoint" do
       num = ValuePoint.new("int", 812)
       num.blueprint.should == "value «int» \n«int» 812"
     end
+    
+    it "should not fail for valueless footnotes" do
+      myHuh = ValuePoint.new("missing")
+      myHuh.blueprint.should == "value «missing» \n«missing»"
+    end
   end
 end

data/spec/parsers/nudge_program_parser_spec.rb

@@ -16,9 +16,54 @@ describe "Nudge Program parser" do
       "block{do int_add}" ,
       "block{do int_add\ndo int_add value «foo»}"].each do |exp|
         lambda{NudgeTree.from(exp)}.should_not raise_error
+        NudgeTree.from(exp)[:tree].should_not == nil
     end
   end
   
+  it "should return the right ProgramPoint class for InstructionPoints" do
+    ["do int_add",
+      "do foo_bar",
+      "do x_1"].each do |exp|
+      NudgeTree.from(exp)[:tree].should be_a_kind_of(InstructionPoint)
+    end
+  end
+    
+  it "should return the right ProgramPoint class for ReferencePoints" do
+    ["ref x88",
+      "ref a_1"].each do |exp|
+      NudgeTree.from(exp)[:tree].should be_a_kind_of(ReferencePoint)
+    end
+  end
+  
+  it "should return the right ProgramPoint class for ValuePoints" do
+    ["value «x»" ,
+      "value «x_1»" ,
+      "value «xyz»" ,
+      "value «my_type»",
+      "value «x»\n«x» 8" ,
+      "value «x_1»\n«x_1» 9" ,
+      "value «xyz»\n«xyz» 10" ,
+      "value «my_type»\n«my_type» 11"].each do |exp|
+        NudgeTree.from(exp)[:tree].should be_a_kind_of(ValuePoint)
+    end
+    
+  end
+  
+  
+  it "should return the right ProgramPoint class for CodeblockPoints" do
+    ["block {}" ,
+      "block {\t}" ,
+      "block {\n }" ,
+      "block { block { block {block{block{}}}} }",
+      "block {do int_add}" ,
+      "block{do int_add}" ,
+      "block{do int_add\ndo int_add value «foo»}\n«foo» baz"].each do |exp|
+        NudgeTree.from(exp)[:tree].should be_a_kind_of(CodeblockPoint)
+    end
+  end
+  
+  
+  
   it "should not parse these examples" do
     ["value int (1)\ndo int_add",
       " ",
@@ -31,17 +76,18 @@ describe "Nudge Program parser" do
       "do this_not_real!",            # actually, I may want this one
       "ref 1x1",
       "ref 1 x 1"].each do |junk|
-      lambda{NudgeTree.from(junk)}.should raise_error(ParseError)
+        NudgeTree.from(junk)[:tree].should be_a_kind_of(NilPoint)
     end
   end
   
+  
+  
   it "should be happy with unicode" do
-    pending "Somebody has to edit the parse.y file so this works, I think"
-    ["value «a_∫»",
+    ["value «a_éüîøö»",
       "do β_assay",
-      "do Int_ADD",
-      "value  \n  «β_distribution»\n«β_distribution» [something here]"].each do |exp|
-      lambda{NudgeTree.from(exp)}.should_not raise_error
+      "ref Ünt_ADD",
+      "block {value «β_distribution»}"].each do |exp|
+      NudgeTree.from(exp)[:tree].should_not be_a_kind_of(NilPoint)
     end
   end
   
@@ -52,35 +98,74 @@ describe "Nudge Program parser" do
       "block {\t}" ,
       "block \n{\t}" ,
       "block   {\n }\n"].each do |exp|
-        lambda{NudgeTree.from(exp)}.should_not raise_error
+        NudgeTree.from(exp)[:tree].should_not be_a_kind_of(NilPoint)
     end
   end
   
+  
   it "should parse well-formed footnotes" do
-    lambda{NudgeTree.from("value «code»\n«int» 9\n«code» value «int»")}.should_not raise_error
-    NudgeTree.from("value «code»\n«int» 9\n«code» value «int»")[:tree].should be_a_kind_of(ValuePoint)
+    NudgeTree.from("value «code»\n«int» 9\n«code» value «int»")[:tree].should_not be_a_kind_of(NilPoint)
+    nt = NudgeTree.from("value «code»\n«int» 9\n«code» value «int»")
+    nt[:tree].should be_a_kind_of(ValuePoint)
+    nt[:tree].blueprint.should == "value «code» \n«code» value «int»\n«int» 9"
   end
   
+  
   it "should work with multi-line footnotes" do
-    pending "Need to adjust StringScanner end-of-footnote code, I think"
-    lambda{NudgeTree.from("value «code»\n«code» block {\ndo thing_1\n  do thing_2}")}.should_not raise_error
+    wordy = "value «code»\n«code» block {\ndo thing_1\n  do thing_2}\n«int» 5"
+    lambda{NudgeTree.from(wordy)}.should_not raise_error
+    NudgeTree.from(wordy)[:tree].blueprint.should == 
+      "value «code» \n«code» block {\ndo thing_1\n  do thing_2}"
   end
-
-  it "should not parse code with malformed footnotes" do
-    lambda{NudgeTree.from("value «code» «int extra» 9\n«code» value «int»")}.should raise_error(ParseError)
+  
+  
+  it "should parse code with malformed footnotes (but they'll turn out weird)" do
+    busted = "value «code» \n«code» do thing\n«float 2» 9"
+    NudgeTree.from(busted).should_not be_a_kind_of(NilPoint)
+    NudgeTree.from(busted)[:tree].blueprint.should == "value «code» \n«code» do thing"
+    
+    strange = "value «code» \n«float 2» 9\n«code» do thing\n"
+    NudgeTree.from(strange).should_not be_a_kind_of(NilPoint)
+    NudgeTree.from(strange)[:tree].blueprint.should == "value «code» \n«code» do thing"
+  end
+  
+  
+  it "should parse code with missing footnote values" do
+    lacuna = "value «code» \n«code»"
+    NudgeTree.from(lacuna).should_not be_a_kind_of(NilPoint)
+    NudgeTree.from(lacuna)[:tree].blueprint.should == "value «code» \n«code»"
+    
+    lacuna = "block {value «code» value «code» value «int»} \n«code» do a\n«code» \n«int» 77"
+    NudgeTree.from(lacuna).should_not be_a_kind_of(NilPoint)
+    NudgeTree.from(lacuna)[:tree].blueprint.should ==
+      "block {\n  value «code»\n  value «code»\n  value «int»} \n«code» do a\n«code»\n«int» 77"
+  end
+  
+  
+  it "should strip whitespace off the front and back of footnote values" do
+    spacey = "value «code»\n«code»  \t\t  value «float»  \t\t\n«float»  \t\n1.234"
+    NudgeTree.from(spacey)[:tree].blueprint.should ==
+      "value «code» \n«code» value «float»\n«float» 1.234"
+  end
+  
+  
+  it "should work for well-formed programs with insufficient footnotes by creating placeholders" do
+    lacuna = "block {value «code» \nvalue «code» \nvalue «foo»}\n«code» value «foo»\n«code» block {value «code»}\n«foo» 1"
+    NudgeTree.from(lacuna).should_not be_a_kind_of(NilPoint)
+    NudgeTree.from(lacuna)[:tree].blueprint.should ==
+      "block {\n  value «code»\n  value «code»\n  value «foo»} \n«code» value «foo»\n«foo» 1\n«code» block {value «code»}\n«code»\n«foo»"
   end
   
-  it "should strip whitespace off footnote values"
   
   it "should not parse a footnotes-only string" do
-    lambda{NudgeTree.from("\n«int» 9\n«code» value «int»")}.should raise_error(ParseError)
-    lambda{NudgeTree.from("«int» 9\n«code» value «int»")}.should raise_error(ParseError)
+    NudgeTree.from("\n«int» 9\n«code» value «int»")[:tree].should be_a_kind_of(NilPoint)
+    NudgeTree.from("«int» 9\n«code» value «int»")[:tree].should be_a_kind_of(NilPoint)
   end
   
+  
   it "should return extra footnotes" do
     hash = NudgeTree.from("do unrelated\n«int» 9\n«code» value «int»")
     hash[:tree].blueprint.should == "do unrelated"
     hash[:unused].should == {"int"=>["9"], "code"=>["value «int»"]}
-  end
-  
-end
+  end  
+end

data/spec/spec_helper.rb

@@ -3,37 +3,50 @@ $: << File.join(File.dirname(__FILE__), "/../lib")
 
 
 require 'spec'
-require 'interpreter/treetophelpers'
 require 'pp'
 require 'nudge'
 require 'erb'
 
-def fixture(name, data = binding)
-  text = File.read(File.join(File.dirname(__FILE__), "/fixtures/#{name}.example"))
-  ERB.new(text).result(data)
-end
+Spec::Runner.configure do |config|
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure 
+      eval("$#{stream} = #{stream.upcase}")
+    end
 
-def load_grammar(name)
-  Treetop.load(File.join(File.dirname(__FILE__), '..',
-    'lib', 'interpreter', 'grammars', "nudge_#{name}.treetop"))
-end
+    result
+  end
 
+  def fixture(name, data = binding)
+    text = File.read(File.join(File.dirname(__FILE__), "/fixtures/#{name}.example"))
+    ERB.new(text).result(data)
+  end
 
-shared_examples_for "every Nudge Instruction" do
-  
-  it "should respond to \#preconditions?" do
-    @i1.should respond_to(:preconditions?)
+  def load_grammar(name)
+    Treetop.load(File.join(File.dirname(__FILE__), '..',
+      'lib', 'interpreter', 'grammars', "nudge_#{name}.treetop"))
   end
+
+  shared_examples_for "every Nudge Instruction" do
+  
+    it "should respond to \#preconditions?" do
+      @i1.should respond_to(:preconditions?)
+    end
   
-  it "should respond to \#setup" do
-    @i1.should respond_to(:setup)
-  end   
+    it "should respond to \#setup" do
+      @i1.should respond_to(:setup)
+    end   
   
-  it "should respond to \#derive" do
-    @i1.should respond_to(:derive)
-  end   
+    it "should respond to \#derive" do
+      @i1.should respond_to(:derive)
+    end   
   
-  it "should respond to \#celanup" do
-    @i1.should respond_to(:cleanup)
-  end   
-end
+    it "should respond to \#celanup" do
+      @i1.should respond_to(:cleanup)
+    end   
+  end
+end

data/templates/nudge_define_instruction.erb

@@ -0,0 +1,6 @@
+class <%=@instname%> < Instruction
+  include DefineInstruction
+  def initialize(context)
+    super(context, :<%=@type%>)
+  end
+end

data/templates/nudge_duplicate_instruction.erb

@@ -0,0 +1,6 @@
+class <%=@instname%> < Instruction
+  include DuplicateInstruction
+  def initialize(context)
+    super(context, :<%=@type%>)
+  end
+end

data/templates/nudge_equal_q_instruction.erb

@@ -0,0 +1,19 @@
+class <%=@instname%> < Instruction
+  
+  def preconditions?
+    needs :<%=@type%>, 2
+  end
+  
+  def setup
+    @arg1 = @context.pop_value(:<%=@type%>)
+    @arg2 = @context.pop_value(:<%=@type%>)
+  end
+  
+  def derive
+    @result = ValuePoint.new("bool", @arg1 == @arg2)
+  end
+  
+  def cleanup
+    pushes :bool, @result
+  end
+end

data/templates/nudge_flush_instruction.erb

@@ -0,0 +1,6 @@
+class <%=@instname%> < Instruction
+  include FlushInstruction
+  def initialize(context)
+    super(context, :<%=@type%>)
+  end
+end

data/templates/nudge_pop_instruction.erb

@@ -0,0 +1,6 @@
+class <%=@instname%> < Instruction
+  include PopInstruction
+  def initialize(context)
+    super(context, :<%=@type%>)
+  end
+end

data/templates/nudge_random_instruction.erb

@@ -0,0 +1,13 @@
+class <%=@instname%> < Instruction
+  def preconditions?
+    true # no preconditions
+  end
+  def setup
+  end
+  def derive
+    @result = ValuePoint.new("<%=@type%>", <%=@camelized_type%>.any_value)
+  end
+  def cleanup
+    pushes :<%=@type%>, @result
+  end
+end

data/templates/nudge_rotate_instruction.erb

@@ -0,0 +1,6 @@
+class <%=@instname%> < Instruction
+  include RotateInstruction
+  def initialize(context)
+    super(context, :<%=@type%>)
+  end
+end

data/templates/nudge_shove_instruction.erb

@@ -0,0 +1,6 @@
+class <%=@instname%> < Instruction
+  include ShoveInstruction
+  def initialize(context)
+    super(context, :<%=@type%>)
+  end
+end

data/templates/nudge_swap_instruction.erb

@@ -0,0 +1,6 @@
+class <%=@instname%> < Instruction
+  include SwapInstruction
+  def initialize(context)
+    super(context, :<%=@type%>)
+  end
+end