karel 0.1.0

data/README.rdoc

@@ -0,0 +1,259 @@
+= Karel the Robot in Ruby
+
+Author::  Dave Copeland (mailto:davetron5000 at g mail dot com)
+Copyright:: Copyright (c) 2010 by Dave Copeland
+License:: Distributes under the Apache License, see LICENSE.txt in the source distro
+
+== What is this?
+
+This is a ruby implementation of Karel The Robot[http://www.cs.mtsu.edu/~untch/karel/], a 
+programming language designed for extreme beginners.   It concerns controlling
+a robot, named Karel, in a grid-based world comprised of walls and beepers.  Karel can pick up and put down beepers, move
+forward, and turn left.  Karel can also detect things about his environment.
+
+== Install
+
+For the time being, there's no gem so just clone the repo.  
+
+    git clone https://davetron5000@github.com/davetron5000/rkarel.git
+    cd rkarel
+    bin/karel init example.karel
+    bin/karel run example.karel
+    bin/karel run -g example.karel
+
+== Usage
+
+While the karel language doesn't have any concept of the world, you must still define one in which your program will run.  This is done
+at the top of the program via:
+
+    WORLD <<END
+       W    B
+       W   
+       WWW
+       B
+    K
+    END
+
+This defines Karel's world to be 5x9 with walls represented by W's, a beeper represented by B's, and Karel's
+initial location represented as a "K".  Karel is assumed to be facing north with no beepers at the start of all programs.
+
+You then can define subroutines as such:
+
+    DEFINE('TURNRIGHT') {
+      TURNLEFT()
+      TURNLEFT()
+      TURNLEFT()
+    }
+
+You can then call this subroutine as you would any other
+
+    MOVE()
+    TURNRIGHT()
+    MOVE()
+    MOVE()
+
+Once you've defined your subroutines, you can begin writing your program:
+
+    MOVE()
+    TURNLEFT()
+    ITERATE(3.TIMES) {
+      MOVE
+    }
+    IF(front_clear) {
+      MOVE()
+    }
+    ELSE {
+      PUTBEEPER()
+    }
+    TURNLEFT()
+    WHILE(not_on_beeper) {
+      MOVE
+    }
+   PICKBEEPER()
+
+=== Commands
+
+[+MOVE+] Move Karel forward one square.  If Karel can't, he explodes and the program aborts
+[+TURNLEFT+] Rotate Karel, in place, to the left
+[+PICKBEEPER+] Pick up the beeper at Karel's position.  If there is no beeper, Karel explodes and the problem aborts
+[+PUTBEEPER+] Put down a beeper at Karel's position.  If there is a beeper or if Karel has no beepers, Karel explodes and the problem aborts
+
+=== Control Flow
+
+[+IF+] takes a condition and a curly-braced block to perform if the condition holds
+[+ELSE+] when after an IF, executes the curly-braced block if the condition didn't hold
+[<code>ITERATE(<i>N</i>.TIMES)</code>] perform something a constant number of times
+[+WHILE+] takes a condition and a curly-braced block and repeatedly performs the block's statements until the condition holds
+
+==== Conditions
+
+[+on_beeper+] true if Karel is on the same square as a beeper
+[+not_on_beeper+] true if Karel is not on the same square as a beeper
+[+front_clear+] true if the square in front of Karel is clear
+[+front_not_clear+] true if the square in front of Karel is not clear
+[+left_clear+] true if the square to the left of Karel is clear
+[+left_not_clear+] true if the square to the left of Karel is not clear
+[+right_clear+] true if the square to the left of Karel is clear
+[+right_not_clear+] true if the square to the left of Karel is not clear
+[+facing_north+] true if Karel is facing north
+[+not_facing_north+] true if Karel is not facing north
+[+facing_south+] true if Karel is facing south
+[+not_facing_south+] true if Karel is not facing south
+[+facing_east+] true if Karel is facing east
+[+not_facing_east+] true if Karel is not facing east
+[+facing_west+] true if Karel is facing west
+[+not_facing_west+] true if Karel is not facing west
+
+=== Subroutines
+
+You can define your own subroutines via the +DEFINE+ directive:
+
+    DEFINE('RUN_TO_WALL') {
+      WHILE(front_clear) {
+        MOVE()
+      }
+    }
+    RUN_TO_WALL()
+
+
+=== Whitespace and comments
+
+Whitespace is not significant and is ignored.  Comments are lines starting with optional whitespace then followed by a +#+.  The remainder
+of the line is ignored.
+
+== Example
+
+Here's an example program that has Karel grabbing both beepers and stopping on the last one (the one in the upper-left corner):
+
+    WORLD <<END
+    B WW  B
+      W
+      W
+
+    WWW    K
+    END
+    
+    WHILE(front_clear) {
+      MOVE()
+    }
+    TURNLEFT()
+    MOVE()
+    PICKBEEPER()
+    TURNLEFT()
+    # Karel is now facing south
+    WHILE(front_clear) {
+      MOVE()
+    }
+    TURNLEFT()
+    TURNLEFT()
+    MOVE()
+    TURNLEFT()
+    WHILE(front_clear) {
+      MOVE()
+    }
+    TURNLEFT()
+    TURNLEFT()
+    TURNLEFT()
+    WHILE(not_on_beeper) {
+      MOVE()
+    }
+    PICKBEEPER()
+    
+We can reduce the line count and make it more readable with some subroutines:
+
+    DEFINE('TURNRIGHT') {
+      ITERATE(3.TIMES) {
+        TURNLEFT()
+      }
+    }
+    DEFINE('TURNAROUND') {
+      TURNLEFT()
+      TURNLEFT()
+    }
+    DEFINE('RUN') {
+      WHILE(front_clear) {
+        MOVE()
+      }
+    }
+    DEFINE('BACKUP') {
+      TURNAROUND()
+      MOVE()
+    }
+
+    RUN()
+    TURNLEFT()
+    MOVE()
+    PICKBEEPER()
+    TURNLEFT()
+    RUN()
+    BACKUP()
+    TURNLEFT()
+    RUN()
+    TURNRIGHT()
+    WHILE(not_on_beeper) {
+      MOVE()
+    }
+    PICKBEEPER()
+
+== Non-DSL Mode
+
+If you wish to use this code as an engine to embed inside another application, the DSL mode is quite inconvienient.  In this case, you can create an object and call the DSL methods on it.
+
+    engine = Engine.new
+    engine.WORLD <<END
+    B WW  B
+      WW  W
+      W  WW
+    K     W
+    END
+
+Need to think this out more; what is possible and what isn't?
+
+== Vim Syntax File 
+
+In <code>contrib</code> is a vim syntax file for karel source as described here.
+
+== Command Line Interface
+
+    karel command_name [command-specific options] [--] arguments...
+
+* Use the command +help+ to get a summary of commands
+* Use the command <tt>help command_name</tt> to get a help for +command_name+
+* Use <tt>--</tt> to stop command line argument processing; useful if your arguments have dashes in them
+
+== Commands
+[<tt>check</tt>] Performs a basic syntax check
+[<tt>help</tt>] Shows list of commands or help for one command
+[<tt>init</tt>] Creates a new example Karel program
+[<tt>run</tt>] Executes a Karel program
+
+=== <tt>check source_file</tt>
+
+Performs a basic syntax check
+
+=== <tt>help [command]</tt>
+
+Shows list of commands or help for one command
+
+=== <tt>init source_file</tt>
+
+Creates a new example Karel program
+
+
+
+==== Options
+These options are specified *after* the command.
+
+[<tt>-f, --force</tt>] Overwite files
+=== <tt>run source_file</tt>
+
+Executes a Karel program
+
+
+
+==== Options
+These options are specified *after* the command.
+
+[<tt>-g, --debug</tt>] Show the world after each command is executed
+[<tt>-s</tt>] Run silently; do not show the world before or after
+[<tt>-x arg</tt>] Number of "ticks" to allow before assuming we are in an infinite loop <i>( default: <tt>1000</tt>)</i>

data/bin/karel

@@ -0,0 +1,138 @@
+#!/usr/bin/ruby
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+$: << File.expand_path(File.dirname(__FILE__) + '/../ext')
+require 'rubygems'
+require 'gli'
+require 'karel'
+require 'karel/syntax_checker'
+
+include GLI
+
+desc 'Executes a Karel program'
+arg_name 'source_file'
+command :run do |c|
+
+  c.desc 'Run silently; do not show the world before or after'
+  c.long_desc 'This will execute the karel source file, exiting with 0 if the program ran without incident.  An exit code of -1 means that Karel exploded, and -2 means that a potential infinite loop was encountered'
+  c.switch :s
+
+  c.desc 'Number of "ticks" to allow before assuming we are in an infinite loop'
+  c.long_desc 'To keep this implementation simple, we will count the number of times we execute a Karel command.  If this number exceeds the number here, we will assume a non-terminating program and exit'
+  c.default_value '1000'
+  c.flag [:x]
+
+  c.desc 'Show the world after each command is executed'
+  c.switch [:g,:debug]
+
+  c.action do |global_options,options,args|
+    raise "You must provide a karel source file" if args.empty?
+    include Karel
+    code = File.open(args[0]).readlines.join("")
+    checker = Karel::SyntaxChecker.new
+    unless checker.valid?(code)
+      checker.errors.keys.sort.each do |line_number|
+        $stderr.puts "#{line_number}: #{checker.errors[line_number]}"
+      end
+      raise "There were syntax errors"
+    end
+    DEBUG() if options[:g]
+    SILENT() if options[:s]
+    eval(code)
+    unless options[:s]
+      puts "Final State"
+      puts THE_WORLD.to_s
+    end
+  end
+end
+
+desc 'Performs a basic syntax check'
+arg_name 'source_file'
+command :check do |c|
+  c.action do |global_options,options,args|
+    raise "You must provide a karel source file" if args.empty?
+    checker = Karel::SyntaxChecker.new
+    code = File.open(args[0]).readlines.join("")
+    unless checker.valid?(code)
+      checker.errors.keys.sort.each do |line_number|
+        $stderr.puts "#{line_number}: #{checker.errors[line_number]}"
+      end
+    end
+  end
+end
+
+desc 'Creates a new example Karel program'
+arg_name 'source_file'
+command :init do |c|
+  c.desc 'Overwite files'
+  c.switch [:f,:force]
+
+  c.action do |global_options,options,args|
+    raise "You must provide a karel source file" if args.empty?
+    not_overwritten = []
+    args.each do |filename|
+      if File.exists?(filename) && !options[:f]
+        not_overwritten << filename 
+      else
+        File.open(filename,'w') do |file|
+          file.puts <<EOF
+# A 10x10 world
+WORLD <<END
+B   WW  WB
+    W
+    W
+    W
+    WB
+  WWWW
+        WW
+         W
+ B
+K
+END
+
+# Create a subroutine
+DEFINE('MOVE_TWICE') {
+  MOVE()
+  MOVE()
+}
+
+MOVE()
+TURNLEFT()
+TURNLEFT()
+TURNLEFT()
+MOVE()
+PICKBEEPER()
+MOVE_TWICE()
+PUTBEEPER()
+WHILE(front_clear) {
+  MOVE()
+}
+EOF
+        end
+      end
+    end
+    not_overwritten.each do |filename|
+      puts "Not overwriting #{filename}; file exists"
+    end
+  end
+end
+
+pre do |global,command,options,args|
+  true
+end
+
+post do |global,command,options,args|
+end
+
+on_error do |exception|
+  case exception
+    when Karel::Explosion 
+      $stderr.puts "Karel Exploded"
+      $stderr.puts THE_WORLD.to_s
+      false
+    else
+#      puts exception.backtrace
+      true
+  end
+end
+
+GLI.run(ARGV)

data/ext/fixnum_TIMES.rb

@@ -0,0 +1,5 @@
+class Fixnum
+  def TIMES
+    self
+  end
+end

data/karel.rdoc

@@ -0,0 +1,44 @@
+= <tt>karel</tt>
+
+    karel command_name [command-specific options] [--] arguments...
+
+* Use the command +help+ to get a summary of commands
+* Use the command <tt>help command_name</tt> to get a help for +command_name+
+* Use <tt>--</tt> to stop command line argument processing; useful if your arguments have dashes in them
+
+== Commands
+[<tt>check</tt>] Performs a basic syntax check
+[<tt>help</tt>] Shows list of commands or help for one command
+[<tt>init</tt>] Creates a new example Karel program
+[<tt>run</tt>] Executes a Karel program
+
+=== <tt>check source_file</tt>
+
+Performs a basic syntax check
+
+=== <tt>help [command]</tt>
+
+Shows list of commands or help for one command
+
+=== <tt>init source_file</tt>
+
+Creates a new example Karel program
+
+
+
+==== Options
+These options are specified *after* the command.
+
+[<tt>-f, --force</tt>] Overwite files
+=== <tt>run source_file</tt>
+
+Executes a Karel program
+
+
+
+==== Options
+These options are specified *after* the command.
+
+[<tt>-g, --debug</tt>] Show the world after each command is executed
+[<tt>-s</tt>] Run silently; do not show the world before or after
+[<tt>-x arg</tt>] Number of "ticks" to allow before assuming we are in an infinite loop <i>( default: <tt>1000</tt>)</i>

data/lib/karel.rb

@@ -0,0 +1,12 @@
+require 'karel/commands'
+require 'karel/exceptions'
+require 'karel/karel'
+require 'karel/square'
+require 'karel/world'
+
+module Karel
+  include Commands
+
+  THE_WORLD = World.new
+  KAREL = Karel.new
+end

data/lib/karel/commands.rb

@@ -0,0 +1,152 @@
+require 'fixnum_TIMES.rb'
+module Karel
+  module Commands
+    INFINITE_LOOP_NUM_STEPS = 1000
+    # Create the world with the given initialization string
+    def WORLD(string)
+      @subroutines ||= {}
+      world_instance.create_from_string(string,karel_instance)
+      unless @silent
+        puts "Initial State"
+        puts THE_WORLD.to_s
+      end
+    end
+
+    def karel_instance; KAREL; end
+    def world_instance; THE_WORLD; end
+    
+    def DEBUG
+      @debug = true
+      @silent = false
+    end
+
+    def SILENT
+      @silent = true
+      @debug = false
+    end
+
+    # Moves Karel forward one square
+    def MOVE
+      x,y = Karel.coordinates_after_move_from(karel_instance.direction,*world_instance.karel)
+      world_instance.karel=[x,y]
+      debug_command('MOVE')
+    end
+
+    # Turns karel to the left in place
+    def TURNLEFT
+      karel_instance.turnleft
+      debug_command('TURNLEFT')
+    end
+
+    def PICKBEEPER
+      karel = world_instance.karel
+      begin
+      world_instance.remove_beeper(*karel)
+      karel_instance.put_beeper_in_bag
+      rescue NoBeeper => x
+        raise Explosion
+      end
+      debug_command('PICKBEEPER')
+    end
+
+    def PUTBEEPER
+      karel = world_instance.karel
+      karel_instance.remove_beeper_from_bag
+      world_instance.add_beeper(*karel)
+      debug_command('PUTBEEPER')
+    end
+
+    def DEFINE(name,&block)
+      raise BadSubroutine unless subroutine_name_ok?(name)
+      @subroutines ||= {}
+      @subroutines[name.to_sym] = block;
+    end
+
+    # Handles calling subroutines defined
+    def method_missing(sym,*args)
+      if !args || args.size == 0
+        if @subroutines[sym]
+          puts "CALLING #{sym}" if @debug
+          @subroutines[sym].call
+        else
+          super.method_missing(sym,args)
+        end
+      else
+        super.method_missing(sym,args)
+      end
+    end
+
+    def ITERATE(num,&block)
+      num.times { block.call }
+    end
+
+    def WHILE(condition,&block)
+      steps = 0
+      while (condition_met? condition)
+        block.call
+        steps += 1
+        raise PossibleInfiniteLoop if steps > INFINITE_LOOP_NUM_STEPS
+      end
+    end
+
+    @last_condition = nil
+    def IF(condition,&block)
+      if condition_met? condition
+        block.call
+      end
+      @last_condition = condition
+    end
+
+    def ELSE(&block)
+      raise "No IF with this ELSE!" if @last_condition.nil?
+      condition = @last_condition
+      @last_condition = nil
+      unless (condition_met? condition)
+        block.call
+      end
+    end
+
+    def condition_met?(condition)
+      raise "No such condition #{condition}" unless CONDITIONS[condition]
+      CONDITIONS[condition].call(world_instance,karel_instance,*world_instance.karel)
+    end
+
+    def subroutine_name_ok?(name)
+      name =~ /^[A-Z][A-Z_0-9]*[A-Z]$/
+    end
+
+    def debug_command(command)
+      if @debug
+        puts "#{karel_instance.num_beepers} beepers> #{command}"
+        puts world_instance.to_s
+      end
+    end
+
+    CONDITIONS = {
+      :on_beeper    => lambda{ |world,karel,row,column| world.clear?(row,column) && world[row,column].beeper? },
+      :front_clear  => lambda{ |world,karel,row,column| world.clear?(*Karel.coordinates_after_move_from(karel.direction,row,column)) },
+      :left_clear   => lambda{ |world,karel,row,column| world.clear?(*Karel.coordinates_after_move_from(Karel.left_of(karel.direction),row,column)) },
+      :right_clear  => lambda{ |world,karel,row,column| world.clear?(*Karel.coordinates_after_move_from(Karel.right_of(karel.direction),row,column)) },
+      :facing_north => lambda{ |world,karel,row,column| karel.direction == :north },
+      :facing_south => lambda{ |world,karel,row,column| karel.direction == :south },
+      :facing_east  => lambda{ |world,karel,row,column| karel.direction == :east },
+      :facing_west  => lambda{ |world,karel,row,column| karel.direction == :west },
+
+      :not_on_beeper    => lambda{ |world,karel,row,column| !CONDITIONS[:on_beeper].call(world,karel,row,column) },
+      :front_not_clear  => lambda{ |world,karel,row,column| !CONDITIONS[:front_clear].call(world,karel,row,column) },
+      :left_not_clear   => lambda{ |world,karel,row,column| !CONDITIONS[:left_clear].call(world,karel,row,column) },
+      :right_not_clear  => lambda{ |world,karel,row,column| !CONDITIONS[:right_clear].call(world,karel,row,column) },
+      :not_facing_north => lambda{ |world,karel,row,column| !CONDITIONS[:facing_north].call(world,karel,row,column) },
+      :not_facing_south => lambda{ |world,karel,row,column| !CONDITIONS[:facing_south].call(world,karel,row,column) },
+      :not_facing_east  => lambda{ |world,karel,row,column| !CONDITIONS[:facing_east].call(world,karel,row,column) },
+      :not_facing_west  => lambda{ |world,karel,row,column| !CONDITIONS[:facing_west].call(world,karel,row,column) },
+    }
+
+    CONDITIONS.each_key do |condition|
+      define_method condition do
+        condition
+      end
+    end
+  end
+
+end

data/lib/karel/exceptions.rb

@@ -0,0 +1,15 @@
+module Karel
+  # Thrown when Karel does something that causes him to explode
+  class Explosion < Exception; end
+  # Thrown if the world was not created in a valid state
+  class InvalidWorld < Exception; end
+  # Thrown when a square is occupied when an operation requires it not to be
+  class SquareOccupied < Exception; end
+  # Thrown when there is no beeper on a square when an operation require there to be
+  class NoBeeper < Exception; end
+  # Thrown when a subroutine is defined that has a bad or not-allowed name
+  class BadSubroutine < Exception; end
+  # Thrown when a while loop has gone on too long and we think there might
+  # be an infinite loop
+  class PossibleInfiniteLoop < Exception; end
+end

data/lib/karel/karel.rb

@@ -0,0 +1,67 @@
+module Karel
+  # The robot itself.  Knows only its internal state, not much about where it is
+  class Karel
+    attr_reader :direction
+    attr_reader :num_beepers
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @direction = :north
+      @num_beepers = 0
+    end
+
+    def put_beeper_in_bag
+      @num_beepers += 1
+    end
+
+    def remove_beeper_from_bag
+      raise Explosion if @num_beepers <= 0
+      @num_beepers -= 1
+    end
+
+    def turnleft
+      @direction = Karel.left_of(@direction)
+    end
+
+    def to_s
+      STRINGS[direction]
+    end
+
+    def self.left_of(direction)
+      new_index = DIRECTIONS.index(direction) + 1
+      new_index = 0 if new_index >= DIRECTIONS.size
+      DIRECTIONS[new_index]
+    end
+
+    def self.right_of(direction)
+      new_index = DIRECTIONS.index(direction) - 1
+      new_index = DIRECTIONS.size - 1 if new_index < 0
+      DIRECTIONS[new_index]
+    end
+
+    def self.coordinates_after_move_from(direction,x,y)
+      if direction == :north
+        [x-1,y]
+      elsif direction == :south
+        [x+1,y]
+      elsif direction == :west
+        [x,y-1]
+      elsif direction == :east
+        [x,y+1]
+      end
+    end
+
+    DIRECTIONS = [:north,:west,:south,:east]
+
+    private 
+    STRINGS = {
+      :north => '^',
+      :west => '<',
+      :south => 'v',
+      :east => '>',
+    }
+  end
+end

data/lib/karel/square.rb

@@ -0,0 +1,42 @@
+module Karel
+  # A square on the board
+  class Square; end
+
+  # A square that can hold a beeper, or Karel.
+  class FreeSquare < Square
+    def initialize(beeper=false)
+      @beeper = beeper
+    end
+
+    def wall?; false; end
+
+    def beeper?; @beeper; end
+
+    def pick_beeper
+      raise NoBeeper unless beeper?
+      @beeper = false
+    end
+
+    def put_beeper
+      raise SquareOccupied if beeper?
+      @beeper = true
+    end
+
+    def to_s
+      if beeper?
+        "B"
+      else
+        " "
+      end
+    end
+  end
+
+  # A wall square
+  class Wall < Square
+    def wall?; true; end
+    def beeper?; false; end
+    def to_s; "W"; end
+    def put_beeper; raise SquareOccupied; end
+    def pick_beeper; raise NoBeeper; end
+  end
+end

data/lib/karel/syntax_checker.rb

@@ -0,0 +1,86 @@
+require 'karel/commands'
+
+module Karel
+  # A very basic and very hacky syntax checker.  This won't ensure the program runs
+  # and is pretty lame overall, but it more or less gets the job done
+  class SyntaxChecker
+    def initialize
+      @builtins = []
+      Commands.public_instance_methods.each do |method|
+        @builtins << method if method =~ /^[A-Z_]*$/
+      end
+      @control = [ 'WHILE', 'IF', 'ELSE', 'ITERATE' ]
+    end
+
+    def valid?(code)
+      line_number = 1
+      @errors = {}
+      in_world = false
+      defines = []
+      code.split(/\n/).each do |line|
+        line_number += 1
+        trimmed = line.strip.gsub(/\(\)/,'').strip
+        if in_world
+          if trimmed =~ /^END\s*$/
+            in_world = false
+          else
+            if trimmed =~ /^[ KWB]*$/
+              # ok
+            else
+              @errors[line_number] = "Bad world definition: #{trimmed}"
+            end
+          end
+        elsif (trimmed =~ /^WORLD\s+<<END$/)
+          in_world = true
+        else
+          next if trimmed =~/^\s*$/
+          next if trimmed =~/^\s*#.*$/
+          if trimmed =~ /^DEFINE\s*\(\s*["'](.[^"']*)["']\s*\)\s*\{\s*$/
+            define = $1
+            if define =~ /^[A-Z_]*$/
+              defines << define
+            else
+              @errors[line_number] = "Bad DEFINE symbol #{define}"
+            end
+          else
+            to_the_bone = trimmed.gsub(/[^A-Z_].*$/,'')
+            if @control.include? to_the_bone
+              if trimmed =~ /^#{to_the_bone}\s*\((.*)\)\s*\{\s*$/
+                condition = $1
+                if to_the_bone == 'ITERATE'
+                  if condition =~ /^\s*[0-9]\.TIMES\s*$/
+                    # ok
+                  else
+                    @errors[line_number] = "Bad #{to_the_bone} condition: #{condition}"
+                  end
+                else
+                  if (trimmed =~ /^ELSE/) 
+                    @errors[line_number] = "Bad #{to_the_bone} statement: #{trimmed}"
+                  end
+                  if condition =~ /^[a-z_]+$/
+                    # ok
+                  else
+                    @errors[line_number] = "Bad #{to_the_bone} condition: #{condition}"
+                  end
+                end
+              else
+                if trimmed =~ /^ELSE\s*\{\s*$/
+                  # ok
+                else
+                  @errors[line_number] = "Bad #{to_the_bone} statement: #{trimmed}"
+                end
+              end
+            elsif trimmed =~ /^\s*\}\s*$/
+              # ignore
+            else
+              @errors[line_number] = "Unknown symbol #{trimmed}" unless (@builtins.include? trimmed) || (defines.include? trimmed)
+            end
+          end
+        end
+      end
+      @errors.empty?
+    end
+
+    def errors; @errors; end
+  end
+end

data/lib/karel/world.rb

@@ -0,0 +1,140 @@
+module Karel
+  # The world in which Karel operates.  
+  class World
+
+    attr_reader :karel
+    attr_reader :width
+    attr_reader :height
+
+    # Creates the world from a string that is a multi-line representation of the world.
+    # This isn't the constructor because our DSL requires uppercase and we don't want
+    # warnings by creating the world twice (once when declaring it as a constant in the Karel
+    # module and once inside the module method WORLD).
+    def create_from_string(definition,karel)
+      @karel = nil
+      @karel_instance = karel
+      @karel_instance.reset
+      @world = []
+      @width = 0
+      row = 0
+      column = 0
+      rows = definition.split(/\n/)
+      @height = rows.size
+      rows.each do |row_data|
+        @width = row_data.length if row_data.length > @width
+        row_data.split(//).each do |square|
+          @karel = [row,column] if square == 'K'
+          @world[row] ||= []
+          @world[row][column] = square_for(square)
+          column += 1
+        end
+        column = 0
+        row += 1
+      end
+      raise InvalidWorld,"There is no Karel in this World" unless @karel
+      fill_in_empty_spaces
+    end
+
+    # Removes a beeper from the world at the given row/column
+    #
+    # raises a NoBeeper exception if there is no beeper at those coordinates.  
+    def remove_beeper(row,column)
+      self[row,column].pick_beeper
+    end
+
+    # Adds a beeper tot he world at the given row/column
+    #
+    # raises a SquareOccupied exception if there is a beeper or wall at those coordinates.  
+    def add_beeper(row,column)
+      self[row,column].put_beeper
+    end
+
+    # Set the location of Karel
+    #
+    # location - an array of size 2, with the row/column where karel should be
+    #
+    # Raises an Explosion if you try to put Karel where there is a wall
+    def karel=(location)
+      raise Explosion,"#{location.inspect} is out of bounds" unless in_bounds?(*location)
+      raise Explosion if self[*location].wall?
+      @karel = location
+    end
+
+    # True if the square could be moved into by Karel
+    def clear?(row,column)
+      if in_bounds?(row,column)
+        !self[row,column].wall?
+      else
+        false
+      end
+    end
+
+    # Provides access to the square at the given row/column
+    #
+    # Returns a Square instance, on which you can call handy methods like beeper? and wall?
+    def [](row,column)
+      @world[row][column]
+    end
+
+    # Returns the string representation, which looks like the 
+    # the string used to construct this
+    def to_s
+      string = "+"
+      @width.times { string += '-' }
+      string += "+\n"
+      @height.times do |row|
+        string += "|"
+        @width.times do |column|
+          kr,kc = karel
+          if (kr == row) && (kc == column)
+            string += @karel_instance.to_s
+          else
+            string += self[row,column].to_s
+          end
+        end
+        string += "|\n"
+      end
+      string += "+"
+      @width.times { string += '-' }
+      string += "+\n"
+      string
+    end
+
+    private
+
+    SQUARE_FACTORIES = {
+      'B' => lambda { FreeSquare.new(true) },
+      'W' => lambda { Wall.new },
+      ' ' => lambda { FreeSquare.new },
+      'K' => lambda { FreeSquare.new },
+    }
+
+    # Given a character, returns the square type
+    # that should go there
+    def square_for(square)
+      raise InvalidWorld,"Square type #{square} is not valid" if SQUARE_FACTORIES[square].nil?
+      SQUARE_FACTORIES[square].call
+    end
+
+    def in_bounds?(row,column)
+      if row < 0 || column < 0
+        false
+      elsif row >= @height
+        false
+      elsif column >= @width
+        false
+      else
+        true
+      end
+    end
+
+    def fill_in_empty_spaces
+      @height.times do |row|
+        @world[row] = [] if @world[row].nil?
+        @width.times do |column|
+          @world[row][column] = FreeSquare.new if @world[row][column].nil?
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: karel
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dave Copeland
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-26 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gli
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 1
+        - 1
+        - 1
+        version: 1.1.1
+  type: :runtime
+  version_requirements: *id001
+description: |
+  This is a ruby implementation of Karel The Robot, a 
+  programming language designed for extreme beginners.   It concerns controlling
+  a robot, named Karel, in a grid-based world comprised of walls and beepers.  Karel can pick up and put down beepers, move
+  forward, and turn left.  Karel can also detect things about his environment.
+
+email: davetron5000@gmail.com
+executables: 
+- karel
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- karel.rdoc
+files: 
+- bin/karel
+- ext/fixnum_TIMES.rb
+- lib/karel/commands.rb
+- lib/karel/exceptions.rb
+- lib/karel/karel.rb
+- lib/karel/square.rb
+- lib/karel/syntax_checker.rb
+- lib/karel/world.rb
+- lib/karel.rb
+- README.rdoc
+- karel.rdoc
+has_rdoc: true
+homepage: http://www.naildrivin5.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Karel The Robot
+- --main
+- README.rdoc
+- -ri
+require_paths: 
+- lib
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An implementation of Karel the Robot as a Ruby DSL
+test_files: []
+