nudge 0.0.1

data/spec/interpreter/instruction_spec.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+class MyThingInstruction < Instruction
+end
+
+class PirateTalkInstruction < Instruction
+  def go
+  end
+end
+
+describe "InstructionPoint" do
+  it "should have a name parameter, with no default" do
+    myI = InstructionPoint.new("foo_bar")
+    myI.name.should == "foo_bar"
+    lambda {InstructionPoint.new()}.should raise_error(ArgumentError)
+  end
+  
+  it "should have a symbol as a name" do
+    myI = InstructionPoint.new("foo_bar")
+    myI.name.should be_a_kind_of(String)
+  end
+  
+  it "should be a kind of program point" do
+    myL = InstructionPoint.new("int_thing")
+    myL.should be_a_kind_of(ProgramPoint)
+  end
+  
+  describe "#tidy" do
+    it "should return 'do x' when the name is 'x'" do
+      myI = InstructionPoint.new("x")
+      myI.tidy.should == "do x"
+    end
+  end
+  
+  [["plant_water","PlantWaterInstruction"],["opinion_greaterthan?", "OpinionGreaterthan?Instruction"]].each do |inp|
+    it "should know the appropriate class name for the Instruction singleton for #{inp}" do
+      pointName = inp[0]
+      cName = inp[1]
+      myI = InstructionPoint.new(pointName)
+      myI.className.should == cName
+    end
+  end
+  
+  
+  describe "#go" do
+    describe "class lookup" do
+      it "should find the appropriate class (by name), if it exists, in an Interpreter context" do
+        myI = InstructionPoint.new("my_thing")
+        myI.classLookup.should == MyThingInstruction
+      end
+
+      it "should raise a InstructionNotFoundError if the class doesn't exist" do
+        myI = InstructionPoint.new("foo_baz")
+        lambda{myI.classLookup}.should raise_error(InstructionPoint::InstructionNotFoundError)
+      end
+    end
+    
+    it "should delegate #go to the appropriate Instruction Class" do
+      context = Interpreter.new
+      context.enable(IntAddInstruction)
+      context.instructions_library[IntAddInstruction].should_receive(:go)
+      myI = InstructionPoint.new("int_add").go(context)
+    end
+  end
+  
+  describe "randomize" do
+    before(:each) do
+      @context = Interpreter.new
+      @context.enable_all_instructions
+    end
+    
+    it "should return one of the active instructions" do
+      myInstrP = InstructionPoint.new("float_multiply")
+      @context.disable_all_instructions
+      @context.enable(IntAddInstruction)
+      myInstrP.randomize(@context)
+      myInstrP.name.should == "int_add"
+    end
+  end
+  
+  describe "any" do
+    before(:each) do
+      @context = Interpreter.new
+      @context.enable_all_instructions
+    end
+    
+    it "should return a new instance of an instruction, invoking randomize" do
+      someI = InstructionPoint.any(@context)
+      someI.should be_a_kind_of(InstructionPoint)
+      @context.disable_all_instructions
+      @context.enable(FloatSubtractInstruction)
+      someI = InstructionPoint.any(@context)
+      someI.name.should == "float_subtract"
+    end
+  end
+end

data/spec/interpreter/interpreter_spec.rb

@@ -0,0 +1,266 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+include Nudge
+
+describe "initialization" do
+  before(:each) do
+    @ii = Interpreter.new()
+    @ii.clear_stacks
+  end
+  
+  it "should have a #parser, which defaults to a new NudgeLanguageParser" do
+    @ii.parser.should be_a_kind_of(NudgeLanguageParser)
+  end
+  
+  it "should have an empty stacks Hash, empty initially" do
+    @ii.stacks.should == {}
+  end
+  
+  it "should keep have an empty instructions attribute, a Hash" do
+    @ii.instructions_library.should == Hash.new
+  end
+  
+  it "should automatically create an entry if an unmentioned stack is referenced by a method" do
+    lambda{@ii.stacks[:pirate].peek}.should_not raise_error
+    @ii.stacks.should include(:pirate)
+    
+    @ii.stacks.should_not include(:ninja) 
+    lambda{@ii.stacks[:ninja].depth}.should_not raise_error
+    @ii.stacks.should include(:ninja)
+    
+    @ii.stacks.should_not include(:robot)
+    lambda{@ii.stacks[:robot].pop}.should_not raise_error
+    @ii.stacks.should include(:robot)
+  end
+  
+  it "should respond to #reset(listing) by parsing the listing and pushing it onto its exec stack" do
+    checker = NudgeLanguageParser.new()
+    myCode = "ref x"
+    @ii.reset(myCode)
+    @ii.stacks.should include(:exec)
+    @ii.stacks[:exec].should be_a_kind_of(Stack)
+    @ii.stacks[:exec].depth.should == 1
+    @ii.stacks[:exec].peek.should be_a_kind_of(ChannelPoint)
+    @ii.stacks[:exec].peek.name.should == checker.parse(myCode).to_points.name
+  end
+  
+  it "#reset should reset the #steps counter, too" do
+    @ii.steps = 100
+    @ii.reset("channel x")
+    @ii.steps.should == 0
+  end
+  
+  it "should load a complex CodeBlock as a single item on the exec stack" do
+    checker = NudgeLanguageParser.new()
+    myCode = "block {\ndo foo\n do bar\n block {\ndo baz}}"
+    @ii.reset(myCode)
+    @ii.stacks.should include(:exec)
+    @ii.stacks[:exec].depth.should == 1
+    whatGotPushed = @ii.stacks[:exec].peek
+    whatGotPushed.should be_a_kind_of(CodeBlock)
+    whatGotPushed.contents.length.should == checker.parse(myCode).to_points.contents.length
+    whatGotPushed.contents[1].name.should == "bar"
+    whatGotPushed.contents[2].contents[0].name.should == "baz"
+  end
+  
+  it "should accept a listing, which should default to an empty string" do
+    ij = Interpreter.new(program:"literal int(7)")
+    ij.stacks[:exec].peek.should be_a_kind_of(LiteralPoint)
+  end
+  
+  it "should have an #enable method that works for Instructions, adding them to the #instructions hash" do
+    @ii.instructions_library.should == {}
+    @ii.enable(IntAddInstruction)
+    @ii.instructions_library[IntAddInstruction].should_not== nil
+    @ii.instructions_library[IntAddInstruction].should be_a_kind_of(IntAddInstruction)
+    @ii.instructions_library[IntAddInstruction].context.should == @ii
+  end
+  
+  it "should have an #enable_all_instructions method" do
+    @ii.instructions_library.should == {}
+    @ii.enable_all_instructions
+    @ii.instructions_library.keys.should == Instruction.all_instructions
+  end
+  
+  it "should have a #disable_all_instructions method" do
+    @ii.enable_all_instructions
+    @ii.instructions_library.should_not == {}
+    @ii.disable_all_instructions
+    @ii.instructions_library.should == {}
+  end
+  
+  it "should have a #disable method that removes Instructions from the #instructions hash" do
+    @ii.enable(IntAddInstruction)
+    @ii.instructions_library[IntAddInstruction].should_not == nil
+    @ii.disable(IntAddInstruction)
+    @ii.instructions_library.should_not include(IntAddInstruction)
+  end
+  
+  describe "variables table" do
+    it "should be an empty hash initially (by deafult)" do
+      @ii.variables.should == {}
+    end
+
+    it "should create a new entry when #bind_variable is called" do
+      @ii.bind_variable("x",LiteralPoint.new(:int,88))
+      @ii.variables["x"].should be_a_kind_of(LiteralPoint)
+      @ii.variables["x"].type.should == :int
+      @ii.variables["x"].value.should == 88
+    end
+    
+    it "should raise an exception if the bound value is anything but a LiteralPoint" do
+      lambda {@ii.bind_variable("x", 88)}.should raise_error(ArgumentError)
+      lambda {@ii.bind_variable("x", [1,2])}.should raise_error(ArgumentError)
+      lambda {@ii.bind_variable("x", nil)}.should raise_error(ArgumentError)
+    end
+    
+    it "should remove an new entry when #unbind_variable is called" do
+      @ii.bind_variable("x",LiteralPoint.new(:int,88))
+      @ii.variables["x"].value.should == 88
+      @ii.unbind_variable("x")
+      @ii.variables["x"].should == nil
+    end
+    
+    it "should be resettable" do
+      @ii.bind_variable("x",LiteralPoint.new(:int,88))
+      @ii.reset_variables
+      @ii.variables.should_not include("x")
+    end
+  end
+  
+  describe "names table" do
+    it "should be an empty hash initially" do
+      @ii.names.should == {}
+    end
+  
+    it "should create a new entry when #bind_name is called" do
+      @ii.bind_name("x",LiteralPoint.new(:bool,false))
+      @ii.names["x"].should be_a_kind_of(LiteralPoint)
+      @ii.names["x"].type.should == :bool
+      @ii.names["x"].value.should == false
+    end
+
+    it "should raise an exception if the bound value is anything but a LiteralPoint" do
+      lambda {@ii.bind_name("x", 88)}.should raise_error(ArgumentError)
+      lambda {@ii.bind_name("x", [1,2])}.should raise_error(ArgumentError)
+      lambda {@ii.bind_name("x", nil)}.should raise_error(ArgumentError)
+    end
+    
+    it "should remove an new entry when #unbind_name is called" do
+      @ii.bind_name("x",LiteralPoint.new(:int,88))
+      @ii.names["x"].value.should == 88
+      @ii.unbind_name("x")
+      @ii.names["x"].should == nil
+    end
+    
+    it "should be resettable" do
+      @ii.bind_name("x",LiteralPoint.new(:int,88))
+      @ii.reset_names
+      @ii.names.should_not include("x")
+    end
+  end
+  
+  describe "references" do
+    it "should return an Array of keys obtained by mergine variables into names (not vice versa)" do
+      @ii.bind_name("x",LiteralPoint.new(:int,88))
+      @ii.bind_variable("y",LiteralPoint.new(:int,88))
+      @ii.bind_name("y",LiteralPoint.new(:bool,false))
+      @ii.references.should == @ii.names.merge(@ii.variables).keys
+      @ii.references.should_not == @ii.variables.merge(@ii.names).keys
+    end
+  end
+  
+  describe "Type list" do
+    it "should have a #types attribute whis defaults to NudgeType.all_types" do
+      @ii.types.should == NudgeType.all_types
+    end
+    
+    it "should have a #enable_all_types/#disable_all_types methods that turn on and off all active types" do
+      @ii.enable(BoolType)
+      @ii.disable_all_types
+      @ii.types.should_not include(BoolType)
+      @ii.enable_all_types
+      @ii.types.should == NudgeType.all_types
+    end
+
+    it "should have #enable/#disable methods that add and remove the types from #types list" do
+      @ii.enable(IntType)
+      @ii.enable(BoolType)
+      @ii.disable(IntType)
+      @ii.active?(IntType).should == false
+      @ii.active?(BoolType).should == true
+      @ii.enable(IntType)
+      @ii.active?(IntType).should == true
+      @ii.active?(BoolType).should == true
+    end
+
+    it "should only ever have one copy of a type on the list at once" do
+      @ii.disable_all_types
+      @ii.enable(IntType)
+      @ii.enable(IntType)
+      @ii.enable(IntType)
+      @ii.types.length.should == 1
+    end
+  end
+  
+end
+
+describe "stepping" do
+  before(:each) do
+    @ii = Interpreter.new()
+    @ii.clear_stacks
+  end
+  
+  it "should step only until the :exec stack is empty (if the PointLimit has not been reached)" do
+    myCode = "block {}"
+    @ii.reset(myCode)
+    lambda{3.times {@ii.step}}.should_not raise_error 
+  end
+  
+  it "should step only until the stepLimit has not been reached, if the :exec stack is full" do
+    myCode = "block {"*20 + "}"*20
+    @ii.stepLimit = 3
+    @ii.reset(myCode)
+    lambda{15.times {@ii.step}}.should_not raise_error
+  end
+  
+  it "should count how many steps are executed" do
+    myCode = "block {"*20 + "}"*20
+    @ii.reset(myCode)
+    11.times {@ii.step}
+    @ii.steps.should == 11
+    11.times {@ii.step}
+    @ii.steps.should == 20
+  end
+  
+end
+
+describe "running" do
+  before(:each) do
+    @ii = Interpreter.new()
+    @ii.clear_stacks
+    myCode = "block {"*20 + "}"*20
+    @ii.reset(myCode)
+  end
+  
+  it "should run until the stepLimit has been reached, if the :exec stack isn't empty" do
+    @ii.stepLimit = 9
+    @ii.run
+    @ii.steps.should == 9
+  end
+  
+  it "should run until the :exec stack is empty (if the PointLimit has not been reached)" do
+    @ii.run
+    @ii.steps.should == 20
+  end
+  
+  it "should do nothing if the :exec stack starts empty" do
+    @ii.reset()
+    @ii.run
+    @ii.steps.should == 0
+  end
+  
+end
+
+describe "channel setup" do
+end

data/spec/interpreter/literal_spec.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+include Nudge
+
+describe "LiteralPoint" do
+  
+    it "should be a kind of program point" do
+      myL = LiteralPoint.new("int", 4)
+      myL.should be_a_kind_of(ProgramPoint)
+    end
+    
+    it "should be initialized with a type and a value, with no defaults" do
+      myL = LiteralPoint.new("int", 4)
+      myL.should be_a_kind_of(LiteralPoint)
+      myL.type.should == :int
+      myL.value.should == 4
+      lambda{LiteralPoint.new()}.should raise_error(ArgumentError)
+      lambda{LiteralPoint.new("bool")}.should raise_error(ArgumentError)
+    end
+    
+    it "should move to the appropriate stack when removed from the exec stack" do
+      ii = Interpreter.new(program:"literal bool (true)")
+      ii.step
+      ii.stacks[:bool].peek.value.should == true
+    end
+    
+    describe "#go" do
+      before(:each) do
+        @ii = Interpreter.new()
+        @ii.clear_stacks
+        @ii.stacks[:int] = Stack.new(:int)
+        @ii.reset("literal int (999)")
+      end
+      
+      it "should pop the exec stack when a LiteralPoint is interpreted" do
+        oldExec = @ii.stacks[:exec].depth
+        @ii.step
+        @ii.stacks[:exec].depth.should == (oldExec-1)
+      end
+      
+      it "should initialize the right stack for the type of the LiteralPoint if it doesn't exist" do
+        @ii.stacks.delete(:int)
+        @ii.step
+        @ii.stacks.should include(:int)
+      end
+      
+      it "should use the existing stack if it does exist" do
+        @ii.step
+        @ii.stacks[:int].depth.should == 1
+      end
+
+      it "should push the value onto the right stack" do
+        @ii.stacks[:exec].push(LiteralPoint.new("int",3))
+        @ii.stacks[:exec].push(LiteralPoint.new("float",2.2))
+        @ii.stacks[:exec].push(LiteralPoint.new("bool",false))
+        
+        3.times {@ii.step}
+        @ii.stacks.should include(:int)
+        @ii.stacks.should include(:float)
+        @ii.stacks.should include(:bool)
+      end
+    end
+    
+    describe "#tidy" do
+      it "should print 'literal type, value' for LiteralPoint#tidy" do
+        myL = LiteralPoint.new("float", -99.121001)
+        myL.tidy.should == "literal float (-99.121001)"
+      end
+    end
+    
+    describe "randomize" do
+      before(:each) do
+        @ii = Interpreter.new()
+        @ii.enable_all_types
+      end
+      
+      it "should return one of the active types (not one of the defined types!)" do
+        myL = LiteralPoint.new("int", 77)
+        @ii.disable_all_types
+        @ii.enable(BoolType)
+        myL.randomize(@ii)
+        myL.type.should == "bool"
+      end
+    end
+    
+    describe "random CodeType should not be a problem" do
+      it "should have a valid code type and a value that parses" do
+        @ii = Interpreter.new()
+        @ii.disable_all_types
+        @ii.disable_all_instructions
+        @ii.enable(CodeType)
+        lambda{LiteralPoint.any(@ii)}.should raise_error(ArgumentError, "Random code cannot be created")
+      end
+    end
+end