nudge 0.1.0 → 0.1.1

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/interpreter/interpreter.rb

@@ -16,6 +16,7 @@ module Nudge
     attr_accessor :program, :stepLimit, :steps
     attr_accessor :stacks, :instructions_library, :variables, :names, :types
     attr_accessor :last_name, :evaluate_references
+    attr_accessor :sensors
     
     
     # A program to be interpreted can be passed in as an optional parameter
@@ -24,6 +25,7 @@ module Nudge
       @program = initialProgram
       @types = params[:types] || NudgeType.all_types
       @stepLimit = params[:step_limit] || 3000
+      @sensors = Hash.new
       
       instructions = params[:instructions] || Instruction.all_instructions
       @instructions_library = Hash.new {|hash, key| raise InstructionPoint::InstructionNotFoundError,
@@ -54,6 +56,7 @@ module Nudge
       @program = program
       self.clear_stacks
       self.reset_names
+      self.reset_sensors
       if program
         @stacks[:exec].push(NudgeProgram.new(program).linked_code)
       end
@@ -67,6 +70,11 @@ module Nudge
     end
     
     
+    def depth(stackname)
+      @stacks[stackname].depth
+    end
+    
+    
     def peek(stackname)
       @stacks[stackname].peek
     end
@@ -127,6 +135,7 @@ module Nudge
       while notDone?
         self.step
       end
+      fire_all_sensors
     end
     
     
@@ -226,5 +235,24 @@ module Nudge
     def disable_all_types
       @types = []
     end
+    
+    
+    def register_sensor(name, &block)
+      raise(ArgumentError, "Sensor name #{name} is not a string") unless name.kind_of?(String)
+      @sensors[name] = block
+    end
+    
+    
+    def reset_sensors
+      @sensors = Hash.new
+    end
+    
+    
+    def fire_all_sensors
+      @sensors.inject({}) do |result, (key, value)|
+        result[key] = @sensors[key].call(self)
+        result
+      end
+    end
   end
 end

data/lib/interpreter/nudge_program.rb

@@ -9,7 +9,6 @@ module Nudge
     attr_accessor :linked_code,:footnotes
     attr_accessor :raw_code
     attr_accessor :code_section, :footnote_section
-    attr_reader :parser
     attr_reader :points
     
     
@@ -17,7 +16,6 @@ module Nudge
       raise(ArgumentError, "NudgeProgram.new should be passed a string") unless sourcecode.kind_of?(String)
       @raw_code = sourcecode
       program_split!
-      @parser = NudgeCodeblockParser.new
       relink_code!
       @points = self.points
     end
@@ -49,7 +47,7 @@ module Nudge
     
     def relink_code!
       if parses?
-        @linked_code = @parser.parse(@code_section).to_point
+        @linked_code = NudgeCodeblockParser.new.parse(@code_section).to_point
         depth_first_association!
       else
         @linked_code = NilPoint.new
@@ -76,7 +74,7 @@ module Nudge
     def pursue_more_footnotes(codepoint_as_string, collected_footnotes = "")
       local_footnotes = ""
       if self.contains_valuepoints?(codepoint_as_string)
-        local_parsetree = @parser.parse(codepoint_as_string)
+        local_parsetree = NudgeCodeblockParser.new.parse(codepoint_as_string)
         if local_parsetree != nil
           local_subtree = local_parsetree.to_point
           if local_subtree.kind_of?(CodeblockPoint)
@@ -213,7 +211,7 @@ module Nudge
     
     
     def parses?(program_blueprint = @code_section)
-      (@parser.parse(program_blueprint) != nil)
+      (NudgeCodeblockParser.new.parse(program_blueprint) != nil)
     end
     
     

data/lib/interpreter/stack.rb

@@ -1,3 +1,4 @@
+#encoding: utf-8
 module Nudge
   
   # Nudge Stacks are Arrays with some added convenience functions.
@@ -34,6 +35,13 @@ module Nudge
       @entries.length
     end
     
+    def inspect
+      result = @entries.reverse.inject("[") do |return_string, item|
+        return_string << "\n«#{item.type}» #{item.value},"
+      end
+      result.chop+"]"
+    end
+    
   end
   
 end

data/spec/interpreter/interpreter_spec.rb

@@ -45,6 +45,13 @@ describe "initialization" do
     @ii.steps.should == 0
   end
   
+  it "#reset should reset the #sensors Hash" do
+    @ii.register_sensor("z") {1201}
+    @ii.reset
+    @ii.sensors["z"].should == nil
+  end
+  
+  
   it "should load a complex CodeBlock as a single item on the exec stack" do
     myCode = "block {\ndo foo\n do bar\n block {\ndo baz}}"
     @ii.reset(myCode)
@@ -230,6 +237,31 @@ describe "Interpreter#peek" do
 end
 
 
+describe "Interpreter#depth" do
+  before(:each) do
+    @ii = Interpreter.new()
+    @ii.clear_stacks
+  end
+  
+  it "should invoke a particular stack's #depth method" do
+    30.times { @ii.stacks[:donut].push(ValuePoint.new("donut", "0")) }
+    lambda{@ii.depth(:donut)}.should_not raise_error
+    @ii.depth(:donut).should == 30
+  end
+  
+  it "should return 0 if the stack doesn't exist" do
+    lambda{@ii.depth(:nonexistent)}.should_not raise_error
+    @ii.depth(:nonexistent).should == 0
+  end
+  
+  it "should validate the stackname as a symbol" do
+    lambda{@ii.depth("not there")}.should raise_error(ArgumentError)
+    lambda{@ii.depth(99)}.should raise_error(ArgumentError)
+  end
+end
+
+
+
 
 describe "Interpreter#peek_value" do
   before(:each) do
@@ -417,6 +449,10 @@ describe "running" do
     @ii.steps.should == 0
   end
   
+  it "should #fire_all_sensors at the end of running" do
+    @ii.should_receive(:fire_all_sensors)
+    @ii.run
+  end
 end
 
 
@@ -458,3 +494,69 @@ describe "resetting" do
     ii.variables.keys.should == ["a"]
   end
 end
+
+
+describe "sensors" do
+  before(:each) do
+    @ii = Interpreter.new
+  end
+  
+  describe "register_sensor" do
+    it "should add a sensor block to the #sensors Hash" do
+      lambda{@ii.register_sensor("y") {}}.should_not raise_error
+      @ii.sensors.length.should == 1
+      @ii.sensors["y"].should be_a_kind_of(Proc)
+    end
+    
+    it "should take a string name, validated as such" do
+      lambda{@ii.register_sensor("z")}.should_not raise_error
+      lambda{@ii.register_sensor(8)}.should raise_error(ArgumentError)
+    end
+    
+    it "should take a block, which is called when the sensor is fired" do
+      @ii.register_sensor("y") {|x| 9}
+      @ii.sensors["y"].call.should == 9
+    end
+    
+    it "should have access to the Interpreter state through a parameter" do
+      @ii.push(:int, 10202)
+      @ii.register_sensor("x1") {|interpreter| interpreter.peek_value(:int)}
+      @ii.sensors["x1"].call(@ii).should == 10202
+    end
+  end
+  
+  describe "clear_sensors" do
+    it "should reset the #sensors Hash to empty" do
+      @ii.register_sensor("y1") {|x| 1}
+      @ii.register_sensor("y2") {|x| 2}
+      @ii.register_sensor("y3") {|x| 4}
+      @ii.sensors.keys.should == ["y1", "y2", "y3"]
+      @ii.reset_sensors
+      @ii.sensors.should == {}
+    end
+  end
+  
+  describe "Interpreter#fire_all_sensors(name)" do
+    it "should call all registered sensors and return a Hash of results" do
+      @ii.register_sensor("y1") {|x| 1}
+      @ii.register_sensor("y2") {|x| 2}
+      @ii.register_sensor("y3") {|x| 4}
+      @ii.fire_all_sensors.should == {"y1"=>1, "y2"=>2, "y3"=>4}
+    end
+    
+    it "should return an empty Hash if nothing is registered" do
+      @ii.fire_all_sensors.should == {}
+    end
+  end
+  
+  describe "interrogating Interpreter state" do
+    it "should be possible to read anything about the Interpreter state" do
+      @ii.reset("block {value «int» value «int»}\n«int» 88\n«int» 11")
+      @ii.register_sensor("steps") {|me| me.steps}
+      @ii.register_sensor("top_int") {|me| me.pop_value(:int)}
+      @ii.register_sensor("second_int") {|me| me.pop_value(:int)}
+      3.times {@ii.step} # so as not to fire sensors at the end
+      @ii.fire_all_sensors.should == {"steps"=>3, "top_int"=>11, "second_int"=>88}
+    end
+  end
+end

data/spec/interpreter/stack_spec.rb

@@ -1,3 +1,4 @@
+#encoding: utf-8
 require File.join(File.dirname(__FILE__), "/../spec_helper")
 include Nudge
 
@@ -78,4 +79,38 @@ describe "stack" do
       @myStack.depth.should == 2
     end
   end
+  
+  
+  describe "inspect" do
+    it "should return the entries wrapped in brackets" do
+      inspectable_me = Stack.new(:foo)
+      3.times {inspectable_me.push(ValuePoint.new("foo", rand(1000)))}
+      inspectable_me.inspect.first.should == "["
+      inspectable_me.inspect.last.should == "]"
+    end
+    
+    it "should return them top-to-bottom" do
+      inspectable_me = Stack.new(:foo)
+      inspectable_me.push(ValuePoint.new("foo", 'bottom'))
+      inspectable_me.push(ValuePoint.new("foo", 'top'))
+      inspectable_me.inspect.should =~ /(.+)top(.+)bottom\]/um
+    end
+    
+    it "should return a string containing every entry" do
+      inspectable_me = Stack.new(:foo)
+      (-2..2).each {|i| inspectable_me.push(ValuePoint.new("foo", i))}
+      (inspectable_me.inspect.scan(/(-\d|\d)/)).flatten.collect {|n| n.to_i}.should ==
+        [2,1,0,-1,-2]
+    end
+    
+    it "should return the type and value of each entry" do
+      inspectable_me = Stack.new(:foo)
+      inspectable_me.push(ValuePoint.new("a", '1'))
+      inspectable_me.push(ValuePoint.new("b", '2'))
+      inspectable_me.push(ValuePoint.new("c", '3'))
+      inspectable_me.push(ValuePoint.new("d", '4'))
+      
+      inspectable_me.inspect.should == "[\n«d» 4,\n«c» 3,\n«b» 2,\n«a» 1]"
+    end
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Bill Tozier