nudge 0.0.1

data/spec/interpreter/parser_spec.rb

@@ -0,0 +1,324 @@
+# coding: utf-8
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+require 'pp'
+include Nudge
+
+describe "parser" do
+  before(:all) do
+    @parser = NudgeLanguageParser.new
+  end  
+  
+  it "should fail for an empty program" do
+    empty = ""
+    @parser.parse(empty).should == nil
+  end
+  
+  
+  
+  describe "works for single-line code" do
+    it "should recognize 'block {}'" do
+      just_block = fixture(:just_block)
+      @parser.parse(just_block).should be_a_kind_of(BlockNode)
+      asCode = @parser.parse(just_block).to_points
+      asCode.should be_a_kind_of(CodeBlock)
+    end
+    
+    it "should have the right #contents for 'block {}'" do
+      just_block = fixture(:just_block)
+      asCode = @parser.parse(just_block).to_points
+      asCode.should be_a_kind_of(CodeBlock)
+      asCode.contents.should be_a_kind_of(Array)
+      asCode.contents.length.should == 0
+    end
+    
+    it %(should recognize \"block {}\\n\") do
+      extraSpace = @parser.parse(fixture(:just_block_with_newline))
+      extraSpace.should be_a_kind_of(BlockNode)
+      asCode = extraSpace.to_points
+      asCode.should be_a_kind_of(CodeBlock)
+      asCode.contents.should be_a_kind_of(Array)
+      asCode.contents.length.should == 0
+    end
+    
+    describe ": just one instruction line" do
+      [fixture(:one_line_instr), "do      foo_bar", "do\tfoo_bar"].each do |b|
+        it "should recognize \"#{b}\"" do
+          @parser.parse(b).should be_a_kind_of(InstructionNode)
+        end
+        
+        it "should return an Instruction object for \"#{b}\"" do
+          asCode = @parser.parse(b).to_points
+          asCode.should be_a_kind_of(InstructionPoint)
+          asCode.name.should == "foo_bar"
+        end
+      end
+    end
+    
+    describe ": just one channel line" do
+      ["ref x", "ref\tx"].each do |b|
+        it "should recognize \"#{b}\"" do
+          @parser.parse(b).should be_a_kind_of(ChannelNode)
+        end
+      
+        it "should return a Channel object for \"#{b}\"" do
+          asCode = @parser.parse(b).to_points
+          asCode.should be_a_kind_of(ChannelPoint)
+          asCode.name.should == "x"
+        end
+      end
+    end
+    
+    describe ": just one literal line" do
+      
+      describe "(integer literals)" do
+        [["literal int(8)",:int,8],
+          ["literal\tint (8)",:int,8],
+          ["literal int( -221 )",:int,-221]
+          ].each do |b|
+          
+          it "should recognize \"#{b[0]}\"" do
+            @parser.parse(b[0]).should be_a_kind_of(LiteralNode)
+          end
+          
+          it "should return a LiteralPoint for \"#{b[0]}\"" do
+            asCode = @parser.parse(b[0]).to_points
+            asCode.should be_a_kind_of(LiteralPoint)
+            asCode.type.should == b[1]
+            asCode.value.should == b[2]
+          end
+        end
+      end
+      
+      describe "(boolean literals)" do
+        [["literal bool(true)",:bool,true],
+          ["literal\t bool  (false)",:bool,false],
+          ["literal bool ( FALSE )",:bool,false],
+          ["literal bool (\tTrue)",:bool,true]
+          ].each do |b|
+          
+          it "should recognize \"#{b[0]}\"" do
+            @parser.parse(b[0]).should be_a_kind_of(LiteralNode)
+          end
+
+          it "should return a LiteralPoint object for \"#{b[0]}\"" do
+            asCode = @parser.parse(b[0]).to_points
+            asCode.should be_a_kind_of(LiteralPoint)
+            asCode.type.should == b[1]
+            asCode.value.should == b[2]
+          end
+        end
+      end
+
+      describe "(float literals)" do
+        [["literal float(-6.2)",:float,-6.2],
+          ["literal\t float  (1992.0001)",:float,1992.0001],
+          ["literal\t float  ( 0.00010101 ) ",:float,0.00010101],
+          ["literal\t float (2)",:float,2.0]].each do |b|
+            
+          it "should recognize \"#{b[0]}\"" do
+            @parser.parse(b[0]).should be_a_kind_of(LiteralNode)
+          end
+          
+          it "should return a LiteralPoint object for \"#{b[0]}\"" do
+            asCode = @parser.parse(b[0]).to_points
+            asCode.should be_a_kind_of(LiteralPoint)
+            asCode.type.should == b[1]
+            asCode.value.should be_close(b[2],0.000001)
+          end          
+        end
+      end
+    end
+    
+    
+    
+    describe ": just one ERC line" do
+      describe "(integer ERCs)" do
+        [["sample int(-912)",:int,-912],["sample\tint ( -88 )",:int,-88]].each do |b|
+          it "should recognize \"#{b}\"" do
+            @parser.parse(b[0]).should be_a_kind_of(ERCNode)
+          end
+          
+          it "should return an Erc object for \"#{b[0]}\"" do
+            asCode = @parser.parse(b[0]).to_points
+            asCode.should be_a_kind_of(Erc)
+            asCode.type.should == b[1]
+            asCode.value.should ==b[2]
+          end          
+        end
+      end
+      
+      describe "(boolean ERCs)" do
+        [["sample bool(true)",:bool, true],
+          ["sample\t bool ( false ) ",:bool, false]].each do |b|
+          it "should recognize \"#{b[0]}\"" do
+            @parser.parse(b[0]).should be_a_kind_of(ERCNode)
+          end
+          
+          it "should return an Erc object for \"#{b[0]}\"" do
+            asCode = @parser.parse(b[0]).to_points
+            asCode.should be_a_kind_of(Erc)
+            asCode.type.should == b[1]
+            asCode.value.should ==b[2]
+          end          
+        end
+        
+        it "should ignore case" do
+          @parser.parse("literal bool (FALSE)").value.should == false
+          @parser.parse("literal bool(True)").value.should == true
+        end
+      end
+      
+      
+      describe "(float ERCs)" do
+        [["sample float(-9999.001)",:float,-9999.001],
+          ["sample\t float ( 33.3 ) ",:float,33.3],
+          ["sample\t\t  \tfloat  (\t12.12\t)",:float,12.12],
+          ["sample         float (1000)",:float,1000.0]].each do |b|
+          it "should recognize \"#{b[0]}\"" do
+            @parser.parse(b[0]).should be_a_kind_of(ERCNode)
+          end
+          
+          it "should return an Erc object for \"#{b[0]}\"" do
+            asCode = @parser.parse(b[0]).to_points
+            asCode.should be_a_kind_of(Erc)
+            asCode.type.should == b[1]
+            asCode.value.should be_close(b[2],0.000001)
+          end
+        end
+      end
+      
+    end
+  end
+  
+  
+  
+  describe "should handle long lists in blocks" do
+    listy = ["block {\n  literal int(1)}", "block {\n  literal int(2)\n  literal int(3)}"]
+    listy.each do |n|
+      it "should recognize \"#{n}\"" do
+        @parser.parse(n).should_not == nil
+      end
+    end
+  end
+  
+  
+  
+  describe "should handle two-line code" do
+    b2s = ["  block {}  block {}","\tblock{}\n\tblock{}","instr hey_there\ninstr now_then"]
+    b2s.each do |b|
+      it "should fail to recognize \"#{b}\" because there are two root lines" do
+        @parser.parse(b).should == nil
+      end
+    end
+    
+    b2s = ["block {\n ref x}"]
+    b2s.each do |b|
+      it "should recognize \"#{b}\"" do
+         @parser.parse(b).should_not == nil
+      end
+      
+      it "should have the right stuff inside it" do
+        asCode = @parser.parse(b).to_points
+        asCode.should be_a_kind_of(CodeBlock)
+        asCode.contents.should be_a_kind_of(Array)
+        asCode.contents[0].should be_a_kind_of(ChannelPoint)
+        asCode.contents[0].name.should == "x"
+      end
+    end
+    
+    b2s = ["block {\n  block {}}"]
+    b2s.each do |b|
+      it "should recognize \"#{b}\"" do
+         @parser.parse(b).should_not == nil
+      end
+      
+      it "should have the right stuff inside it" do
+        asCode = @parser.parse(b).to_points
+        asCode.should be_a_kind_of(CodeBlock)
+        asCode.contents.should be_a_kind_of(Array)
+        asCode.contents[0].should be_a_kind_of(CodeBlock)
+        asCode.contents[0].contents.should == []
+      end
+    end
+    
+    b2s = [["block {\n  do hey_now}",InstructionPoint],
+      ["block {\n  literal int (22) }",LiteralPoint],
+      ["block {\n  ref WVIZ}",ChannelPoint]]
+    b2s.each do |b|
+      it "should have the correct inner node type for \"#{b[0]}\"" do
+        asCode = @parser.parse(b[0]).to_points
+        asCode.should be_a_kind_of(CodeBlock)
+        asCode.contents.should be_a_kind_of(Array)
+        asCode.contents[0].should be_a_kind_of(b[1])
+      end
+    end
+  end
+  
+  
+  
+  describe "it should work for long lists of one-line points in a block" do
+    b2s = [["block {\n  do A\n  do B\n  do C}",3],
+      ["block {\n  literal int(22)\n  literal int( 23) \n  literal int( 24 )\n ref x\nref y}",5],
+      ["block {\n  ref WVIZ\n  ref WAMU}",2]]
+    b2s.each do |b|
+      it "should have the correct inner node type for \"#{b[0]}\"" do
+        asCode = @parser.parse(b[0]).to_points
+        asCode.should be_a_kind_of(CodeBlock)
+        asCode.contents.should be_a_kind_of(Array)
+        asCode.contents.length.should == b[1]
+      end
+    end
+  end
+  
+  
+  
+  describe "should handle nested blocks" do
+    nesty = ["block{\n  block {\n    block {}}}","block {\n  block {}\n  block {\n    block {\n      block {}}}}"]
+    nesty.each do |n|
+      it "should recognize \"#{n}\"" do
+        @parser.parse(n).should_not == nil
+      end
+    end
+  end
+  
+  
+  
+  describe "should handle structured blocks" do
+    nasty = ["block{\n  ref x\n  block {\n    ref y}}","block {\n  block {}\n  ref x\n  ref y}"]
+    nasty.each do |n|
+      it "should recognize \"#{n}\"" do
+        @parser.parse(n).should_not == nil
+      end
+    end
+  end
+  
+  
+  
+  describe "handling complex literals" do
+    it "should be able to parse code literals" do
+      meta = "block { literal code(block {sample int«8»})}"
+      trickymeta = @parser.parse(meta)
+      trickymeta.should_not == nil
+      trickymeta.to_points.contents[0].should be_a_kind_of(LiteralPoint)
+    end
+    
+    it "should be able to parse nested code literals (and samples)" do
+      nested = "block { literal code( sample code « sample code «do int_add»»)}"
+      trickymeta = @parser.parse(nested)
+      trickymeta.should_not == nil
+      trickymeta.to_points.contents[0].should be_a_kind_of(LiteralPoint)
+    end
+  end
+  
+  
+  
+  describe "should handle one-point programs with whitespace" do
+    buggy = ["block{}", " block{}", "  do int_add", " ref x"]
+    buggy.each do |n|
+      it "should recognize \"#{n}\"" do
+        @parser.parse(n).should_not == nil
+      end
+    end
+  end
+end

data/spec/interpreter/stack_spec.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+describe "stack" do
+  before(:each) do
+    @myStack = Stack.new(:int)
+  end
+  
+  describe "initialization" do
+    it "should have a name" do
+      @myStack.name.should == :int
+    end
+    
+    it "should only accept a symbol as a name" do
+      lambda{ Stack.new("hi")}.should raise_error(ArgumentError,"Stack name must be a Symbol")
+      lambda{ Stack.new(88)}.should raise_error(ArgumentError)
+      lambda{ Stack.new(:caprica)}.should_not raise_error
+    end
+
+    it "should have no entries" do
+      @myStack.entries.should have(0).items
+    end
+  end
+  
+  
+  describe "pushing and popping" do
+    it "should allow an object to be pushed" do
+      @myStack.push(12)
+      @myStack.entries[0].should == 12
+    end
+    
+    it "should grow by one when an item is pushed" do
+      @myStack.push(1)
+      @myStack.push(2)
+      @myStack.push(3)
+      @myStack.entries.should have(3).items
+    end
+    
+    it "should ignore attempts to push nil" do
+      @myStack.push(nil)
+      @myStack.entries.should have(0).items
+    end
+    
+    it "should return its top item when popping" do
+      @myStack.push('hello')
+      fellOff = @myStack.pop
+      fellOff.should == 'hello'
+      @myStack.entries.should have(0).items
+    end
+    
+    it "should fail silently if popped when empty, returning nil" do
+      empty = @myStack.pop
+      empty.should == nil
+      @myStack.entries.should have(0).items
+    end
+  end
+  
+  describe "peeking" do
+    it "should return but not pop the last item on the stack" do
+      @myStack.push(1)
+      @myStack.peek.should == 1
+      @myStack.push(2)
+      @myStack.peek.should == 2
+      @myStack.push(3)
+      @myStack.peek.should == 3
+    end
+    
+    it "should fail silently if popped when empty, returning nil" do
+      @myStack.peek.should == nil
+    end
+  end
+  
+  describe "depth" do
+    it "should return the number of items" do
+      @myStack.depth.should == 0
+      @myStack.push(1)
+      @myStack.push(2)
+      @myStack.depth.should == 2
+    end
+  end
+end

data/spec/interpreter/types_spec.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+describe "Type list" do
+  it "should have an #all_types [getter] method to return a list of every defined type" do
+    # will be a list of every type subclassed from NudgeType
+    NudgeType.all_types.should include(IntType)
+  end
+end
+
+describe "Int Type" do
+  it "should be a Singleton" do
+    IntType.instance.should be_a_kind_of(Singleton)
+  end
+  
+  it "should parse a string from code and produce the actual value" do
+    IntType.from_s("3").should == 3
+    lambda{IntType.from_s()}.should raise_error
+  end
+  it "should return the result of self.randomize when it receives an #any_value call" do
+    IntType.should_receive(:rand).and_return(0)
+    IntType.any_value.should == IntType.defaultLowest
+    IntType.should_receive(:rand).and_return(IntType.defaultHighest-IntType.defaultLowest)
+    IntType.any_value.should == IntType.defaultHighest
+    
+  end
+  it "should return a result from a given range when that range is passed in" do
+    IntType.should_receive(:rand).and_return(0.0)
+    param1 = {:randomIntegerLowerBound => 9, :randomIntegerUpperBound =>10}
+    IntType.random_value(param1).should == 9
+    IntType.should_receive(:rand).and_return(3.0)
+    param2 = {:randomIntegerLowerBound => 90, :randomIntegerUpperBound =>100}
+    IntType.random_value(param2).should == 93
+  end
+  
+  it "should work for any order of lower and upper bounds" do
+    IntType.should_receive(:rand).and_return(3)
+    backwards = {:randomIntegerLowerBound => 100, :randomIntegerUpperBound =>90}
+    IntType.random_value(backwards).should == 93
+  end
+  
+  it "should actually work" do
+    lambda{IntType.any_value}.should_not raise_error
+  end
+  
+end
+
+
+describe "Bool Type" do
+  it "should be a Singleton" do
+    BoolType.instance.should be_a_kind_of(Singleton)
+  end
+  it "should parse a string from code and produce the actual value" do
+    BoolType.from_s("false").should == false
+    lambda{BoolType.from_s()}.should raise_error
+  end
+  it "should return the result of self.randomize when it receives an #any_value call" do
+    BoolType.should_receive(:rand).and_return(0.1)
+    BoolType.any_value.should == true
+    BoolType.should_receive(:rand).and_return(0.9)
+    BoolType.any_value.should == false
+  end
+  
+  it "should return a result from a biased coin when the prob of true is passed in" do
+    BoolType.should_receive(:rand).and_return(0.1)
+    BoolType.any_value.should == true
+    BoolType.should_receive(:rand).and_return(0.1)
+    BoolType.random_value(:randomBooleanTruthProb => 0.05).should == false
+  end
+  
+  it "should actually work" do
+    lambda{BoolType.any_value}.should_not raise_error
+  end
+end
+
+
+describe "Float Type" do
+  it "should be a Singleton" do
+    FloatType.instance.should be_a_kind_of(Singleton)
+  end
+  it "should return the result of self.randomize when it receives an #any_value call" do
+    FloatType.should_receive(:random_value).and_return(-9.2)
+    FloatType.any_value.should == -9.2
+  end
+  it "should return a result from a given range when that range is passed in" do
+    FloatType.should_receive(:rand).and_return(0.0)
+    FloatType.random_value(:randomFloatLowerBound=>0.0, :randomFloatUpperBound=>10.0).should == 0.0
+    FloatType.should_receive(:rand).and_return(0.5)
+    FloatType.random_value(:randomFloatLowerBound=>-101.101,:randomFloatUpperBound=>101.101).should == 0.0
+  end
+  
+  it "should work for any order of lower and upper bounds" do
+    FloatType.should_receive(:rand).and_return(0.5)
+    backwards = {:randomFloatLowerBound=>101.101, :randomFloatUpperBound=>-101.101}
+    FloatType.random_value(backwards).should == 0.0
+  end
+  
+  it "should actually work" do
+    lambda{FloatType.any_value}.should_not raise_error
+  end
+  
+end

data/spec/search/batch_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+include Nudge
+
+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-Individual is added after initialization" do
+    careful = Batch.[](Individual.new("block {}"), Individual.new("block {}"))
+    careful.length.should == 2
+    
+    lambda{careful = Batch.[](12)}.should raise_error(ArgumentError)
+    lambda{careful = Batch.[](Individual.new("do int_add"))}.should_not raise_error(ArgumentError)
+    
+    lambda{careful = Batch.[](Individual.new("do int_add"),12)}.should raise_error(ArgumentError)
+    lambda{careful = Batch.[](Individual.new("do int_add"),
+      Individual.new("do int_add"))}.should_not raise_error(ArgumentError)
+      
+    lambda{careful = Batch.new(12)}.should raise_error(ArgumentError)
+    lambda{careful = Batch.new(Individual.new("do int_add"))}.should_not raise_error(ArgumentError)
+    
+    lambda{careful[1] = 991}.should raise_error(ArgumentError)
+    lambda{careful[1] = Individual.new("do int_add")}.should_not raise_error(ArgumentError)
+    
+    lambda{careful << false}.should raise_error(ArgumentError)
+    lambda{careful << Individual.new("do int_add")}.should_not raise_error(ArgumentError)
+    
+  end
+end

data/spec/search/experiments/experiment_spec.rb

@@ -0,0 +1,101 @@
+require File.join(File.dirname(__FILE__), "./../../spec_helper")
+require 'fakeweb'
+include Nudge
+
+
+
+describe "Experiment" do
+  before(:each) do
+    @exp = Experiment.new
+  end
+  
+  it "should have a name defaulting to 'default_experiment'" do
+    @exp.name.should == 'default_experiment'
+    Experiment.new(name: "regress").name.should == "regress"
+  end
+  
+  describe "#config object" do
+    it "should have a #config attribute, of class Config" do
+      @exp.config.should_not == nil
+      @exp.config.should be_a_kind_of(Nudge::Config)
+    end
+  end
+  
+  it "should have an #instructions Array, defaulting to all of them" do
+    (@exp.instructions.sort_by {|i| i.to_s}).should == (Instruction.all_instructions.sort_by {|i| i.to_s})
+  end
+  
+  it "should have a #types Array, defaulting to [BoolType, FloatType, IntType]" do
+    @exp.types.should == [BoolType, FloatType, IntType]
+  end
+  
+  
+  describe "stations" do
+    before(:each) do
+      @exp = Experiment.new
+      Station.cleanup
+    end
+    
+    it "should have an empty hash of Station names" do
+      @exp.station_names.should == []
+    end
+    
+    describe "build_station" do
+      it "should create a new Station instance, and add it to its own #stations list" do
+        @exp.build_station("wondrous")
+        @exp.station_names.should include("wondrous")
+        Station.stations.keys.should include("wondrous")
+      end
+      
+      it "should use the parameters passed in" do
+        @exp.build_station("wondrous", capacity:12)
+        Station.stations["wondrous"].capacity.should == 12
+      end
+    end
+    
+    describe "connect_stations" do
+      it "should create a #flows_into connection between two Stations when called" do
+        @exp.build_station("alphaville")
+        @exp.build_station("beta_2")
+        Station.stations["alphaville"].downstream.should be_empty
+        Station.stations["beta_2"].downstream.should be_empty
+        @exp.connect_stations("alphaville", "beta_2")
+        Station.stations["alphaville"].downstream.should include("beta_2")
+      end
+      
+      it "should raise an ArgumentError if either name does not yet exist in the Experiment" do
+        @exp.build_station("alphaville")
+        @exp.build_station("beta_2")
+        lambda{@exp.connect_stations("alphaville", "beta_2")}.should_not raise_error(ArgumentError)
+        lambda{@exp.connect_stations("cygnus", "beta_2")}.should raise_error(ArgumentError)
+        lambda{@exp.connect_stations("alphaville", "cygnus")}.should raise_error(ArgumentError)
+      end
+    end
+  end
+  
+  describe "objectives" do
+    it "should have a library of 'permitted' objectives, an empty hash to begin with" do
+      @exp.objectives.should == {}
+    end
+    
+  end
+  
+  describe "databases" do
+    it "should have a couchDB URL attribute, via parameter setting or default" do
+      @exp.couch_url.should == "http://localhost:5984"
+      otherplace = 'http://vagueserver.com:99999'
+      Experiment.new(:couch_url => otherplace).couch_url.should == otherplace
+    end
+    
+    it "should have a method to check that couchDB is accessible" do
+      FakeWeb.register_uri(:get, "http://localhost:5984", :status => ["200", "OK"])
+      @exp.couch_url = "http://localhost:5984"
+      @exp.couch_live?.should == true
+            
+      FakeWeb.register_uri(:get, "http://localhost:99999", :exception => SocketError)
+      @exp.couch_url = "http://localhost:99999"
+      @exp.couch_live?.should == false
+    end
+  end
+  
+end

data/spec/search/helpers_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+include Nudge
+
+describe "Config" do
+  it "should have a class #setup method that stores a block" do
+    Nudge::Config.should respond_to(:setup)
+    Nudge::Config.setup {:foo}
+    Nudge::Config.stored_state.should be_a_kind_of(Proc)
+    Nudge::Config.stored_state.call.should == :foo
+  end
+  
+end
+
+
+describe "InterpreterSettings" do
+  before(:each) do
+    @s1 = InterpreterSettings.new
+  end
+  
+  it "should have an Array of active instruction classNames" do
+    @s1.instructions.should be_a_kind_of(Array)
+  end
+  
+  it "should default to all instructions defined" do
+    @s1.instructions.should == Instruction.all_instructions
+  end
+  
+  it "should have an Array of variable names" do
+    @s1.references.should == []
+  end
+  
+  it "should have an Array of active Types" do
+    @s1.types.should be_a_kind_of(Array)
+  end
+  
+  it "should default to the Push types" do
+    @s1.types.should == NudgeType.push_types
+  end
+  
+  describe "setting the value of Setting#attribute in initialization" do
+    it "should allow Hash-values for instructions" do
+      bools = [BoolAndInstruction, BoolOrInstruction]
+      s2 = InterpreterSettings.new(:instructions => bools)
+      s2.instructions.should == bools
+    end
+    
+    it "should allow Hash-values for types" do
+      push = [IntType, BoolType, FloatType]
+      s2 = InterpreterSettings.new(:types => push)
+      s2.types.should == push
+    end
+    
+    it "should allow Hash-values for variable names" do
+      vars = ["x1", "x3", "y1"]
+      s2 = InterpreterSettings.new(:references => vars)
+      s2.references.should == vars
+    end
+  end
+end