yabfi 0.1.1

data/spec/lib/yabfi/consumer_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+describe YABFI::Consumer do
+  subject { described_class.new(input) }
+  let(:input) { [] }
+
+  describe '#end_of_input?' do
+    let(:input) { [1, 2, 3] }
+
+    context 'when all of the input has been consumed' do
+      before { subject.seek(input.length) }
+
+      it 'returns true' do
+        expect(subject).to be_end_of_input
+      end
+    end
+
+    context 'when some of the input has not been consumed' do
+      it 'returns false' do
+        input.length.times do |int|
+          subject.seek(int)
+          expect(subject).to_not be_end_of_input
+        end
+      end
+    end
+  end
+
+  describe '#peek' do
+    let(:input) { %w(a b c) }
+
+    context 'when all of the input has been consumed' do
+      before { subject.seek(input.length) }
+
+      it 'fails with EndOfInput' do
+        expect { subject.peek }.to raise_error(described_class::EndOfInput)
+      end
+    end
+
+    context 'when some of the input has not been consumed' do
+      it 'returns the next character in the Array' do
+        input.each_with_index do |sym, int|
+          subject.seek(int)
+          expect(subject.peek).to eq(sym)
+        end
+      end
+
+      it 'does not advance the parse' do
+        expect { subject.peek }.to_not change { subject.consume_index }
+      end
+    end
+  end
+
+  describe '#advance' do
+    let(:input) { %w(a b c d e f) }
+
+    context 'when all of the input has been consumed' do
+      before { subject.seek(input.length) }
+
+      it 'fails with EndOfInput' do
+        expect { subject.advance }.to raise_error(described_class::EndOfInput)
+      end
+    end
+
+    context 'when some of the input has not been consumed' do
+      it 'returns the next character in the Array and advances the parse' do
+        input.each { |str| expect(subject.advance).to eq(str) }
+        expect { subject.advance }.to raise_error(described_class::EndOfInput)
+      end
+    end
+  end
+
+  describe '#satisfy' do
+    let(:input) { (0..9).to_a }
+
+    context 'when all of the input has been consumed' do
+      before { subject.seek(input.length) }
+
+      it 'fails with EndOfInput' do
+        expect { subject.satisfy(&:odd?) }
+          .to raise_error(described_class::EndOfInput)
+      end
+    end
+
+    context 'when some of the input has not been consumed' do
+      context 'but the predicate returns a falsey value' do
+        it 'fails with a Unsatisfied' do
+          expect { subject.satisfy(&:odd?) }
+            .to raise_error(YABFI::Consumer::Unsatisfied)
+        end
+      end
+
+      context 'and the predicate returns a truthy value' do
+        it 'returns the matched token and advances the parse' do
+          input.each do |num|
+            predicate = num.even? ? :even? : :odd?
+            expect(subject.satisfy(&predicate)).to eq(num)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#eq' do
+    let(:input) { %w(cat dog chicken) }
+
+    context 'when all of the input has been consumed' do
+      before { subject.seek(input.length) }
+
+      it 'fails with EndOfInput' do
+        expect { subject.eq('cat') }.to raise_error(described_class::EndOfInput)
+      end
+    end
+
+    context 'when some of the input has not been consumed' do
+      context 'but the expected token does not match the actual token' do
+        it 'fails with a Unsatisfied' do
+          expect { subject.eq('dog') }
+            .to raise_error(YABFI::Consumer::Unsatisfied)
+        end
+      end
+
+      context 'and the expeted token matches the actual token' do
+        it 'returns the matched token and advances the parse' do
+          input.each { |str| expect(subject.eq(str)).to eq(str) }
+        end
+      end
+    end
+  end
+
+  describe '#one_of' do
+    let(:input) { %i(foo bar baz) }
+
+    context 'when all of the input has been consumed' do
+      before { subject.seek(input.length) }
+
+      it 'fails with EndOfInput' do
+        expect { subject.one_of(*input) }
+          .to raise_error(described_class::EndOfInput)
+      end
+    end
+
+    context 'when some of the input has not been consumed' do
+      context 'but the expeted tokens do not match the actual token' do
+        it 'fails with a Unsatisfied' do
+          expect { subject.one_of(:hey, :hi, :howdy) }
+            .to raise_error(YABFI::Consumer::Unsatisfied)
+        end
+      end
+
+      context 'and the expeted tokens match the actual token' do
+        it 'returns the matched token and advances the parse' do
+          expect(subject.one_of(:foo, :bar)).to eq(:foo)
+          expect(subject.one_of(:bar, :baz)).to eq(:bar)
+          expect(subject.one_of(:baz, :foo)).to eq(:baz)
+        end
+      end
+    end
+  end
+
+  describe '#attempt' do
+    let(:input) { [1, :mixed, 'array', nil] }
+
+    context 'when the parse fails with in the given block' do
+      it 'returns nil' do
+        expect(subject.attempt { token(:mixed) }).to be(nil)
+      end
+
+      it 'resets the counter' do
+        expect { subject.attempt { [1, 2].each { |n| subject.eq(n) } } }
+          .to_not change { subject.consume_index }
+      end
+    end
+
+    context 'when the parse does not fail with in the given block' do
+      it 'returns the result' do
+        expect(subject.attempt { subject.satisfy(&:odd?) }).to eq(1)
+      end
+
+      it 'advances the parse' do
+        expect { subject.attempt { subject.eq(1) } }
+          .to change { subject.consume_index }
+          .from(0)
+          .to(1)
+      end
+    end
+  end
+
+  describe '#many' do
+    let(:input) { [2, 4, 6, 8, 9] }
+
+    it 'calls the given block until it fails or returns nil' do
+      expect(subject.many { subject.satisfy(&:even?) }).to eq([2, 4, 6, 8])
+      expect(subject.eq(9)).to eq(9)
+      expect(subject).to be_end_of_input
+    end
+  end
+
+  describe '#many_one' do
+    let(:input) { [1, 3, 5, 2, 4, 6] }
+
+    context 'when 0 results can be matched' do
+      it 'fails with Unsatisfied' do
+        expect { subject.many_one { subject.eq(2) } }
+          .to raise_error(described_class::Unsatisfied)
+      end
+    end
+
+    context 'when 1 result can be matched' do
+      it 'advances the parse and returns the result' do
+        expect(subject.many_one { subject.eq(1) }).to eq([1])
+        expect(subject.many_one { subject.eq(3) }).to eq([3])
+      end
+    end
+
+    context 'when many results can be matched' do
+      it 'advances the parse and returns the results' do
+        expect(subject.many_one { subject.satisfy(&:odd?) }).to eq([1, 3, 5])
+        expect(subject.many_one { subject.satisfy(&:even?) }).to eq([2, 4, 6])
+        expect(subject).to be_end_of_input
+      end
+    end
+  end
+end

data/spec/lib/yabfi/encoder_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe YABFI::Encoder do
+  describe '.encode' do
+    let(:ary) do
+      [
+        [:put, 3],
+        [:change_value, 4],
+        [:branch_if_zero, 4],
+        [:change_pointer, 1],
+        [:get, 1],
+        [:branch_not_zero, -2],
+        [:branch_if_zero, 3],
+        [:change_value, -1],
+        [:branch_not_zero, -1],
+        [:change_value, 65],
+        [:put, 1]
+      ]
+    end
+    let(:expected) do
+      [
+        [3, 3],
+        [0, 4],
+        [4, 4],
+        [1, 1],
+        [2, 1],
+        [5, -2],
+        [4, 3],
+        [0, -1],
+        [5, -1],
+        [0, 65],
+        [3, 1]
+      ]
+    end
+
+    it 'encodes the instructions into integers' do
+      expect(subject.encode(ary)).to eq(expected)
+    end
+  end
+end

data/spec/lib/yabfi/lexer_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe YABFI::Lexer do
+  subject { described_class }
+
+  describe '#run!' do
+    context 'when all of the input cannot be consumed' do
+      let(:input) do
+        %i(
+          loop
+          end
+          pred
+          fail
+        )
+      end
+
+      it 'fails with Consumer::Unsatisfied' do
+        expect { subject.run!(input) }
+          .to raise_error(YABFI::Consumer::Unsatisfied)
+      end
+    end
+
+    context 'when all of the input can be consumed' do
+      let(:input) do
+        %i(
+          succ
+          loop
+          loop
+          prev
+          prev
+          end
+          put
+          end
+          next
+          get
+          pred
+        )
+      end
+      let(:expected) do
+        [
+          [:change_value, 1],
+          [
+            :loop,
+            [
+              [
+                :loop,
+                [
+                  [:change_pointer, -2]
+                ]
+              ],
+              [:put, 1]
+            ]
+          ],
+          [:change_pointer, 1],
+          [:get, 1],
+          [:change_value, -1]
+        ]
+      end
+
+      it 'returns the syntax forest' do
+        expect(subject.run!(input)).to eq(expected)
+      end
+    end
+  end
+end

data/spec/lib/yabfi/parser_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe YABFI::Parser do
+  describe '.parse' do
+    let(:io) { StringIO.new('+-<>,.[] some comment') }
+    let(:enum) { subject.parse(io) }
+    let(:expected) { %i(succ pred prev next get put loop end) }
+
+    it 'returns an Enumator that yields each command from the given IO' do
+      expect(enum.to_a).to eq(expected)
+    end
+  end
+end

data/spec/lib/yabfi/unroll_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe YABFI::Unroll do
+  describe '.unroll' do
+    let(:tokens) do
+      %i(
+        succ
+        succ
+        next
+        loop
+        loop
+        prev
+        end
+        loop
+        get
+        end
+        next
+        end
+        put
+        pred
+      )
+    end
+    let(:input) { YABFI::Lexer.run!(tokens) }
+    let(:expected) do
+      [
+        [:change_value, 2],
+        [:change_pointer, 1],
+        [:branch_if_zero, 9],
+        [:branch_if_zero, 3],
+        [:change_pointer, -1],
+        [:branch_not_zero, -1],
+        [:branch_if_zero, 3],
+        [:get, 1],
+        [:branch_not_zero, -1],
+        [:change_pointer, 1],
+        [:branch_not_zero, -7],
+        [:put, 1],
+        [:change_value, -1]
+      ]
+    end
+
+    it 'unrolls the syntax forest' do
+      expect(subject.unroll(input)).to eq(expected)
+    end
+  end
+end

data/spec/lib/yabfi/vm_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe YABFI::VM do
+  let(:input) { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:eof) { -1 }
+  subject { described_class.new(input, output, eof) }
+
+  describe '#execute!' do
+    let(:commands) { [] }
+
+    before { subject.load!(YABFI::Encoder.encode(commands)) }
+
+    context 'when it executes a change_value command' do
+      let(:commands) do
+        [
+          [:change_value, -4],
+          [:change_value, 7]
+        ]
+      end
+
+      it 'changes the value at the memory cursor by the given delta' do
+        expect { subject.execute! }
+          .to change { subject.state[:current_value] }
+          .from(0)
+          .to(3)
+      end
+
+      it 'advances the program counter by 1' do
+        expect { subject.execute! }
+          .to change { subject.state[:program_counter] }
+          .by(commands.length)
+      end
+    end
+
+    context 'when it executes a change_pointer command' do
+      context 'when the pointer is moved below 0' do
+        let(:commands) do
+          [
+            [:change_pointer, 3],
+            [:change_pointer, -4]
+          ]
+        end
+
+        it 'fails with MemoryOutOfBounds' do
+          expect { subject.execute! }
+            .to raise_error(described_class::MemoryOutOfBounds)
+        end
+      end
+
+      context 'when the pointer is moved above 0' do
+        let(:commands) do
+          [
+            [:change_pointer, 100],
+            [:change_pointer, -65]
+          ]
+        end
+
+        it 'moves the cursor' do
+          expect { subject.execute! }
+            .to change { subject.state[:memory_cursor] }
+            .from(0)
+            .to(35)
+        end
+
+        it 'advances the program counter by 1' do
+          expect { subject.execute! }
+            .to change { subject.state[:program_counter] }
+            .by(commands.length)
+        end
+      end
+    end
+
+    context 'when it executes a get command' do
+      context 'when EOF is encountered' do
+        let(:commands) do
+          [
+            [:get, 1]
+          ]
+        end
+
+        it 'sets the current memory location to the specified EOF value' do
+          subject.execute!
+          expect(subject.state[:current_value]).to eq(eof)
+        end
+
+        it 'advances the program counter by 1' do
+          expect { subject.execute! }
+            .to change { subject.state[:program_counter] }
+            .by(commands.length)
+        end
+      end
+
+      context 'when EOF is not encountered' do
+        let(:input) { StringIO.new('ABC') }
+        let(:commands) do
+          [
+            [:get, 2]
+          ]
+        end
+
+        it 'sets the current memory localtion to the int value of the input' do
+          subject.execute!
+          expect(subject.state[:current_value]).to eq('B'.ord)
+        end
+
+        it 'advances the program counter by 1' do
+          expect { subject.execute! }
+            .to change { subject.state[:program_counter] }
+            .by(commands.length)
+        end
+      end
+    end
+
+    context 'when it executes a put command' do
+      let(:commands) do
+        [
+          [:change_value, 'E'.ord],
+          [:put, 5]
+        ]
+      end
+
+      it 'prints the current memory location the specified number of times' do
+        expect { subject.execute! }
+          .to change { output.string }
+          .from('')
+          .to('EEEEE')
+      end
+
+      it 'advances the program counter by 1' do
+        expect { subject.execute! }
+          .to change { subject.state[:program_counter] }
+          .by(commands.length)
+      end
+    end
+
+    context 'when it executes a branch_if_zero command' do
+      context 'when the current memory location is zero' do
+        let(:commands) do
+          [
+            [:branch_if_zero, 5]
+          ]
+        end
+
+        it 'branches to the specified location' do
+          expect { subject.execute! }
+            .to change { subject.state[:program_counter] }
+            .to(5)
+        end
+      end
+
+      context 'when the current memory location is not zero' do
+        let(:commands) do
+          [
+            [:change_value, 1],
+            [:branch_if_zero, -1],
+            [:change_value, 2]
+          ]
+        end
+
+        it 'advances the program counter by 1' do
+          expect { subject.execute! }
+            .to change { subject.state[:program_counter] }
+            .by(commands.length)
+        end
+      end
+    end
+
+    context 'when it executes a branch_not_zero command' do
+      context 'when the current memory location is zero' do
+        let(:commands) do
+          [
+            [:branch_not_zero, -1],
+            [:change_value, 1]
+          ]
+        end
+
+        it 'advances the program counter by 1' do
+          expect { subject.execute! }
+            .to change { subject.state[:program_counter] }
+            .by(commands.length)
+        end
+      end
+
+      context 'when the current memory location is not zero' do
+        let(:commands) do
+          [
+            [:change_value, 3],
+            [:change_value, -1],
+            [:branch_not_zero, -1]
+          ]
+        end
+
+        it 'branches to the specified location' do
+          subject.execute!
+          expect(subject.state[:current_value]).to be_zero
+        end
+      end
+    end
+  end
+end

data/spec/lib/yabfi_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe YABFI do
+  it 'has a version number' do
+    expect(YABFI::VERSION).to_not be(nil)
+  end
+
+  describe '.eval' do
+    let(:commands) { '' }
+    let(:input) { StringIO.new }
+    let(:output) { StringIO.new }
+    let(:eof) { 0 }
+
+    before { subject.eval!(commands, input: input, output: output, eof: eof) }
+
+    context 'when the program is "Hello World"' do
+      let(:commands) do
+        <<-EOS
+          >++++++++[<+++++++++>-]<.>>+>+>++>[-]+<[>[->+<<++++>]<<]>.+++++++..+++
+          .>>+++++++.<<<[[-]<[-]>]<+++++++++++++++.>>.+++.------.--------.>>+.>+
+          +++.
+        EOS
+      end
+
+      it 'evaluates the commands' do
+        expect(output.string).to eq("Hello World!\n")
+      end
+    end
+
+    context 'when the program is "cat"' do
+      let(:commands) { ',[.,]' }
+      let(:string) { 'Howdy ho! Cowby hat!' }
+      let(:input) { StringIO.new(string) }
+
+      it 'evaluates the commands' do
+        expect(output.string).to eq(string)
+      end
+    end
+
+    context 'when the program is wc' do
+      let(:commands) do
+        <<-EOS
+          >>>+>>>>>+>>+>>+[<<],[
+              -[-[-[-[-[-[-[-[<+>-[>+<-[>-<-[-[-[<++[<++++++>-]<
+                  [>>[-<]<[>]<-]>>[<+>-[<->[-]]]]]]]]]]]]]]]]
+              <[-<<[-]+>]<<[>>>>>>+<<<<<<-]>[>]>>>>>>>+>[
+                  <+[
+                      >+++++++++<-[>-<-]++>[<+++++++>-[<->-]+[+>>>>>>]]
+                      <[>+<-]>[>>>>>++>[-]]+<
+                  ]>[-<<<<<<]>>>>
+              ],
+          ]+<++>>>[[+++++>>>>>>]<+>+[[<++++++++>-]<.<<<<<]>>>>>>>>]
+        EOS
+      end
+      let(:input) { StringIO.new("one two\nthree four\n") }
+
+      it 'evaluates the commands' do
+        expect(output.string).to eq("\t2\t4\t19\n")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'pry'
+require 'simplecov'
+SimpleCov.start
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'yabfi'
+
+RSpec.configure do |config|
+  config.around(:each) do |example|
+    if ENV['NO_RESCUE'] == 'true'
+      example.run
+    else
+      Pry.rescue do
+        err = example.run
+        pending = err.is_a?(RSpec::Core::Pending::PendingExampleFixedError)
+        Pry.rescued(err) if err && !pending && $stdin.tty? && $stdout.tty?
+      end
+    end
+  end
+end

data/yabfi.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'yabfi/version'
+
+Gem::Specification.new do |spec|
+  spec.name                  = 'yabfi'
+  spec.version               = YABFI::VERSION
+  spec.authors               = ['Tom Hulihan']
+  spec.email                 = ['hulihan.tom159@gmail.com']
+  spec.summary               = 'Yet Another BrainFuck Interpreter'
+  spec.description           = [
+    'This gem uses native C extensions to interpret Brainfuck programs.',
+    'An optimizing compiler written in Ruby sits on top of the interpreter',
+    'which speeds up the computation quite a bit.'
+  ].join(' ')
+  spec.homepage              = 'https://github.com/nahiluhmot/yabfi'
+  spec.license               = 'MIT'
+  spec.files                 = `git ls-files -z`.split("\x0")
+  spec.require_paths         = ['lib']
+  spec.executables           = ['yabfi']
+  spec.required_ruby_version = '>= 2.0.0'
+  spec.extensions            = ['ext/yabfi/extconf.rb']
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake-compiler', '~> 0.9.5'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-stack_explorer'
+  spec.add_development_dependency 'pry-rescue'
+  spec.add_development_dependency 'simplecov'
+end