nudge 0.0.2 → 0.1.0

data/spec/interpreter/parser_spec.rb

@@ -1,324 +0,0 @@
-# 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/search/batch_spec.rb

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

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

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