nudge 0.0.1

data/spec/integration/search_integration.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+include Nudge
+
+describe "Couch Writing" do
+  before(:each) do
+    Station.cleanup
+    time_now = Time.now
+    Time.stub!(:now).and_return(time_now)
+    time_now.stub!(:to_i).and_return(999999)
+    
+    @dude = Individual.new("block {}")
+    @homeBase = Station.new("away")
+    @dude.scores = {"happiness" => 54}
+    @homeBase.add_individual(@dude)
+    
+    @theActualDB = CouchRest.database!(@homeBase.database)
+  end
+  
+  after(:each) do
+    @theActualDB.delete!
+  end
+  
+  
+  it "should write its data to the database for its Station" do
+    @dude.write
+    @dude.id.should_not == nil
+  end
+
+  it "should write the genome" do
+    @dude.write
+    id = @dude.id
+    foundThing = @theActualDB.get(id)
+    foundThing["genome"].should == @dude.genome
+  end
+  
+  it "should write the scores hash" do
+    @dude.write
+    id = @dude.id
+    foundThing = @theActualDB.get(id)
+    foundThing["scores"].should == @dude.scores
+  end
+
+  it "should write the birthmoment of the individual" do
+    @dude.write
+    id = @dude.id
+    foundThing = @theActualDB.get(id)
+    foundThing["creation_time"].should == 999999
+  end
+end
+
+describe "Individual#find in Couch" do
+  before(:each) do
+    @couch_url = "http://localhost:5984/slash"
+    @theActualDB = CouchRest.database!(@couch_url)
+    @theData = {"genome"=>"do int_add", "scores"=> {"happiness"=>99}, "creation_time"=> 10000}
+    theResult = @theActualDB.save_doc(@theData)
+    @oldID = theResult["id"]
+  end
+  
+  it "should return an Individual from a couch_url with a given ID" do
+    dude = Individual.get(@couch_url,@oldID)
+    dude.id.should == @oldID
+    dude.genome.should == @theData["genome"]
+    dude.scores.should == @theData["scores"]
+    dude.timestamp.should == @theData["creation_time"]
+  end
+end

data/spec/interpreter/channel_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+
+describe "Channel Point" do
+  it "should be a kind of program point" do
+    myC = ChannelPoint.new("x")
+    myC.should be_a_kind_of(ProgramPoint)
+  end
+  
+  it "should have a name parameter with no default" do
+    myC = ChannelPoint.new("x")
+    myC.should be_a_kind_of(ChannelPoint)
+    myC.name.should == "x"
+    lambda {ChannelPoint.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", LiteralPoint.new("float", 1.1))
+      @ii.bind_name("y", LiteralPoint.new("int", 99999))
+      #reference "z" is unbound
+    end
+    
+    it "should pop the exec stack when the program_point ChannelPoint 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.value.should == 1.1
+      2.times {@ii.step}
+      @ii.stacks[:exec].depth.should == 2
+      @ii.stacks[:exec].peek.value.should == 99999
+    end
+    
+    it "should push the ChannelPoint 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.value.should == 1.1
+      2.times {@ii.step}
+      @ii.stacks[:int].peek.value.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 = ChannelPoint.new("x")
+      myC.tidy.should == "ref x"
+    end
+  end
+  
+  describe "randomize" do
+    it "should set the ChannelPoint's name to a randomly selected channel or name key" do
+      context = Interpreter.new
+      context.reset_variables
+      context.reset_names
+      myC = ChannelPoint.new("a")
+      context.bind_name("y",LiteralPoint.new("bool", false))
+      myC.randomize(context)
+      myC.name.should == "y"
+      context.reset_names
+      context.bind_variable("z",LiteralPoint.new("bool", false))
+      myC.randomize(context)
+      myC.name.should == "z"
+    end
+  end
+  
+  describe "#any" do
+    it "should be a class method that returns a completely random instance of a ChannelPoint" do
+      context = Interpreter.new
+      context.reset_variables
+      context.reset_names
+      context.bind_name("y",LiteralPoint.new("bool", false))
+      rC = ChannelPoint.any(context)
+      rC.name.should == "y"
+      context.reset_names
+      context.bind_variable("d",LiteralPoint.new("bool", false))
+      rC = ChannelPoint.any(context)
+      rC.name.should == "d"
+    end
+  end
+end

data/spec/interpreter/codeblock_spec.rb

@@ -0,0 +1,135 @@
+# coding: utf-8
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+describe "codeblock objects" do
+  describe "should only accept #new from a NudgeLanguageParser"
+  
+  it "should be a kind of program point" do
+    myB = CodeBlock.new()
+    myB.should be_a_kind_of(ProgramPoint)
+  end
+  
+  it "should take a listing as a param, default to 'block {}'" do
+    sCode = CodeBlock.new()
+    sCode.listing.should == "block {}"
+    tCode = CodeBlock.new("block {\n  literal int, 3}")
+    tCode.listing.should == "block {\n  literal int, 3}"
+  end
+  
+  it "should expose its #contents" do
+    parser = NudgeLanguageParser.new()
+    cbs = ["block {\n  literal int(3)}",
+      "block { do int_add \ndo int_subtract\n do int_divide}",
+      "block { block{}}", "block{ block{ do int_add block{ block{} block{}}} }"]
+    
+    cbs.each do |myCode|
+      handMade = CodeBlock.new(myCode)
+      generated = parser.parse(myCode).to_points
+      handMade.contents.length.should == generated.contents.length
+      handMade.contents[0].tidy.should == generated.contents[0].tidy
+      handMade.listing.should == generated.listing
+    end
+  end
+  
+  
+  it "should return an indented nested text version for #tidy" do
+    parser = NudgeLanguageParser.new()
+    myB = parser.parse("block {}").to_points
+    myB.tidy.should == "block {}"
+    
+    myB = parser.parse("block {\n\n}").to_points
+    myB.tidy.should == "block {}"
+    
+    myB = parser.parse("block {\nblock{}\n}").to_points
+    myB.tidy.should == "block {\n  block {}}"
+    
+    myB = parser.parse("block {\nblock{\nblock{}}\n}").to_points
+    myB.tidy.should == "block {\n  block {\n    block {}}}"
+    
+    myB = parser.parse("block {\nblock{}\nblock{}}").to_points
+    myB.tidy.should == "block {\n  block {}\n  block {}}"
+    
+    myB = parser.parse("block {\ndo x\ndo y}").to_points
+    myB.tidy.should == "block {\n  do x\n  do y}"
+  end
+  
+  it "--no really, even for VERY complicated trees" do
+    parser = NudgeLanguageParser.new()
+    myComplicated = fixture(:untidy1)
+    myExpected = fixture(:untidy1fixed)
+    myB = parser.parse(myComplicated).to_points
+    myB.tidy.should == myExpected.chomp
+    
+    myDeep = "block {"* 88 + "}"*88
+    myB = parser.parse(myDeep).to_points
+    myB.tidy.split(/\n/).length.should == 88
+  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 {\nliteral int(1)\nliteral int(2)\nliteral int(3)\nliteral int(4)}")
+      @ii.stacks[:exec].depth.should == 1
+      @ii.step
+      @ii.stacks[:exec].depth.should == 4
+      @ii.stacks[:exec].pop.value.should == 1
+      @ii.stacks[:exec].pop.value.should == 2
+      @ii.stacks[:exec].pop.value.should == 3
+      @ii.stacks[:exec].pop.value.should == 4
+      @ii.stacks[:exec].pop.should == nil
+    end
+    
+    it " : if it is a deeply nested Codeblock" do
+      @ii.reset("block {\nblock {\n block {\nliteral int (1)}\nliteral bool (false)}}")
+      @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(LiteralPoint)
+      item.value.should == 1
+      item = @ii.stacks[:exec].pop
+      item.should be_a_kind_of(LiteralPoint)
+      item.value.should == false
+    end
+  end
+end
+
+
+describe "codeblock methods" do
+  describe "#points" do
+    it "should return the number of lines in the block" do
+      myP = CodeBlock.new("block {}")
+      myP.points.should == 1
+      
+      myP = CodeBlock.new("block { block { block {}}}")
+      myP.points.should == 3
+      
+      myP = CodeBlock.new("block { block {} block {}}")
+      myP.points.should == 3
+      
+      myP = CodeBlock.new("block { do int_add}")
+      myP.points.should == 2
+      
+      myP = CodeBlock.new("block { do int_add ref x1\nref x2}")
+      myP.points.should == 4
+      
+    end
+  end
+end

data/spec/interpreter/codetype_spec.rb

@@ -0,0 +1,257 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+describe "Code Type" do
+  it "should be a Singleton" do
+    CodeType.instance.should be_a_kind_of(Singleton)
+  end
+  
+  
+  it "should return the result of self.randomize when it receives an #any_value call" do
+    CodeType.should_receive(:random_value).and_return("hi there!")
+    CodeType.any_value(Interpreter.new).should == "hi there!"
+  end
+  
+  
+  
+  describe "#random_skeleton" do    
+    it "should accept params for points and branchiness" do
+      lambda{CodeType.random_skeleton(3,1)}.should_not raise_error
+    end
+    
+    it "should return a string filled with asterisks and 'block{}'" do
+      CodeType.random_skeleton(3,0).should == "block {**}"
+      CodeType.random_skeleton(3,1).should == "block {**}"      
+      CodeType.random_skeleton(1,1).should == "block {}"
+      CodeType.random_skeleton(2,2).should == "block { block {}}"
+      CodeType.random_skeleton(20,3).count("}").should == 3
+    end
+    
+    it "should limit range-check the blocks parameter" do
+      CodeType.random_skeleton(1,40).should == "block {}"
+      CodeType.random_skeleton(4,20).count("}").should == 4
+      CodeType.random_skeleton(4,-20).count("}").should == 1
+      CodeType.random_skeleton(1,-20).should == "*"
+    end
+  end
+  
+  
+  
+  describe "any_type" do
+    before(:each) do
+      @context = Interpreter.new
+    end
+    
+    it "should return a single sample from the #types method of the context passed in" do
+      @context = Interpreter.new
+      @context.disable_all_types
+      @context.enable(IntType)
+      CodeType.any_type(@context.types).should == IntType
+    end
+    
+    it "should default to the list of active types in the context" do
+      @context.disable_all_types
+      @context.enable(IntType)
+      CodeType.any_type(@context.types).should == IntType
+    end
+    
+    it "should raise an error if the list of active_types is empty and none is passed in" do
+      @context.disable_all_types
+      lambda{CodeType.any_type(@context.types)}.should raise_error(ArgumentError)
+    end
+    
+    it "should raise an error if the list of types passed in is empty" do
+      @context.disable_all_types
+      lambda{CodeType.any_type(@context.types)}.should raise_error(ArgumentError)
+    end
+  end
+  
+  
+  
+  describe "any_instruction" do
+    before(:each) do
+      @context = Interpreter.new
+    end
+    
+    it "should return a single sample from the context passed in (no implied validation)" do
+      @context.disable_all_instructions
+      @context.enable(IntAddInstruction)
+      CodeType.any_instruction(@context.instructions).should == IntAddInstruction
+    end
+    
+    it "should raise an error if the no instructions are active in the context and none are passed in" do
+      @context.disable_all_instructions
+      lambda{CodeType.any_instruction(@context.instructions)}.should raise_error(ArgumentError)
+    end
+  end
+  
+  describe "any_reference" do
+    before(:each) do
+      @context = Interpreter.new
+    end
+  
+    it "should return a random reference from the context" do
+      @context.reset_variables
+      @context.bind_variable("x",LiteralPoint.new(:int,12))
+      CodeType.any_reference(@context.references).should == "x"
+    end
+    
+    
+    it "should raise an error if the list of active references is empty" do
+      @context.reset_variables
+      @context.reset_names
+      lambda{CodeType.any_reference(@context.references)}.should raise_error(ArgumentError)
+    end
+  end
+  
+  
+  
+  describe "#random_value" do
+    before(:each) do
+      @context = Interpreter.new
+      @context.reset_variables
+      @context.reset_names
+      @context.disable_all_instructions
+      @context.disable_all_types
+    end
+    
+    describe "skeletons" do
+      before(:each) do
+        @context.enable(IntType)
+      end
+      
+      it "should use a points parameter to set the length" do
+        rp = CodeType.random_value(@context,:points => 3)
+      end
+      
+      it "should by default generate a random skeleton" do
+        CodeType.should_receive(:random_skeleton).and_return("**")
+        rp = CodeType.random_value(@context,:points => 2)
+      end
+      
+      it "should allow a skeleton to be passed in as a param" do
+        CodeType.should_not_receive(:random_skeleton)
+        rp = CodeType.random_value(@context,:skeleton => "**")
+      end
+      
+      it "should allow a partially filled-in skeleton to be passed in" do
+        rp = CodeType.random_value(@context,:skeleton => "* do thing")
+        rp.should include(" do thing")
+        rp.should_not include("*")
+      end
+      
+      it "should always return a one-line program listing (no linefeeds)" do
+        rp = CodeType.random_value(@context, :points => 10, :blocks => 5)
+        rp.should_not include("\n")
+      end
+      
+      it "should use '@' as a placeholder that is not replaced with code" do
+        rp = CodeType.random_value(@context, :skeleton => "@ do thing")
+        rp.should == "@ do thing"
+      end
+    end
+    
+    describe "argument checking" do
+      it "should raise an ArgumentError if there are no Instructions, References or Types" do
+        @context.reset_variables
+        @context.reset_names
+        @context.disable_all_types
+        @context.disable_all_instructions
+        lambda{CodeType.random_value(@context)}.should raise_error
+      end
+    end
+    
+    describe "program leaves" do
+      describe "instructions" do
+        it "should work when there are no active instructions" do
+          @context.bind_variable("x",LiteralPoint.new(:int,12))
+          @context.enable(IntType)
+          lambda{CodeType.random_value(@context)}.should_not raise_error
+        end
+        
+        it "should default to a sample of the active instructions" do
+          @context.should_receive(:instructions).and_return([IntAddInstruction])
+          CodeType.random_value(@context)
+        end
+        
+        it "should allow a list of instructions to be passed in as a param" do
+          lambda{CodeType.random_value(@context,:instructions => [IntAddInstruction])}.should_not raise_error
+        end
+      end
+      
+      describe "channels" do
+        it "should work when there are no active channels" do
+          @context.enable(IntAddInstruction)
+          @context.enable(IntType)
+          lambda{CodeType.random_value(@context)}.should_not raise_error
+        end
+        
+        it "should default to a sample of active variables and names" do
+          @context.should_receive(:references).and_return(["x"])
+          CodeType.random_value(@context)
+        end
+        
+        it "should allow a list of channel names to be passed in as a param" do
+          lambda{CodeType.random_value(@context,:references => ["x"])}.should_not raise_error
+        end
+      end
+      
+      describe "types" do
+        it "should work when there are no active types" do
+          @context.bind_variable("x",LiteralPoint.new(:int,12))
+          @context.enable(IntAddInstruction)
+          lambda{CodeType.random_value(@context)}.should_not raise_error
+        end
+        
+        it "should default to a sample of active types" do
+          @context.should_receive(:types).and_return([IntType])
+          CodeType.random_value(@context)
+        end
+        
+        it "should allow a list of types to be passed in as a param" do
+          lambda{CodeType.random_value(@context,:types => [BoolType])}.should_not raise_error
+        end
+      end
+    end
+  end
+  
+  
+  
+  describe "roulette_wheel" do
+    it "should take three lists as parameters" do
+      lambda{CodeType.roulette_wheel()}.should raise_error
+      lambda{CodeType.roulette_wheel([1])}.should raise_error
+      lambda{CodeType.roulette_wheel([1],[2])}.should raise_error
+      lambda{CodeType.roulette_wheel([1],[2],[3])}.should_not raise_error
+    end
+    
+    it "should map its three lists to (references, instructions, types) respectively" do
+      CodeType.should_receive(:rand).and_return(1)
+      CodeType.roulette_wheel([1],[2],[3]).should == "reference"
+      CodeType.should_receive(:rand).and_return(2)
+      CodeType.roulette_wheel([1],[2],[3]).should == "instruction"
+      CodeType.should_receive(:rand).and_return(3)
+      CodeType.roulette_wheel([1],[2],[3]).should == "sample"
+    end
+    
+    it "should raise an exception if a bad value is returned (for next spec)" do
+      CodeType.should_receive(:rand).and_return(99)
+      lambda{CodeType.roulette_wheel([1],[2],[3])}.should raise_error
+    end
+    
+    it "should have a uniform probability of picking any item" do
+      CodeType.should_receive(:rand).and_return(1)
+      CodeType.roulette_wheel([1],[2,3],[4,5,6]).should == "reference"
+      CodeType.should_receive(:rand).and_return(3)
+      CodeType.roulette_wheel([1],[2,3],[4,5,6]).should == "instruction"
+      CodeType.should_receive(:rand).and_return(6)
+      CodeType.roulette_wheel([1],[2,3],[4,5,6]).should == "sample"
+      
+      # OK here's the logic: if it's one higher, it'll fail because every entry gets exactly one
+      CodeType.should_receive(:rand).and_return(6,7)
+      lambda{CodeType.roulette_wheel([1,2,3],[4,5],[6])}.should_not raise_error
+      lambda{CodeType.roulette_wheel([1,2,3],[4,5],[6])}.should raise_error
+    end
+  end
+
+end

data/spec/interpreter/erc_spec.rb

@@ -0,0 +1,130 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+describe "erc" do
+  describe "initialization" do
+    it "should take a type name with no default value" do
+      myE = Erc.new("int",11)
+      myE.type.should == :int
+      lambda {Erc.new()}.should raise_error(ArgumentError)
+    end
+    
+    it "should take an obligatory value param, with no default" do # this is a change of the original specs
+      myE = Erc.new("int",-99999)
+      myE.value.should == -99999
+      lambda{Erc.new("int")}.should raise_error(ArgumentError)
+    end
+    
+    it "should set the value as with a LiteralPoint, if it's given" do
+      myE = Erc.new("bool",false)
+      myE.value.should == false
+    end
+    
+    it "should be a kind of program point" do
+      myE = Erc.new("bool", true)
+      myE.should be_a_kind_of(ProgramPoint)
+    end
+  end
+  
+  describe "converting to a literal" do
+    it "should allow you to cast it to a Literal with the same values" do
+      myE = Erc.new("int", 4)
+      asL = myE.to_literal
+      asL.type.should == :int
+      asL.value.should == 4
+    end
+  end
+  
+  describe "#go" do
+    before(:each) do
+      @ii = Interpreter.new()
+      @ii.clear_stacks
+      @ii.stacks[:int] = Stack.new(:int)
+      @ii.reset("sample int (999)")
+    end
+    
+    it "should pop the exec stack when an Erc 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 Erc 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(Erc.new("int",3))
+      @ii.stacks[:exec].push(Erc.new("float",2.2))
+      @ii.stacks[:exec].push(Erc.new("bool",false))
+      
+      3.times {@ii.step}
+      @ii.stacks.should include(:int)
+      @ii.stacks.should include(:float)
+      @ii.stacks.should include(:bool)
+    end
+  end
+  
+  describe "#tidy" do
+    it "should print 'sample type, value' for Erc#tidy" do
+      myE = Erc.new("float", -99.121001)
+      myE.tidy.should == "sample float (-99.121001)"
+    end
+  end
+  
+  describe "randomize" do
+    before(:each) do
+      @ii = Interpreter.new()
+      @ii.enable_all_types
+    end
+    
+    it "should return one of the active types (not one of the defined types!)" do
+      myErc = LiteralPoint.new("float", -77.89)
+      @ii.disable_all_types
+      @ii.enable(IntType)
+      myErc.randomize(@ii)
+      myErc.type.should == "int"
+    end
+  end
+  
+  describe "#any" do
+    before(:each) do
+      @ii = Interpreter.new()
+      @ii.enable_all_types
+    end
+    
+    it "should return a new instance, invoking #randomize" do
+      rE = Erc.any(@ii)
+      rE.should be_a_kind_of(Erc)
+      @ii.disable_all_types
+      @ii.enable(BoolType)
+      rE = Erc.any(@ii)
+      rE.type.should == "bool"
+    end
+  end
+  
+  describe "#resample" do
+    it "should change the value only of the calling Erc instance, not its type" do
+      rE = Erc.new("int", 99)
+      rE.should be_a_kind_of(Erc)
+      IntType.should_receive(:any_value).and_return(2)
+      rE.value.should == 99
+      rE.resample
+      rE.value.should == 2
+      
+      rE = Erc.new("bool", false)
+      rE.should be_a_kind_of(Erc)
+      BoolType.should_receive(:any_value).and_return(true)
+      rE.value.should == false
+      rE.resample
+      rE.value.should == true
+    end      
+  end
+end