nudge 0.0.2 → 0.1.0

data/spec/interpreter/reference_point_spec.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+
+describe "ReferencePoint" do
+  it "should be a kind of program point" do
+    myC = ReferencePoint.new("x")
+    myC.should be_a_kind_of(ProgramPoint)
+  end
+  
+  it "should have a name parameter with no default" do
+    myC = ReferencePoint.new("x")
+    myC.name.should == "x"
+    lambda {ReferencePoint.new()}.should raise_error(ArgumentError)
+  end
+  
+  describe "#go" do
+    before(:each) do
+      @ii = Interpreter.new()
+      @ii.reset("block{\nref x\nref y\nref z}")
+      @ii.bind_variable("x", ValuePoint.new(:float, "1.1"))
+      @ii.bind_name("y", ValuePoint.new(:int, "99999"))
+      #reference "z" is unbound
+    end
+    
+    it "should pop the exec stack when the program_point ReferencePoint is interpreted" do
+      @ii.stacks[:exec].depth.should == 1
+      @ii.step
+      @ii.stacks[:exec].depth.should == 3
+      @ii.step
+      @ii.stacks[:exec].depth.should == 3
+      @ii.stacks[:exec].peek.raw.should == "1.1"
+      2.times {@ii.step}
+      @ii.stacks[:exec].depth.should == 2
+      @ii.stacks[:exec].peek.raw.should == "99999"
+    end
+    
+    it "should push the ReferencePoint object onto the :name stack if it's not bound" do
+      6.times {@ii.step}
+      @ii.stacks[:name].depth.should == 1
+      @ii.stacks[:name].peek.name.should == "z"
+    end
+
+    it "should push the value onto the right stack" do
+      3.times {@ii.step}
+      @ii.stacks[:float].peek.raw.should == "1.1"
+      2.times {@ii.step}
+      @ii.stacks[:int].peek.raw.should == "99999"
+      @ii.step
+      @ii.stacks[:name].peek.name.should == "z"
+    end
+  end
+  
+  describe "#tidy" do
+    it "should return 'ref x' when the name is 'x'" do
+      myC = ReferencePoint.new("x")
+      myC.tidy.should == "ref x"
+    end
+  end
+  
+  describe "blueprint" do
+    it "should work just like #tidy" do
+      ReferencePoint.new("jump_a2").blueprint.should == "ref jump_a2" 
+    end
+  end
+  
+  describe "#blueprint_parts" do
+    it "should return an Array containing (1) ReferencePoint#tidy and (2) an empty string" do
+      myRP = ReferencePoint.new("bah_8")
+      myRP.blueprint_parts.should == [myRP.tidy,""]
+    end
+  end  
+end

data/spec/interpreter/stack_spec.rb

@@ -24,7 +24,7 @@ describe "stack" do
   
   
   describe "pushing and popping" do
-    it "should allow an object to be pushed" do
+    it "should allow any object to be pushed" do
       @myStack.push(12)
       @myStack.entries[0].should == 12
     end

data/spec/interpreter/treetophelpers.rb

@@ -24,4 +24,97 @@ module TreetopParserMatchers
   def treetop_parse(input_string) 
     ParserMatcher.new(input_string) 
   end 
-end 
+end
+
+module TrekGrammarParsingMatchers
+  class ShouldParse
+    def initialize(contents, parser)
+      @contents = contents
+      @parser = parser
+    end
+    
+    def matches?(contents)
+      string =
+      case @contents
+      when String
+        @contents
+      when File
+        raise "shit!"
+      end
+      
+      @parsed_value = @parser.parse(string)
+      
+      !@parsed_value.nil?
+    end
+    
+    def failure_message
+      "expected Parser to #{description} but it did not."
+    end
+    
+    def negative_failure_message
+      "expected Parser to not parse #{description} but got syntax tree: #{@parsed_value.inspect}"
+    end
+    
+    def description
+      case @contents
+      when String
+        "parse '#{@contents}'"
+      when File
+        "parse contents of file #{@contents}"
+      end
+    end
+  end
+  
+  
+  class ShouldCapture
+    def initialize(name, nodes)
+      @name = name
+      @nodes = nodes
+    end
+    
+    def matches?(contents)
+      captured_name? && captured_with_correct_value?
+    end
+    
+    def failure_message
+      "expected parser to capture #{@name.inspect}, but it did not"
+    end
+    
+    def negative_failure_message
+      message = "did not expect parser to capture #{@name.inspect}"
+      if captured_name?
+        message << ", but it captured as #{@nodes.send(@name).inspect}"
+      end
+      message
+    end
+    
+    def captured_name?
+      @nodes.respond_to?(@name)
+    end
+    
+    def captured_with_correct_value?
+      return true unless @value
+      @nodes.send(@name).text_value == @value
+    end
+    
+    def description
+      @description = "capture #{@name}"
+      if defined?(@value)
+        @description << " as '#{@value}'"
+      end
+      @description
+    end
+    
+    def as(value)
+      @value = value
+      self 
+    end
+  end
+  
+  def parse(contents)
+    ShouldParse.new(contents, @parser)
+  end
+  def capture(name_as_symbol)
+    ShouldCapture.new(name_as_symbol, @parsed)
+  end
+end

data/spec/interpreter/types_spec.rb

@@ -1,17 +1,19 @@
+#encoding: utf-8
 require File.join(File.dirname(__FILE__), "/../spec_helper")
 include Nudge
 
 describe "Type list" do
   it "should have an #all_types [getter] method to return a list of every defined type" do
     # will be a list of every type subclassed from NudgeType
-    p NudgeType.all_types
     NudgeType.all_types.should include(NudgeType::IntType)
   end
 end
 
 describe "base class" do
   before(:all) do
-    class FooType < BasicType; end
+    class FooType
+      extend TypeBehaviors
+    end
     @klass = FooType
   end
   
@@ -37,86 +39,132 @@ describe "base class" do
   
 end
 
-describe "Int Type" do
-  
-  it "should parse a string from code and produce the actual value" do
-    IntType.from_s("3").should == 3
-    lambda{IntType.from_s()}.should raise_error
-  end
-  it "should return the result of self.randomize when it receives an #any_value call" do
-    IntType.should_receive(:rand).and_return(0)
-    IntType.any_value.should == IntType.defaultLowest
-    IntType.should_receive(:rand).and_return(IntType.defaultHighest-IntType.defaultLowest)
-    IntType.any_value.should == IntType.defaultHighest
+describe "built-in Nudge Types :" do
+  describe "Int Type" do
+    it "should parse a string from code and produce the actual value" do
+      IntType.from_s("3").should == 3
+      lambda{IntType.from_s()}.should raise_error
+    end
     
-  end
-  it "should return a result from a given range when that range is passed in" do
-    IntType.should_receive(:rand).and_return(0.0)
-    param1 = {:randomIntegerLowerBound => 9, :randomIntegerUpperBound =>10}
-    IntType.random_value(param1).should == 9
-    IntType.should_receive(:rand).and_return(3.0)
-    param2 = {:randomIntegerLowerBound => 90, :randomIntegerUpperBound =>100}
-    IntType.random_value(param2).should == 93
-  end
-  
-  it "should work for any order of lower and upper bounds" do
-    IntType.should_receive(:rand).and_return(3)
-    backwards = {:randomIntegerLowerBound => 100, :randomIntegerUpperBound =>90}
-    IntType.random_value(backwards).should == 93
-  end
-  
-  it "should actually work" do
-    lambda{IntType.any_value}.should_not raise_error
-  end
-  
-end
+    it "should have a #recognizes? method that returns true if the arg responds to to_i" do
+      IntType.recognizes?(3).should == true
+      IntType.recognizes?(-3).should == true
+      IntType.recognizes?(3.1321).should == true
+      
+      
+      IntType.recognizes?(nil).should == false
+      IntType.recognizes?("hi there").should == false
+      
+      IntType.recognizes?([1,2,3]).should == false
+      IntType.recognizes?(Object.new).should == false
+    end
+    
+    it "should return the result of self.randomize when it receives an #any_value call" do
+      IntType.should_receive(:rand).and_return(0)
+      IntType.any_value.should == IntType.defaultLowest
+      IntType.should_receive(:rand).and_return(IntType.defaultHighest-IntType.defaultLowest)
+      IntType.any_value.should == IntType.defaultHighest
+    end
 
+    it "should return a result from a given range when that range is passed in" do
+      IntType.should_receive(:rand).and_return(0.0)
+      param1 = {:randomIntegerLowerBound => 9, :randomIntegerUpperBound => 10}
+      IntType.random_value(param1).should == 9
+      IntType.should_receive(:rand).and_return(3.0)
+      param2 = {:randomIntegerLowerBound => 90, :randomIntegerUpperBound => 100}
+      IntType.random_value(param2).should == 93
+    end
 
-describe "Bool Type" do
-  it "should parse a string from code and produce the actual value" do
-    BoolType.from_s("false").should == false
-    lambda{BoolType.from_s()}.should raise_error
-  end
-  it "should return the result of self.randomize when it receives an #any_value call" do
-    BoolType.should_receive(:rand).and_return(0.1)
-    BoolType.any_value.should == true
-    BoolType.should_receive(:rand).and_return(0.9)
-    BoolType.any_value.should == false
-  end
-  
-  it "should return a result from a biased coin when the prob of true is passed in" do
-    BoolType.should_receive(:rand).and_return(0.1)
-    BoolType.any_value.should == true
-    BoolType.should_receive(:rand).and_return(0.1)
-    BoolType.random_value(:randomBooleanTruthProb => 0.05).should == false
-  end
-  
-  it "should actually work" do
-    lambda{BoolType.any_value}.should_not raise_error
-  end
-end
+    it "should work for any order of lower and upper bounds" do
+      IntType.should_receive(:rand).and_return(3)
+      backwards = {:randomIntegerLowerBound => 100, :randomIntegerUpperBound => 90}
+      IntType.random_value(backwards).should == 93
+    end
 
+    it "should actually work" do
+      lambda{IntType.any_value}.should_not raise_error
+    end
 
-describe "Float Type" do
-  it "should return the result of self.randomize when it receives an #any_value call" do
-    FloatType.should_receive(:random_value).and_return(-9.2)
-    FloatType.any_value.should == -9.2
-  end
-  it "should return a result from a given range when that range is passed in" do
-    FloatType.should_receive(:rand).and_return(0.0)
-    FloatType.random_value(:randomFloatLowerBound=>0.0, :randomFloatUpperBound=>10.0).should == 0.0
-    FloatType.should_receive(:rand).and_return(0.5)
-    FloatType.random_value(:randomFloatLowerBound=>-101.101,:randomFloatUpperBound=>101.101).should == 0.0
-  end
-  
-  it "should work for any order of lower and upper bounds" do
-    FloatType.should_receive(:rand).and_return(0.5)
-    backwards = {:randomFloatLowerBound=>101.101, :randomFloatUpperBound=>-101.101}
-    FloatType.random_value(backwards).should == 0.0
   end
-  
-  it "should actually work" do
-    lambda{FloatType.any_value}.should_not raise_error
+
+
+  describe "Bool Type" do
+    it "should parse a string from code and produce the actual value" do
+      BoolType.from_s("false").should == false
+      lambda{BoolType.from_s()}.should raise_error
+    end
+    
+    it "should have a #recognizes? method that returns true if the arg is TrueClass or FalseClass" do
+      BoolType.recognizes?(true).should == true
+      BoolType.recognizes?(false).should == true
+      
+      BoolType.recognizes?(nil).should == false
+      BoolType.recognizes?("false").should == false
+      BoolType.recognizes?(99).should == false
+      BoolType.recognizes?(0).should == false      
+      
+      BoolType.recognizes?([1,2,3]).should == false
+      BoolType.recognizes?(Object.new).should == false
+    end
+    
+    
+    
+    it "should return the result of self.randomize when it receives an #any_value call" do
+      BoolType.should_receive(:rand).and_return(0.1)
+      BoolType.any_value.should == true
+      BoolType.should_receive(:rand).and_return(0.9)
+      BoolType.any_value.should == false
+    end
+
+    it "should return a result from a biased coin when the prob of true is passed in" do
+      BoolType.should_receive(:rand).and_return(0.1)
+      BoolType.any_value.should == true
+      BoolType.should_receive(:rand).and_return(0.1)
+      BoolType.random_value(:randomBooleanTruthProb => 0.05).should == false
+    end
+
+    it "should actually work" do
+      lambda{BoolType.any_value}.should_not raise_error
+    end
   end
-  
+
+
+  describe "Float Type" do
+    it "should return the result of self.randomize when it receives an #any_value call" do
+      FloatType.should_receive(:random_value).and_return(-9.2)
+      FloatType.any_value.should == -9.2
+    end
+    
+    it "should have a #recognizes? method that returns true if the arg responds to to_f" do
+      FloatType.recognizes?(3.991).should == true
+      FloatType.recognizes?(-3.99129).should == true
+      FloatType.recognizes?(3).should == true
+      FloatType.recognizes?(Complex(2,3)).should == true
+      FloatType.recognizes?(Rational("2/3")).should == true
+      
+      FloatType.recognizes?(nil).should == false
+      FloatType.recognizes?("2.123").should == false
+      FloatType.recognizes?([1.1, 2.2, 3.3]).should == false
+      FloatType.recognizes?(Object.new).should == false
+    end
+    
+    
+    it "should return a result from a given range when that range is passed in" do
+      FloatType.should_receive(:rand).and_return(0.0)
+      FloatType.random_value(:randomFloatLowerBound=>0.0, :randomFloatUpperBound=>10.0).should == 0.0
+      FloatType.should_receive(:rand).and_return(0.5)
+      FloatType.random_value(:randomFloatLowerBound=>-101.101,:randomFloatUpperBound=>101.101).should == 0.0
+    end
+
+    it "should work for any order of lower and upper bounds" do
+      FloatType.should_receive(:rand).and_return(0.5)
+      backwards = {:randomFloatLowerBound=>101.101, :randomFloatUpperBound=>-101.101}
+      FloatType.random_value(backwards).should == 0.0
+    end
+
+    it "should actually work" do
+      lambda{FloatType.any_value}.should_not raise_error      
+    end
+  end  
 end
+

data/spec/interpreter/value_point_spec.rb

@@ -0,0 +1,173 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+describe "ValuePoint" do
+  it "should be a kind of program point" do
+    myL = ValuePoint.new("int", "4")
+    myL.should be_a_kind_of(ProgramPoint)
+  end
+  
+  
+  it "should be initialized with a type and a raw value, with raw defaulting to nil" do
+    i4 = ValuePoint.new("int", "4")
+    i4.type.should == :int
+    i4.raw.should == "4"
+    lambda{ValuePoint.new()}.should raise_error(ArgumentError)
+    lambda{ValuePoint.new("bool")}.should_not raise_error(ArgumentError)
+  end
+  
+  
+  describe "raw" do
+    it "should cast the representation of the thing as a string unless nil" do
+      lambda{ValuePoint.new("anything", "something")}.should_not raise_error(ArgumentError)
+      ValuePoint.new("fiddlefaddle", 88).raw.should == "88"
+      ValuePoint.new("int", 8).raw.should == "8"
+    end
+  end
+  
+  
+  describe "nudgetype" do
+    it "should be able to identify its NudgeType, and if it's defined" do
+      ValuePoint.new("int").nudgetype.should == "IntType"
+      ValuePoint.new("int").nudgetype_defined?.should == true
+      ValuePoint.new("bool").nudgetype_defined?.should == true
+      ValuePoint.new("float").nudgetype_defined?.should == true
+      
+      ValuePoint.new("foo").nudgetype.should == "FooType"
+      ValuePoint.new("foo").nudgetype_defined?.should == false
+    end
+  end
+  
+  
+  describe "#value" do
+    it "should use the #from_s method from the appropriate NudgeType, if defined" do
+      ValuePoint.new("int",9912).value.should == 9912
+      ValuePoint.new("float",1.2).value.should == 1.2
+      ValuePoint.new("bool",false).value.should == false
+    end
+    
+    it "should not create a value if none is present in #raw" do
+      ValuePoint.new("int").value.should == nil
+      ValuePoint.new("float").value.should == nil
+      ValuePoint.new("bool",nil).value.should == nil
+    end
+    
+    it "should return the raw string as a value if the type is not defined" do
+      left_field = ValuePoint.new("foo", "some weird thing")
+      left_field.value.should == "some weird thing"
+    end
+    
+  end
+  
+  
+  it "should accept a string or symbol for #type, but set it to a symbol" do
+    ValuePoint.new("int", "4").type.should == :int
+    ValuePoint.new(:int, "4").type.should == :int
+    lambda {ValuePoint.new(false, "4")}.should raise_error(ArgumentError)
+  end
+  
+  
+  it "should move to the appropriate stack when removed from the exec stack" do
+    ii = Interpreter.new(program:"value «bool»\n«bool»true")
+    ii.step
+    ii.stacks[:bool].peek.raw.should == "true"
+    
+    ii.reset("value «code» \n«code» block { do foo_bar}")
+    ii.step
+    ii.stacks[:code].peek.raw.should == "block { do foo_bar}"
+  end
+  
+  
+  describe "#go" do
+    before(:each) do
+      @ii = Interpreter.new()
+      @ii.clear_stacks
+      @ii.stacks[:exec].push(ValuePoint.new("int",222))
+    end
+    
+    it "should pop the exec stack when a ValuePoint is interpreted" do
+      oldExec = @ii.stacks[:exec].depth
+      @ii.step
+      @ii.stacks[:exec].depth.should == (oldExec-1)
+    end
+    
+    it "should initialize the right stack for the type of the ValuePoint if it doesn't exist" do
+      @ii.stacks.delete(:int)
+      @ii.step
+      @ii.stacks.should include(:int)
+    end
+    
+    it "should use the existing stack if it does exist" do
+      @ii.step
+      @ii.stacks[:int].depth.should == 1
+    end
+    
+    it "should push the value onto the right stack" do
+      @ii.stacks[:exec].push(ValuePoint.new("int",3))
+      @ii.stacks[:exec].push(ValuePoint.new("float",2.2))
+      @ii.stacks[:exec].push(ValuePoint.new("fiddle",false))
+      
+      3.times {@ii.step}
+      @ii.stacks.should include(:int)
+      @ii.stacks.should include(:float)
+      @ii.stacks.should include(:fiddle)
+    end
+    
+    it "should push an :error if there is no associated value" do
+      context = Interpreter.new
+      unbound = ValuePoint.new("int")
+      unbound.go(context)
+      context.stacks[:int].depth.should == 0
+      context.stacks[:error].peek.value.should == "int point has no value string"
+    end
+  end
+  
+  
+  describe "#tidy" do
+    it "should print 'value «type»' for ValuePoint#tidy" do
+      myL = ValuePoint.new("float", -99.121001)
+      myL.tidy.should == "value «float»"
+    end
+  end
+  
+  
+  describe "#clone" do
+    it "should return a new object" do
+      myL = ValuePoint.new("float", 128.1)
+      ValuePoint.should_receive(:new)
+      myL.clone
+    end
+    
+    it "should have an identical raw value, but not be the same string object" do
+      myL = ValuePoint.new("float", 1228.1)
+      myL.clone.raw.object_id.should_not == myL.raw.object_id
+    end
+  end
+  
+  
+  describe "#blueprint_parts" do
+    it "should description 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»",""]
+      
+      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"]
+    end
+  end
+  
+  describe "blueprint" do
+    it "should return a combined string composed of the #blueprint_parts separated by a newline" do
+      mat = ValuePoint.new("matrix", "[1,3, 5;\t9,2, 11; \t92,-221,2]")
+      mat.blueprint.should == "value «matrix» \n«matrix» [1,3, 5;\t9,2, 11; \t92,-221,2]"
+      
+      num = ValuePoint.new("int", 812)
+      num.blueprint.should == "value «int» \n«int» 812"
+    end
+  end
+end

data/spec/parsers/nudge_program_parser_spec.rb

@@ -0,0 +1,86 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+include Nudge
+
+describe "Nudge Program parser" do
+  
+  it "should parse all these simple examples" do
+    ["value «int»" ,
+      "do int_add" ,
+      "ref x88" ,
+      "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»}"].each do |exp|
+        lambda{NudgeTree.from(exp)}.should_not raise_error
+    end
+  end
+  
+  it "should not parse these examples" do
+    ["value int (1)\ndo int_add",
+      " ",
+      "block",
+      "do _this",
+      "oneword",
+      "9this",
+      "do 9this",
+      "do is_real?",                  # actually, I may want this one
+      "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)
+    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_∫»",
+      "do β_assay",
+      "do Int_ADD",
+      "value  \n  «β_distribution»\n«β_distribution» [something here]"].each do |exp|
+      lambda{NudgeTree.from(exp)}.should_not raise_error
+    end
+  end
+  
+  it "should be happy with extra spaces" do
+    ["\tvalue \n\t«int»" ,
+      "do \n      int_add" ,
+      "ref \nx88\n" ,
+      "block {\t}" ,
+      "block \n{\t}" ,
+      "block   {\n }\n"].each do |exp|
+        lambda{NudgeTree.from(exp)}.should_not raise_error
+    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)
+  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
+  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)
+  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)
+  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