rubotz 0.0.1

data/README

@@ -0,0 +1,95 @@
+= Rubotz
+
+Rubotz is a Ruby library which generates and compiles NXC programs for Lego Mindstorms
+NXT robots.
+
+You can program your robot in Ruby, including the compilation phase, and then simply
+copy the generated executable from your computer to your Mindstorms robot with third-party
+programs such as NXTBrowser.
+
+= Proof-Of-Concept Release Only
+
+Rubotz v0.0.1 is a proof-of-concept release. It implements only a subset of available motor
+functionality and only one sensor (the ultrasonic sensor). Mindstorms ships with 4 sensors
+and additional third-party sensors are available as well. NXC supports a multi-threaded
+model, which is very cool; Rubotz currently only supports one ("main") thread.
+
+Support for multiple threads is planned; support for all stock sensors and the full
+range of motor functionality is planned as well.
+
+= Documentation Is For Computers To Read
+
+I don't really believe in documentation; I believe that your documentation should consist
+entirely of your specs. Specs are documentation which you can run as code, and therefore
+they are *self-verifying* documentation; any other kind of documentation is really just a
+statement of opinion. However, I definitely want people who are interested to be able to
+use the software!
+
+The specs dir absolutely contains the best documentation, but I've also made an effort to
+augment that with text and RDoc. However, if you're confused about something, the specs are
+*by definition* the canonical example of how to do it.
+
+== How To Program Your Robot In Ruby
+
+Rubotz.compile takes an options hash, using it as faux keyword arguments in the Rails style.
+Rubotz.program takes a block, with Ruby code which it then translates into NXC.
+
+The examples directory contains an example as runnable code - logically enough - but I'm
+repeating it here to demonstrate.
+
+This code is based on a robot I built which aims an ultrasonic sensor at the floor and drives
+forward, backing away and turning if it encounters a dropoff indicating a table edge.
+
+Check it out on YouTube: http://www.youtube.com/watch?v=uQ4BwxH7uoY
+(it's pretty straightforward).
+
+  Rubotz.compile :file => "rubotz",
+                 :program => (Rubotz.program do
+                                the_robot "drives around the table scanning its ultrasonic sensor"
+                                initializing do
+                                  short ultrasonic_sensor
+                                  activate(UltrasonicSensor.port(4))
+                                end
+                                looping do
+                                  clear_screen
+                                  monitoring(UltrasonicSensor) do |ultrasonic_sensor|
+                                    ultrasonic_sensor.> 30 do
+                                      display :line => 7, :text => "Danger"
+                                      display :line => 8, :number => ultrasonic_sensor
+                                      sound "! Attention.rso"
+                                      motor :synchronized => true,
+                                            :direction => :reverse,
+                                            :ports => [:B, :C],
+                                            :power => 25,
+                                            :turn => 0
+                                      wait 1500
+                                      motor :synchronized => true,
+                                            :direction => :reverse,
+                                            :ports => [:B, :C],
+                                            :power => 25,
+                                            :turn => 100
+                                      wait 325
+                                    end
+                                    ultrasonic_sensor.<= 30 do
+                                      display :line => 7, :text => "Safe"
+                                      display :line => 8, :number => ultrasonic_sensor
+                                      motor :synchronized => true,
+                                            :direction => :forwards,
+                                            :ports => [:B, :C],
+                                            :power => 35,
+                                            :turn => 5
+                                    end
+                                  end
+                                  wait 25
+                                end
+                              end)
+
+The above code successfully generates NXC code for the table robot, and successfully
+compiles that code using my NXC install into a format which successfully runs on my Mindstorms
+robot brain. To transfer the generated code to the robot brain, I use NXTBrowser on OS X:
+
+http://web.mac.com/carstenm/Lego/NXT/Entries/2006/12/4_NXTBrowser_-_Bluetooth_connectivity_on_an_Intel_Mac.html
+
+I'm very confident that alternatives exist for other platforms. I'm also very confident this will
+work on other people's computers and Mindstorms brains as well as my own, but definitely correct me
+if I got that wrong! (You can reach me by e-mail at gilesb@gmail.com.)

data/config/nxt_home.yaml

@@ -0,0 +1 @@
+nxt_home: /Users/giles/programming/nxt

data/examples/table_wanderer.rb

@@ -0,0 +1,66 @@
+# If you don't know what you're doing here, please be careful, as you **are** using this software
+# at your own risk. Some Mindstorms users are kids; while a kid could figure this out, you would
+# have to be careful to use NXTBrowser correctly, and be careful with Ruby too. Using this software
+# at your own risk means that if your Mindstorms is destroyed, I won't buy you a new one, and that
+# goes double for your computer.
+
+# This code is based on a robot I built which aims an ultrasonic sensor at the floor and drives
+# forward, backing away and turning if it encounters a dropoff indicating a table edge.
+
+# Check it out on YouTube: http://www.youtube.com/watch?v=uQ4BwxH7uoY
+# (it's pretty straightforward).
+
+# If you build that robot, or an equivalent robot, and you have an appropriate config file in
+# the /config dir - replacing the default, which points to a subdir of my own home dir - you
+# should be able to auto-generate an NXC program simply by running the Ruby code in this file.
+# You can then transfer the .rxe generated executable to your Mindstorms NXT robot using
+# a third-party app like (for instance) NXTBrowser:
+# http://web.mac.com/carstenm/Lego/NXT/Entries/2006/12/4_NXTBrowser_-_Bluetooth_connectivity_on_an_Intel_Mac.html
+
+# I used this program to drive development of Rubotz v0.0.1, so check out the table wanderer
+# spec for a lot more detail on how to use Rubotz. You will need to have NXC installed on your
+# system, with a working compiler.
+
+require File.join(File.dirname(__FILE__), '../lib/rubotz')
+include Rubotz
+
+Rubotz.compile :file => "rubotz",
+               :program => (Rubotz.program do
+                              the_robot "drives around the table scanning its ultrasonic sensor"
+                              initializing do
+                                short ultrasonic_sensor
+                                activate(UltrasonicSensor.port(4))
+                              end
+                              looping do
+                                clear_screen
+                                monitoring(UltrasonicSensor) do |ultrasonic_sensor|
+                                  ultrasonic_sensor.> 30 do
+                                    display :line => 7, :text => "Danger"
+                                    display :line => 8, :number => ultrasonic_sensor
+                                    sound "! Attention.rso"
+                                    motor :synchronized => true,
+                                          :direction => :reverse,
+                                          :ports => [:B, :C],
+                                          :power => 25,
+                                          :turn => 0
+                                    wait 1500
+                                    motor :synchronized => true,
+                                          :direction => :reverse,
+                                          :ports => [:B, :C],
+                                          :power => 25,
+                                          :turn => 100
+                                    wait 325
+                                  end
+                                  ultrasonic_sensor.<= 30 do
+                                    display :line => 7, :text => "Safe"
+                                    display :line => 8, :number => ultrasonic_sensor
+                                    motor :synchronized => true,
+                                          :direction => :forwards,
+                                          :ports => [:B, :C],
+                                          :power => 35,
+                                          :turn => 5
+                                  end
+                                end
+                                wait 25
+                              end
+                            end)

data/lib/rubotz.rb

@@ -0,0 +1,58 @@
+%w{erb
+   yaml
+   lib/rubotz/generator
+   lib/rubotz/ultrasonic_sensor}.each {|lib| require lib}
+
+module Rubotz
+  SIMPLE_WHILE = "#{File.dirname(__FILE__)}/../templates/simple_while.nxc.erb"
+  CONFIG = YAML.load_file("#{File.dirname(__FILE__)}/../config/nxt_home.yaml")
+  
+  class << self
+    # Rubotz.compile takes two keyword arguments - a filename and a Rubotz.program
+    # call, which takes a block. Here's the simplest possible instance:
+    #
+    #   Rubotz.compile(:filename => "f", :program => (Rubotz.program {true}))
+    #
+    # Technically even simpler instances are *possible*, but would probably do bad
+    # things.
+    #
+    # One bad thing to watch out for is that there is a hard limit on the number of
+    # characters you can use in a filename, and I'm not yet sure what that is. However,
+    # beyond a certain number of characters, Mindstorms won't recognize the .rxe
+    # suffix on your generated executable, and when that happens, it assumes the file
+    # is data rather than a program. The workaround is obvious: use short file names.
+    #
+    # One other caveat: compile saves your generated code, and will overwrite existing
+    # generated code if it was generated with the same :filename. Keep an eye on your
+    # nxt/code dir, or use unique filenames, or be bold and fearless. Whatever. It's up
+    # to you.
+    def compile(options = {})
+      filename = options[:file].gsub(/ /, "_")
+      File.open("#{Rubotz::CONFIG['nxt_home']}/code/#{filename}.nxc", "w") do |file|
+        file.puts options[:program]
+      end
+      system ("cd #{Rubotz::CONFIG['nxt_home']}; " +
+              "./nbc " +
+              "-O=bin/#{filename}.rxe " +
+              "code/#{filename}.nxc")
+    end
+    # Rubotz.generate is an internal method. It's not marked private because I don't
+    # really care, I kind of have a laissez-faire, Perlish attitude to methods, if you
+    # shoot yourself in the foot, hey, it's your foot. However, it's really only useful
+    # if you're writing new generator code.
+    def generate(&block)
+      Generator.new(&block).code
+    end
+    # Rubotz.program takes a block of Ruby code and evals it in the context of a Generator,
+    # which knows how to turn that code into NXC code. It then runs the generated NXC code
+    # through ERb, to mesh with existing boilerplate stuff in NXC. Note however that it does
+    # not save a file, it simply returns the generated code in the ERb template as text.
+    def program(&block)
+      generator = Generator.new(&block)
+      initialization_section = generator.initialization_section
+      loop_body = generator.loop_body
+      comment = generator.comment || ""
+      ERB.new(File.read(SIMPLE_WHILE)).result(binding)
+    end
+  end
+end

data/lib/rubotz/generator.rb

@@ -0,0 +1,103 @@
+require 'lib/rubotz/motor_generator'
+module Rubotz
+  # Pretty much all the methods that you program Rubotz robots with live in this class. (It
+  # may be wiser to isolate those methods in an API module and then mix that in, since that
+  # would make the documentation clearer, but this is how it works for now.)
+  #
+  # Instantiating an object of this class should never be necessary unless you're rewriting
+  # the main module or doing similar development. In the course of actually programming a robot,
+  # you just use the methods of the class as if they were regular Ruby keywords.
+  class Generator
+    attr_accessor :code,
+                  :initialization_section,
+                  :loop_body,
+                  :comment
+    def initialize(&block)
+      @code = ""
+      instance_eval(&block)
+    end
+
+    # Example: activate(UltrasonicSensor.port(4)). You need to do this in the initialization
+    # section of your program, before going into the loop body and actually accessing the sensor.
+    def activate(sensor)
+      @code += sensor
+    end
+    # Does what it says on the tin.
+    def clear_screen
+      @code += "ClearScreen();\n"
+    end
+    # The display method takes a hash of symbols and strings, and uses that to write to the
+    # Mindstorms NXT display. For example:
+    #
+    #   display :line => 7, :text => "Hello World"
+    #   display :line => 8, :number => ultrasonic_sensor
+    #
+    # (Although support for variable interpolation is currently imperfect, it works perfectly
+    # for this particular method.)
+    #
+    # The NXT brain has 8 lines on its display, and you probably have to call clear_screen
+    # before you update it. Numbering starts at 1, not 0.
+    def display(options = {})
+      line_number = options[:line] || 1
+      if options.include?(:text)
+        @code += "TextOut(0, LCD_LINE#{line_number}, \"#{options[:text]}\");\n"
+      elsif options.include?(:number)
+        @code += "NumOut(0, LCD_LINE#{line_number}, #{options[:number]});\n"
+      end
+    end
+    # The current Rubotz model is very limited; you have one constantly-running loop, and an
+    # initialization section beforehand, which is where you declare variables and activate sensors.
+    # Use initializing to wrap code which goes in the initialization section of a loop, rather
+    # than in the loop itself.
+    def initializing(&block)
+      @initialization_section = Rubotz.generate(&block)
+    end
+    # The current Rubotz model is very limited; you have one constantly-running loop, and an
+    # initialization section beforehand, which is where you declare variables and activate sensors.
+    # Use looping to wrap code which goes in the constantly-running loop.
+    def looping(&block)
+      @loop_body = Rubotz.generate(&block)
+    end
+    # This method_missing assumes missing methods are actually references to as-yet-undefined
+    # variables. Although variable interpolation is currently imperfect in Rubotz, this method
+    # causes all its successes.
+    def method_missing(method, *args)
+      "#{method}"
+    end
+    # Use monitoring to wrap blocks which check a sensor for data and then make decisions based
+    # on that data. Its args are a sensor class, and the block you're wrapping in it.
+    def monitoring(sensor_class, &block)
+      @code += sensor_class.new.instance_eval(&block)
+    end
+    # The motor method simply passes a MotorGenerator the options you specify; see the MotorGenerator
+    # RDoc for details on how to use this method, and what those options should be.
+    def motor(options = {})
+      @code += MotorGenerator.new(options).generate
+    end
+    # The short method allows you to declare a variable of the short type.
+    def short(variable_name)
+      @code += "short #{variable_name};\n"
+    end
+    # This method plays a sound which already exists on your NXC. Third-party utilities such as
+    # NXTBrowser make transferring new sounds to your Mindstorms NXT a piece of cake.
+    def sound(filename)
+      @code += "PlayFile(\"#{filename}\");\n"
+    end
+    # This method merely generates a comment in the generated NXC source code.
+    def the_robot(does_something)
+      @comment = "// the robot #{does_something}\n"
+    end
+    # This method pauses program execution. It doesn't cause the _robot_ to wait, but the
+    # _program_. This makes it a vital method. After you turn your motors on and start moving
+    # in a given direction, you need to wait an arbitrary amount of time before you do anything
+    # else; otherwise you'll simply turn on your motors and the program will immediately jump
+    # to the next instruction without actually driving anywhere.
+    #
+    # I think wait works in terms of milliseconds, but honestly I don't know. The units are some
+    # kind of fraction of a second which appears to work in some order of magnitude. In practical
+    # terms, just use round numbers and experiment to see what works for you.
+    def wait(number)
+      @code += "Wait(#{number});\n"
+    end
+  end
+end

data/lib/rubotz/motor_generator.rb

@@ -0,0 +1,49 @@
+module Rubotz
+  # The MotorGenerator initializes with an options hash instead of a block. For example:
+  #
+  #   motor :synchronized => true,
+  #         :direction => :reverse,
+  #         :ports => [:B, :C],
+  #         :power => 25,
+  #         :turn => 0
+  #
+  # The NXC API has a number of different options for motors. This seemed like the best way
+  # to implement them, but currently MotorGenerator implements only a subset of available
+  # motor functionality, and if/when that functionality expands, the structure of the class
+  # may change.
+  #
+  # Currently MotorGenerators can only generate Sync commands, and only know how to power
+  # ports B and C.
+  #
+  # The methods in this class are basically irrelevant from a user perspective. What matters
+  # is the keywords you use, or more precisely the symbol keys to the options hash. First the
+  # lame stuff: :synchronized makes no difference at all, and the only legal values for :ports
+  # is [:B, :C], and you have to specify that. Sorry.
+  #
+  # However, :direction, :power, and :turn are all actually valid and usable. They're all also
+  # reasonably obvious. :direction is either :reverse or :forwards. I'm pretty sure :power maxes
+  # out at 100, and I know it starts at 0. :turn also starts at 0 but honestly I have no idea
+  # what its legal maximum is, if any. Feel free to experiment with this!
+  class MotorGenerator
+    def initialize(options = {})
+      @options = options
+    end
+    def generate
+      "#{motor_command}(#{ports}, #{power_and_turn});\n"
+    end
+    def motor_command
+      if :reverse == @options[:direction] # && @options[:synchronized]
+        "OnRevSync"
+      elsif :forwards == @options[:direction] # && @options[:synchronized]
+        "OnFwdSync"
+      end
+    end
+    def power_and_turn
+      "#{@options[:power] || 0}, #{@options[:turn] || 0}"
+    end
+    def ports
+      "OUT_BC" if [:B, :C] == @options[:ports]
+    end
+  end
+end
+

data/lib/rubotz/ultrasonic_sensor.rb

@@ -0,0 +1,57 @@
+module Rubotz
+  # The UltrasonicSensor class is a code generator for the NXT ultrasonic sensor. It provides
+  # simple value comparison methods, value assignment NXC code, and an activation class method.
+  # Its variable is currently hard-coded; this is planned to change.
+  #
+  # Ultimately all XyzSensors will inherit from a base Sensor class. This class will very likely be
+  # the only one to override Sensor's #port method (see NXC docs for why).
+  class UltrasonicSensor
+    # Create the UltrasonicSensor, with a variable declaration and relevant NXC API code.
+    def initialize
+      @code = "ultrasonic_sensor = SensorUS(S4);\n"
+    end
+    class << self
+      # Activation code for initialization blocks.
+      def port(number)
+        "SetSensorLowspeed(S#{number});\n"
+      end
+    end
+
+    # Utility method for variable interpolation in code which refers to this sensor.
+    def to_s
+      "ultrasonic_sensor"
+    end
+    # UltrasonicSensor#> generates an if block around the >, the sensor itself (as an NXC
+    # variable), and the value to be compared against. It then executes arbitrary Ruby within
+    # the context of that if block. In practice this means turning Rubotz code into NXC code.
+    # (The instance method approach to value comparison is definitely a bit of a kludge, but it
+    # was a lot less work for me personally than implementing a parser.)
+    def > (number, &block)
+      @code += "if (ultrasonic_sensor > #{number}) {\n" + Rubotz.generate(&block) + "}\n"
+    end
+    # UltrasonicSensor#>= generates an if block around the >=, the sensor itself (as an NXC
+    # variable), and the value to be compared against. It then executes arbitrary Ruby within
+    # the context of that if block. In practice this means turning Rubotz code into NXC code.
+    # (The instance method approach to value comparison is definitely a bit of a kludge, but it
+    # was a lot less work for me personally than implementing a parser.)
+    def >= (number, &block)
+      @code += "if (ultrasonic_sensor >= #{number}) {\n" + Rubotz.generate(&block) + "}\n"
+    end
+    # UltrasonicSensor#< generates an if block around the <, the sensor itself (as an NXC
+    # variable), and the value to be compared against. It then executes arbitrary Ruby within
+    # the context of that if block. In practice this means turning Rubotz code into NXC code.
+    # (The instance method approach to value comparison is definitely a bit of a kludge, but it
+    # was a lot less work for me personally than implementing a parser.)
+    def < (number, &block)
+      @code += "if (ultrasonic_sensor < #{number}) {\n" + Rubotz.generate(&block) + "}\n"
+    end
+    # UltrasonicSensor#<= generates an if block around the <=, the sensor itself (as an NXC
+    # variable), and the value to be compared against. It then executes arbitrary Ruby within
+    # the context of that if block. In practice this means turning Rubotz code into NXC code.
+    # (The instance method approach to value comparison is definitely a bit of a kludge, but it
+    # was a lot less work for me personally than implementing a parser.)
+    def <= (number, &block)
+      @code += "if (ultrasonic_sensor <= #{number}) {\n" + Rubotz.generate(&block) + "}\n"
+    end
+  end
+end

data/rubotz.gemspec

@@ -0,0 +1,14 @@
+require 'rubygems' 
+SPEC = Gem::Specification.new do |s| 
+  s.name = s.rubyforge_project = "rubotz"
+  s.version = "0.0.1"
+  s.author = "Giles Bowkett"
+  s.email = "gilesb@gmail.com"
+  s.homepage = "http://rubotz.rubyforge.org"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Code generator for Lego Mindstorms NXT. Proof-of-concept release only."
+  s.files = Dir.glob("**/*")
+  s.require_path = "lib"
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README"] 
+end 

data/slow_spec/compiler_spec.rb

@@ -0,0 +1,24 @@
+# this spec is painfully slow. everything else runs fast, but this one example can take a
+# second and a half. I'm breaking BDD rules here with such a slow, unmocked spec, but it was
+# useful for me to make sure the compiler stuff really worked. this spec lives in slow_spec
+# rather than spec so that you can do the usual "spec spec" and get the majority of specs
+# taken care of super-quick.
+
+require "lib/rubotz"
+
+describe Rubotz, "compiling an empty program" do
+  
+  before(:each) do
+    @blank_defaults = {:program => (Rubotz.program do ; end),
+                       :file => "simple program"}
+  end
+
+  it "puts output in the output dir" do
+    Rubotz.compile(@blank_defaults)
+    File.exists?("#{Rubotz::CONFIG["nxt_home"]}/bin/simple_program.rxe").should be_true
+  end
+  
+  after(:all) do
+    system("cd #{Rubotz::CONFIG["nxt_home"]}; rm code/simple_program.nxc bin/simple_program.rxe")
+  end
+end

data/spec/generating_spec.rb

@@ -0,0 +1,17 @@
+require "lib/rubotz"
+
+describe Rubotz, "generating an empty program" do
+
+  it "generates blank programs in uncompiled NXC, not counting indentation" do
+    simple_while =<<SIMPLE_WHILE
+#include "NXCDefs.h"
+task main() {
+  
+  while(true) {
+    
+  }
+}
+SIMPLE_WHILE
+    (Rubotz.program do ; end).gsub(/\s+/, " ").should == simple_while.gsub(/\s+/, " ")
+  end
+end

data/spec/table_wanderer_spec.rb

@@ -0,0 +1,211 @@
+# This code is based on a robot I built which aims an ultrasonic sensor at the floor and drives
+# forward, backing away and turning if it encounters a dropoff indicating a table edge.
+
+# Check it out on YouTube: http://www.youtube.com/watch?v=uQ4BwxH7uoY
+# (it's pretty straightforward).
+
+require "lib/rubotz"
+include Rubotz
+
+describe Rubotz do
+  before(:each) do
+    @the_main_program_in_nxc =<<THE_MAIN_PROGRAM_IN_NXC
+#include "NXCDefs.h"
+// the robot drives around the table scanning its ultrasonic sensor
+task main() {
+  short ultrasonic_sensor;
+  SetSensorLowspeed(S4);
+  while(true) {
+    ClearScreen();
+    ultrasonic_sensor = SensorUS(S4);
+      if (ultrasonic_sensor > 30) {
+        TextOut(0, LCD_LINE7, "Danger");
+        NumOut(0, LCD_LINE8, ultrasonic_sensor);
+        PlayFile("! Attention.rso");
+        OnRevSync(OUT_BC, 25, 0);
+        Wait(1500);
+        OnRevSync(OUT_BC, 25, 100);
+        Wait(325);
+      }
+      if (ultrasonic_sensor <= 30) {
+        TextOut(0, LCD_LINE7, "Safe");
+        NumOut(0, LCD_LINE8, ultrasonic_sensor);
+        OnFwdSync(OUT_BC, 35, 5);
+      }
+    Wait(25);
+  }
+}
+THE_MAIN_PROGRAM_IN_NXC
+  end
+  
+  it "generates unindented single-threaded code for a robot which wanders a table without falling off" do
+    (Rubotz.program do
+      the_robot "drives around the table scanning its ultrasonic sensor"
+      initializing do
+        short ultrasonic_sensor
+        activate(UltrasonicSensor.port(4))
+      end
+      looping do
+        clear_screen
+        monitoring(UltrasonicSensor) do |ultrasonic_sensor|
+          ultrasonic_sensor.> 30 do
+            display(:line => 7, :text => "Danger")
+            display(:line => 8, :number => ultrasonic_sensor)
+            sound("! Attention.rso")
+            motor(:synchronized => true,
+                  :direction => :reverse,
+                  :ports => [:B, :C],
+                  :power => 25,
+                  :turn => 0)
+            wait(1500)
+            motor(:synchronized => true,
+                  :direction => :reverse,
+                  :ports => [:B, :C],
+                  :power => 25,
+                  :turn => 100)
+            wait(325)
+          end
+          ultrasonic_sensor.<= 30 do
+            display(:line => 7, :text => "Safe")
+            display(:line => 8, :number => ultrasonic_sensor)
+            motor(:synchronized => true,
+                  :direction => :forwards,
+                  :ports => [:B, :C],
+                  :power => 35,
+                  :turn => 5)
+          end
+        end
+        wait(25)
+      end
+    end).gsub(/\s+/, " ").should == @the_main_program_in_nxc.gsub(/\s+/, " ")
+  end
+  
+  it "indents generated code correctly" do
+    # (Rubotz.indent(@the_main_program_in_nxc.gsub(/\s+/, " "))).should == @the_main_program_in_nxc
+    pending "implement"
+  end
+  
+  it "somehow merges its indentation with the indentation it gets from ERb" do
+    pending "I have no idea"
+  end
+  
+  it "creates initialization sections with arbitrary code" do
+    (Generator.new do
+      initializing do
+        short ultrasonic_sensor
+      end
+    end).initialization_section.should == "short ultrasonic_sensor;\n"
+  end
+  
+  it "creates loop bodies with arbitrary code" do
+    (Generator.new do
+      looping do
+        short ultrasonic_sensor
+      end
+    end).loop_body.should == "short ultrasonic_sensor;\n"
+  end
+  
+  it "declares short variables" do
+    (Rubotz.generate {short ultrasonic_sensor}).should == "short ultrasonic_sensor;\n"
+  end
+  
+  it "has a #the_robot method which generates comments" do
+    (Generator.new do
+      the_robot "drives around the table scanning its ultrasonic sensor"
+    end).comment.should == "// the robot drives around the table scanning its ultrasonic sensor\n"
+  end
+  
+  it "activates the ultrasonic sensor" do
+    (Rubotz.generate {activate(UltrasonicSensor.port(4))}).should == "SetSensorLowspeed(S4);\n"
+  end
+
+  it "generates variables and ifs for testing the ultrasonic sensor (without indentation)" do
+    ultrasonic_nxc =<<ULTRASONIC_NXC
+ultrasonic_sensor = SensorUS(S4);
+  if (ultrasonic_sensor > 30) {
+    TextOut(0, LCD_LINE7, "greater than 30");
+  }
+  if (ultrasonic_sensor < 23) {
+    TextOut(0, LCD_LINE7, "less than 23");
+  }
+  if (ultrasonic_sensor >= 30) {
+    TextOut(0, LCD_LINE7, "greater than or equal to 30");
+  }
+  if (ultrasonic_sensor <= 23) {
+    TextOut(0, LCD_LINE7, "less than or equal to 23");
+  }
+ULTRASONIC_NXC
+    (Rubotz.generate do
+      monitoring(UltrasonicSensor) do |ultrasonic_sensor|
+        ultrasonic_sensor.> 30 do
+          display(:line => 7, :text => "greater than 30")
+        end
+        ultrasonic_sensor.< 23 do
+          display(:line => 7, :text => "less than 23")
+        end
+        ultrasonic_sensor.>= 30 do
+          display(:line => 7, :text => "greater than or equal to 30")
+        end
+        ultrasonic_sensor.<= 23 do
+          display(:line => 7, :text => "less than or equal to 23")
+        end
+      end
+    end).gsub(/\s+/, " ").should == ultrasonic_nxc.gsub(/\s+/, " ")
+  end
+  
+  it "generates clear screen code" do
+    (Rubotz.generate {clear_screen}).should == "ClearScreen();\n"
+  end
+  
+  it "generates display code for text and numbers" do
+    (Rubotz.generate {display(:line => 7,
+                              :text => "Safe")}).should == "TextOut(0, LCD_LINE7, \"Safe\");\n"
+    (Rubotz.generate {display(:line => 8,
+                              :number => 25)}).should == "NumOut(0, LCD_LINE8, 25);\n"
+  end
+  
+  it "generates display code with inline variables" do
+    (Rubotz.generate {display(:line => 8,
+                              :number => ultrasonic_sensor)}).should == "NumOut(0, LCD_LINE8, ultrasonic_sensor);\n"
+  end
+  
+  it "generates play sound code" do
+    (Rubotz.generate {sound("! Attention.rso")}).should == "PlayFile(\"! Attention.rso\");\n"
+  end
+  
+  it "generates motor control code" do
+    (Rubotz.generate {motor(:synchronized => true,
+                            :direction => :reverse,
+                            :ports => [:B, :C],
+                            :power => 25,
+                            :turn => 100)}).should == "OnRevSync(OUT_BC, 25, 100);\n"
+    (Rubotz.generate {motor(:synchronized => true,
+                            :direction => :forwards,
+                            :ports => [:B, :C],
+                            :power => 25,
+                            :turn => 100)}).should == "OnFwdSync(OUT_BC, 25, 100);\n"
+    (Rubotz.generate {motor(:direction => :forwards,
+                            :ports => [:B, :C],
+                            :power => 50)}).should == "OnFwdSync(OUT_BC, 50, 0);\n"
+    (Rubotz.generate {motor(:direction => :banana,
+                            :ports => :B,
+                            :power => "houseplant")}).should_not == "OnFwdSync(OUT_BC, 50, 0);\n"
+  end
+  
+  it "generates motor control code with inline variables" do
+    (Rubotz.generate {motor(:direction => :forwards,
+                            :ports => [:B, :C],
+                            :power => power,
+                            :turn => turn)}).should == "OnFwdSync(OUT_BC, power, turn);\n"
+  end
+  
+  it "generates wait commands" do
+    (Rubotz.generate {wait(325)}).should == "Wait(325);\n"
+    (Rubotz.generate {wait(1000)}).should == "Wait(1000);\n"
+  end
+  
+  it "generates wait commands with inline variables" do
+    (Rubotz.generate {wait(delay)}).should == "Wait(delay);\n"
+  end
+
+end

data/templates/simple_while.nxc.erb

@@ -0,0 +1,8 @@
+#include "NXCDefs.h"
+<%= comment %>
+task main() {
+  <%= initialization_section %>
+  while(true) {
+    <%= loop_body %>
+  }
+}

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: rubotz
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Giles Bowkett
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-12 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: gilesb@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- config
+- config/nxt_home.yaml
+- examples
+- examples/table_wanderer.rb
+- lib
+- lib/rubotz
+- lib/rubotz/generator.rb
+- lib/rubotz/motor_generator.rb
+- lib/rubotz/ultrasonic_sensor.rb
+- lib/rubotz.rb
+- README
+- rubotz-0.0.1.gem
+- rubotz.gemspec
+- slow_spec
+- slow_spec/compiler_spec.rb
+- spec
+- spec/generating_spec.rb
+- spec/table_wanderer_spec.rb
+- templates
+- templates/simple_while.nxc.erb
+has_rdoc: true
+homepage: http://rubotz.rubyforge.org
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rubotz
+rubygems_version: 1.0.0
+signing_key: 
+specification_version: 2
+summary: Code generator for Lego Mindstorms NXT. Proof-of-concept release only.
+test_files: []
+