brainfuck 0.0.1 → 0.1.0

data/.gitignore

@@ -1,3 +1,4 @@
 pkg/*
 *.gem
 .bundle
+coverage

data/Gemfile.lock

@@ -1,14 +1,18 @@
 PATH
   remote: .
   specs:
-    brainfuck (0.0.1)
+    brainfuck (0.1.0)
       highline
+      parslet
 
 GEM
   remote: http://rubygems.org/
   specs:
+    blankslate (2.1.2.3)
     diff-lcs (1.1.2)
     highline (1.6.1)
+    parslet (1.0.0)
+      blankslate (~> 2.1.2.3)
     rspec (2.2.0)
       rspec-core (~> 2.2)
       rspec-expectations (~> 2.2)
@@ -29,5 +33,6 @@ DEPENDENCIES
   brainfuck!
   bundler
   highline
+  parslet
   rspec
   simplecov

data/Readme.md

@@ -2,22 +2,20 @@
 
 Just another Brainfuck interpreter in Ruby!
 (If you don't know what Brainfuck is, you definitely
-[should][http://en.wikipedia.org/wiki/Brainfuck]).
+[should](http://en.wikipedia.org/wiki/Brainfuck)).
 
 This interpreter works with MRI 1.8.7, 1.9.2 and JRuby 1.5.5.
 
-## Known caveats (yes, before anything)
+## UPDATE: Known caveats solved since 0.1.0!
 
-Ok, I admit it. Nested loops don't work in an extremely reliable manner, so to
-speak. I suggest you NOT TO USE THIS IN PRODUCTION APPS. Yes, forget about
-using this interpreter for that high-security online payment system you wrote in Brainfuck.
-
-Oh and why are nested loops tricky with this interpreter? I was tired and Civilization 5
-was installed in my laptop and... You know, forks and pull requests are always welcome! :)
+Thanks to a complete rewrite using Kaspar Schiess' `parslet` (which you should
+definitely [check it out](http://github.com/kschiess/parslet)) nested loops
+work flawlessly. So yes, you can now run that high-security online payment
+system you wrote in Brainfuck :)
 
 ## Installation and usage
 
-You just `gem install brainfuck`!
+You just `gem install brainfuck` (or `gem 'brainfuck'` in your Gemfile)!
 
 And then: `brainfuck my_file.bf`
 
@@ -25,14 +23,9 @@ You can also require the gem and use inline brainfuck in your ruby scripts like
 
     require 'brainfuck'
 
-    interpreter = Brainfuck.new
-    interpreter.compile "+++>+++<---"
-
-    interpreter.cells
+    Brainfuck.run "+++>+++<---"
     # => [0, 3]
 
-It's very basic, and needs *a lot* of refactoring, but for now... there you go! ;)
-
 ## Note on Patches/Pull Requests
  
 * Fork the project.
@@ -46,4 +39,4 @@ It's very basic, and needs *a lot* of refactoring, but for now... there you go!
 
 ## Copyright
 
-Copyright (c) 2010 Josep M. Bach. See LICENSE for details.
+Copyright (c) 2011 Josep M. Bach. See LICENSE for details.

data/bin/brainfuck

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
 require 'brainfuck'
-Brainfuck::Interpreter.new.compile File.read(ARGV.first)
+Brainfuck.run File.read(ARGV.first)

data/brainfuck.gemspec

@@ -15,6 +15,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "brainfuck"
 
   s.add_runtime_dependency "highline"
+  s.add_runtime_dependency "parslet"
   s.add_development_dependency "rspec"
   s.add_development_dependency "bundler"
   s.add_development_dependency "simplecov"

data/lib/brainfuck.rb

@@ -1,102 +1,22 @@
+require 'parslet'
 require 'highline/system_extensions'
 
-module Brainfuck
-  class Interpreter
-    include HighLine::SystemExtensions
-
-    INSTRUCTIONS = %w{> < + - [ ] . ,}
-
-    attr_accessor :cells
-    attr_reader :pointer
-    attr_reader :code
-
-    def initialize
-      @cells = [0]
-      @pointer = 0
-      @code = nil
-    end
-
-    def current
-      @cells[pointer] ||= 0
-    end
-    def current=(value)
-      @cells[pointer] = (value % 255) rescue 0
-    end
+require 'brainfuck/stack'
+require 'brainfuck/ast'
 
-    def forward
-      @pointer += 1
-      initialize_cell_if_nil
-    end
-    def backward
-      @pointer -= 1
-      ensure_pointer_is_above_zero
-      initialize_cell_if_nil
-    end
-    def increase
-      @cells[pointer] = (@cells[pointer] + 1) % 255
-    end
-    def decrease
-      @cells[pointer] = (@cells[pointer] - 1) % 255
-    end
-
-    def compile(code)
-      @code = clean(code)
-      run
-    end
+require 'brainfuck/parser'
+require 'brainfuck/interpreter'
 
-    def run(from = nil, to = nil)
-      index = 0
-      context = 0
-
-      c = code.dup
-
-      if from && to
-        context = from 
-        c = c.slice(from...to)
-      end
-
-      c.each_char do |char|
-        index += 1
-        case char
-          when '>'
-            forward 
-          when '<'
-            backward 
-          when '+'
-            increase
-          when '-'
-            decrease
-          when '.'
-            stdout.print current.chr
-          when ','
-            self.current = get_character
-          when '['
-            @start = index
-          when ']'
-            @end = index unless @end && @start < @end
-            run(@start, @end) unless current == 0
-            @start = context || nil
-        end
-      end
-    end
-
-    private
-
-    def clean(code)
-      code.chars.select {|c| INSTRUCTIONS.include? c }.join
-    end
-
-    def stdout
-      $stdout
-    end
-
-    def initialize_cell_if_nil
-      @cells[pointer] ||= 0
-    end
+module Brainfuck
+  class << self
+    def run code
+      Interpreter.stack.clear
 
-    def ensure_pointer_is_above_zero
-      raise "Tried to access cell #{@pointer}." if @pointer < 0
+      code = Parser.clean code
+      parsed = Parser.new.parse code
+      ast = Interpreter.new.apply parsed
+      ast.each(&:eval)
+      Interpreter.stack.to_a
     end
-
   end
 end

data/lib/brainfuck/ast.rb

@@ -0,0 +1,32 @@
+module Brainfuck
+  module AST
+    class FwdNode < Struct.new(:stack)
+      def eval; stack.fwd ; end
+    end
+    class BwdNode < Struct.new(:stack)
+      def eval; stack.bwd ; end
+    end
+
+    class IncNode < Struct.new(:stack)
+      def eval; stack.inc ; end
+    end
+    class DecNode < Struct.new(:stack)
+      def eval; stack.dec ; end
+    end
+    class PutsNode < Struct.new(:stack)
+      def eval; stack.puts ; end
+    end
+    class GetsNode < Struct.new(:stack)
+      def eval; stack.gets ; end
+    end
+    class IterationNode < Struct.new(:stack, :exp)
+      def eval
+        until stack.current == 0
+          exp.each do |node|
+            node.eval
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainfuck/interpreter.rb

@@ -0,0 +1,20 @@
+module Brainfuck
+  class Interpreter < Parslet::Transform
+    def self.stack
+      @@stack ||= Stack.new
+    end
+    
+    rule(:fwd => simple(:fwd))            { AST::FwdNode.new(Interpreter.stack) }
+    rule(:bwd => simple(:bwd))            { AST::BwdNode.new(Interpreter.stack) }
+
+    rule(:inc => simple(:inc))            { AST::IncNode.new(Interpreter.stack) }
+    rule(:dec => simple(:dec))            { AST::DecNode.new(Interpreter.stack) }
+
+    rule(:puts => simple(:puts))          { AST::PutsNode.new(Interpreter.stack) }
+    rule(:gets => simple(:gets))          { AST::GetsNode.new(Interpreter.stack) }
+
+    rule(:iteration => subtree(:iteration)) { AST::IterationNode.new(Interpreter.stack, iteration) }
+
+    rule(:exp => subtree(:exp)) { exp }
+  end
+end

data/lib/brainfuck/parser.rb

@@ -0,0 +1,31 @@
+module Brainfuck
+  class Parser < Parslet::Parser
+    INSTRUCTIONS = %w{> < + - [ ] . ,}
+
+    class << self
+      def clean code
+        code.chars.select {|c| INSTRUCTIONS.include? c }.join
+      end
+    end
+
+    rule(:lparen)     { str('[') >> space? }
+    rule(:rparen)     { str(']') >> space? }
+
+    rule(:space)      { match('\s').repeat(1) }
+    rule(:space?)     { space.maybe }
+
+    rule(:fwd)        { str('>') >> space? }
+    rule(:bwd)        { str('<') >> space? }
+
+    rule(:inc)        { str('+') >> space? }
+    rule(:dec)        { str('-') >> space? }
+
+    rule(:puts)       { str('.') >> space? }
+    rule(:gets)       { str(',') >> space? }
+
+    rule(:iteration)  { lparen >> expression >> rparen }
+
+    rule(:expression) { (iteration.as(:iteration) | fwd.as(:fwd) | bwd.as(:bwd) | inc.as(:inc) | dec.as(:dec) | puts.as(:puts) | gets.as(:gets)).repeat.as(:exp) }
+    root :expression
+  end
+end

data/lib/brainfuck/stack.rb

@@ -0,0 +1,51 @@
+module Brainfuck
+  class Stack
+    include HighLine::SystemExtensions
+
+    attr_reader :current
+    def initialize
+      @pointer = 0
+      @stack = [0]
+    end
+    def current
+      @stack[@pointer]
+    end
+    def fwd
+      @pointer += 1
+      initialize_cell_if_nil
+    end
+    def bwd
+      @pointer -= 1
+      ensure_pointer_is_above_zero
+      initialize_cell_if_nil
+    end
+    def inc
+      @stack[@pointer] = (current + 1) % 255
+    end
+    def dec
+      @stack[@pointer] = (current - 1) % 255
+    end
+    def puts
+      $stdout.print current.chr
+    end
+    def gets
+      @stack[@pointer] = (get_character % 255) rescue 0
+    end
+
+    def to_a
+      @stack
+    end
+
+    def clear
+      initialize
+    end
+
+    private
+    def initialize_cell_if_nil
+      @stack[@pointer] ||= 0
+    end
+    def ensure_pointer_is_above_zero
+      raise "Tried to access cell #{@pointer}." if @pointer < 0
+    end
+  end
+end

data/lib/brainfuck/version.rb

@@ -1,3 +1,3 @@
 module Brainfuck
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/{acceptance_spec.rb → acceptance/acceptance_spec.rb}

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 module Brainfuck
-  describe Interpreter, "acceptance specs" do
+  describe "Acceptance specs" do
+
+    subject { Brainfuck }
 
     describe "without loops nor user input" do
       let(:code) do
@@ -10,17 +12,11 @@ module Brainfuck
         EOS
       end
       it "sets two cells to 2 and 1" do
-        subject.should_receive(:code).and_return code
-        subject.compile(code)
-        subject.cells.should == [2,1]
+        subject.run(code).should == [2,1]
       end
       it "prints 2 and 1" do
-        output = double('output')
-        subject.should_receive(:stdout).twice.and_return(output)
-        output.should_receive(:print).with(1.chr).ordered
-        output.should_receive(:print).with(2.chr).ordered
-
-        subject.compile(code)
+        $stdout.should_receive(:print).twice
+        subject.run code
       end
     end
 
@@ -31,11 +27,12 @@ module Brainfuck
         EOS
       end
       it "sets the first cell to a + 4" do
-        input = double('input')
-        subject.should_receive(:get_character).once.and_return 97
+        stack = Stack.new
+        Interpreter.stub(:stack).and_return stack
 
-        subject.compile(code)
-        subject.current.should == 101
+        stack.should_receive(:get_character).once.and_return 97
+
+        subject.run(code).should == [101]
       end
     end
 
@@ -46,29 +43,30 @@ module Brainfuck
         EOS
       end
       it "runs the loop 4 times" do
-        subject.compile(code)
-        subject.current.should == 1
+        subject.run(code).should == [1]
       end
     end
     
     describe "cell hopping examples" do
 
       it "transfers the content from one cell to another" do
-        subject.cells = [10]
-        subject.compile("[>+<-]")
-        subject.cells.should == [0,10]
+        subject.run("++++++++++      [>+<-]").should == [0,10]
       end
 
       it "transfers the content from one cell to the third" do
-        subject.cells = [10]
-        subject.compile("[>+<-]>[>+<-]")
-        subject.cells.should == [0,0,10]
+        subject.run("++++++++++      [>+<-]>[>+<-]").should == [0,0,10]
       end
 
       it "transfers the content from one cell to the third and back to the second" do
-        subject.cells = [10]
-        subject.compile("[>+<-]>[>+<-]>[<+>-]")
-        subject.cells.should == [0,10,0]
+        subject.run("++++++++++      [>+<-]>[>+<-]>[<+>-]").should == [0,10,0]
+      end
+
+    end
+
+    describe "nested loop examples" do
+
+      it "work flawlessly" do
+        subject.run("[++++++++++[-]+-+-]").should == [0]
       end
 
     end
@@ -76,7 +74,7 @@ module Brainfuck
     describe "hello world" do
 
       it "displays hello world" do
-        subject.compile <<-EOS
+        subject.run <<-EOS
           +++++ +++++            
           [                      
               > +++++ ++         

data/spec/brainfuck/ast_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Brainfuck
+  describe AST do
+    let(:stack) { double('stack') }
+
+    %w{fwd bwd inc dec puts gets}.each do |node|
+      describe "AST::#{node.capitalize}Node" do
+        subject { eval("AST::#{node.capitalize}Node").new stack }
+        describe "#eval" do
+          it 'calls stack##{node}' do
+            subject.stack.should_receive(node)
+            subject.eval
+          end
+        end
+      end
+    end
+
+    describe AST::IterationNode do
+      let(:nodes) do
+        [ double('node'), double('node2') ]
+      end
+      subject { AST::IterationNode.new stack, nodes }
+      describe "#eval" do
+        it 'evaluates the expression until the stack cell is 0' do
+          subject.stack.stub(:current).and_return 3, 2, 1, 0
+          nodes.each do |node|
+            node.should_receive(:eval).exactly(3).times
+          end
+          subject.eval
+        end
+      end
+    end
+
+  end
+end

data/spec/brainfuck/interpreter_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Brainfuck
+  describe Interpreter do
+
+    describe ".stack" do
+      it 'returns a new or cached Stack' do
+        stack = Interpreter.stack
+        stack.should be_kind_of(Stack)
+        Interpreter.stack.should === stack
+      end
+    end
+
+    describe "rules" do
+      %w{fwd bwd inc dec puts gets iteration exp}.each do |rule|
+        it 'implements a rule for :#{rule} node' do
+          subject.rules.map(&:first).map do |pattern|
+            pattern.instance_variable_get(:@pattern)
+          end.map(&:keys).flatten.should include(:"#{rule}")
+        end
+      end
+    end
+    
+  end
+end

data/spec/brainfuck/parser_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Brainfuck
+  describe Parser do
+
+    describe "INSTRUCTIONS constant" do
+      it 'returns valid symbols' do
+        Parser::INSTRUCTIONS.should == %w{> < + - [ ] . ,}
+      end
+    end
+
+    describe ".clean" do
+      it 'cleans all non-valid symbols from a string' do
+        Parser.clean(">3< 223+fn - ()()[r23-] .bdn*& ,").should == '><+-[-].,'
+      end
+    end
+
+    describe "rules" do
+      %w{lparen rparen space space? fwd bwd inc dec puts gets iteration expression}.each do |rule|
+        it 'implements a rule for :#{rule} node' do
+          subject.should respond_to(:"#{rule}")
+        end
+      end
+    end
+    
+  end
+end

data/spec/brainfuck/stack_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Brainfuck
+  describe Stack do
+
+    describe "#current" do
+      it 'returns the current value of the stack' do
+        subject.current.should == 0
+      end
+    end
+
+    describe "#fwd" do
+      it 'advanced the pointer' do
+        subject.fwd
+        subject.instance_variable_get(:@pointer).should == 1
+      end
+    end
+
+    describe "#bwd" do
+      it 'decreases the pointer' do
+        subject.instance_variable_set(:@pointer, 4)
+        subject.bwd
+        subject.instance_variable_get(:@pointer).should == 3
+      end
+      context "if the pointer is trying to get below zero" do
+        it 'raises' do
+          subject.instance_variable_set(:@pointer, 0)
+          expect {
+            subject.bwd
+          }.to raise_error(RuntimeError, "Tried to access cell -1.")
+        end
+      end
+    end
+
+    describe "#inc" do
+      it 'increases the current cell' do
+        subject.instance_variable_set(:@stack, [4])
+        subject.inc
+        subject.current.should == 5
+      end
+    end
+
+    describe "#dec" do
+      it 'decreases the current cell' do
+        subject.instance_variable_set(:@stack, [4])
+        subject.dec
+        subject.current.should == 3
+      end
+    end
+
+    describe "#puts" do
+      it 'prints the current character' do
+        subject.stub_chain('current.chr').and_return 'A'
+        $stdout.should_receive(:print).with 'A'
+        subject.puts
+      end
+    end
+
+    describe "#gets" do
+      it 'prints the current character' do
+        subject.should_receive(:get_character).and_return 97
+        subject.gets
+        subject.current.should == 97
+      end
+    end
+
+    describe "#to_a" do
+      it 'returns the stack array' do
+        subject.to_a.should == [0]
+      end
+    end
+
+    describe "#clear" do
+      it 'clears the stack' do
+        subject.should_receive(:initialize)
+        subject.clear
+      end
+    end
+
+  end
+end

data/spec/brainfuck_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Brainfuck do
+
+  describe ".run" do
+    it 'runs the code and returns the stack' do
+      code = double('code') 
+      parsed = double('parsed')
+      ast = [double('node'), double('node')]
+
+      Brainfuck::Interpreter.stack.should_receive(:clear)
+
+      Brainfuck::Parser.should_receive(:clean).with("code").and_return(code)
+      Brainfuck::Parser.stub_chain('new.parse').with(code).and_return parsed
+      Brainfuck::Interpreter.stub_chain('new.apply').with(parsed).and_return ast
+      
+      ast.each { |n| n.should_receive(:eval) }
+
+      subject.run("code").should === Brainfuck::Interpreter.stack.to_a
+    end
+  end   
+
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Josep M. Bach
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-02 00:00:00 +01:00
+date: 2011-01-12 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,7 +31,7 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: parslet
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -41,10 +41,10 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
+  type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: bundler
+  name: rspec
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -57,7 +57,7 @@ dependencies:
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: simplecov
+  name: bundler
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
@@ -69,6 +69,19 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
 description: Another Brainfuck interpreter in Ruby
 email: 
 - josep.m.bach@gmail.com
@@ -88,9 +101,17 @@ files:
 - brainfuck.gemspec
 - examples/hello_world.bf
 - lib/brainfuck.rb
+- lib/brainfuck/ast.rb
+- lib/brainfuck/interpreter.rb
+- lib/brainfuck/parser.rb
+- lib/brainfuck/stack.rb
 - lib/brainfuck/version.rb
-- spec/acceptance_spec.rb
-- spec/interpreter_spec.rb
+- spec/acceptance/acceptance_spec.rb
+- spec/brainfuck/ast_spec.rb
+- spec/brainfuck/interpreter_spec.rb
+- spec/brainfuck/parser_spec.rb
+- spec/brainfuck/stack_spec.rb
+- spec/brainfuck_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/txus/brainfuck
@@ -125,6 +146,10 @@ signing_key:
 specification_version: 3
 summary: Another Brainfuck interpreter in Ruby
 test_files: 
-- spec/acceptance_spec.rb
-- spec/interpreter_spec.rb
+- spec/acceptance/acceptance_spec.rb
+- spec/brainfuck/ast_spec.rb
+- spec/brainfuck/interpreter_spec.rb
+- spec/brainfuck/parser_spec.rb
+- spec/brainfuck/stack_spec.rb
+- spec/brainfuck_spec.rb
 - spec/spec_helper.rb

data/spec/interpreter_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-module Brainfuck
-  describe Interpreter do
-    subject { Interpreter.new }
-
-    it "initializes with an array of cells with a single 0 element" do
-      subject.cells.should == [0]
-    end
-
-    describe "#clean" do
-      it "cleans the code from comments and whitespace" do
-        subject.send(:clean, " < > h -  + ..,hb [lk]f").should == '<>-+..,[]'
-      end
-    end
-
-    describe "#compile" do
-      it "cleans the code first and runs it second" do
-        code = double('code')
-        subject.should_receive(:clean).once.with(code).ordered.and_return("")
-        subject.should_receive(:run).once
-
-        subject.compile(code)
-      end
-    end
-
-    describe "#run" do
-      it "converts > into forward" do
-        subject.stub(:code).and_return ">"
-        subject.should_receive(:forward).once
-        subject.run
-      end
-      it "converts < into backward" do
-        subject.stub(:code).and_return "<"
-        subject.should_receive(:backward).once
-        subject.run
-      end
-      it "converts + into increase" do
-        subject.stub(:code).and_return "+"
-        subject.should_receive(:increase).once
-        subject.run
-      end
-      it "converts - into decrease" do
-        subject.stub(:code).and_return "-"
-        subject.should_receive(:decrease).once
-        subject.run
-      end
-      it "converts , into get_character" do
-        subject.stub(:code).and_return ","
-        subject.should_receive(:get_character).once
-        subject.run
-      end
-      it "converts . into stdout.print" do
-        subject.stub(:code).and_return "."
-        output = double('output')
-        subject.should_receive(:stdout).once.and_return(output)
-        subject.should_receive(:current).once.and_return(117)
-        output.should_receive(:print).once
-
-        subject.run
-      end
-    end
-
-  end
-end