rpiet 0.1

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+manifest.mf
+*~
+*.orig
+*.rej
+/target/
+dist
+build
+nbproject

data/README.md

@@ -0,0 +1,19 @@
+# RPiet - Ruby implementation of Piet programming language
+
+Check it out: http://www.dangermouse.net/esoteric/piet.html
+
+This is a pretty naive implementation, but it can run things like fib:
+
+[[/tree/master/images/helloworld-pietbig.gif|align=center]]
+
+## Running
+
+rpiet --debug images/nfib.png
+
+Or an image from the net (notice codel size arg):
+
+rpiet -c 8 http://www.retas.de/thomas/computer/programs/useless/secunet_contest/entry_3/s2_8.gif
+
+Or for more fun:
+
+rpiet http://www.dangermouse.net/esoteric/piet/pietquest.png

data/bin/rpiet

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'rpiet'
+require 'rpiet/image/url_image'
+
+codel_size = 1
+
+log = RPiet::Logger::NoOutput
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} -d image_file"
+
+  opts.on("-d", "--debug style", "turn on debugging") do |style|
+    log = case style
+    when 'simple'
+      RPiet::Logger::SimpleAsciiOutput
+    when 'complex'
+      RPiet::Logger::ComplexAsciiOutput
+    end
+  end
+  opts.on("-c", "--codel-size w", "size of codel") { |w| codel_size = w.to_i }
+end
+
+opts.parse!(ARGV)
+opts.usage("You need to supply a source image filename.") unless ARGV.first
+
+filename = ARGV.first
+filename = 'file:' + ARGV.first if File.exist? filename
+image = RPiet::Image::URLImage.new(filename, codel_size)
+RPiet::Interpreter.new(image, log.new).run

data/lib/rpiet.rb

@@ -0,0 +1,2 @@
+require 'rpiet/version'
+require 'rpiet/interpreter'

data/lib/rpiet/codel_chooser.rb

@@ -0,0 +1,29 @@
+require 'rpiet/direction_pointer'
+
+module RPiet
+  class CodelChooser
+    LEFT, RIGHT = -1, 1
+    attr_reader :direction
+    def initialize; @direction = LEFT; end
+    def switch!(amount = 1); @direction *= -1.**(amount % 2); end
+
+    def ascii(dp)
+      case dp.direction
+      when RPiet::Direction::RIGHT
+        @direction == LEFT ? "^" : "v"
+      when RPiet::Direction::UP
+        @direction == LEFT ? "<" : ">"
+      when RPiet::Direction::LEFT
+        @direction == LEFT ? "v" : "^"
+      when RPiet::Direction::DOWN
+        @direction == LEFT ? ">" : "<"
+      end
+    end
+
+    def inspect
+      (@direction == LEFT ? "left(0)" : "right(1)")
+    end
+    alias :to_s :inspect
+  end
+end
+

data/lib/rpiet/color.rb

@@ -0,0 +1,54 @@
+require 'rpiet/cycle'
+
+module RPiet
+  class Color
+    extend RPiet::CycleMethod
+
+    cycle :LIGHTNESS, :LIGHT, :NORMAL, :DARK
+    cycle :HUE, :RED, :YELLOW, :GREEN, :CYAN, :BLUE, :MAGENTA
+
+    attr_reader :hue, :lightness
+
+    def initialize(lightness, hue)
+      @lightness, @hue = lightness, hue
+    end
+
+    def to_initial
+      @lightness.to_initial + @hue.to_initial
+    end
+
+    def to_s
+      (@lightness == LIGHTNESS::NORMAL ? "" : @lightness.to_s + ' ') + @hue.to_s
+    end
+    alias :inspect :to_s
+
+    RGB_WHITE, WHITE = '0xffffff', Color.new('white', '')
+    RGB_BLACK, BLACK = '0x000000', Color.new('black', '')
+
+    class << WHITE; def to_initial; '..'; end; end
+    class << BLACK; def to_initial; '++'; end; end
+
+    RGB = {
+      '0xffc0c0' => Color.new(LIGHTNESS::LIGHT, HUE::RED),
+      '0xffffc0' => Color.new(LIGHTNESS::LIGHT, HUE::YELLOW),
+      '0xc0ffc0' => Color.new(LIGHTNESS::LIGHT, HUE::GREEN),
+      '0xc0ffff' => Color.new(LIGHTNESS::LIGHT, HUE::CYAN),
+      '0xc0c0ff' => Color.new(LIGHTNESS::LIGHT, HUE::BLUE),
+      '0xffc0ff' => Color.new(LIGHTNESS::LIGHT, HUE::MAGENTA),
+      '0xff0000' => Color.new(LIGHTNESS::NORMAL, HUE::RED),
+      '0xffff00' => Color.new(LIGHTNESS::NORMAL, HUE::YELLOW),
+      '0x00ff00' => Color.new(LIGHTNESS::NORMAL, HUE::GREEN),
+      '0x00ffff' => Color.new(LIGHTNESS::NORMAL, HUE::CYAN),
+      '0x0000ff' => Color.new(LIGHTNESS::NORMAL, HUE::BLUE),
+      '0xff00ff' => Color.new(LIGHTNESS::NORMAL, HUE::MAGENTA),
+      '0xc00000' => Color.new(LIGHTNESS::DARK, HUE::RED),
+      '0xc0c000' => Color.new(LIGHTNESS::DARK, HUE::YELLOW),
+      '0x00c000' => Color.new(LIGHTNESS::DARK, HUE::GREEN),
+      '0x00c0c0' => Color.new(LIGHTNESS::DARK, HUE::CYAN),
+      '0x0000c0' => Color.new(LIGHTNESS::DARK, HUE::BLUE),
+      '0xc000c0' => Color.new(LIGHTNESS::DARK, HUE::MAGENTA),
+      RGB_WHITE => WHITE,
+      RGB_BLACK => BLACK
+    }
+  end
+end

data/lib/rpiet/cycle.rb

@@ -0,0 +1,59 @@
+module RPiet
+  class Cycle
+    attr_reader :name, :value
+
+    def initialize(value, name, list)
+      @value, @name, @list = value, name.to_s.downcase, list
+    end
+
+    def delta(other)
+      (@value - other.value) % @list.length      
+    end
+
+    def -(other)
+      @list[(@value - other.value) % @list.length]
+    end
+
+    def +(other)
+      @list[(@value + other.value) % @list.length]
+    end
+
+    def incr(amount = 1)
+      @list[(@value + amount) % @list.length]
+    end
+
+    def decr(amount = 1)
+      @list[(@value - amount) % @list.length]
+    end
+
+    def to_initial
+      @name[0]
+    end
+
+    def to_s
+      "#{@name}(#{@value})"
+    end
+    alias :inspect :to_s
+  end
+
+  module CycleMethod
+    ##
+    # Define a constant in self and then populate a series of constants
+    # within that with cycled values from 0-n.
+    def cycle(const_name, *names)
+      
+      list = []
+      if const_name.is_a? Symbol
+        holder_module = Module.new
+        const_set const_name, holder_module 
+      else
+        holder_module = const_name
+      end
+      names.each_with_index do |name, i|
+        list[i] = Cycle.new(i, name, list)
+        holder_module.const_set name, list[i]
+      end
+    end
+    module_function :cycle
+  end
+end

data/lib/rpiet/direction_pointer.rb

@@ -0,0 +1,39 @@
+require 'rpiet/cycle'
+require 'rpiet/codel_chooser'
+
+module RPiet
+  extend RPiet::CycleMethod
+  cycle :Direction, :RIGHT, :DOWN, :LEFT, :UP
+
+  class << Direction::RIGHT; def deltas; [1, 0]; end; end
+  class << Direction::DOWN; def deltas; [0, 1]; end; end
+  class << Direction::LEFT; def deltas; [-1, 0]; end; end
+  class << Direction::UP; def deltas; [0, -1]; end; end
+
+  class DirectionPointer
+    attr_reader :direction
+
+    def initialize
+      @direction = RPiet::Direction::RIGHT
+    end
+
+    def rotate!(amount = 1)
+      @direction = @direction.incr amount
+    end
+
+    def next_possible(x, y)
+      dx, dy = @direction.deltas
+      [x + dx, y + dy]
+    end
+
+    ASCII_ARROWS = ['>', 'v', '<', '^']
+    def ascii
+      ASCII_ARROWS[@direction.value]
+    end
+
+    def inspect
+      @direction.inspect
+    end
+    alias :to_s :inspect
+  end
+end

data/lib/rpiet/event_handler.rb

@@ -0,0 +1,66 @@
+module RPiet
+  module EventHandler
+    def dmesg(message)
+      $stderr.puts message
+    end
+
+    def initialized(runtime)
+    end
+
+    def step_begin(runtime)
+    end
+
+    def trying_again(runtime, ex, ey)
+    end
+
+    def seen_white(runtime)
+    end
+
+    def execution_completed(runtime)
+    end
+
+    def operation(runtime, operation)
+    end
+  end
+
+  module Logger
+    class NoOutput
+      include RPiet::EventHandler
+    end
+    
+    class SimpleAsciiOutput
+      include RPiet::EventHandler
+
+      def initialized(runtime)
+        dmesg "codel_size: #{runtime.source.codel_size}"
+      end
+
+      def step_begin(runtime)
+        dmesg "step \##{runtime.step} -- #{runtime.pvm}"
+      end
+
+      def trying_again(runtime, ex, ey)
+        dmesg "Trying again at #{ex}, #{ey}. #{runtime.pvm}"
+      end
+
+      def seen_white(runtime)
+        dmesg "Entering white; sliding thru"
+      end
+
+      def execution_completed(runtime)
+        dmesg "Execution trapped, program terminates"
+      end
+
+      def operation(runtime, operation)
+        dmesg "exec: #{operation} -- #{runtime.pvm}"
+      end
+    end
+
+    class ComplexAsciiOutput < SimpleAsciiOutput
+      def step_begin(runtime)
+        super
+        dmesg runtime.source.ascii(runtime.groups[runtime.x][runtime.y])
+      end
+    end
+  end
+end

data/lib/rpiet/group.rb

@@ -0,0 +1,107 @@
+require 'rpiet/direction_pointer'
+require 'rpiet/codel_chooser'
+
+module RPiet
+  class Group
+    include RPiet::Direction
+    attr_reader :rgb, :points
+
+    def initialize(rgb, point)
+      @rgb, @points = rgb, []
+      @max = { RIGHT => [], LEFT => [], UP => [], DOWN => [] }
+
+      self << point
+    end
+
+    def point_for(pvm)
+      case pvm.dp.direction
+      when RIGHT then
+        pvm.cc.direction == RPiet::CodelChooser::LEFT ? @rl : @rr
+      when LEFT then
+        pvm.cc.direction == RPiet::CodelChooser::LEFT ? @ll : @lr
+      when DOWN then
+        pvm.cc.direction == RPiet::CodelChooser::LEFT ? @dl : @dr
+      when UP then
+        pvm.cc.direction == RPiet::CodelChooser::LEFT ? @ul : @ur
+      end
+    end
+
+    def <<(point)
+      update_up point
+      update_down point
+      update_left point
+      update_right point
+      
+      @points << point
+    end
+
+    def include?(point)
+      @points.include? point
+    end
+
+    def finish
+      @rl, @rr = ends(@max[RIGHT].sort { |a, b| a[1] <=> b[1] })
+      @lr, @ll = ends(@max[LEFT].sort { |a, b| a[1] <=> b[1] })
+      @ul, @ur = ends(@max[UP].sort { |a, b| a[0] <=> b[0] })
+      @dr, @dl = ends(@max[DOWN].sort { |a, b| a[0] <=> b[0] })
+    end
+
+    def ends(list)
+      [list[0], list[-1]]
+    end
+    private :ends
+
+    def update_up(point)
+      arr = @max[UP]
+      if arr.empty? || point[1] < arr[0][1]
+        @max[UP] = [point]
+      elsif point[1] == arr[0][1]
+        arr << point 
+      end
+    end
+
+    def update_down(point)
+      arr = @max[DOWN]
+      if arr.empty? || point[1] > arr[0][1]
+        @max[DOWN] = [point]
+      elsif point[1] == arr[0][1]
+        arr << point         
+      end
+    end
+
+    def update_left(point)
+      arr = @max[LEFT]
+      if arr.empty? || point[0] < arr[0][0]
+        @max[LEFT] = [point]
+      elsif point[0] == arr[0][0]
+        arr << point         
+      end
+    end
+
+    def update_right(point)
+      arr = @max[RIGHT]
+      if arr.empty? || point[0] > arr[0][0]
+        @max[RIGHT] = [point]
+      elsif point[0] == arr[0][0]
+        arr << point         
+      end
+    end
+
+    def merge(groups, group)
+      group.points.each do |point|
+        self << point
+        groups[point[0]][point[1]] = self
+      end
+    end
+
+    def size
+      @points.size
+    end
+
+    def inspect
+      "Group #{rgb}: Size: #{size} Points: #{@points.inspect}\n" +
+      "rr #@rr rl #@rl lr #@lr ll #@ll ur #@ur ul #@ul dr #@dr dl #@dl"
+    end
+    alias :to_s :inspect
+  end
+end

data/lib/rpiet/image/ascii_image.rb

@@ -0,0 +1,55 @@
+require 'rpiet/image/image'
+
+module RPiet
+  module Image
+    class AsciiImage < RPiet::Image::Image
+      def initialize(string, codel_size=1)
+        @codel_size = codel_size
+        lines = string.split("\n")
+        @data = []
+        lines.each do |line|
+          @data << line.split(/\s+/).map { |e| str_to_rgb(e) }
+        end
+      end
+
+      def raw_pixel(x, y)
+        @data[x][y]
+      end
+
+      def raw_height
+        @data.length
+      end
+
+      def raw_width
+        @data[0].length
+      end
+
+      STR2RGB = {
+        'lr' => [0xff, 0xc0, 0xc0],
+        'ly' => [0xff, 0xff, 0xc0],
+        'lg' => [0xc0, 0xff, 0xc0],
+        'lc' => [0xc0, 0xff, 0xff],
+        'lb' => [0xc0, 0xc0, 0xff],
+        'lm' => [0xff, 0xc0, 0xff],
+        'nr' => [0xff, 0x00, 0x00],
+        'ny' => [0xff, 0xff, 0x00],
+        'ng' => [0xc0, 0xff, 0x00],
+        'nc' => [0x00, 0xff, 0xff],
+        'nb' => [0x00, 0x00, 0xff],
+        'nm' => [0xff, 0x00, 0xff],
+        'dr' => [0xc0, 0x00, 0x00],
+        'dy' => [0xc0, 0xc0, 0x00],
+        'dg' => [0x00, 0xc0, 0x00],
+        'dc' => [0x00, 0xc0, 0xc0],
+        'db' => [0x00, 0x00, 0xc0],
+        'dm' => [0xc0, 0x00, 0xc0],
+        '..' => [0xff, 0xff, 0xff],
+        '++' => [0x00, 0x00, 0x00]
+      }
+
+      def str_to_rgb(str)
+        STR2RGB[str]
+      end
+    end
+  end
+end

data/lib/rpiet/image/image.rb

@@ -0,0 +1,43 @@
+require 'rpiet/color'
+
+module RPiet
+  module Image
+    ##
+    # Abstract base class for all image providers.  Image providers only need to
+    # implement raw_pixel, raw_width, and raw_height.
+    #
+    class Image
+      attr_reader :codel_size 
+
+      def initialize(codel_size)
+        @codel_size = codel_size
+      end
+
+      def pixel(x, y)
+        r,g,b = raw_pixel(x * @codel_size, y * @codel_size)
+        color_for(format "0x%02x%02x%02x" % [r,g,b])
+      end
+
+      def color_for(rgb_hex)
+        RPiet::Color::RGB[rgb_hex]
+      end
+
+      def ascii(group = [])
+        s = ''
+        w, h = size
+        h.times do |j|
+          w.times do |i|
+            value = pixel(i, j).to_initial 
+            s << (group.include?([i, j]) ? value.upcase : value) << ' '
+          end
+          s << "\n"
+        end
+        s
+      end
+
+      def size
+        [raw_width/@codel_size, raw_height/@codel_size]
+      end
+    end
+  end
+end

data/lib/rpiet/image/url_image.rb

@@ -0,0 +1,28 @@
+require 'java'
+require 'rpiet/image/image'
+
+# Raw in Java is BufferendImage.  In MRI it just needs to define:
+#  width, height, getRGB(x, y)
+module RPiet
+  module Image
+    class URLImage < RPiet::Image::Image
+      def initialize(file, codel_size=1)
+        super(codel_size)
+        @raw = javax.imageio.ImageIO.read(java.net.URL.new(file))
+      end
+
+      def raw_pixel(x, y)
+        rgb = @raw.getRGB(x, y)
+        [(rgb >> 16 ) & 0xff, (rgb >> 8) & 0xff, rgb & 0xff]
+      end
+
+      def raw_width
+        @raw.width
+      end
+
+      def raw_height
+        @raw.height
+      end
+    end
+  end
+end

data/lib/rpiet/interpreter.rb

@@ -0,0 +1,112 @@
+require 'rpiet/color'
+require 'rpiet/machine'
+require 'rpiet/group'
+require 'rpiet/event_handler'
+
+module RPiet
+  class Interpreter
+    attr_reader :pvm, :source, :groups, :x, :y, :step
+
+    def initialize(source, event_handler=RPiet::Logger::NoOutput.new)
+      @x, @y, @pvm, @step = 0, 0, RPiet::Machine.new, 1
+      @source, @event_handler = source, event_handler
+      @rows, @cols = @source.size
+      @pixels = alloc_matrix { |i, j| @source.pixel(i, j)}
+      @groups = calculate_groups(alloc_matrix { |i, j| 0 })
+      @event_handler.initialized(self)
+    end
+
+    def run
+      while(next_step) do
+      end
+    end
+
+    ##
+    # Is this point on the image and not black?
+    def valid?(x, y)
+      x >= 0 && x < @rows && y >= 0 && y < @cols && 
+        @pixels[x][y] != RPiet::Color::BLACK
+    end
+
+    def next_step
+      @pvm.block_value = @groups[@x][@y].size
+      i = 0
+      seen_white = false
+      @event_handler.step_begin(self)
+      ex, ey = @groups[@x][@y].point_for(@pvm)
+      while i < 8 do
+        nx, ny = @pvm.next_possible(ex, ey)
+
+        if !valid?(nx, ny)
+          i += 1
+          @pvm.orient_elsewhere(i)
+
+          ex, ey = @groups[@x][@y].point_for(@pvm) if !seen_white
+          @event_handler.trying_again(self, ex, ey)
+          next
+        elsif @pixels[nx][ny] == RPiet::Color::WHITE
+          if !seen_white
+            seen_white = true
+            i = 0
+            @event_handler.seen_white(self)
+          end
+          ex, ey = nx, ny
+        else
+          if !seen_white
+            operation = @pvm.execute(@pixels[nx][ny], @pixels[@x][@y])
+          else
+            operation = 'noop'            
+          end
+          @event_handler.operation(self, operation)
+          @x, @y = nx, ny
+          @step += 1
+          return true
+        end
+      end
+      @event_handler.execution_completed(self)
+      false
+    end
+
+    # always look up, left, or make new group
+    def calculate_groups(groups)
+      all_groups = []
+      walk_matrix(groups) do |i, j|
+        rgb = @pixels[i][j]
+        up = j-1 >= 0 ? groups[i][j-1] : nil
+        left = i-1 >= 0 ? groups[i-1][j] : nil
+        if up && up.rgb == rgb
+          up << [i, j]
+          groups[i][j] = up
+          # disjoint groups to merge
+          up.merge(groups, left) if left && left != up && left.rgb == rgb
+        end
+
+        if groups[i][j] == 0 && left && left.rgb == rgb
+          left << [i, j]
+          groups[i][j] = left
+        end
+
+        if groups[i][j] == 0
+          groups[i][j] = RPiet::Group.new(rgb, [i, j])
+          all_groups << groups[i][j]
+        end
+      end
+      all_groups.each { |group| group.finish }
+      groups
+    end
+
+    def alloc_matrix
+      Array.new(@rows) { Array.new(@cols) {nil} }.tap do |matrix|
+        walk_matrix(matrix) { |i, j| matrix[i][j] = yield i, j }
+      end
+    end
+
+    def walk_matrix(matrix)
+      0.upto(@rows-1) do |i|
+        0.upto(@cols-1) do |j|
+          yield i, j
+        end
+      end
+    end
+  end
+end

data/lib/rpiet/machine.rb

@@ -0,0 +1,111 @@
+require 'rpiet/direction_pointer'
+require 'rpiet/codel_chooser'
+
+module RPiet
+  ## 
+  # This is a simple piet runtime to be controled by interp.
+  #
+  # dp - Direction Pointer (right, down, left, up)
+  # cc - Codel Chooser (left, right)
+  class Machine
+    attr_reader :dp, :cc, :stack
+    attr_accessor :block_value
+
+    def initialize
+      @stack, @dp, @cc = [], DirectionPointer.new, CodelChooser.new
+      @block_value = 1
+    end
+
+    ##
+    # Return the next possible location based on direction pointers facing
+    def next_possible(x, y)
+      @dp.next_possible(x, y)
+    end
+
+    ##
+    # Change either codel chooser or direction pointer to try and look
+    # at a different codel.
+    def orient_elsewhere(i)
+      if i.even?
+        dp.rotate!
+      else
+        cc.switch!
+      end
+    end
+     
+    def noop; end
+    def push;  @stack << @block_value; end
+    def pop; @stack.pop; end
+
+    def add; math_op :+; end
+    def sub; math_op :-; end
+    def mult; math_op :*; end
+    def div; math_op :/; end
+    def mod; math_op :%; end
+
+    def gtr; bin_op { |a, b| @stack << (a > b ? 1 : 0) }; end
+    def not; unary_op { |top| @stack << (!top || top == 0 ? 1 : 0) }; end
+    def dup; @stack << @stack[-1]; end
+    def nout; unary_op { |top| print top }; end
+    def cout; unary_op { |top| print top.chr }; end
+    def pntr; unary_op { |top| @dp.rotate! top }; end
+    def swch; unary_op { |top| @cc.switch! top }; end
+    def n_in; puts "Enter an integer: "; @stack << $stdin.gets.to_i; end
+    def c_in; $stdout.write "> "; c = $stdin.read(1).ord; @stack << c; end
+    def roll
+      bin_op do |depth, num| 
+        num %= depth
+        return if depth <= 0 || num == 0
+        if num > 0
+          @stack[-depth..-1] = @stack[-num..-1] + @stack[-depth...-num]
+        elsif num < 0
+          @stack[-depth..-1] = @stack[-depth...-num] + @stack[-num..-1]
+        end
+      end
+    end
+
+    def inspect
+      "dp: #{@dp.ascii}, cc: #{@cc.ascii(@dp)}, bv: #{@block_value}, st: #{@stack}"
+    end
+    alias :to_s :inspect
+
+    ##
+    # Execute the operation represented by the two colors
+    def execute(color1, color2)
+      dh = color1.hue.delta color2.hue
+      dd = color1.lightness.delta color2.lightness
+      operation = OPERATION[dh][dd]
+      __send__(operation)
+    end
+
+    private
+    def bin_op(&block)
+      return unless @stack.length >= 2
+      block.call *@stack.pop(2)
+    end
+    
+    def unary_op(&block)
+      return unless @stack.length >= 1
+      block.call(@stack.pop)
+    end
+
+    def math_op(op); bin_op { |a, b| @stack << a.send(op, b) }; end
+
+    ##
+    #                     Lightness change
+    #Hue change     None         1 Darker     2 Darker
+    #  None                      push         pop
+    # 1 Step        add          subtract     multiply
+    # 2 Steps       divide       mod          not
+    # 3 Steps       greater      pointer      switch
+    # 4 Steps       duplicate    roll         in(number)
+    # 5 Steps       in(char)     out(number)  out(char)
+    #
+    OPERATION = [[:noop, :push, :pop],
+                 [:add,  :sub, :mult],
+                 [:div,  :mod, :not],
+                 [:gtr,  :pntr, :swch],
+                 [:dup,  :roll, :n_in],
+                 [:c_in, :nout, :cout]]
+  end
+end

data/lib/rpiet/version.rb

@@ -0,0 +1,3 @@
+module RPiet
+  VERSION = '0.1'
+end

data/spec/cycle_spec.rb

@@ -0,0 +1,56 @@
+require 'rpiet/cycle'
+
+module A
+  extend RPiet::CycleMethod
+  cycle :Letter, :A, :B, :C
+end
+
+describe "RPiet::Cycle" do
+  it "can do cycle addition" do
+    (A::Letter::A + A::Letter::A).should == A::Letter::A
+    (A::Letter::A + A::Letter::B).should == A::Letter::B
+    (A::Letter::A + A::Letter::C).should == A::Letter::C
+    (A::Letter::B + A::Letter::A).should == A::Letter::B
+    (A::Letter::B + A::Letter::B).should == A::Letter::C
+    (A::Letter::B + A::Letter::C).should == A::Letter::A
+    (A::Letter::C + A::Letter::A).should == A::Letter::C
+    (A::Letter::C + A::Letter::B).should == A::Letter::A
+    (A::Letter::C + A::Letter::C).should == A::Letter::B
+  end
+
+  it "can do cycle subtraction" do
+    (A::Letter::A - A::Letter::A).should == A::Letter::A
+    (A::Letter::A - A::Letter::B).should == A::Letter::C
+    (A::Letter::A - A::Letter::C).should == A::Letter::B
+    (A::Letter::B - A::Letter::A).should == A::Letter::B
+    (A::Letter::B - A::Letter::B).should == A::Letter::A
+    (A::Letter::B - A::Letter::C).should == A::Letter::C
+    (A::Letter::C - A::Letter::A).should == A::Letter::C
+    (A::Letter::C - A::Letter::B).should == A::Letter::B
+    (A::Letter::C - A::Letter::C).should == A::Letter::A
+  end
+
+  it "can increment" do
+    A::Letter::A.incr.should == A::Letter::B
+    A::Letter::B.incr.should == A::Letter::C
+    A::Letter::C.incr.should == A::Letter::A
+  end
+
+  it "can decrement" do
+    A::Letter::A.decr.should == A::Letter::C
+    A::Letter::B.decr.should == A::Letter::A
+    A::Letter::C.decr.should == A::Letter::B
+  end
+
+  it "can calculate deltas" do
+    A::Letter::A.delta(A::Letter::A).should == 0
+    A::Letter::A.delta(A::Letter::B).should == 2
+    A::Letter::A.delta(A::Letter::C).should == 1
+    A::Letter::B.delta(A::Letter::A).should == 1
+    A::Letter::B.delta(A::Letter::B).should == 0
+    A::Letter::B.delta(A::Letter::C).should == 2
+    A::Letter::C.delta(A::Letter::A).should == 2
+    A::Letter::C.delta(A::Letter::B).should == 1
+    A::Letter::C.delta(A::Letter::C).should == 0
+  end
+end

data/spec/direction_pointer_spec.rb

@@ -0,0 +1,17 @@
+require 'rpiet/direction_pointer'
+
+describe "DirectionPointer" do
+  it "can rotate" do
+    dp = RPiet::DirectionPointer.new
+
+    dp.direction.should == RPiet::Direction::RIGHT
+    dp.rotate!
+    dp.direction.should == RPiet::Direction::DOWN
+    dp.rotate!
+    dp.direction.should == RPiet::Direction::LEFT
+    dp.rotate!
+    dp.direction.should == RPiet::Direction::UP
+    dp.rotate!(2)
+    dp.direction.should == RPiet::Direction::DOWN
+  end
+end

data/spec/group_spec.rb

@@ -0,0 +1,57 @@
+require 'rpiet/group'
+require 'rpiet/machine'
+
+describe "Group" do
+  before do
+    @group = RPiet::Group.new('0x0000c0', [0, 3])
+    [[0, 4], [0, 5], [0, 6], [0, 7], [1, 3], [1, 4], [1, 5], 
+     [1, 6], [2, 3], [2, 4], [2, 5], [2, 6], [3, 3], [3, 4], [3, 5], [3, 6], 
+     [4, 3], [4, 4], [4, 5], [4, 6], [5, 4], [6, 4], [6, 5], [6, 6], [7, 4], 
+     [7, 5], [7, 6], [8, 5], [8, 6]].each do |point|
+      @group << point
+    end
+    @group.finish
+
+    @group2 = RPiet::Group.new('0xff0000', [7, 0])
+    
+    [[7, 1], [6, 1], [6, 2], [5, 2], [6, 3], [7, 2], 
+     [7, 3], [8, 0], [8, 1]].each do |point|
+      @group2 << point
+    end
+    @group2.finish
+
+    @pvm = RPiet::Machine.new
+  end
+
+  it "knows its size" do
+    @group.size.should == 30
+  end
+
+  it "can pick the right points" do
+    @group.point_for(@pvm).should == [8, 5] # dp: RIGHT cc: LEFT  -> UR
+    @pvm.cc.switch! # LEFT -> RIGHT
+    @group.point_for(@pvm).should == [8, 6] # dp: RIGHT cc: RIGHT  -> LR
+    @pvm.dp.rotate! # dp: RIGHT -> DOWN
+    @pvm.cc.switch! # cc: RIGHT -> LEFT
+    @group.point_for(@pvm).should == [0, 7] # dp: DOWN cc: LEFT -> LR
+    @pvm.cc.switch! # cc: LEFT -> RIGHT
+    @group.point_for(@pvm).should == [0, 7] # dp: DOWN cc: RIGHT -> LL
+    @pvm.dp.rotate! # dp: DOWN -> LEFT
+    @pvm.cc.switch! # cc: RIGHT -> LEFT
+    @group.point_for(@pvm).should == [0, 7] # dp: LEFT cc: LEFT -> LL
+    @pvm.cc.switch! # cc: LEFT -> RIGHT
+    @group.point_for(@pvm).should == [0, 3] # dp: LEFT cc: RIGHT -> UL
+    @pvm.dp.rotate! # dp: LEFT -> UP
+    @pvm.cc.switch! 
+    @group.point_for(@pvm).should == [0, 3] # dp: UP cc: LEFT -> UL
+    @pvm.cc.switch! # cc: LEFT -> RIGHT
+    @group.point_for(@pvm).should == [4, 3] # dp: UP cc: RIGHT -> UR
+
+    # Since last group only has single wide bottom let's try another
+    @pvm.cc.switch! # cc: RIGHT -> LEFT
+    @pvm.dp.rotate! 2 # dp: UP -> DOWN
+    @group2.point_for(@pvm).should == [7, 3] # dp: DOWN cc: LEFT -> LR
+    @pvm.cc.switch! # cc: RIGHT -> LEFT
+    @group2.point_for(@pvm).should == [6, 3] # dp: DOWN cc: RIGHT -> LL
+  end
+end

data/spec/interpreter_spec.rb

@@ -0,0 +1,14 @@
+require 'rpiet/interpreter'
+require 'rpiet/image/ascii_image'
+
+describe "RPiet::Interpreter" do
+  it "Can push" do
+    source = RPiet::Image::AsciiImage.new "nb db ++\nnb ++ ++\n++ ++ ++\n"
+    interpreter = RPiet::Interpreter.new(source)
+
+    interpreter.next_step
+    interpreter.pvm.stack.should == [2]
+    interpreter.next_step
+    interpreter.pvm.stack.should == []
+  end
+end

data/spec/machine_spec.rb

@@ -0,0 +1,23 @@
+require 'rpiet/machine'
+
+describe "RPiet::Machine" do
+  it "can roll" do
+    machine = RPiet::Machine.new
+
+    [115, 100, 101, 2, 1].each do |value|
+      machine.block_value = value
+      machine.push
+    end
+
+    machine.roll
+    machine.stack.should == [115, 101, 100]
+
+    [3, 1].each do |value|
+      machine.block_value = value
+      machine.push
+    end
+
+    machine.roll
+    machine.stack.should == [100, 115, 101]
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: rpiet
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: '0.1'
+platform: ruby
+authors:
+- Thomas E. Enebo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-10-24 00:00:00.000000000 Z
+dependencies: []
+description: An implementation of the esoteric programming language Piet
+email: tom.enebo@gmail.com
+executables:
+- rpiet
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- bin/rpiet
+- images/.DS_Store
+- images/cowsay.gif
+- images/helloworld-piet.gif
+- images/helloworld-pietbig.gif
+- images/hi.gif
+- images/loop2to0.gif
+- images/nfib.png
+- lib/rpiet.rb
+- lib/rpiet/codel_chooser.rb
+- lib/rpiet/color.rb
+- lib/rpiet/cycle.rb
+- lib/rpiet/direction_pointer.rb
+- lib/rpiet/event_handler.rb
+- lib/rpiet/group.rb
+- lib/rpiet/image/ascii_image.rb
+- lib/rpiet/image/image.rb
+- lib/rpiet/image/url_image.rb
+- lib/rpiet/interpreter.rb
+- lib/rpiet/machine.rb
+- lib/rpiet/version.rb
+- spec/cycle_spec.rb
+- spec/direction_pointer_spec.rb
+- spec/group_spec.rb
+- spec/interpreter_spec.rb
+- spec/machine_spec.rb
+homepage: http://github.com/enebo/rpiet
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: A Piet runtime
+test_files:
+- spec/cycle_spec.rb
+- spec/direction_pointer_spec.rb
+- spec/group_spec.rb
+- spec/interpreter_spec.rb
+- spec/machine_spec.rb