answer-factory 0.0.1

data/readme.md

@@ -0,0 +1,29 @@
+# Pragmatic Genetic Programming with Nudge
+
+## Caveat
+
+This particular project is undergoing a lot of serious surgery right now.
+
+## What it does
+
+Well, it's complicated, and in a state of dynamic change right this second.
+
+Let's just say it helps _regular people_ build, run and manage technical experiments that use genetic programming. There's more... but that's the bottom line.
+
+## Getting started
+
+You'll need a working (and running) installation of CouchDB.
+
+Then:
+
+    gem install nudge
+    gem install thor
+    gem install couch-rest
+    gem install sinatra
+    
+and for running specs (which you _should be doing_):
+    
+    gem install rspec
+    gem install sinatra
+    gem install fakeweb
+    

data/spec/answer_spec.rb

@@ -0,0 +1,412 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+
+describe "Answer" do
+  
+  describe "initialization" do
+    it "should accept a string OR a NudgeProgram as an initialization parameter" do
+      lambda{Answer.new("any string")}.should_not raise_error
+      lambda{Answer.new(NudgeProgram.new("block {}"))}.should_not raise_error
+    end
+    
+    it "should validate the initial parameter and make sure it's only one of the accepted classes" do
+      lambda{Answer.new(8812.9)}.should raise_error(ArgumentError)
+      lambda{Answer.new(Time.now)}.should raise_error(ArgumentError)
+      lambda{Answer.new}.should raise_error(ArgumentError)
+    end
+    
+    it "should set the #draft_blueprint attribute from the string, if present" do
+      Answer.new("do x").draft_blueprint.should == "do x"
+      Answer.new("some «random»\njunk").draft_blueprint.should == "some «random»\njunk"
+    end
+    
+    it "should set the #draft_blueprint attribute to the blueprint of the NudgeProgram, if present" do
+      Answer.new(NudgeProgram.new("value «foo»\n«foo» bar")).draft_blueprint.should ==
+        "value «foo» \n«foo» bar"
+    end
+    
+    it "should set the #program attribute to a new NudgeProgram based on init'n string, if present" do
+      np = Answer.new("do x").program
+      np.should be_a_kind_of(NudgeProgram)
+      np.blueprint.should == "do x"
+    end
+    
+    it "should set the #program attribute even if the init'n string is unparseable" do
+      np = Answer.new("not a program")
+      np.program.should be_a_kind_of(NudgeProgram)
+      np.draft_blueprint.should == "not a program"
+      np.program.linked_code.should be_a_kind_of(NilPoint)
+      np.program.blueprint.should == ""
+    end
+    
+    it "should set the #program attribute to the init'n NudgeProgram, if present" do
+      prog = NudgeProgram.new("block {ref a ref b}")
+      na = Answer.new(prog)
+      na.program.should == prog
+      na.draft_blueprint.should == prog.blueprint
+    end
+    
+    it "should respond to #blueprint by returning self.program.blueprint" do
+      prog = NudgeProgram.new("block {ref a do x}")
+      na = Answer.new(prog)
+      prog.should_receive(:blueprint).and_return("hi there")
+      na.blueprint.should == "hi there"
+    end
+    
+    it "should have a #scores hash, which is empty" do
+      Answer.new("foo").scores.should == {}
+    end
+    
+    it "should have a #timestamp, which is when (wall clock time) it was made" do
+      tn = Time.now
+      Time.should_receive(:now).and_return(tn)
+      Answer.new("bar").timestamp.should == tn
+    end
+        
+    it "should have a [named] #progress attribute, defaulting to zero" do
+      Answer.new("baz").progress.should == 0
+      Answer.new("baz", progress:12).progress.should == 12
+    end
+    
+    it "should have an #ancestors Array, defaulting to []" do
+      Answer.new("quux").ancestors.should == []
+      Answer.new("quux", ancestors:[1,2,3]).ancestors.should == [1,2,3]
+    end
+  end
+  
+  
+  describe "serialization" do
+    describe "writing" do
+      before(:each) do
+        @a1 = Answer.new("block {do a}")
+      end
+      
+      it "should contain the blueprint" do
+        @a1.data['blueprint'].should == @a1.blueprint
+      end
+      
+      it "should contain the tags" do
+        @a1.data['tags'].should == @a1.tags
+      end
+      
+      
+      it "should contain the scores" do
+        @a1.data['scores'].should == @a1.scores
+      end
+      
+      it "should contain the timestamp" do
+        @a1.data['timestamp'].should == @a1.timestamp
+      end
+    end
+    
+    describe "reading" do
+      
+    end
+  end
+  
+  
+  describe "#parses?" do
+    it "should respond to #parses? with an answer from its NudgeProgram" do
+      Answer.new("not good word").parses?.should == false
+      Answer.new("block {do nice_nudge}").parses?.should == true
+    end
+  end
+  
+  
+  describe "scores" do
+    before(:each) do
+      @answer1 = Answer.new("do a")
+      @answer1.scores[:error] = 81.9
+      @answer1.scores[:a_1] = 2200
+      
+      @answer2 = Answer.new("some other crap")
+      @answer2.scores[:error] = 7
+      @answer2.scores[:a_1] = 1200
+    end
+    
+    it "should require symbols as keys" do
+      lambda{@answer2.scores["foo"]}.should raise_error(ArgumentError)
+      lambda{@answer2.scores[:bar]}.should_not raise_error(ArgumentError)
+    end
+    
+    describe "#known_criteria" do
+      it "#known_criteria should return a sorted list of the keys of the scores hash" do
+        @answer1.known_criteria.should == [:a_1, :error]
+        Answer.new("x").known_criteria.should == []
+      end
+    end
+    
+    describe "#score_vector" do
+      it "#score_vector should return an Array of #scores" do
+        a1s = @answer1.score_vector
+        a1s.should be_a_kind_of(Array)
+        a1s.sort.should == [2200, 81.9].sort # ignoring returned orderuntil next spec
+      end
+      
+      it "should use the argument to order the scores in the result" do
+        @answer1.score_vector([:a_1]).should == [2200]
+        @answer1.score_vector([:error, :a_1]).should == [81.9, 2200]
+      end
+      
+      it "the scores should be by default in #known_criteria (alphabetical) order" do
+        @answer1.scores[:bobby] = -121.1
+        a1s = @answer1.score_vector
+        a1s[0].should == @answer1.scores[:a_1]
+        a1s[1].should == @answer1.scores[:bobby]
+        a1s[2].should == @answer1.scores[:error]
+      end
+      
+      it "should return nil for any nonexistent score item" do
+        @answer1.score_vector([:nonexisto, :a_1]).should == [nil, 2200]
+      end
+    end
+    
+    describe "#dominated_by?" do
+      
+      it "should return false when the compared Answer doesn't have the same scoring_criteria" do
+        @answer1.scores = {a:10}
+        @answer2.scores = {     b:99}
+        @answer1.dominated_by?(@answer2).should == false
+        
+        @answer1.scores = {a:10, b:10}
+        @answer2.scores = {      b:99, c:10}
+        @answer1.dominated_by?(@answer2).should == false
+        
+        @answer1.scores = {a:10, b:10, c:10, d:10}
+        @answer2.scores = {      b:99, c:10, d:1}
+        @answer1.dominated_by?(@answer2).should == false
+        
+        @answer1.scores = {x1:1, x2:2, x3:3}
+        @answer2.scores = {      x2:0,      x4:12}
+        @answer1.dominated_by?(@answer2).should == false
+        @answer2.dominated_by?(@answer1).should == false
+      end
+      
+      it "should use the comparison template to check whether the scoring criteria are the same" do
+        @answer1.scores = {a:10, b:10, c:10, d:10}
+        @answer2.scores = {      b:99, c:10, d:1}
+        @answer1.dominated_by?(@answer2).should == false
+        
+        @answer1.scores = {a:10, b:10, c:10, d:10}
+        @answer2.scores = {      b:99, c:10, d:1}
+        @answer1.dominated_by?(@answer2, [:d]).should == true
+        @answer2.dominated_by?(@answer1, [:b,:c]).should == true
+      end
+      
+      it "should return true if another Answer has one score better and all the rest the same" do
+        @answer1.scores = {:a => 10, :b =>10}
+        @answer2.scores = {:a => 10, :b => 9}
+        @answer1.dominated_by?(@answer2).should == true
+      end
+      
+      it "should return false if another Answer has all scores worse" do
+        @answer1.scores = {:a => 10, :b =>10}
+        @answer2.scores = {:a=> 1000, :b => 1000}
+        @answer1.dominated_by?(@answer2).should == false
+      end
+      
+      it "should return false if another Answer has all scores the same and one worse" do
+        @answer1.scores = {:a => 10, :b =>10}
+        @answer2.scores = {:a=> 10, :b => 1000}
+        @answer1.dominated_by?(@answer2).should == false
+      end
+      
+      it "should return false if another Answer has some scores better and some worse" do
+        @answer1.scores = {:a => 10, :b =>10}
+        @answer2.scores = {:a=> 1000, :b => 1}
+        @answer1.dominated_by?(@answer2).should == false
+      end
+      
+      it "should return true if another Answer has all scores better" do
+        @answer1.scores = {:a => 10, :b =>10}
+        @answer2.scores = {:a=> 1, :b => 1}
+        @answer1.dominated_by?(@answer2).should == true
+      end
+      
+      it "should return false if another Answer has all scores identical" do
+        @answer1.scores = {:a => 10, :b =>10}
+        @answer2.scores = {:a=> 10, :b => 10}
+        @answer1.dominated_by?(@answer2).should == false
+      end
+      
+      it "should use known_criteria if no comparison template is passed in" do
+        @answer1.scores = {:a => 10, :b =>10, :c => 100}
+        @answer2.scores = {:a=> 1, :b => 1, :c => 99}
+        @answer1.should_receive(:known_criteria).at_least(1).times.and_return([:a,:b,:c])
+        @answer1.dominated_by?(@answer2).should == true
+      end
+      
+      it "should use a comparison template if one is passed in" do
+        @answer1.scores = {:a => 10, :b =>10, :c => 10}
+        @answer2.scores = {:a=> 1, :b => 200, :c => 10}
+        @answer1.dominated_by?(@answer2, [:a]).should == true
+        @answer1.dominated_by?(@answer2, [:b]).should == false
+        @answer1.dominated_by?(@answer2, [:c]).should == false
+        
+        @answer2.dominated_by?(@answer1, [:a]).should == false
+        @answer2.dominated_by?(@answer1, [:b]).should == true
+        @answer2.dominated_by?(@answer1, [:c]).should == false
+        
+        @answer1.dominated_by?(@answer2, [:a, :c]).should == true
+        @answer2.dominated_by?(@answer1, [:b, :c]).should == true
+      end
+      
+      
+      it "should be conservative when comparing against a missing score" do
+        @answer1.scores = {:a => 10, :b =>nil, :c => 100}
+        @answer2.scores = {:a=> 1, :b => 12, :c => 99}
+        lambda{@answer1.dominated_by?(@answer2)}.should_not raise_error(NoMethodError)
+        @answer1.dominated_by?(@answer2).should == false
+      end
+    end
+  end
+  
+  
+  describe "#points method" do
+    it "should return self.program.points" do
+      Answer.new("").points.should == 0
+      Answer.new("block {do a do b}").points.should == 3
+      Answer.new("block {value «foo» block {value «foo»}}").points.should == 4
+    end
+  end
+  
+  
+  describe "replace_point_or_clone" do
+    before(:each) do
+      @simple = Answer.new("block { do a do b do c do d do e}")
+      @complicated = Answer.new("block { block {do a} do b block { block {do c} block {do d}} do e}")
+      @str_insert  = "ref x"
+      @pt_insert = ReferencePoint.new("y")
+    end
+    
+    it "should return a NudgeProgram (not an Answer)" do
+      @simple.replace_point_or_clone(2,@str_insert).should be_a_kind_of(NudgeProgram)
+    end
+    
+    it "should return a clone of the original NudgeProgram if the position param is out of bounds" do
+      new_guy = @simple.replace_point_or_clone(-11,"do x")
+      new_guy.blueprint.should == @simple.blueprint
+      new_guy.object_id.should_not == @simple.program.object_id
+      
+      new_guy = @simple.replace_point_or_clone(1911,"do x")
+      new_guy.blueprint.should == @simple.blueprint
+    end
+    
+    it "should raise an ArgumentError if passed an unparseable replacement" do
+      lambda{@simple.replace_point_or_clone(3,"some crap")}.should raise_error(ArgumentError)
+      lambda{@simple.replace_point_or_clone(3,"block {}")}.should_not raise_error
+    end
+    
+    it "should produce a new parsable NudgeProgram with a new blueprint (as expected)" do
+      @simple.replace_point_or_clone(2,@str_insert).blueprint.should ==
+        "block {\n  ref x\n  do b\n  do c\n  do d\n  do e}"
+      @complicated.replace_point_or_clone(2,@str_insert).blueprint.should ==
+        "block {\n  ref x\n  do b\n  block {\n    block {\n      do c}\n    block {\n      do d}}\n  do e}"
+    end
+    
+    it "should replace the expected specific point (and any subpoints and footnotes it has)" do
+      a1 = Answer.new("block {value «code» value «int»}\n«code» value «float»\n«float» 1.1\n«int» 12")
+      a1.replace_point_or_clone(2,"do x").blueprint.should ==
+        "block {\n  do x\n  value «int»} \n«int» 12"
+    end
+        
+    it "should insert the new footnotes it needs in the right place in the footnote_section" do
+      a1 = Answer.new("block {value «code» value «int»}\n«code» value «float»\n«float» 1.1\n«int» 12")
+      a1.replace_point_or_clone(3,"value «foo»\n«foo» bar").blueprint.should ==
+        "block {\n  value «code»\n  value «foo»} \n«code» value «float»\n«float» 1.1\n«foo» bar"
+    end
+    
+    it "should not affect extra (unused) footnotes" do
+      a1 = Answer.new("block {value «int»}\n«float» 1.1\n«int» 12")
+      a1.replace_point_or_clone(2, "do x").blueprint.should ==
+        "block {\n  do x} \n«float» 1.1"
+    end
+    
+    it "should work when putting in something that lacks a footnote" do
+      @simple.replace_point_or_clone(3, "value «quux»").blueprint.should ==
+        "block {\n  do a\n  value «quux»\n  do c\n  do d\n  do e} \n«quux»"
+    end
+    
+    it "should act as expected when replacing the root" do
+      @simple.replace_point_or_clone(1, "value «quux»").blueprint.should ==
+        "value «quux» \n«quux»"
+    end
+  end
+  
+  
+  
+  describe "delete_point_or_clone" do
+    before(:each) do
+      @simple = Answer.new("block { do a do b do c do d do e}")
+      @complicated = Answer.new("block { block {do a} do b block { block {do c} block {do d}} do e}")
+    end
+    
+    
+    it "should return a NudgeProgram (not an Answer)" do
+      @simple.delete_point_or_clone(2).should be_a_kind_of(NudgeProgram)
+    end
+    
+    it "should return a clone of the calling Answer's program if the point is out of bounds" do
+      new_guy = @simple.delete_point_or_clone(-11)
+      new_guy.blueprint.should == @simple.blueprint
+      new_guy.object_id.should_not == @simple.program.object_id
+      
+      new_guy = @simple.delete_point_or_clone(1911)
+      new_guy.blueprint.should == @simple.blueprint
+    end
+    
+    it "should return a NudgeProgram with at least one fewer program points (if the range is OK)" do
+      @complicated.delete_point_or_clone(2).points.should < @complicated.points
+    end
+    
+    it "should delete the expected specific point (and any subpoints it has)" do
+      @complicated.delete_point_or_clone(5).blueprint.should == 
+        "block {\n  block {\n    do a}\n  do b\n  do e}"
+    end
+    
+    it "should return NudgeProgram.new('block {}') when the entire program is deleted" do
+      @complicated.delete_point_or_clone(1).blueprint.should == "block {}"
+    end
+    
+    it "should delete the footnotes associated with a point it deletes" do
+      a1 = Answer.new("block {value «a» value «b» value «c»}\n«a» 1\n«b» 2\n«c» 3")
+      a1.delete_point_or_clone(3).blueprint.should ==
+        "block {\n  value «a»\n  value «c»} \n«a» 1\n«c» 3"
+    end
+    
+    it "should not delete extra footnotes" do
+      a1 = Answer.new("block {value «a»}\n«a» 1\n«b» 2\n«c» 3")
+      a1.delete_point_or_clone(2).blueprint.should ==
+        "block {} \n«b» 2\n«c» 3"
+    end
+  end
+  
+  
+  describe "tags" do
+    it "should have a tags array" do
+      Answer.new("").tags.should be_a_kind_of(Set)
+    end
+    
+    it "should be possible to set the tags upon initialization" do
+      Answer.new("do a", tags:[:here, :now]).tags.should == Set.new([:here, :now])
+    end
+    
+    it "should have an #add_tag method" do
+      a1 = Answer.new("")
+      a1.add_tag(:foo)
+      a1.tags.should include(:foo)
+    end
+    
+    it "should validate that tags being added are Symbols" do
+      lambda{Answer.new("").add_tag("foo")}.should raise_error(ArgumentError)
+    end
+    
+    it "should have an #remove_tag method" do
+      a1 = Answer.new("", tags:[:a, :b])
+      a1.tags.should include(:a)
+      a1.remove_tag(:a)
+      a1.tags.should_not include(:a)
+    end
+  end
+end

data/spec/batch_spec.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), "./spec_helper")
+
+describe "Batches" do
+  it "should be a kind of Array" do
+    Batch.new.should be_a_kind_of(Array)
+  end
+  
+  it "should raise an exception if a non-Answer is added after initialization" do
+    careful = Batch.[](Answer.new("block {}"), Answer.new("block {}"))
+    careful.length.should == 2
+    
+    lambda{careful = Batch.[](12)}.should raise_error(ArgumentError)
+    lambda{careful = Batch.[](Answer.new("do int_add"))}.should_not raise_error(ArgumentError)
+    
+    lambda{careful = Batch.[](Answer.new("do int_add"),12)}.should raise_error(ArgumentError)
+    lambda{careful = Batch.[](Answer.new("do int_add"),
+      Answer.new("do int_add"))}.should_not raise_error(ArgumentError)
+      
+    lambda{careful = Batch.new(12)}.should raise_error(ArgumentError)
+    lambda{careful = Batch.new(Answer.new("do int_add"))}.should_not raise_error(ArgumentError)
+    
+    lambda{careful[1] = 991}.should raise_error(ArgumentError)
+    lambda{careful[1] = Answer.new("do int_add")}.should_not raise_error(ArgumentError)
+    
+    lambda{careful << false}.should raise_error(ArgumentError)
+    lambda{careful << Answer.new("do int_add")}.should_not raise_error(ArgumentError)
+  end
+  
+  
+  describe "database persistence" do
+    before(:each) do
+      FakeWeb.allow_net_connect = false
+    end
+    
+    describe "bulk_save!" do
+      it "should have a #bulk_save method" do
+        Batch.new.should respond_to(:bulk_save!)
+      end
+      
+      it "should validate a String as its argument" do
+        lambda{Batch.new.bulk_save!("some string")}.should_not raise_error(ArgumentError)
+        lambda{Batch.new.bulk_save!(8812)}.should raise_error(ArgumentError)
+      end
+      
+      
+      describe "writing" do
+        before(:each) do
+          @uri = "http://mycouch.db/boo"
+          @b1 = Batch.new
+          @a1 = Answer.new("do a")
+          @b1 << @a1
+        end
+        
+        it "should create the database if it doesn't exist" do
+          FakeWeb.register_uri(:any, @uri, :body => "We are here!", :status => [200, "OK"])
+          CouchRest.stub(:database!).and_return(the_db = Object.new)
+          the_db.stub!(:bulk_save)
+          CouchRest.should_receive(:database!)
+          Batch.new.bulk_save!(@uri)
+        end
+
+        it "should bulk_save the Answers" do
+          CouchRest.stub(:database!).and_return(the_db = Object.new)
+          the_db.should_receive(:bulk_save)
+          @b1.bulk_save!(@uri)
+        end
+        
+        describe "data" do
+          it "should return an array of its contents' #data" do
+            @b1.data.should == [ @a1.data ]
+          end
+        end
+      end
+      
+      describe "reading" do
+        before(:each) do
+          @uri = "http://127.0.0.1/baz:5984"
+        end
+        
+        it "create a new Batch" do
+          Batch.load_tagged_answers(@uri,"foo").should be_a_kind_of(Batch)
+        end
+        
+        it "should access the database" do
+          CouchRest.should_receive(:database).with(@uri)
+          Batch.load_tagged_answers(@uri, "workstation_1")
+        end
+        
+        it "should work"
+      end
+      
+    end
+    
+    
+    it "should have a Batch.load_from_couch method that reads a bunch of Answers from the db"
+    
+  end
+end