answer-factory 0.0.1

data/spec/operators/pointDeletion_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "PointDeleteOperator search operator" do
+  describe "generate" do
+    before(:each) do
+      @zapper = PointDeleteOperator.new()
+      @dude1 = Answer.new("block { do thing1 \n do thing2 \n do thing3}")
+    end
+    
+    it "should accept a Batch as a param" do
+      lambda{@zapper.generate()}.should raise_error(ArgumentError)
+      lambda{@zapper.generate(812)}.should raise_error(ArgumentError)
+      lambda{@zapper.generate(Batch.new)}.should_not raise_error(ArgumentError)
+      lambda{@zapper.generate(Batch[@dude1])}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should raise an Argument error if all contents of the crowd aren't Answers" do
+      lambda{@zapper.generate([])}.should_not raise_error(ArgumentError)
+      lambda{@zapper.generate([ 77 ])}.should raise_error(ArgumentError)
+      lambda{@zapper.generate([ @dude1, 77 ])}.should raise_error(ArgumentError)
+    end
+    
+    it "should return a Batch as a result" do
+      @zapper.generate([@dude1]).should be_a_kind_of(Batch)
+    end
+    
+    it "should use Answer#delete_point to produce the variants" do
+      @dude1.should_receive(:delete_point_or_clone).and_return("do parseable")
+      @zapper.generate([@dude1])
+    end
+    
+    it "should produce one result per individual in the wildtype crowd as a default" do
+      @zapper.generate([@dude1]).length.should == 1
+      @zapper.generate([@dude1, @dude1]).length.should == 2
+    end
+    
+    it "should produce more if passed the optional howManyCopies parameter > 1" do
+      @zapper.generate([@dude1],2).length.should == 2
+      @zapper.generate([@dude1, @dude1],3).length.should == 6
+    end
+    
+    it "should produce individuals from which a random point (and its subpoints) is deleted" do
+      @zapper.generate([@dude1],5).each {|baby| baby.points.should < @dude1.points}
+    end
+    
+    it "should produce 'block {}' whenever a root is deleted" do
+      @zapper.should_receive(:rand).with(4).and_return(0)
+      @zapper.generate([@dude1])[0].blueprint.should == "block {}"
+    end
+    
+    it "should increment the progress of the offspring" do
+      @dude1.stub(:progress).and_return(195)
+      @zapper.generate([@dude1])[0].progress.should == 196
+    end
+    
+    it "should handle moving the footnotes correctly"
+    
+    it "should maintain unused footnotes correctly"
+    
+  end
+end

data/spec/operators/pointMutation_spec.rb

@@ -0,0 +1,77 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "PointMutationOperator" do
+  describe "initialization" do
+    it "should have a params attribute when created that sets basic values for code generation" do
+      PointMutationOperator.new.incoming_options.should == {}
+      mutator = PointMutationOperator.new(:points => 3, :blocks => 1)
+      mutator.incoming_options.should_not == {}
+      mutator.incoming_options[:points].should == 3
+    end
+  end
+  
+  describe "generate" do
+    before(:each) do
+      @gammaray = PointMutationOperator.new(target_size_in_points: 3, types_name: ["int"])
+      @dude1 = Answer.new("block { do x1 \n do x2 \n do x3}")
+    end
+    
+    it "should accept an Array of one or more Answers as a param" do
+      lambda{@gammaray.generate()}.should raise_error(ArgumentError)
+      lambda{@gammaray.generate(99)}.should raise_error(ArgumentError)
+      lambda{@gammaray.generate([])}.should raise_error(ArgumentError)
+      lambda{@gammaray.generate([99])}.should raise_error(ArgumentError)
+      
+      lambda{@gammaray.generate([@dude1])}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should return a Batch as a result" do
+      @gammaray.generate([@dude1]).should be_a_kind_of(Batch)
+    end
+    
+    it "should use Answer#replace_point to produce the variants" do
+      @dude1.should_receive(:replace_point_or_clone).and_return("do anything")
+      @gammaray.generate([@dude1])
+    end
+    
+    it "should produce one result per individual in the wildtype crowd as a default" do
+      @gammaray.generate([@dude1]).length.should == 1
+      @gammaray.generate([@dude1,@dude1]).length.should == 2
+    end
+    
+    it "should produce more if passed the optional howManyCopies parameter > 1" do
+      @gammaray.generate([@dude1],3).length.should == 3
+      @gammaray.generate([@dude1,@dude1],2).length.should == 4
+    end
+    
+    it "should produce individuals from which a random point (and all subpoints) is replaced" do
+      @gammaray.should_receive(:rand).and_return(0)
+      @gammaray.generate([@dude1])[0].points.should == 3 # totally replaced with 3-pt code
+      @gammaray.should_receive(:rand).and_return(1)
+      @gammaray.generate([@dude1])[0].points.should == 6 #replace point 2 with 3-pt code
+      @gammaray.should_receive(:rand).and_return(2)
+      @gammaray.generate([@dude1])[0].points.should == 6 #replace point 3 with 3-pt code
+      @gammaray.should_receive(:rand).and_return(3)
+      @gammaray.generate([@dude1])[0].points.should == 6 #replace point 4 with 3-pt code
+    end
+    
+    it "should accept temporarily overriding params to pass into CodeType.random_value" do
+      @gammaray.should_receive(:rand).and_return(0)
+      @gammaray.generate([@dude1])[0].points.should == 3 # totally replaced with 3-pt code
+      @gammaray.should_receive(:rand).and_return(0)
+      @gammaray.generate([@dude1],1,target_size_in_points: 10)[0].points.should == 10
+    end
+    
+    it "should increment the #progress of the offspring" do
+      @dude1.stub(:progress).and_return(888)
+      @gammaray.generate([@dude1],13).each {|baby| baby.progress.should == 889}
+    end
+    
+    it "should handle moving the footnotes correctly"
+    
+    it "should maintain unused footnotes correctly"
+    
+    it "should introduce new footnotes smoothly, if a ValuePoint is added"
+  end
+end

data/spec/operators/random_guess_spec.rb

@@ -0,0 +1,77 @@
+#encoding:utf-8
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "random_guess operator" do
+  before(:each) do
+    @myGuesser = RandomGuessOperator.new
+  end
+  
+  it "should be a kind of SearchOperator" do
+    @myGuesser.should be_a_kind_of(SearchOperator)
+  end
+  
+  it "should have a params attribute when created that sets basic values for code generation" do
+    RandomGuessOperator.new.incoming_options.should == {}
+    thisGuesser = RandomGuessOperator.new(foo:99, bar:101)
+    thisGuesser.incoming_options.should_not == {}
+    thisGuesser.incoming_options[:foo].should == 99
+  end
+  
+  
+  it "should produce a Batch of Answers when it receives #generate" do
+    newDudes = @myGuesser.generate
+    newDudes.should be_a_kind_of(Batch)
+    newDudes[0].should be_a_kind_of(Answer)
+    newDudes[0].blueprint.should_not == nil
+    newDudes[0].program.should_not == nil
+  end
+  
+  it "should produce one as a default, more if a higher number is passed in" do
+    @myGuesser.generate.length.should == 1
+    @myGuesser.generate(4).length.should == 4
+  end
+  
+  it "should have a parsed blueprint as its #program attribute" do
+    newDudes = @myGuesser.generate
+    newDudes[0].program.should be_a_kind_of(NudgeProgram)
+  end
+  
+  it "should accept temporarily overriding options to pass into CodeType.any_value" do
+    @myNewGuesser = RandomGuessOperator.new(
+      target_size_in_points: 7,
+      instruction_names: ["int_add", "int_subtract"],
+      reference_names: ["x1", "x2", "x3"])
+      
+    lambda{@myNewGuesser.generate(
+      3,
+      target_size_in_points: 12,
+      reference_names: ["y1"])}.should_not raise_error
+      
+    @myNewGuesser.generate(
+      3,
+      target_size_in_points: 12)[0].program.points.should_not == 7
+      
+    @myNewGuesser.generate(
+      3,
+      target_size_in_points: 12)[0].program.points.should == 12
+      
+    @myNewGuesser.generate(
+      1,
+      target_size_in_points: 16,
+      probabilities:{b:0,r:1,v:0,i:0},
+      reference_names: ["y1"])[0].blueprint.should include("y1")
+  end
+  
+  it "should produce a Batch that contains Answers with progress=0 only" do
+    @myGuesser.generate(12).each {|dude| dude.progress.should == 0}
+  end
+  
+  it "should handle generated footnotes correctly" do
+    @myGuesser.generate(1,
+      target_size_in_points: 52,
+      type_names:["int"],
+      probabilities: {b:0,v:1,i:0,r:0})[0].program.footnote_section.scan(/«int»/).length.should == 51
+  end
+  
+end

data/spec/operators/resample_and_clone_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "resample_and_clone operator" do
+  before(:each) do
+    @myGuesser = RandomGuessOperator.new(type_names: ["int"], instruction_names: ["int_add"])
+    @mySampler = ResampleAndCloneOperator.new
+  end
+  
+  it "should be a kind of SearchOperator" do
+    @mySampler.should be_a_kind_of(SearchOperator)
+  end
+
+  it "should produce a list of Answers when it receives #generate" do
+    newDudes = @mySampler.generate(@myGuesser.generate(3))
+    newDudes.should be_a_kind_of(Batch)
+    newDudes[0].should be_a_kind_of(Answer)
+    newDudes[0].blueprint.should_not == nil
+    newDudes[0].program.should_not == nil
+  end
+  
+  it "should produce one Answer with a blueprint identical to one of the passed in crowd's" do
+    pop = @myGuesser.generate(1)
+    newDudes = @mySampler.generate(pop)
+    newDudes[0].blueprint.should == pop[0].blueprint
+  end
+  
+  it "should return more than one individual when asked to, resampling as needed" do
+    newDudes = @mySampler.generate(@myGuesser.generate(10))
+    newDudes.length.should == 1
+    newDudes = @mySampler.generate(@myGuesser.generate(3),2)
+    newDudes.length.should == 2
+    newDudes = @mySampler.generate(@myGuesser.generate(1),2)
+    newDudes.length.should == 2
+    newDudes[0].blueprint.should == newDudes[1].blueprint
+  end
+  
+  it "should not return links to the original program copies in the new clones" do
+    pop = @myGuesser.generate(3)
+    newDudes = @mySampler.generate(pop)
+    pop.collect {|old_dude| old_dude.program.object_id}.should_not include(newDudes[0].program.object_id)
+  end
+  
+  it "should have a parsed blueprint as its #program attribute" do
+    pop = @myGuesser.generate(3)
+    newDudes = @mySampler.generate(pop)
+    newDudes[0].program.should be_a_kind_of(NudgeProgram)
+  end
+  
+  it "should increment the #progress of each clone" do
+    pop = @myGuesser.generate(3)
+    pop.each {|donor| donor.stub(:progress).and_return(12)}
+    newDudes = @mySampler.generate(pop)
+    newDudes.each {|kid| kid.progress.should == 13}
+  end
+  
+  it "should handle footnotes correctly"
+  
+  it "should use a deep copy to clone new guys, not just clone"
+end

data/spec/operators/resample_values_spec.rb

@@ -0,0 +1,135 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "ResampleValuesOperator search operator" do
+  
+  it "should not need any initial parameters" do
+    lambda{ResampleValuesOperator.new()}.should_not raise_error
+  end
+  
+  it "should be possible to pass in stored parameters" do
+    lambda{ResampleValuesOperator.new(randomIntegerLowerBound: 12)}.should_not raise_error
+    rs = ResampleValuesOperator.new({boolTrueProbability: 0.2})
+    rs.incoming_options.should include(:boolTrueProbability)
+  end
+  
+  describe "generate" do
+    before(:each) do
+      @rs = ResampleValuesOperator.new({boolTrueProbability: 0.2})
+      @intDude = Answer.new("block {value «int»}\n«int» 3")
+      @boolDude = Answer.new("block {value «bool»}\n«bool» false")
+      @floatDude = Answer.new("block {value «float»}\n«float» -991.2213")
+      @complicatedDude = Answer.new(
+        "block {value «int» value «bool» block {value «float»}}\n«int» 3\n«bool» false\n«float» 0.0")
+    end
+    
+    it "should require a Batch as a first parameter" do
+      lambda{@rs.generate()}.should raise_error(ArgumentError)
+      lambda{@rs.generate(Batch.new)}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should raise an ArgumentError if the array parameter isn't all Answers" do
+      lambda{@rs.generate([88])}.should raise_error(ArgumentError)
+      lambda{@rs.generate([@intDude])}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should by default produce one (1) resampled mutant for each input" do
+      @rs.generate([@intDude]).length.should == 1
+      @rs.generate([@intDude, @intDude]).length.should == 2
+    end
+    
+    it "should call #any_value for each line in each individual that is a 'sample'" do
+      IntType.should_receive(:any_value).and_return(777)
+      newGuys = @rs.generate([@intDude])
+      
+      BoolType.should_receive(:any_value).and_return(false)
+      newGuys = @rs.generate([@boolDude])
+      
+      FloatType.should_receive(:any_value).and_return(9.999)
+      newGuys = @rs.generate([@floatDude])
+      
+      IntType.should_receive(:any_value).and_return(777)
+      BoolType.should_receive(:any_value).and_return(false)
+      FloatType.should_receive(:any_value).and_return(9.999)
+      newGuys = @rs.generate([@complicatedDude])
+      
+      IntType.should_receive(:any_value).and_return(1,2)
+      BoolType.should_receive(:any_value).and_return(false,true)
+      FloatType.should_receive(:any_value).and_return(1.0,2.0)
+      oldGuys = [@intDude,@boolDude,@floatDude,@complicatedDude]
+      newGuys = @rs.generate(oldGuys,1)
+    end
+    
+    it "should be possible to pass in a higher integer, and get that many variants for each input" do
+      IntType.should_receive(:any_value).and_return(11,22,33)
+      newGuys = @rs.generate([@intDude],3)
+      newGuys[0].blueprint.should include("11")
+      newGuys[1].blueprint.should include("22")
+      newGuys[2].blueprint.should include("33")
+      
+      IntType.should_receive(:any_value).and_return(4,5,6,7)
+      newGuys = @rs.generate([@intDude, @intDude],2)
+    end
+    
+    it "should be using the Operator's saved parameters as a default behavior" do
+      wholeLottaParams = {
+        :randomIntegerLowerBound => 1000,
+        :randomIntegerUpperBound => 1005,
+        :randomBooleanTruthProb => 0.2,
+        :randomFloatLowerBound => 112.0,
+        :randomFloatUpperBound => 112.5}
+      
+      resampleLimited = ResampleValuesOperator.new(wholeLottaParams)
+      
+      IntType.should_receive(:any_value).with(hash_including(wholeLottaParams))
+      newGuys = resampleLimited.generate([@intDude])
+      
+      BoolType.should_receive(:any_value).with(hash_including(wholeLottaParams))
+      newGuys = resampleLimited.generate([@boolDude])
+      
+      FloatType.should_receive(:any_value).with(hash_including(wholeLottaParams))
+      newGuys = resampleLimited.generate([@floatDude])
+    end
+    
+    it "should return Answers who (probably) differ from the originals passed in" do
+      outOfRangeParams = {
+        :randomIntegerLowerBound => 1000,
+        :randomIntegerUpperBound => 1005,
+        :randomBooleanTruthProb => 1.0,
+        :randomFloatLowerBound => 112.0,
+        :randomFloatUpperBound => 112.5}
+      resampleFarAway = ResampleValuesOperator.new(outOfRangeParams)
+      newGuys = resampleFarAway.generate([@intDude])
+      newGuys[0].blueprint.should =~ /100[0-5]/
+      newGuys = resampleFarAway.generate([@boolDude])
+      newGuys[0].blueprint.should =~ /true/
+      newGuys = resampleFarAway.generate([@floatDude])
+      newGuys[0].blueprint.should =~ /112\.[0-5]/
+    end
+    
+    it "should be possible to temporarily override some or all of the preset @params" do
+      bigInt = {:randomIntegerLowerBound => 90000,:randomIntegerUpperBound => 91000}
+      toBeOverridden = ResampleValuesOperator.new(bigInt)
+      defaults = toBeOverridden.generate([@intDude],5)
+      defaults.each {|dude| dude.blueprint.should =~ /9\d\d\d\d/}
+      
+      littler = toBeOverridden.generate([@intDude],5,
+        :randomIntegerLowerBound => -19, :randomIntegerUpperBound => -10)
+      littler.each {|dude| dude.blueprint.should =~ /-1\d/}
+    end
+    
+    it "should increment the #progress of every clone" do
+      @complicatedDude.stub!(:progress).and_return(192)
+      @rs.generate([@complicatedDude],5).each {|clone| clone.progress.should == 193}
+    end
+    
+    it "should leave unrecognized types with footnote values in place" do
+      hunh = Answer.new("value «foo»\n«foo» bar")
+      ResampleValuesOperator.new.generate([hunh])[0].blueprint.should include("bar")
+    end
+    
+    it "should work with CodeType footnotes, and reduce the number of points in each successive call"
+  end
+  
+end

data/spec/operators/uniformBackboneCrossover_spec.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "UniformBackboneCrossoverOperator" do
+  before(:each) do
+    @newDudes = []
+    @options = {target_size_in_points: 6, instruction_names: ["a", "b", "c"], type_names: ["int"]}
+    @myXover = UniformBackboneCrossoverOperator.new
+    @myGuesser = RandomGuessOperator.new(@options)
+  end
+  
+  it "should be a kind of SearchOperator" do
+    @myXover.should be_a_kind_of(SearchOperator)
+  end
+  
+  it "should produce a Batch of Answers when it receives #generate" do
+    @newDudes = @myXover.generate(@myGuesser.generate(2))
+    @newDudes.should be_a_kind_of(Batch)
+    @newDudes.each {|dude| dude.should be_a_kind_of(Answer)}
+  end
+  
+  it "should produce the same number of Answers it gets as a default" do
+    @newDudes = @myXover.generate(@myGuesser.generate(6))
+    @newDudes.length.should == 6
+  end
+  
+  it "should have an optional parameter that specifies the number of offspring to produce" do
+    @newDudes = @myXover.generate(@myGuesser.generate(2),5)
+    @newDudes.length.should == 5
+  end
+  
+  it "should only include backbone points from one of the parents in the offsprings' genomes" do
+    rents = @myGuesser.generate(2)
+    @newDudes = @myXover.generate(rents,1)
+    @newDudes.length.should == 1
+    allParentalPoints = rents[0].program[1].contents + rents[1].program[1].contents
+    allTidied = allParentalPoints.collect {|pt| "#{pt.tidy}<br />"}
+  end
+  
+  it "should return an identical individual if given only one parent" do
+    rent = @myGuesser.generate(1)
+    @newDudes = @myXover.generate(rent,3)
+    @newDudes.each {|kid| kid.program.tidy.should == rent[0].program.tidy}
+  end
+  
+  
+  it "should not affect the original parents set in any way" do
+    rents = @myGuesser.generate(2)
+    originalMom = rents[0].object_id
+    @newDudes = @myXover.generate(rents,1)
+    rents[0].object_id.should == originalMom
+  end
+  
+  it "should return offspring with #progress values incremented from the largest parent value" do
+    rents = @myGuesser.generate(2)
+    rents[0].should_receive(:progress).at_least(1).times.and_return(12)
+    rents[1].should_receive(:progress).at_least(1).times.and_return(33)
+    @newDudes = @myXover.generate(rents,20)
+    @newDudes.each {|baby| [13, 34].should include(baby.progress)}
+  end
+  
+  it "should handle moving the footnotes correctly"
+  
+  it "should maintain unused footnotes correctly"
+  
+  
+end