brain_love 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in brain_love.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Marjan Krekoten' (Мар'ян Крекотень)
+
+MIT License
+
+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/README.md

@@ -0,0 +1,50 @@
+# BrainLove
+
+Ruby implementation of [brainfuck](http://esolangs.org/wiki/Brainfuck).
+
+## Installation
+
+Install it as:
+
+    $ gem install brain_love
+
+## Usage
+
+### Standalone
+
+    # Hello World
+    brain_love -e '>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.'
+
+Or from file:
+
+    brain_love some_file.bf
+
+### In your code
+
+    require 'brain_love'
+
+    # Hello World
+    BrainLove.run_string('>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.')
+
+## Portability
+
+ * Data space contains 30 000 cells
+ * Data cell is unsigned byte (wraps around)
+ * EOF sets data cell to 0
+ * Nested loops
+
+## Current limitations
+
+ * jump offsets are 1 byte
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+Copyright (c) 2012 Мар'ян Крекотень (Marjan Krekoten'). Distributed under the MIT License. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+desc "Default task is to run specs :) Did you expect something else?"
+task :default => :spec

data/bin/brain_love

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('../../lib', __FILE__)
+require 'brain_love'
+require 'optparse'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: brain_love [OPTIONS] [FILE]\nVersion: #{BrainLove::VERSION}"
+
+  opts.on("-e", "--execute CODE", "Brainfuck one liner. FILE param not accepted") do |code|
+    options[:execute] = code
+  end
+
+  opts.on('-v', '--version', 'Show version') do
+    options[:version] = true
+  end
+
+  opts.on_tail('-h', '--help', "This message") do
+    puts opts
+    exit
+  end
+end.parse!
+
+if options[:version]
+  puts "Version: #{BrainLove::VERSION}"
+end
+
+if code = options[:execute]
+  BrainLove.run_string(code)
+elsif !ARGV.empty? && options[:execute].nil?
+  ARGV.each { |_| BrainLove.run_file(_) }
+end

data/brain_love.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/brain_love/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Marjan Krekoten' (Мар'ян Крекотень)"]
+  gem.email         = ["krekoten@gmail.com"]
+  gem.description   = %q{Brainfuck implementation for fun and love}
+  gem.summary       = %q{Brainfuck}
+  gem.homepage      = "http://krekoten.github.com/brain_love"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "brain_love"
+  gem.require_paths = ["lib"]
+  gem.version       = BrainLove::VERSION
+
+  gem.add_development_dependency "rspec"
+  gem.add_runtime_dependency "parslet"
+end

data/lib/brain_love/ast.rb

@@ -0,0 +1,31 @@
+module BrainLove
+  module AST
+
+    class Node
+      attr_reader :value
+
+      def initialize(value = nil)
+        @value = value
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.value == other.value
+      end
+
+      def accept(visitor)
+        visitor.send("visit_#{self.class.to_s.split('::').last}", self)
+      end
+    end
+
+    class Statements < Node; end
+    class IncrementPointer < Node; end
+    class DecrementPointer < Node; end
+    class IncrementByte < Node; end
+    class DecrementByte < Node; end
+    class OutputByte < Node; end
+    class InputByte < Node; end
+    class Loop < Node; end
+
+  end
+end

data/lib/brain_love/compiler.rb

@@ -0,0 +1,89 @@
+module BrainLove
+  class Compiler
+
+    attr_reader :bytecode, :ip
+
+    def initialize
+      @bytecode = ""
+      @ip = 0
+    end
+
+    def inc_dp
+      @bytecode << VM::INC_DP.chr
+    end
+
+    def dec_dp
+      @bytecode << VM::DEC_DP.chr
+    end
+
+    def inc_byte
+      @bytecode << VM::INC_BYTE.chr
+    end
+
+    def dec_byte
+      @bytecode << VM::DEC_BYTE.chr
+    end
+
+    def putc
+      @bytecode << VM::PUTC.chr
+    end
+
+    def getc
+      @bytecode << VM::GETC.chr
+    end
+
+    def jmpfz(at, offset)
+      @bytecode[at] = VM::JMPFZ.chr
+      @bytecode[at + 1] = offset.chr
+    end
+
+    def jmpbnz(offset)
+      @bytecode << VM::JMPBNZ.chr << offset.chr
+    end
+
+    def noop
+      @bytecode << VM::NOOP
+    end
+
+    def current_ip
+      @bytecode.bytesize
+    end
+
+    def visit_Statements(statements)
+      statements.value.each { |st| st.accept(self) }
+    end
+
+    def visit_Loop(_loop)
+      jmpf_ip = current_ip
+      noop
+      noop
+      _loop.value.accept(self)
+      jmpbnz(current_ip - jmpf_ip)
+      jmpfz(jmpf_ip, current_ip)
+    end
+
+    def visit_DecrementPointer(_)
+      dec_dp
+    end
+
+    def visit_IncrementPointer(_)
+      inc_dp
+    end
+
+    def visit_IncrementByte(_)
+      inc_byte
+    end
+
+    def visit_DecrementByte(_)
+      dec_byte
+    end
+
+    def visit_OutputByte(_)
+      putc
+    end
+
+    def visit_InputByte(_)
+      getc
+    end
+  end
+end

data/lib/brain_love/parser.rb

@@ -0,0 +1,28 @@
+require 'parslet'
+
+module BrainLove
+  class Parser < Parslet::Parser
+    rule(:increment_pointer)  { str('>').as(:increment_pointer) }
+    rule(:decrement_pointer)  { str('<').as(:decrement_pointer) }
+    rule(:increment_byte)     { str('+').as(:increment_byte) }
+    rule(:decrement_byte)     { str('-').as(:decrement_byte) }
+    rule(:output_byte)        { str('.').as(:output_byte) }
+    rule(:input_byte)         { str(',').as(:input_byte) }
+    rule(:jump_forward)       { str('[') }
+    rule(:jump_backward)      { str(']') }
+
+    rule :command do
+      increment_pointer |
+      decrement_pointer |
+      increment_byte    |
+      decrement_byte    |
+      output_byte       |
+      input_byte
+    end
+
+    rule(:commands)           { command.repeat(1) }
+    rule(:_loop)              { (jump_forward >> (commands | _loop).as(:statements).repeat >> jump_backward).as(:loop) }
+
+    rule(:root)               { (commands | _loop).as(:statements).repeat.as(:statements) }
+  end
+end

data/lib/brain_love/transformer.rb

@@ -0,0 +1,26 @@
+module BrainLove
+  class Transformer < Parslet::Transform
+    rule(:increment_pointer => simple(:_))  { AST::IncrementPointer.new }
+    rule(:decrement_pointer => simple(:_))  { AST::DecrementPointer.new }
+    rule(:increment_byte    => simple(:_))  { AST::IncrementByte.new }
+    rule(:decrement_byte    => simple(:_))  { AST::DecrementByte.new }
+    rule(:output_byte       => simple(:_))  { AST::OutputByte.new }
+    rule(:input_byte        => simple(:_))  { AST::InputByte.new }
+
+    rule(:loop => simple(:_)) do
+      AST::Loop.new
+    end
+
+    rule(:loop => sequence(:statements)) do
+      AST::Loop.new(statements.first)
+    end
+
+    rule :statements => simple(:statements) do
+      AST::Statements.new([statements])
+    end
+
+    rule :statements => sequence(:statements) do
+      AST::Statements.new(statements)
+    end
+  end
+end

data/lib/brain_love/version.rb

@@ -0,0 +1,3 @@
+module BrainLove
+  VERSION = "0.0.1"
+end

data/lib/brain_love/vm.rb

@@ -0,0 +1,90 @@
+module BrainLove
+  class VM
+
+    NOOP      = 0
+    INC_DP    = 1
+    DEC_DP    = 2
+    INC_BYTE  = 3
+    DEC_BYTE  = 4
+    PUTC      = 5
+    GETC      = 6
+    JMPFZ     = 7
+    JMPBNZ    = 8
+
+    attr_reader :ip, :dp, :code, :data
+
+    def initialize(code, input, output)
+      @code, @input, @output = code, input, output
+      @ip = 0
+      @dp = 0
+      @data = [0] * 30_000
+    end
+
+    def code_dump
+      index = 0
+      @code.each_byte do |b|
+        print "#{index} "
+        index += 1
+        case b
+        when NOOP
+          puts "NOOP"
+        when INC_DP
+          puts "INC_DP"
+        when DEC_DP
+          puts "DEC_DP"
+        when INC_BYTE
+          puts "INC_BYTE"
+        when DEC_BYTE
+          puts "DEC_BYTE"
+        when PUTC
+          puts "PUTC"
+        when GETC
+          puts "GETC"
+        when JMPFZ
+          puts "JMPFZ"
+          @jmp = true
+        when JMPBNZ
+          puts "JMPBNZ"
+          @jmp = true
+        else
+          if @jmp
+            @jmp = false
+            puts " offset #{b}"
+          else
+            puts "UNKNOWN BYTECODE"
+          end
+        end
+      end
+    end
+
+    def execute
+      while @ip < @code.bytesize do
+        case @code[@ip].ord
+        when NOOP
+        when INC_DP
+          @dp += 1
+        when DEC_DP
+          @dp -= 1
+        when INC_BYTE
+          @data[@dp] += 1
+        when DEC_BYTE
+          @data[@dp] -= 1
+        when PUTC
+          @output.putc(@data[@dp].chr)
+        when GETC
+          @data[@dp] = (@input.getc || 0).ord
+        when JMPFZ
+          @ip += @code[@ip + 1].ord - 1 if @data[@dp] == 0
+        when JMPBNZ
+          unless @data[@dp] == 0
+            @ip -= @code[@ip + 1].ord
+          else
+            @ip += 1
+          end
+        end
+
+        @ip += 1
+      end
+    end
+  end
+end

data/lib/brain_love.rb

@@ -0,0 +1,24 @@
+require "brain_love/version"
+require "brain_love/ast"
+require "brain_love/parser"
+require "brain_love/transformer"
+require "brain_love/vm"
+require "brain_love/compiler"
+
+module BrainLove
+
+  def run_string(code, input = STDIN, output = STDOUT)
+    ast = Transformer.new.apply(Parser.new.parse(code))
+    compiler = Compiler.new
+    ast.accept(compiler)
+    VM.new(compiler.bytecode, input, output).execute
+  end
+  module_function :run_string
+
+  def run_file(file, input = STDIN, output = STDOUT)
+    code = File.open(file) { |f| f.read }
+    run_string(code, input, output)
+  end
+  module_function :run_file
+
+end

data/spec/bin/brain_love_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+def run_brain_love(cmd)
+  `#{File.expand_path('../../../bin/brain_love', __FILE__)} #{cmd}`
+end
+
+describe 'brain_love' do
+  let(:hello_world) { '>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.' }
+
+  describe 'FILE' do
+    it 'executes code from file' do
+      run_brain_love(fixture_path('hello_world.bf')).should == 'Hello World!'
+    end
+  end
+
+  describe '-e' do
+    it 'executes code' do
+      run_brain_love("-e '#{hello_world}'").should == 'Hello World!'
+    end
+  end
+end

data/spec/brain_love/compiler_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+def bytecode(*bytes)
+  bytes.map(&:chr).join
+end
+
+describe BrainLove::Compiler do
+  let(:compiler) { BrainLove::Compiler.new }
+
+  it "emits INC_DP" do
+    compiler.inc_dp
+    compiler.bytecode.should == bytecode(BrainLove::VM::INC_DP)
+  end
+
+  it "emits DEC_DP" do
+    compiler.dec_dp
+    compiler.bytecode.should == bytecode(BrainLove::VM::DEC_DP)
+  end
+
+  it "emits INC_BYTE" do
+    compiler.inc_byte
+    compiler.bytecode.should == bytecode(BrainLove::VM::INC_BYTE)
+  end
+
+  it "emits DEC_BYTE" do
+    compiler.dec_byte
+    compiler.bytecode.should == bytecode(BrainLove::VM::DEC_BYTE)
+  end
+
+  it "emits PUTC" do
+    compiler.putc
+    compiler.bytecode.should == bytecode(BrainLove::VM::PUTC)
+  end
+
+  it "emits GETC" do
+    compiler.getc
+    compiler.bytecode.should == bytecode(BrainLove::VM::GETC)
+  end
+
+  it "emits JMPFZ" do
+    compiler.jmpfz(0, 0)
+    compiler.bytecode.should == bytecode(BrainLove::VM::JMPFZ, 0)
+  end
+
+  it "emits JMPBNZ" do
+    compiler.jmpbnz(3)
+    compiler.bytecode.should == bytecode(BrainLove::VM::JMPBNZ, 3)
+  end
+end

data/spec/brain_love/parser_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe BrainLove::Parser do
+  describe 'increment the pointer' do
+    subject { BrainLove::Parser.new.increment_pointer }
+
+    it { should parse('>') }
+  end
+
+  describe 'decrement the pointer' do
+    subject { BrainLove::Parser.new.decrement_pointer }
+
+    it { should parse('<') }
+  end
+
+  describe 'increment the byte at the pointer' do
+    subject { BrainLove::Parser.new.increment_byte }
+
+    it { should parse('+') }
+  end
+
+  describe 'decrement the byte at the pointer' do
+    subject { BrainLove::Parser.new.decrement_byte }
+
+    it { should parse('-') }
+  end
+
+  describe 'output the byte at the pointer' do
+    subject { BrainLove::Parser.new.output_byte }
+
+    it { should parse('.') }
+  end
+
+  describe 'input a byte and sore at the pointer' do
+    subject { BrainLove::Parser.new.input_byte }
+
+    it { should parse(',') }
+  end
+
+  describe 'jump forward if the byte at the pointer is zero' do
+    subject { BrainLove::Parser.new.jump_forward }
+
+    it { should parse('[') }
+  end
+
+  describe 'jump backward if the byte at the pointer is zero' do
+    subject { BrainLove::Parser.new.jump_backward }
+
+    it { should parse(']') }
+  end
+
+  describe 'integration' do
+    it { should parse('[+++>++<--]') }
+    it { should parse('[]') }
+    it { should parse('++[]') }
+    it { should parse('[[]]') }
+    it { should parse('[[++]++]>.') }
+
+    it { should_not parse('[') }
+    it { should_not parse(']') }
+  end
+end

data/spec/brain_love/transformer_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+def ast_statement(nodes)
+  BrainLove::AST::Statements.new(nodes)
+end
+
+describe BrainLove::Transformer do
+  describe 'simple commands' do
+    it { should transform('>').to(ast_statement([ast_statement([BrainLove::AST::IncrementPointer.new])])) }
+    it { should transform('<').to(ast_statement([ast_statement([BrainLove::AST::DecrementPointer.new])])) }
+    it { should transform('+').to(ast_statement([ast_statement([BrainLove::AST::IncrementByte.new])])) }
+    it { should transform('-').to(ast_statement([ast_statement([BrainLove::AST::DecrementByte.new])])) }
+    it { should transform('.').to(ast_statement([ast_statement([BrainLove::AST::OutputByte.new])])) }
+    it { should transform(',').to(ast_statement([ast_statement([BrainLove::AST::InputByte.new])])) }
+  end
+
+  describe 'loop' do
+    it { should transform('[]').to(ast_statement([ast_statement([BrainLove::AST::Loop.new()])])) }
+  end
+
+  describe 'commands and loop' do
+    it do
+      should transform(',[.,]').to(
+        ast_statement([
+          ast_statement([
+            BrainLove::AST::InputByte.new
+          ]),
+          ast_statement([
+            BrainLove::AST::Loop.new(
+              ast_statement([
+                BrainLove::AST::OutputByte.new,
+                BrainLove::AST::InputByte.new
+              ])
+            )
+          ])
+        ])
+      )
+    end
+  end
+end

data/spec/brain_love/vm_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'stringio'
+
+describe BrainLove::VM do
+  let(:input) { double('input stream') }
+  let(:output) { double('output stream') }
+  let(:vm) { BrainLove::VM.new(code, input, output) }
+
+  describe "initial state" do
+    let(:code) { [].join }
+
+    it "sets IP to 0" do
+      vm.ip.should == 0
+    end
+
+    it "sets DP to 0" do
+      vm.dp.should == 0
+    end
+  end
+
+  describe "INC_DP" do
+    let(:code) { [BrainLove::VM::INC_DP].map(&:chr).join }
+
+    it "increments the pointer by one" do
+      expect { vm.execute }.to change { vm.dp }.by(1)
+    end
+  end
+
+  describe "DEC_DP" do
+    let(:code) { [BrainLove::VM::INC_DP, BrainLove::VM::DEC_DP].map(&:chr).join }
+
+    it "decrements the pointer by one" do
+      expect { vm.execute }.to change { vm.dp }.by(0)
+    end
+  end
+
+  describe "INC_BYTE" do
+    let(:code) { [BrainLove::VM::INC_DP, BrainLove::VM::INC_BYTE].map(&:chr).join }
+
+    it "increments the byte at the pointer by one" do
+      expect { vm.execute }.to change { vm.data[1] }.by(1)
+    end
+  end
+
+  describe "DEC_BYTE" do
+    let(:code) { [BrainLove::VM::INC_DP, BrainLove::VM::INC_BYTE, BrainLove::VM::INC_BYTE, BrainLove::VM::DEC_BYTE].map(&:chr).join }
+
+    it "decrements the byte at the pointer by one" do
+      expect { vm.execute }.to change { vm.data[1] }.by(1)
+    end
+  end
+
+  describe "PUTC" do
+    let(:code) { ([BrainLove::VM::INC_BYTE] * 97 << BrainLove::VM::PUTC).map(&:chr).join }
+
+    it "sends the byte at the pointer as char to output stream" do
+      output.should_receive(:putc).with("a")
+      vm.execute
+    end
+  end
+
+  describe "GETC" do
+    let(:code) { [BrainLove::VM::INC_DP, BrainLove::VM::GETC].map(&:chr).join }
+
+    before do
+      input.should_receive(:getc).and_return("a")
+    end
+
+    it "reads char from input stream" do
+      vm.execute
+    end
+
+    it "stores char as a byte at the pointer" do
+      vm.execute
+      vm.data[1].should == 97
+    end
+  end
+
+  describe "JMPFZ" do
+    let(:code) { [BrainLove::VM::JMPFZ, 3, BrainLove::VM::INC_BYTE, BrainLove::VM::INC_DP, BrainLove::VM::GETC, BrainLove::VM::PUTC].map(&:chr).join }
+
+    it "jumps forward if current byte is 0" do
+      input.stub(:getc).and_return('t')
+      output.should_receive(:putc).with('t')
+      expect { vm.execute }.to change { vm.data[0] }.by(0)
+    end
+  end
+
+  describe "JMPBNZ" do
+    let(:code) { [BrainLove::VM::INC_BYTE, BrainLove::VM::DEC_BYTE, BrainLove::VM::JMPBNZ, 0, BrainLove::VM::INC_BYTE].map(&:chr).join }
+
+    it "jumps bacward unless current byte is 0" do
+      expect { vm.execute }.to change { vm.data[0] }.by(1)
+    end
+  end
+end

data/spec/brain_love_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'stringio'
+
+describe BrainLove do
+  describe '#run_string' do
+    it 'executes code from string' do
+      output = StringIO.new
+      BrainLove.run_string(
+        '>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.',
+        nil,
+        output
+      )
+      output.string.should == 'Hello World!'
+    end
+  end
+
+  describe '#run_file' do
+    it 'executes code from file' do
+      output = StringIO.new
+      BrainLove.run_file(
+        fixture_path('hello_world.bf'),
+        nil,
+        output
+      )
+      output.string.should == 'Hello World!'
+    end
+  end
+end

data/spec/fixtures/hello_world.bf

@@ -0,0 +1 @@
+>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'brain_love'
+
+def fixture_path(name)
+  File.expand_path("../fixtures/#{name}", __FILE__)
+end
+
+RSpec::Matchers.define :parse do |string_for_parsing|
+  match do |parser|
+    begin
+      parser.parse(string_for_parsing)
+      true
+    rescue Parslet::ParseFailed, NotImplementedError => e
+      @error = parser.error_tree
+      false
+    end
+  end
+
+  failure_message_for_should do |parser|
+    "expected #{parser} to parse #{string_for_parsing}\n#{@error}"
+  end
+
+  failure_message_for_should_not do |parser|
+    "didn't expect #{parser} to parse #{string_for_parsing}"
+  end
+
+  description do
+    "parse #{string_for_parsing}"
+  end
+end
+
+RSpec::Matchers.define :transform do |string_for_transforming|
+  match do |transformer|
+    @intermediate_representation = transformer.apply(@raw_ir = BrainLove::Parser.new.parse(string_for_transforming))
+    @node == @intermediate_representation
+  end
+
+  chain :to do |node|
+    @node = node
+  end
+
+  failure_message_for_should do |transformer|
+    "expected #{string_for_transforming}\n" <<
+    "to be transformed to\n#{@node.inspect}\n" <<
+    "got\n#{@intermediate_representation.inspect}\nir:\n#{@raw_ir}"
+  end
+
+  description do
+    "transform #{string_for_transforming} to AST node"
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: brain_love
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Marjan Krekoten' (Мар'ян Крекотень)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Brainfuck implementation for fun and love
+email:
+- krekoten@gmail.com
+executables:
+- brain_love
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/brain_love
+- brain_love.gemspec
+- lib/brain_love.rb
+- lib/brain_love/ast.rb
+- lib/brain_love/compiler.rb
+- lib/brain_love/parser.rb
+- lib/brain_love/transformer.rb
+- lib/brain_love/version.rb
+- lib/brain_love/vm.rb
+- spec/bin/brain_love_spec.rb
+- spec/brain_love/compiler_spec.rb
+- spec/brain_love/parser_spec.rb
+- spec/brain_love/transformer_spec.rb
+- spec/brain_love/vm_spec.rb
+- spec/brain_love_spec.rb
+- spec/fixtures/hello_world.bf
+- spec/spec_helper.rb
+homepage: http://krekoten.github.com/brain_love
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Brainfuck
+test_files:
+- spec/bin/brain_love_spec.rb
+- spec/brain_love/compiler_spec.rb
+- spec/brain_love/parser_spec.rb
+- spec/brain_love/transformer_spec.rb
+- spec/brain_love/vm_spec.rb
+- spec/brain_love_spec.rb
+- spec/fixtures/hello_world.bf
+- spec/spec_helper.rb