turing_tarpit 1.0.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+## 1.0.0
+
+Initial Release

data/README.md

@@ -0,0 +1,40 @@
+# Turing Tarpit, A Brainfuck Interpreter
+
+This was built as a demo application for Practicing Ruby Issue 3.3. You can
+subscribe to the journal at: http://practicingruby.com
+
+## Using Turing Tarpit
+
+You need Ruby 1.9.3 to make this project work. It might be possible to get the
+code running using 1.9.2 + the io-console gem, but that's completely untested
+currently.
+
+Turing Tarpit can be installed as a gem via rubygems.org, but if you're thinking
+about hacking on it, the easiest way to try it out is to run the "Hello World"
+program included in this repository:
+
+    $ ruby bin/turing_tarpit test/fixtures/hello.bf
+
+There is also a Rot13 example (test/fixtures/rot13.bf), but be warned: You 
+need to know how to enter null characters to be able to cleanly exit it. 
+In OS X terminal, this can be done by pressing Ctrl+Shift+2.
+
+Both examples are based on the code in the 
+[Brainfuck Wikipedia article](http://en.wikipedia.org/wiki/Brainfuck).
+
+## Running the tests
+
+Before sending pull requests, please make sure all tests pass.
+
+    $ bundle
+    $ ruby test/suite.rb
+
+## License
+
+Copyright (c) 2011 Gregory Brown 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE

data/bin/turing_tarpit

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/turing_tarpit"
+
+interpreter = TuringTarpit::Interpreter.new(ARGF.read)
+
+TuringTarpit::Evaluator.run(interpreter)

data/lib/turing_tarpit.rb

@@ -0,0 +1,10 @@
+require "io/console"
+
+require_relative 'turing_tarpit/version'
+require_relative 'turing_tarpit/interpreter'
+require_relative 'turing_tarpit/evaluator'
+
+module TuringTarpit
+  PointerBoundaryError = Class.new(StandardError)
+  InvalidValue         = Class.new(StandardError)
+end

data/lib/turing_tarpit/evaluator.rb

@@ -0,0 +1,70 @@
+module TuringTarpit
+  class Evaluator 
+    CELL_SIZE = 256
+
+    def self.run(interpreter)
+      evaluator = new
+
+      loop do
+        if operation = interpreter.next_operation(evaluator.cell_value)
+          evaluator.send(operation)
+        end
+      end
+    end
+
+    def initialize
+      self.pointer_position = 0
+      self.cells            = []
+    end
+
+    attr_reader :pointer_position
+
+    def cell_value
+      cells[pointer_position] ||= 0
+    end
+
+    def cell_value=(value)
+      raise InvalidValue unless valid_cell_value?(value)
+
+      cells[pointer_position] = value
+    end
+
+    def increment_cell_value
+      self.cell_value = (cell_value + 1) % CELL_SIZE
+    end
+
+    def decrement_cell_value
+      self.cell_value = (cell_value - 1) % CELL_SIZE
+    end
+
+    def increment_pointer
+      self.pointer_position = pointer_position + 1
+    end
+
+    def decrement_pointer
+      raise PointerBoundaryError unless pointer_position > 0
+
+      self.pointer_position = pointer_position - 1
+    end
+
+    def output_cell_value
+      putc(cell_value)
+    end
+
+    def input_cell_value
+      value = $stdin.getch.ord
+      return if value.zero?
+
+      self.cell_value = value
+    end
+
+    private
+
+    attr_accessor :cells, :parser
+    attr_writer   :pointer_position
+
+    def valid_cell_value?(value)
+      value.kind_of?(Integer) && value.between?(0,CELL_SIZE-1)
+    end
+  end
+end

data/lib/turing_tarpit/interpreter.rb

@@ -0,0 +1,79 @@
+module TuringTarpit
+  class Interpreter
+    FORWARD_JUMP  = "["
+    BACKWARD_JUMP = "]"
+
+    OPERATIONS = { "+" => :increment_cell_value,
+                   "-" => :decrement_cell_value,
+                   ">" => :increment_pointer,
+                   "<" => :decrement_pointer,
+                   "." => :output_cell_value,
+                   "," => :input_cell_value }
+
+    def initialize(chars)
+      self.chars = chars
+      self.index = -1
+    end
+
+    def next_operation(cell_value)
+      case next_char
+      when FORWARD_JUMP
+        if cell_value.zero?
+          jump_forward 
+        else
+          skip_while(FORWARD_JUMP) 
+        end
+      when BACKWARD_JUMP
+        if cell_value.zero?
+          skip_while(BACKWARD_JUMP) 
+        else
+          jump_back
+        end
+      end
+
+      OPERATIONS[current_char]
+    end
+
+    private
+
+    def current_char
+      chars[index]
+    end
+
+    def next_char
+      raise StopIteration if chars.length == index + 1
+
+      self.index = index + 1
+      current_char
+    end
+
+    def skip_while(char)
+      next_char until current_char != char
+    end
+
+    def jump_forward
+      jump(FORWARD_JUMP, BACKWARD_JUMP, 1)
+      next_char
+    end
+
+    def jump_back
+      jump(BACKWARD_JUMP, FORWARD_JUMP, -1)
+      next_char
+    end
+
+    def jump(from, to, step)
+      counter = 1
+      until counter == 0
+        self.index = index + step
+        case chars[index]
+        when from
+          counter += 1
+        when to
+          counter -= 1
+        end
+      end
+    end
+    
+    attr_accessor :chars, :index
+  end
+end

data/lib/turing_tarpit/version.rb

@@ -0,0 +1,3 @@
+module TuringTarpit
+  VERSION = "1.0.0"
+end

data/test/fixtures/hello.bf

@@ -0,0 +1,21 @@
++++++ +++++             initialize counter (cell #0) to 10
+[                       use loop to set the next four cells to 70/100/30/10
+    > +++++ ++              add  7 to cell #1
+    > +++++ +++++           add 10 to cell #2 
+    > +++                   add  3 to cell #3
+    > +                     add  1 to cell #4
+    <<<< -                  decrement counter (cell #0)
+]                   
+> ++ .                  print 'H'
+> + .                   print 'e'
++++++ ++ .              print 'l'
+.                       print 'l'
++++ .                   print 'o'
+> ++ .                  print ' '
+<< +++++ +++++ +++++ .  print 'W'
+> .                     print 'o'
++++ .                   print 'r'
+----- - .               print 'l'
+----- --- .             print 'd'
+> + .                   print '!'
+> .                     print '\n'

data/test/fixtures/rot13.bf

@@ -0,0 +1,28 @@
+-,+[                         Read first character and start outer character reading loop
+    -[                       Skip forward if character is 0
+        >>++++[>++++++++<-]  Set up divisor (32) for division loop
+                               (MEMORY LAYOUT: dividend copy remainder divisor quotient zero zero)
+        <+<-[                Set up dividend (x minus 1) and enter division loop
+            >+>+>-[>>>]      Increase copy and remainder / reduce divisor / Normal case: skip forward
+            <[[>+<-]>>+>]    Special case: move remainder back to divisor and increase quotient
+            <<<<<-           Decrement dividend
+        ]                    End division loop
+    ]>>>[-]+                 End skip loop; zero former divisor and reuse space for a flag
+    >--[-[<->+++[-]]]<[      Zero that flag unless quotient was 2 or 3; zero quotient; check flag
+        ++++++++++++<[       If flag then set up divisor (13) for second division loop
+                               (MEMORY LAYOUT: zero copy dividend divisor remainder quotient zero zero)
+            >-[>+>>]         Reduce divisor; Normal case: increase remainder
+            >[+[<+>-]>+>>]   Special case: increase remainder / move it back to divisor / increase quotient
+            <<<<<-           Decrease dividend
+        ]                    End division loop
+        >>[<+>-]             Add remainder back to divisor to get a useful 13
+        >[                   Skip forward if quotient was 0
+            -[               Decrement quotient and skip forward if quotient was 1
+                -<<[-]>>     Zero quotient and divisor if quotient was 2
+            ]<<[<<->>-]>>    Zero divisor and subtract 13 from copy if quotient was 1
+        ]<<[<<+>>-]          Zero divisor and add 13 to copy if quotient was 0
+    ]                        End outer skip loop (jump to here if ((character minus 1)/32) was not 2 or 3)
+    <[-]                     Clear remainder from first division if second division was skipped
+    <.[-]                    Output ROT13ed character from copy and clear it
+    <-,+                     Read next character
+]                            End character reading loop

data/test/helper.rb

@@ -0,0 +1,8 @@
+require "minitest/autorun"
+require_relative "../lib/turing_tarpit"
+
+module MiniTest
+  class Spec
+    alias insist lambda
+  end
+end

data/test/integration/evaluator_test.rb

@@ -0,0 +1,36 @@
+require "stringio"
+require_relative "../helper"
+
+describe "Evaluator" do
+  before do
+    $stdin = StringIO.new
+
+    def $stdin.getch
+      getc
+    end
+  end
+
+  it "must successfully run hello_world.bf" do
+    insist { bf_eval("hello.bf") }.must_output("Hello World!\n")
+  end
+
+  it "must successfully run rot13.bf" do
+    provide_input("Uryyb Jbeyq!\n\0")
+    insist { bf_eval("rot13.bf") }.must_output("Hello World!\n")
+  end
+
+  after do
+    $stdin = STDIN
+  end
+
+  def provide_input(text)
+    $stdin << text
+    $stdin.rewind
+  end
+
+  def bf_eval(filename)
+    src_file    = "#{File.dirname(__FILE__)}/../fixtures/#{filename}"
+    interpreter = TuringTarpit::Interpreter.new(File.read(src_file))
+    TuringTarpit::Evaluator.run(interpreter)
+  end
+end

data/test/suite.rb

@@ -0,0 +1,6 @@
+require 'simplecov'
+SimpleCov.start
+
+require_relative "units/interpreter_test"
+require_relative "units/evaluator_test"
+require_relative "integration/evaluator_test"

data/test/units/evaluator_test.rb

@@ -0,0 +1,112 @@
+require_relative "../helper"
+
+describe "Evaluator" do
+  it "must have an initial cell value of 0" do
+    evaluator = TuringTarpit::Evaluator.new
+    evaluator.cell_value.must_equal(0)
+  end
+
+  it "must be able to set the cell value at the current position" do
+    evaluator = TuringTarpit::Evaluator.new
+
+    evaluator.cell_value = 20
+
+    evaluator.cell_value.must_equal(20)
+  end
+
+  it "must restrict cell values to integers between 0 and 255" do
+    evaluator = TuringTarpit::Evaluator.new
+
+    insist { evaluator.cell_value = 1.5 }.
+      must_raise(TuringTarpit::InvalidValue)
+
+    insist { evaluator.cell_value = -1 }.
+      must_raise(TuringTarpit::InvalidValue)
+
+    insist { evaluator.cell_value = 256 }.must_raise(TuringTarpit::InvalidValue) 
+  end
+
+  it "must be able to increment the cell value at the current position" do
+    evaluator = TuringTarpit::Evaluator.new
+
+
+    evaluator.increment_cell_value
+    evaluator.cell_value.must_equal(1)
+
+    evaluator.increment_cell_value
+    evaluator.cell_value.must_equal(2)
+  end
+
+  it "must be able to decrement the cell value at the current position" do
+    evaluator = TuringTarpit::Evaluator.new
+
+    5.times { evaluator.increment_cell_value }
+    2.times { evaluator.decrement_cell_value }
+
+    evaluator.cell_value.must_equal(3)
+
+    evaluator.decrement_cell_value
+
+    evaluator.cell_value.must_equal(2)
+  end
+
+  it "must have an initial pointer position of 0" do
+    evaluator = TuringTarpit::Evaluator.new
+    evaluator.pointer_position.must_equal(0)
+  end
+
+  it "must be able to increment the pointer position" do
+    evaluator = TuringTarpit::Evaluator.new
+
+    evaluator.increment_pointer
+
+    evaluator.pointer_position.must_equal(1)
+
+    evaluator.increment_pointer
+    evaluator.pointer_position.must_equal(2)
+  end
+
+  it "must be able to decrement the pointer position" do
+    evaluator = TuringTarpit::Evaluator.new
+    3.times { evaluator.increment_pointer }
+    evaluator.decrement_pointer
+
+    evaluator.pointer_position.must_equal(2)
+
+    evaluator.decrement_pointer
+    evaluator.pointer_position.must_equal(1)
+  end
+
+  it "must raise an error if decrementing when pointer position is 0" do
+    evaluator = TuringTarpit::Evaluator.new
+
+    insist { evaluator.decrement_pointer }
+      .must_raise(TuringTarpit::PointerBoundaryError)
+  end
+
+  it "must treat cell values independently" do
+    evaluator = TuringTarpit::Evaluator.new
+    evaluator.increment_cell_value
+
+    evaluator.cell_value.must_equal(1)
+
+    evaluator.increment_pointer
+    evaluator.cell_value.must_equal(0)
+
+    4.times { evaluator.increment_cell_value }
+    evaluator.cell_value.must_equal(4)
+
+    evaluator.decrement_pointer
+    evaluator.cell_value.must_equal(1)
+  end
+
+  it "must overflow the cell value gracefully" do
+    evaluator = TuringTarpit::Evaluator.new
+
+    evaluator.decrement_cell_value
+    evaluator.cell_value.must_equal(255)
+
+    evaluator.increment_cell_value
+    evaluator.cell_value.must_equal(0)
+  end
+end

data/test/units/interpreter_test.rb

@@ -0,0 +1,75 @@
+require_relative "../helper"
+
+describe "Interpreter" do
+  it "must be able to process a program with no jumps" do
+    interpreter = TuringTarpit::Interpreter.new("+-<>.,")
+
+    operations = [:increment_cell_value, 
+                  :decrement_cell_value,
+                  :decrement_pointer,
+                  :increment_pointer,
+                  :output_cell_value,
+                  :input_cell_value]
+      
+    operations.each do |sym|
+      interpreter.next_operation(0).must_equal(sym)
+    end
+
+    insist { interpreter.next_operation(0) }.must_raise(StopIteration)
+  end
+
+  it "must be able to process a program with a forward jump" do
+    interpreter = TuringTarpit::Interpreter.new("[++++]-")
+    interpreter.next_operation(0).must_equal(:decrement_cell_value)
+    insist { interpreter.next_operation(0) }.must_raise(StopIteration)
+  end
+
+  it "must be able to process a program with a forward jump" do
+    interpreter = TuringTarpit::Interpreter.new("[++++]-")
+    interpreter.next_operation(0).must_equal(:decrement_cell_value)
+    insist { interpreter.next_operation(0) }.must_raise(StopIteration)
+  end
+
+  it "must be able to process a program with a finite loop" do
+    interpreter = TuringTarpit::Interpreter.new("++[-]")
+    interpreter.next_operation(0).must_equal(:increment_cell_value)
+    interpreter.next_operation(1).must_equal(:increment_cell_value)
+    interpreter.next_operation(2).must_equal(:decrement_cell_value)
+    interpreter.next_operation(1).must_equal(:decrement_cell_value)
+
+    insist { interpreter.next_operation(0) }.must_raise(StopIteration)
+  end
+
+  it "must be able to process a program with an infinite (non-empty) loop" do
+    interpreter = TuringTarpit::Interpreter.new("+[+]")
+
+    interpreter.next_operation(0).must_equal(:increment_cell_value)
+    (1..5).each do |i| 
+      interpreter.next_operation(i).must_equal(:increment_cell_value)
+    end
+  end
+
+  it "must be able to process a nested jump" do
+    interpreter = TuringTarpit::Interpreter.new("[++++++[----]++].")
+
+    interpreter.next_operation(0).must_equal(:output_cell_value)
+    insist { interpreter.next_operation(0) }.must_raise(StopIteration)
+  end
+
+  it "must be able to process a nested loop" do
+    interpreter = TuringTarpit::Interpreter.new("++++[-[.-],]")
+
+    4.times { |i| interpreter.next_operation(i) }
+    interpreter.next_operation(4).must_equal(:decrement_cell_value)
+    interpreter.next_operation(3).must_equal(:output_cell_value)
+    interpreter.next_operation(3).must_equal(:decrement_cell_value)
+    interpreter.next_operation(2).must_equal(:output_cell_value)
+    interpreter.next_operation(2).must_equal(:decrement_cell_value)
+    interpreter.next_operation(1).must_equal(:output_cell_value)
+    interpreter.next_operation(1).must_equal(:decrement_cell_value)
+    interpreter.next_operation(0).must_equal(:input_cell_value)
+
+    insist { interpreter.next_operation(0) }.must_raise(StopIteration)
+  end
+
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: turing_tarpit
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Gregory Brown
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &2168716700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2168716700
+description: A brainfuck interpreter
+email:
+- gregory.t.brown@gmail.com
+executables:
+- turing_tarpit
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/turing_tarpit
+- lib/turing_tarpit/evaluator.rb
+- lib/turing_tarpit/interpreter.rb
+- lib/turing_tarpit/version.rb
+- lib/turing_tarpit.rb
+- test/fixtures/hello.bf
+- test/fixtures/rot13.bf
+- test/helper.rb
+- test/integration/evaluator_test.rb
+- test/suite.rb
+- test/units/evaluator_test.rb
+- test/units/interpreter_test.rb
+- README.md
+- CHANGELOG
+homepage: http://github.com/elm-city-craftworks/turing_tarpit
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: turing_tarpit
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A brainfuck interpreter
+test_files: []