nudge 0.0.2 → 0.1.0

data/spec/integration/search_integration.rb

@@ -1,67 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,135 +0,0 @@
-# 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/erc_spec.rb

@@ -1,130 +0,0 @@
-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

data/spec/interpreter/literal_spec.rb

@@ -1,94 +0,0 @@
-require File.join(File.dirname(__FILE__), "/../spec_helper")
-include Nudge
-
-describe "LiteralPoint" do
-  
-    it "should be a kind of program point" do
-      myL = LiteralPoint.new("int", 4)
-      myL.should be_a_kind_of(ProgramPoint)
-    end
-    
-    it "should be initialized with a type and a value, with no defaults" do
-      myL = LiteralPoint.new("int", 4)
-      myL.should be_a_kind_of(LiteralPoint)
-      myL.type.should == :int
-      myL.value.should == 4
-      lambda{LiteralPoint.new()}.should raise_error(ArgumentError)
-      lambda{LiteralPoint.new("bool")}.should raise_error(ArgumentError)
-    end
-    
-    it "should move to the appropriate stack when removed from the exec stack" do
-      ii = Interpreter.new(program:"literal bool (true)")
-      ii.step
-      ii.stacks[:bool].peek.value.should == true
-    end
-    
-    describe "#go" do
-      before(:each) do
-        @ii = Interpreter.new()
-        @ii.clear_stacks
-        @ii.stacks[:int] = Stack.new(:int)
-        @ii.reset("literal int (999)")
-      end
-      
-      it "should pop the exec stack when a LiteralPoint 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 LiteralPoint 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(LiteralPoint.new("int",3))
-        @ii.stacks[:exec].push(LiteralPoint.new("float",2.2))
-        @ii.stacks[:exec].push(LiteralPoint.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 'literal type, value' for LiteralPoint#tidy" do
-        myL = LiteralPoint.new("float", -99.121001)
-        myL.tidy.should == "literal 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
-        myL = LiteralPoint.new("int", 77)
-        @ii.disable_all_types
-        @ii.enable(BoolType)
-        myL.randomize(@ii)
-        myL.type.should == :bool
-      end
-    end
-    
-    describe "random CodeType should not be a problem" do
-      it "should have a valid code type and a value that parses" do
-        @ii = Interpreter.new()
-        @ii.disable_all_types
-        @ii.disable_all_instructions
-        @ii.enable(CodeType)
-        lambda{LiteralPoint.any(@ii)}.should raise_error(ArgumentError, "Random code cannot be created")
-      end
-    end
-end