nudge 0.1.2 → 0.1.3

data/Rakefile

@@ -16,8 +16,8 @@ begin
     gemspec.required_ruby_version = '>= 1.9.1'
     
     # dependencies
-    gemspec.add_dependency('treetop', '>= 1.4.3')
     gemspec.add_dependency('activesupport', '>= 2.3.5')
+    gemspec.add_dependency('thor', '>= 0.13')
     
     # files
     gemspec.files.exclude '_spikes/**'

data/Thorfile

@@ -0,0 +1,59 @@
+require 'active_support'
+
+class Extend_Nudge < Thor::Group
+  include Thor::Actions
+  
+  # Define arguments and options
+  argument :project_name
+  class_option :test_framework, :default => :rspec
+
+  def self.source_root
+    File.dirname(__FILE__)
+  end
+end
+
+
+class New_Nudge_Type < Thor::Group
+  include Thor::Actions
+  
+  # Define arguments and options
+  argument :type_root
+  class_option :test_framework, :default => :rspec
+  desc "Creates a new NudgeType class definition file, typical instructions, and rspec files"
+  
+
+  def self.source_root
+    File.dirname(__FILE__)
+  end
+  
+  def self.type_name(string)
+    string.camelize + "Type"
+  end
+  
+  def create_lib_file
+    @camelcased_type_name = New_Nudge_Type.type_name(type_root)
+    filename = "#{@camelcased_type_name}.rb"
+    template('templates/nudge_type_class.erb', "#{type_root}/lib/types/#{filename}")
+  end
+  
+  def create_lib_spec
+    @camelcased_type_name = New_Nudge_Type.type_name(type_root)
+    filename = "#{@camelcased_type_name}_spec.rb"
+    template('templates/nudge_type_spec.erb', "#{type_root}/spec/#{filename}")
+  end  
+  
+  def create_instructions
+    suite = ["define", "equal_q", "duplicate", "flush", "pop",
+      "random", "rotate", "shove", "swap", "yank", "yankdup"]
+    
+    suite.each do |inst|
+      @core = "#{type_root}_#{inst}"
+      filename = "#{@core}.rb"
+      @instname = "#{@core.camelize}Instruction"
+      @type = type_root
+      @camelized_type = New_Nudge_Type.type_name(type_root)
+      template("templates/nudge_#{inst}_instruction.erb", "#{type_root}/lib/instructions/#{filename}")
+    end
+  end  
+  
+end

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/bin/nudge

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby -U 
 
-puts "Hi there"
+puts "Hi there; not doing anything right now."

data/lib/cli/runner.rb

@@ -14,7 +14,7 @@ module Nudge
       @filename = filename
       @nudge_program = NudgeProgram.new("")
       @options = options
-      @interpreter = Interpreter.new(@options)
+      @interpreter = Interpreter.new("",@options)
     end
     
     

data/lib/interpreter/interpreter.rb

@@ -20,8 +20,8 @@ module Nudge
     
     
     # A program to be interpreted can be passed in as an optional parameter
-    def initialize(params = {})
-      initialProgram = params[:program] || nil
+    def initialize(program = nil, params = {})
+      initialProgram = program
       @program = initialProgram
       @types = params[:types] || NudgeType.all_types
       @step_limit = params[:step_limit] || 3000
@@ -57,7 +57,7 @@ module Nudge
       self.clear_stacks
       self.reset_names
       self.reset_sensors
-      if program
+      if !program.nil?
         @stacks[:exec].push(NudgeProgram.new(program).linked_code)
       end
       @steps = 0

data/lib/interpreter/nudge_program.rb

@@ -21,86 +21,19 @@ module Nudge
     def initialize(sourcecode)
       raise(ArgumentError, "NudgeProgram.new should be passed a string") unless sourcecode.kind_of?(String)
       @raw_code = sourcecode
-      program_split!
-      relink_code!
-      @points = self.points
-    end
-    
-    
-    
-    
-    
-    def program_split!
+      
+      # snipped out:
+      # program_split!
       split_at_first_guillemet=@raw_code.partition( /^(?=«)/ )
       @code_section = split_at_first_guillemet[0].strip
       @footnote_section = split_at_first_guillemet[2].strip
-      @footnotes = tokenized_footnote_section
-    end
-    
-    
-    
-    def tokenized_footnote_section
-      shattered = @footnote_section.split( /^(?=«)/ )
-      breaker = /^«([a-zA-Z][a-zA-Z0-9_]*)»\s*(.*)\s*/m
-      pairs = shattered.collect {|fn| fn.match(breaker)[1..2]}
-      fn = Hash.new {|hash, key| hash[key] = [] }
-      @footnote_order = []
-      pairs.each do |key,value|
-        fn[key.to_sym] << value.strip
-      end
-      return fn
-    end
-    
-    
-    
-    def relink_code!
-      if parses?
-        @linked_code = NudgeCodeblockParser.new.parse(@code_section).to_point
-        depth_first_association!
-      else
-        @linked_code = NilPoint.new
-      end
-    end
-    
-    
-    
-    def depth_first_association!(program_point=@linked_code)
-      if program_point.kind_of?(ValuePoint)
-        program_point.raw = @footnotes[program_point.type].shift
-        if program_point.raw != nil
-          if program_point.type == :code
-            program_point.raw << pursue_more_footnotes(program_point.raw)
-          end
-        end
-      elsif program_point.kind_of?(CodeblockPoint)
-        program_point.contents.each {|branch| depth_first_association!(branch)}
-      end
-    end
-    
-    
-    
-    def pursue_more_footnotes(codepoint_as_string, collected_footnotes = "")
-      local_footnotes = ""
-      if self.contains_valuepoints?(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)
-            local_subtree.contents.each do |branch|
-              local_footnotes << pursue_more_footnotes(branch.tidy)
-            end
-          elsif local_subtree.kind_of?(ValuePoint)
-            local_subtree.raw = @footnotes[local_subtree.type].shift
-            if local_subtree.raw != nil
-              local_footnotes = "\n«#{local_subtree.type}» #{local_subtree.raw}"
-              if local_subtree.type == :code
-                local_footnotes << pursue_more_footnotes(local_subtree.raw,collected_footnotes)
-              end
-            end
-          end
-        end
-      end
-      return collected_footnotes + local_footnotes
+      
+      #snipped out:
+      #relink_code!
+      parsed_code = NudgeTree.from(@raw_code)
+      @linked_code = parsed_code[:tree] 
+      @footnotes = parsed_code[:unused]
+      @points = self.points
     end
     
     

data/lib/interpreter/parse.tab.rb

@@ -1,10 +1,5 @@
 # encoding: utf-8
 
-# DO NOT MODIFY!!!!
-# This file is automatically generated by racc 1.4.5
-# from racc grammer file "parse.y".
-#
-
 require 'racc/parser'
 require 'strscan'
 
@@ -16,30 +11,50 @@ module_eval <<'..end parse.y modeval..ida1760a43d7', 'parse.y', 22
     nt = NudgeTree.new(string)
     result = nt.send(:do_parse)
     {tree:result, unused:nt.footnotes}
+  rescue ParseError => exc
+    {tree:NilPoint.new, unused:{}}
   end
   
-  attr_accessor :footnotes
+  
+  attr_accessor :tree, :footnotes, :unused_footnotes
+  
   
   def initialize(string)
     @tokens = []
     @string = string.strip
     @footnotes = Hash.new { |hash, category| hash[category] = [] }
-    
+    @unused_footnotes = {}
     self.make_footnotes!
     self.tokenize!
   end
   
+  
   def make_footnotes!
-    return unless split_point = @string.index(/^«/)
+    return unless split_point = @string.index(/\n«/um)
     raise ParseError, "No program string" if split_point == 0
     
-    ss = StringScanner.new(@string.slice!((split_point - 1)..-1))
+    ss = StringScanner.new(@string.slice!((split_point)..-1))
+    
+    fn_head = /\n«([\p{Alpha}][_\p{Alnum}]*)»/u
     
-    while ss.scan(/\n/)
-      @footnotes[ss.scan(/«[\p{Alpha}][_\p{Alnum}]*»/u)[1..-2]] << ss.scan(/[^\n]*/).strip # <-- /\n«/
+    while ss.exist?(fn_head)
+      ss.scan_until(fn_head)
+      cat = ss[1]
+      if ss.exist?(/\n«/um)
+        ss.scan_until(/(.*?)\n«/um)
+        fn = ss[1]
+      elsif ss.eos?
+        fn = ""
+      else
+        ss.scan_until(/(.*)$/um)
+        fn = ss[1]
+      end
+      ss.pos -= 3
+      @footnotes[cat] << fn.strip
     end
   end
   
+  
   def pop_footnote(category)
     value = @footnotes[category].shift
     
@@ -52,14 +67,14 @@ module_eval <<'..end parse.y modeval..ida1760a43d7', 'parse.y', 22
     return value
   end
   
+  
   def collect_embedded_footnotes!(code_text, embedded_footnotes)
-    ss = StringScanner.new(code_text)
-    
-    while ss.skip_until(/«[\p{Alpha}][\p{Alnum}_]*»/)
-      category = ss.matched[1...-1]
-      footnote = @footnotes[category].shift
+    ss = StringScanner.new(code_text)    
+    while ss.skip_until(/«([\p{Alpha}][\p{Alnum}_]*?)»/um)
+      category = ss[1]
+      footnote = @footnotes[category].shift || ""
       
-      embedded_footnotes << "«#{category}»#{footnote}"
+      embedded_footnotes << "«#{category}» #{footnote}"
       
       if category == "code"
         self.collect_embedded_footnotes!(footnote, embedded_footnotes)
@@ -67,10 +82,12 @@ module_eval <<'..end parse.y modeval..ida1760a43d7', 'parse.y', 22
     end
   end
   
+  
   def next_token
     return @tokens.shift
   end
   
+  
   def tokenize!
     ss = StringScanner.new(@string)
     
@@ -80,9 +97,9 @@ module_eval <<'..end parse.y modeval..ida1760a43d7', 'parse.y', 22
           nil
         when /[{}«»]/
           [c, 0]
-        when /[\p{Alpha}]/
-          ss.pointer -= 1
-          ss.scan(/[\p{Alpha}][\p{Alnum}_]*/)  # <- \p{Alpha}
+        when /[\p{Alpha}]/u
+          ss.unscan
+          ss.scan(/[\p{Alpha}][_\p{Alnum}]*/u)  # <- \p{Alpha}
           
           case m = ss.matched
             when "block", "ref", "do", "value"
@@ -91,7 +108,7 @@ module_eval <<'..end parse.y modeval..ida1760a43d7', 'parse.y', 22
               [:ID, m]
           end
         else
-          raise ParseError, "Couldn't tokenize program string"
+          raise ParseError, "Couldn't tokenize program string \"#{@string}\""
       end
     end
     
@@ -99,6 +116,7 @@ module_eval <<'..end parse.y modeval..ida1760a43d7', 'parse.y', 22
     @tokens << [false, false]
   end
   
+  
   def on_error(error_token_id, error_value, value_stack)
     raise ParseError, "Couldn't parse program string"
   end

data/lib/interpreter/programPoints.rb

@@ -92,10 +92,7 @@ module Nudge
     def initialize(type,representation=nil)
       raise(ArgumentError, "Type must be a symbol or string") unless [Symbol,String].include?(type.class)
       @type = type.to_sym
-      if representation != nil
-        representation = representation.to_s
-      end
-      @raw = representation
+      @raw = representation.nil? ? nil : representation.to_s
     end
     
     def go(context)
@@ -147,13 +144,13 @@ module Nudge
     end
     
     def blueprint_parts
-      fn = @raw ? "«#{self.type}» #{self.raw}" : ""
+      fn = "«#{self.type}» #{self.raw}".strip
       return [self.tidy, fn]
     end
     
     def blueprint
       pts = self.blueprint_parts
-      return "value «#{self.type}» \n«#{self.type}» #{self.raw.strip}".strip
+      return "#{pts[0]} \n#{pts[1]}"
     end
   end
   

data/readme.md

@@ -8,16 +8,50 @@ See the [project Wiki](http://github.com/Vaguery/Nudge/wikis) for a more thoroug
 
 ## Getting started
 
+### Ruby 1.9
+
+Make sure your Ruby version is 1.9 (or higher) by running
+
+    ruby -v
+
+and getting something along the lines of `ruby 1.9.1p378 (2010-01-10 revision 26273) [i386-darwin10.2.0]` as a response. If you see `ruby 1.8.7`, we'd recommend a look at [rvm](http://rvm.beginrescueend.com/).
+
+### Installing the gem
+
     gem install nudge
 
 As of this writing, the `nudge` gem can be used as a library in your Ruby programs. S Real Soon Now, it'll be part of a more interesting gem…
 
-Meanwhile, try this:
+### A test run
+
+Meanwhile, try something like this in irb:
 
+    #encoding: utf-8
+    # you'll need to use unicode for all Nudge programs
+    
     require 'nudge'
     include Nudge
     
-    my_program = Nudge.random(target_size_in_points:20) # generates 
+    my_program = NudgeProgram.random(
+      :target_size_in_points => 50,
+      :reference_names => ["x1", "x2"])
+    
+    puts "Your random program:\n\n#{my_program.blueprint}"
+    
+    my_interpreter = Interpreter.new()
+    
+    my_interpreter.reset(my_program.blueprint)
+    
+    
+    # set up some sensors, so we know what happens afterwards
+    my_interpreter.register_sensor("int_1") {|state| state.peek_value(:int)} # reads the top :int value
+    my_interpreter.register_sensor("bool_1") {|state| state.peek_value(:bool)} # reads the top :bool value
+    my_interpreter.register_sensor("steps") {|state| state.steps} # reads the number of steps the interpreter took
+    
+    puts "\n\nsensor values: #{my_interpreter.run}"
+
+When you run that, you'll get something [like this](http://gist.github.com/347215)—though your code and output will (hopefully) be a different random result!
+
 ## Requirements
 
 The interpreter code relies heavily on functional programming features of Ruby 1.9+. If you have not yet installed Ruby 1.9, I'd recommend using [rvm](http://rvm.beginrescueend.com/) to set up a special "sandbox" version of 1.9 until you're ready to upgrade your development or production machine.

data/spec/command_line/thor_spec.rb

@@ -0,0 +1,51 @@
+#encoding: utf-8
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+include Nudge
+
+describe "thor new_nudge_type MY_TYPE" do
+  before(:each) do
+  end
+  
+  describe "documentation" do
+    it "should have a desc field"
+  end
+  
+  
+  describe "validating type names" do
+    it "should check to see the type_name matches the allowed pattern"
+    
+    it "should quit and warn you if it doesn't match"
+  end
+  
+  
+  describe "checking for preexisting files" do
+    it "should ask if you already have something there"
+    
+    it "should replace it without asking if you use '--force'"
+    
+    it "should replace it if you answer 'yes'"
+  end
+  
+  
+  describe "creating core lib/MyType.rb file" do
+    it "should use template 'templates/nudge_type_class.tt"
+    
+    
+    it "should require 'nudge'"
+    
+  end
+  
+  
+  describe "creating boilerplate instruction code" do
+    it "should make lib/instructions/foo_define.rb"
+    it "should make lib/instructions/foo_equal_q.rb"
+    it "should make lib/instructions/foo_duplicate.rb"
+    it "should make lib/instructions/foo_flush.rb"
+    it "should make lib/instructions/foo_pop.rb"
+    it "should make lib/instructions/foo.random.rb" # if it's a candidate for literals
+    it "should make lib/instructions/foo_rotate.rb"
+    it "should make lib/instructions/foo_shove.rb"
+    it "should make lib/instructions/foo_swap.rb"
+    it "should make lib/instructions/foo_yank.rb"
+  end
+end

data/spec/instructions/code/code_noop_spec.rb

@@ -26,7 +26,7 @@ describe CodeNoopInstruction do
 
     describe "\#cleanup" do
       it "should change nothing about the interpreter except the step count" do
-        @context = Interpreter.new(program:"do code_noop")
+        @context = Interpreter.new("do code_noop")
         @context.enable(CodeNoopInstruction)
         earlier = @context.steps
         @context.run

data/spec/interpreter/codeblock_point_spec.rb

@@ -3,8 +3,7 @@ require File.join(File.dirname(__FILE__), "/../spec_helper")
 include Nudge
 
 def magicCodeblockPointMaker(program_blueprint)
-  my_kludge = NudgeProgram.new(program_blueprint)
-  return my_kludge.linked_code
+  NudgeTree.from(program_blueprint)[:tree]
 end
 
 
@@ -43,10 +42,10 @@ describe "blueprint_parts" do
   context "when there need to be footnotes" do
     it "should work for blocks containing nil-valued ValuePoints" do
       CodeblockPoint.new([ValuePoint.new("foo")]).blueprint_parts.should ==
-        ["block {\n  value «foo»}",""]
+        ["block {\n  value «foo»}","«foo»"]
       annoyinglyWordy = magicCodeblockPointMaker("block { block { block { value «foo»}}}")
       annoyinglyWordy.blueprint_parts.should ==
-        ["block {\n  block {\n    block {\n      value «foo»}}}",""]
+        ["block {\n  block {\n    block {\n      value «foo»}}}","«foo»"]
     end
     
     it "should work with footnotes from the root" do

data/spec/interpreter/interpreter_spec.rb

@@ -65,8 +65,8 @@ describe "initialization" do
   end
   
   it "should accept a blueprint, which should default to an empty string" do
-    Interpreter.new(program:"value «int» \n«int» 7").program.should == "value «int» \n«int» 7"
-    # Interpreter.new().program.should == ""
+    Interpreter.new("value «int» \n«int» 7").program.should == "value «int» \n«int» 7"
+    Interpreter.new().program.should == nil
   end
   
   it "should have an #enable method that works for Instructions, adding them to the #instructions hash" do
@@ -444,7 +444,6 @@ describe "running" do
   
   it "should do nothing if the :exec stack starts empty" do
     @ii.reset()
-    puts @ii.stacks[:exec].depth
     @ii.run
     @ii.steps.should == 0
   end
@@ -461,7 +460,7 @@ end
 
 describe "resetting" do
   it "should clear the steps" do
-    ii = Interpreter.new(program:"block {ref a ref b}")
+    ii = Interpreter.new("block {ref a ref b}")
     ii.run
     ii.steps.should == 3
     ii.reset
@@ -484,7 +483,7 @@ describe "resetting" do
   end
   
   it "should clear the program, if none is given" do
-    ii = Interpreter.new(program:"block {}")
+    ii = Interpreter.new("block {}")
     ii.reset
     ii.program.should == nil
   end