answer-factory 0.0.9 → 0.0.10

data/lib/operators/point_delete_operator.rb

@@ -0,0 +1,19 @@
+module AnswerFactory
+  class PointDeleteOperator < SearchOperator
+    def generate(crowd, howManyCopies = 1)
+      raise(ArgumentError) if !crowd.kind_of?(Array)
+      crowd.each {|dude| raise(ArgumentError) if !dude.kind_of?(Answer) }
+      
+      result = Batch.new
+      crowd.each do |dude|
+        howManyCopies.times do
+          where = rand(dude.points)+1
+          variant = dude.delete_point_or_clone(where)
+          baby = Answer.new(variant, progress:dude.progress + 1)
+          result << baby
+        end
+      end
+      return result
+    end
+  end
+end

data/lib/operators/point_mutation_operator.rb

@@ -0,0 +1,22 @@
+module AnswerFactory
+  class PointMutationOperator < SearchOperator
+    
+    def generate(crowd, howManyCopies = 1, overridden_options ={})
+      raise(ArgumentError) if !crowd.kind_of?(Array)
+      raise(ArgumentError) if crowd.empty?
+      crowd.each {|dude| raise(ArgumentError) if !dude.kind_of?(Answer) }
+      
+      result = Batch.new
+      crowd.each do |dude|
+        howManyCopies.times do
+          where = rand(dude.points)+1
+          newCode = CodeType.any_value(@incoming_options.merge(overridden_options))
+          variant = dude.replace_point_or_clone(where,newCode)
+          baby = Answer.new(variant, progress:dude.progress + 1)
+          result << baby 
+        end
+      end
+      return result
+    end
+  end
+end

data/lib/operators/program_point_count_evaluator.rb

@@ -0,0 +1,14 @@
+module AnswerFactory
+  class ProgramPointEvaluator < Evaluator
+    def evaluate(batch)
+      raise(ArgumentError, "Can only evaluate a Batch of Answers") if !batch.kind_of?(Batch)
+      batch.each do |i|
+        if i.parses?
+          i.scores[@score_label] = i.program.points
+        else
+          raise(ArgumentError, "Program is not parseable")
+        end
+      end
+    end
+  end
+end

data/lib/operators/random_guess_operator.rb

@@ -0,0 +1,30 @@
+module AnswerFactory
+  class RandomGuessOperator < SearchOperator
+  
+    # returns an Array of random Answers
+    #
+    # the first (optional) parameter specifies how many to make, and defaults to 1
+    # the second (also optional) parameter is a hash that
+    # can temporarily override those set in the initialization
+    #
+    # For example, if
+    # <tt>myRandomGuesser = RandomGuessOperator.new(:randomIntegerLowerBound => -90000)</tt>
+    #
+    # [<tt>myRandomGuesser.generate()</tt>]
+    #   produces a list of 1 Answer, and if it has any IntType samples they will be in [-90000,100]
+    #   (since the default +:randomIntegerLowerBound+ is 100)
+    # [<tt>myRandomGuesser.generate(1,:randomIntegerLowerBound => 0)</tt>]
+    #   makes one Answer whose IntType samples (if any) will be between [0,100]
+  
+    def generate(crowd, overridden_options = {})
+      every_option = @incoming_options.merge(overridden_options)
+      how_many = every_option[:how_many] || 1
+      how_many.times do
+        newGenome = CodeType.any_value(every_option)
+        newDude = Answer.new(newGenome, progress:0)
+        crowd << newDude
+      end
+      return crowd
+    end
+  end
+end

data/lib/operators/resample_and_clone_operator.rb

@@ -0,0 +1,28 @@
+module AnswerFactory
+  class ResampleAndCloneOperator < SearchOperator
+  
+    # returns an Array of clones of Answers randomly selected from the crowd passed in
+    # 
+    # the first (required) parameter is an Array of Answers
+    # the second (optional) parameter is how many samples to take, and defaults to 1
+    #
+    # For example, if
+    # <tt>@currentPopulation = [a list of 300 Answers]</tt> and
+    # <tt>myRandomSampler = ResampleAndCloneOperator.new(@currentPopulation)</tt>
+    # [<tt>myRandomSampler.generate()</tt>]
+    #   produces a list of 1 Answer, which is a clone of somebody from <tt>@currentPopulation</tt>
+    # [<tt>myRandomGuesser.generate(11)</tt>]
+    #   returns a list of 11 Answers cloned from <tt>@currentPopulation</tt>,
+    #   possibly including repeats
+  
+    def generate(crowd, howMany = 1)
+      result = Batch.new
+      howMany.times do
+        donor = crowd.sample
+        clone = Answer.new(donor.blueprint, progress:donor.progress + 1)
+        result << clone
+      end
+      return result
+    end
+  end
+end

data/lib/operators/resample_values_operator.rb

@@ -0,0 +1,40 @@
+#encoding: utf-8
+module AnswerFactory
+  
+  class ResampleValuesOperator < SearchOperator
+  
+    def generate(crowd, howManyCopies = 1, overridden_options = {})
+      crowd.each {|dude| raise(ArgumentError) if !dude.kind_of?(Answer) }
+    
+      result = Batch.new
+      regenerating_options = @incoming_options.merge(overridden_options)
+      crowd.each do |dude|
+        howManyCopies.times do
+          wildtype_program = dude.program
+          starting_footnotes = wildtype_program.footnote_section.split( /^(?=«)/ )
+          breaker = /^«([a-zA-Z][a-zA-Z0-9_]*)»\s*(.*)\s*/m
+          type_value_pairs = starting_footnotes.collect {|fn| fn.match(breaker)[1..2]}
+        
+          mutant_blueprint = wildtype_program.code_section
+        
+          type_value_pairs.each do |pair|
+          
+            begin
+              type_name = pair[0]
+              type_class = "#{type_name}_type".camelize.constantize
+              reduced_size = regenerating_options[:target_size_in_points] || rand(dude.points/2)
+              reduced_option = {target_size_in_points:reduced_size}
+              resampled_value = type_class.any_value(regenerating_options.merge(reduced_option)).to_s
+            rescue NameError
+              resampled_value = pair[1]
+            end            
+            mutant_blueprint << "\n«#{pair[0].strip}» #{resampled_value.strip}"
+          end
+          mutant = Answer.new(mutant_blueprint, progress:dude.progress + 1)
+          result << mutant
+        end
+      end
+      return result
+    end
+  end
+end

data/lib/operators/{evaluators.rb → test_case_evaluator.rb}

@@ -1,35 +1,4 @@
 module AnswerFactory
-  
-  class Evaluator < SearchOperator
-    attr_accessor :name
-    
-    def initialize(params = {})
-      raise(ArgumentError, "Evaluators must be initialized with names") if params[:name] == nil
-      @name = params[:name]
-    end
-  end
-  
-  
-  
-  
-  
-  class ProgramPointEvaluator < Evaluator
-    def evaluate(batch)
-      raise(ArgumentError, "Can only evaluate a Batch of Answers") if !batch.kind_of?(Batch)
-      batch.each do |i|
-        if i.parses?
-          i.scores[@name] = i.program.points
-        else
-          raise(ArgumentError, "Program is not parseable")
-        end
-      end
-    end
-  end
-  
-  
-  
-  
-  
   class TestCase
     attr_accessor :bindings, :expectations, :gauges
     
@@ -59,7 +28,7 @@ module AnswerFactory
       variable_names = params[:references] || []
       
       batch.each do |dude|
-        if !params[:deterministic] || !dude.scores[@name]
+        if !params[:deterministic] || !dude.scores[@score_label]
           score = 0
           readings = {}
           cases.each do |example|
@@ -100,11 +69,11 @@ module AnswerFactory
             score += difference.abs
           end
           # aggregate differences
-          dude.scores[@name] = score.to_f / cases.length
+          dude.scores[@score_label] = score.to_f / cases.length
         
           puts "#{score.to_f / cases.length}" if params[:feedback]
         else
-          puts dude.scores[@name] if params[:feedback]
+          puts dude.scores[@score_label] if params[:feedback]
         end
       end
     end

data/lib/operators/uniform_backbone_crossover_operator.rb

@@ -0,0 +1,53 @@
+module AnswerFactory
+  class UniformBackboneCrossoverOperator < SearchOperator
+    
+    # Returns a Batch of new Answers whose programs are made by stitching together
+    # the programs of pairs of 'parents'. The incoming Batch is divided into pairs based on
+    # adjacency (modulo the Batch.length), one pair for each 'offspring' to be made. To make
+    # an offspring, the number of backbone program points is determined in each parent; 'backbone'
+    # refers to the number of branches directly within the root of the program, not the entire tree.
+    #
+    # To construct an offspring's program, program points are copied from the first parent with
+    # probability p, or the second parent with probability (1-p), for each point in the first
+    # parent's backbone. So if there are 13 and 6 points, respectively, the first six points are
+    # selected randomly, but the last 7 are copied from the first parent. If there are 8 and 11
+    # respectively, then the last 3 will be ignored from the second parent in any case.
+    #   
+    #   the first (required) parameter is an Array of Answers
+    #   the second (optional) parameter is how many crossovers to make,
+    #     which defaults to the number of Answers in the incoming Batch
+    
+    def generate(crowd, howMany = crowd.length, prob = 0.5)
+      result = Batch.new
+      howMany.times do
+        where = rand(crowd.length)
+        mom = crowd[where]
+        dad = crowd[ (where+1) % crowd.length ]
+        mom_backbone_length = mom.program[1].contents.length
+        dad_backbone_length = dad.program[1].contents.length
+        
+        baby_blueprint_parts = ["",""]
+        (0..mom_backbone_length-1).each do |backbone_point|
+          if rand() < prob
+            next_chunks = mom.program[1].contents[backbone_point].blueprint_parts || ["",""]
+          else
+            if backbone_point < dad_backbone_length
+              next_chunks = (dad.program[1].contents[backbone_point].blueprint_parts || ["", ""])
+            else
+              next_chunks = ["",""]
+            end
+          end
+          baby_blueprint_parts[0] << " #{next_chunks[0]}"
+          baby_blueprint_parts[1] << " \n#{next_chunks[1]}"
+        end
+        mom.program.unused_footnotes.each {|fn| baby_blueprint_parts[1] += "\n#{fn}"}
+        
+        baby_blueprint = "block {#{baby_blueprint_parts[0]}} #{baby_blueprint_parts[1]}"
+        baby = Answer.new(baby_blueprint, progress:[mom.progress,dad.progress].max + 1)
+        
+        result << baby
+      end
+      return result
+    end
+  end
+end

data/readme.md

@@ -22,10 +22,35 @@ The AnswerFactory infrastructure has been designed to help _regular people_ buil
 
 ## Getting started
 
-You'll need a working (and running) installation of CouchDB.
+The `answer-factory` gem depends on Ruby 1.9 or higher. We recommend [rvm](http://rvm.beginrescueend.com/) if you'd like to maintain several Ruby installations.
 
-Then:
+You'll also need a working installation of [CouchDB](http://couchdb.apache.org/) available. This can be a remote instance, as long as you have the necessary permissions to create and manage databases.
 
+Then:
     gem install answer-factory
     
-This should automatically load dependent gems, including nudge, rspec, and many others.
+This will automatically install several dependencies, including [nudge](http://github.com/Vaguery/Nudge), rspec, and others.
+
+### Creating a new AnswerFactory project
+
+Use this command line script to build an AnswerFactory project folder:
+    answer-factory your-project-name-here
+
+This will create a new directory called 'your-project-name-here', and install a rudimentary subtree of folders and files. Perhaps most important is the `Thorfile`, which contains most of the generators you can use to simplify project creation and management.
+
+### Replicating a pre-existing project or demo
+
+TBD
+
+### Generating new Nudge type defintitions
+
+The Nudge language gem installed along with `answer-factory` includes a full-featured programming language designed for genetic programming projects, with integer, floating-point, boolean, and code types.
+
+Often your project's domain model will call for additional types. To generate some basic infrastructure for a new NudgeType subclass, navigate to the root of your project folder and invoke the thor script
+    thor new_nudge_type your-nudge-type-name
+This will create a template for your class definition in the `/lib/nudge/types` subdirectory (which you should edit as indicated in the comments to use), several standard nudge instruction classes in `/lib/nudge/instructions`, and rspec files.
+
+### Activating the AnswerFactory daemon
+
+Make sure CouchDB is running and available, navigate to your project's root folder, and invoke
+    ruby activate.rb

data/spec/answer_spec.rb

@@ -78,7 +78,7 @@ describe "Answer" do
   describe "serialization" do
     describe "writing" do
       before(:each) do
-        @a1 = Answer.new("block {do a}")
+        @a1 = Answer.new("block {do a}", progress:12)
       end
       
       it "should contain the blueprint" do
@@ -94,12 +94,44 @@ describe "Answer" do
         @a1.data['scores'].should == @a1.scores
       end
       
+      it "should contain the progress" do
+        @a1.data['progress'].should == @a1.progress
+      end
+      
+      
       it "should contain the timestamp" do
         @a1.data['timestamp'].should == @a1.timestamp
       end
     end
     
     describe "reading" do
+      before(:each) do
+        @couchified = {"id"=>"0f60c293ad736abfdb083d33f71ef9ab", "key"=>"ws1", "value"=>{"_id"=>"0f60c293ad736abfdb083d33f71ef9ab", "_rev"=>"1-473467b6dc1a4cba3498dd6eeb8e3206", "blueprint"=>"do bar", "tags"=>["quux", "whatevz"], "scores"=>{"badness" => 12.345}, "progress" => 12, "timestamp"=>"2010/04/14 17:09:14 +0000"}}
+        @my_a = Answer.from_serial_hash(@couchified)
+      end
+      
+      it "should record the couch_doc_id" do
+        @my_a.couch_id.should == "0f60c293ad736abfdb083d33f71ef9ab"
+      end
+      
+      it "should accept a blueprint string" do
+        @my_a.blueprint.should == "do bar"
+      end
+      
+      it "should collect the tag Array into a Set of symbols" do
+        @my_a.tags.should be_a_kind_of(Set)
+        @my_a.tags.should include(:quux)
+        @my_a.tags.should include(:whatevz)
+      end
+            
+      it "should gather up the scores Hash" do
+        @my_a.scores.should be_a_kind_of(Hash)
+        @my_a.scores.should include(:badness)
+      end
+      
+      it "should read the progress" do
+        @my_a.progress.should == 12
+      end
       
     end
   end

data/spec/batch_spec.rb

@@ -74,25 +74,38 @@ describe "Batches" do
       
       describe "reading" do
         before(:each) do
-          @uri = "http://127.0.0.1/baz:5984"
+          @uri = "http://127.0.0.1:5984/my_factory"
+          @design_doc = "ws1/current"  # we'll assume this has been set up!
+          @view_uri = "http://127.0.0.1:5984/my_factory/_design/ws1/_view/current"
+          FakeWeb.allow_net_connect = false
+          @canned = '{"total_rows":1,"offset":0,"rows":[{"id":"0f60c293ad736abfdb083d33f71ef9ab","key":"ws1","value":{"_id":"0f60c293ad736abfdb083d33f71ef9ab","_rev":"1-473467b6dc1a4cba3498dd6eeb8e3206","blueprint":"do bar","tags":[],"scores":{},"progress":12,"timestamp":"2010/04/14 17:09:14 +0000"}}]}'
+          
         end
         
-        it "create a new Batch" do
-          Batch.load_tagged_answers(@uri,"foo").should be_a_kind_of(Batch)
+        it "should connect to the right view in the right design doc in the persistent store" do
+          FakeWeb.register_uri(:any, @view_uri, :body => @canned, :status => [200, "OK"])
+          lambda{Batch.load_from_couch(@uri,@design_doc)}.should_not raise_error
+            # because it hit the right URI!
         end
         
-        it "should access the database" do
-          CouchRest.should_receive(:database).with(@uri)
-          Batch.load_tagged_answers(@uri, "workstation_1")
-        end
+        it "should handle errors returned from CouchDB"
+        
+        it "should handle db connection problems"
         
-        it "should work"
+        it "should create an Answer for every row received" do
+          FakeWeb.register_uri(:any, @view_uri, :body => @canned, :status => [200, "OK"])
+          little_batch = Batch.load_from_couch(@uri,@design_doc)
+          little_batch.length.should == 1
+          little_batch[0].blueprint.should == "do bar"
+        end
+
+        it "should raise an warning and create an empty Batch if it can't parse the result" do
+          FakeWeb.register_uri(:any, @view_uri, :body => "some random crap", :status => [200, "OK"])
+          little_batch = Batch.load_from_couch(@uri,@design_doc)
+          little_batch.length.should == 0
+        end
       end
       
     end
-    
-    
-    it "should have a Batch.load_from_couch method that reads a bunch of Answers from the db"
-    
   end
 end

data/spec/factories/factory_spec.rb

@@ -11,6 +11,59 @@ describe "Factory" do
     Factory.new.name.should == "my_factory"
   end
   
+  
+  describe "databases" do
+    describe "#couch_available?" do
+      it "should have a method to check that couchDB is accessible" do
+        f1 = Factory.new("boo")
+        lambda{f1.couch_available?}.should_not raise_error
+      end
+      
+      it "should return true if the uri is reachable" do
+        uri = "http://mycouch.db/boo"
+        f1 = Factory.new("boo")
+        f1.configatron.couchdb_uri = uri
+        FakeWeb.register_uri(:any, uri, :body => "We are here!", :status => [200, "OK"])
+        f1.couch_available?.should == true
+      end
+      
+      it "should return false if the uri is offline or 404's out" do
+        uri = "http://mycouch.db/boo"
+        f1 = Factory.new("boo")
+        f1.configatron.couchdb_uri = uri
+        f1.configatron.couchdb_uri.should == uri
+        FakeWeb.register_uri(:any, uri, :body => "Go away!", :status => [404, "Not Found"])
+        f1.couch_available?.should == false
+        
+        f1 = Factory.new("boo") # depends on this being wrong
+        f1.configatron.couchdb_uri = "http://127.0.0.1:9991/place"
+        f1.couch_available?.should == false
+      end
+    end
+  end
+  
+  
+  describe "build" do
+    it "should read the config files"
+    
+    it "should #reset"
+  end
+  
+  
+  describe "reset" do
+    it "should erase the couchdb"
+    
+    it "should set up a new couchdb"
+    
+    it "should set up the necessary design documents in the db"
+  end
+  
+  
+  describe "activate" do
+    it "should check the config files"
+  end
+  
+  
   describe "ontology" do
     it "should have a master Instruction list" do
       Factory.new("foo").instruction_library.should == Instruction.all_instructions
@@ -44,43 +97,7 @@ describe "Factory" do
       Factory.new.workstation_names.should == []
     end
     
-    describe "build_workstation" do
-      it "should create a new workstation"
-      it "should set up all the interior dynamics of the workstation"
-      it "should use the master config for defaults of the new workstation"
-      it "should suffice to create a pass-through workstation just to name it"
-    end
   end
   
-  describe "activate" do
-    it "should have an #activate method"
-  end
   
-  describe "databases" do
-    
-    describe "#couch_available?" do
-      it "should have a method to check that couchDB is accessible" do
-        f1 = Factory.new("boo")
-        lambda{f1.couch_available?}.should_not raise_error
-      end
-      
-      it "should return true if the uri is reachable" do
-        uri = "http://mycouch.db/boo"
-        f1 = Factory.new("boo")
-        f1.configatron.couchdb_uri = uri
-        FakeWeb.register_uri(:any, uri, :body => "We are here!", :status => [200, "OK"])
-        f1.couch_available?.should == true
-      end
-      
-      it "should return false if the uri is offline or 404's out" do
-        uri = "http://mycouch.db/boo"
-        f1 = Factory.new("boo", couchdb_uri:uri)
-        FakeWeb.register_uri(:any, uri, :body => "Go away!", :status => [404, "Not Found"])
-        f1.couch_available?.should == false
-        
-        f1 = Factory.new("boo", couchdb_uri:"http://127.0.0.1:9991/place") # depends on this being wrong
-        f1.couch_available?.should == false
-      end
-    end
-  end
 end