brainclusterfuck 0.0.1 → 0.2.0

data/lib/brainclusterfuck/opcodes/modify_pointer.rb

@@ -0,0 +1,9 @@
+require 'brainclusterfuck/opcodes/modifying_base'
+
+module Brainclusterfuck::Opcodes
+  class ModifyPointer < ModifyingBase
+    def can_squeeze_with?(other)
+      super && (modify_by * other.modify_by) > 0 # same sign
+    end
+  end
+end

data/lib/brainclusterfuck/opcodes/modify_value.rb

@@ -0,0 +1,6 @@
+require 'brainclusterfuck/opcodes/modifying_base'
+
+module Brainclusterfuck::Opcodes
+  class ModifyValue < ModifyingBase
+  end
+end

data/lib/brainclusterfuck/opcodes/modifying_base.rb

@@ -0,0 +1,27 @@
+require 'brainclusterfuck/opcodes/base'
+
+module Brainclusterfuck::Opcodes
+  class ModifyingBase < Base
+    attr_reader :modify_by
+
+    def initialize(modify_by, cycles)
+      @modify_by = modify_by.to_i
+      @cycles = cycles.to_i
+    end
+
+    def ==(other)
+      other.class == self.class &&
+        other.modify_by == modify_by &&
+        other.cycles == cycles
+    end
+
+    def can_squeeze_with?(other)
+      other.class == self.class
+    end
+
+    def squeeze_with(other)
+      raise "Cannot squeeze: #{self}, #{other}" unless can_squeeze_with?(other)
+      self.class.new(modify_by + other.modify_by, cycles + other.cycles)
+    end
+  end
+end

data/lib/brainclusterfuck/opcodes/print.rb

@@ -0,0 +1,13 @@
+require 'brainclusterfuck/opcodes/base'
+
+module Brainclusterfuck::Opcodes
+  class Print < Base
+    def initialize
+      @cycles = 1
+    end
+
+    def ==(other)
+      other.is_a?(Print)
+    end
+  end
+end

data/lib/brainclusterfuck/terminal.rb

@@ -5,5 +5,9 @@ module Brainclusterfuck
     def initialize
       @text = ''
     end
+
+    def print(char)
+      @text << char
+    end
   end
 end

data/lib/brainclusterfuck/version.rb

@@ -1,3 +1,3 @@
 module Brainclusterfuck
-  VERSION = "0.0.1"
+  VERSION = "0.2.0"
 end

data/spec/compiler_spec.rb

@@ -1,31 +1,78 @@
 require 'spec_helper'
 require 'brainclusterfuck/compiler'
-require 'brainclusterfuck/opcode'
+require 'brainclusterfuck/compile_error'
+require 'brainclusterfuck/opcodes'
 
 describe Brainclusterfuck::Compiler do
-  it 'raises if there are no tokens' do
-    expect { Brainclusterfuck::Compiler.new([]) }.to raise_error
+  describe 'invalid token streams' do
+    it 'raises if there are no tokens' do
+      expect { Brainclusterfuck::Compiler.new([]) }.to raise_error(Brainclusterfuck::CompileError)
+    end
+
+    it 'raises if there are unrecognized tokens' do
+      expect { Brainclusterfuck::Compiler.new([:foo]) }.to raise_error(Brainclusterfuck::CompileError)
+    end
+
+    it 'raises if an end loop occurs before an open loop' do
+      expect { Brainclusterfuck::Compiler.new([:loop_end]) }.to raise_error(Brainclusterfuck::PrematurelyTerminatedLoopError)
+    end
+
+    it 'raises if an open loop does not have an end loop' do
+      expect { Brainclusterfuck::Compiler.new([:loop_start]) }.to raise_error(Brainclusterfuck::UnterminatedLoopError)
+    end
+
+    it 'raises if there are too many end loops' do
+      expect { Brainclusterfuck::Compiler.new([:loop_start, :loop_end, :loop_end]) }.to raise_error(Brainclusterfuck::PrematurelyTerminatedLoopError)
+    end
+
+    it 'raises if there are not enough open loops' do
+      expect { Brainclusterfuck::Compiler.new([:loop_start, :loop_start, :loop_end]) }.to raise_error(Brainclusterfuck::UnterminatedLoopError)
+    end
   end
 
   it 'converts tokens to the correct operations' do
-    compiler = Brainclusterfuck::Compiler.new([:v_incr, :p_incr, :v_decr, :p_decr])
+    compiler = Brainclusterfuck::Compiler.new([:v_incr, :p_incr, :loop_start, :v_decr, :loop_end, :p_decr, :print])
     expect(compiler.bytecode).to eq([
-      Brainclusterfuck::Opcode::ModifyValue.new(1, 1),
-      Brainclusterfuck::Opcode::ModifyPointer.new(1, 1),
-      Brainclusterfuck::Opcode::ModifyValue.new(-1, 1),
-      Brainclusterfuck::Opcode::ModifyPointer.new(-1, 1)
+      Brainclusterfuck::Opcodes::ModifyValue.new(1, 1),
+      Brainclusterfuck::Opcodes::ModifyPointer.new(1, 1),
+      Brainclusterfuck::Opcodes::LoopStart.new(1),
+      Brainclusterfuck::Opcodes::ModifyValue.new(-1, 1),
+      Brainclusterfuck::Opcodes::LoopEnd.new(1),
+      Brainclusterfuck::Opcodes::ModifyPointer.new(-1, 1),
+      Brainclusterfuck::Opcodes::Print.new
     ])
   end
 
   describe '#squeeze_operations' do
-    it 'compresses the incr/decr operations' do
+    it 'compresses the lone incr/decr operations' do
       tokens = (Array.new(8) { :v_incr }).concat(Array.new(3) { :p_decr })
       compiler = Brainclusterfuck::Compiler.new(tokens)
       compiler.squeeze_operations!
 
       expect(compiler.bytecode).to eq([
-        Brainclusterfuck::Opcode::ModifyValue.new(8, 8),
-        Brainclusterfuck::Opcode::ModifyPointer.new(-3, 3)
+        Brainclusterfuck::Opcodes::ModifyValue.new(8, 8),
+        Brainclusterfuck::Opcodes::ModifyPointer.new(-3, 3)
+      ])
+    end
+
+    it 'merges opposite-direction value modifiers' do
+      tokens = (Array.new(8) { :v_incr }).concat(Array.new(3) { :v_decr })
+      compiler = Brainclusterfuck::Compiler.new(tokens)
+      compiler.squeeze_operations!
+
+      expect(compiler.bytecode).to eq([
+        Brainclusterfuck::Opcodes::ModifyValue.new(5, 11)
+      ])
+    end
+
+    it 'does not merge opposite-direction pointer modifiers' do
+      tokens = (Array.new(8) { :p_incr }).concat(Array.new(3) { :p_decr })
+      compiler = Brainclusterfuck::Compiler.new(tokens)
+      compiler.squeeze_operations!
+
+      expect(compiler.bytecode).to eq([
+        Brainclusterfuck::Opcodes::ModifyPointer.new(8, 8),
+        Brainclusterfuck::Opcodes::ModifyPointer.new(-3, 3)
       ])
     end
 
@@ -39,8 +86,9 @@ describe Brainclusterfuck::Compiler do
       compiler.squeeze_operations!
 
       expect(compiler.bytecode).to eq([
-        Brainclusterfuck::Opcode::ModifyValue.new(2, 4),
-        Brainclusterfuck::Opcode::ModifyPointer.new(-4, 8)
+        Brainclusterfuck::Opcodes::ModifyValue.new(2, 4),
+        Brainclusterfuck::Opcodes::ModifyPointer.new(-6, 6),
+        Brainclusterfuck::Opcodes::ModifyPointer.new(2, 2)
       ])
     end
 
@@ -49,9 +97,27 @@ describe Brainclusterfuck::Compiler do
       compiler.squeeze_operations!
 
       expect(compiler.bytecode).to eq([
-        Brainclusterfuck::Opcode::Print.new,
-        Brainclusterfuck::Opcode::Print.new,
-        Brainclusterfuck::Opcode::Print.new
+        Brainclusterfuck::Opcodes::Print.new,
+        Brainclusterfuck::Opcodes::Print.new,
+        Brainclusterfuck::Opcodes::Print.new
+      ])
+    end
+
+    it 'handles loops properly' do
+      compiler = Brainclusterfuck::Compiler.new([
+        :loop_start,
+        :v_decr,
+        :v_decr,
+        :v_decr,
+        :loop_end
+      ])
+
+      compiler.squeeze_operations!
+
+      expect(compiler.bytecode).to eq([
+        Brainclusterfuck::Opcodes::LoopStart.new(1),
+        Brainclusterfuck::Opcodes::ModifyValue.new(-3, 3),
+        Brainclusterfuck::Opcodes::LoopEnd.new(1)
       ])
     end
   end

data/spec/integration/basic_loops_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'Basic loops' do
+  let(:lexer) { Brainclusterfuck::Lexer.new(program) }
+  let(:compiler) { Brainclusterfuck::Compiler.new(lexer.tokens) }
+  let(:terminal) { Brainclusterfuck::Terminal.new }
+  let(:memory) { Brainclusterfuck::Memory.new(1) }
+
+  let(:interpreter) do
+    Brainclusterfuck::Interpreter.new(
+      bytecode: compiler.bytecode,
+      terminal: terminal,
+      memory: memory
+    )
+  end
+
+  describe 'the decrement macro' do
+    let(:program) { '[-]' }
+    let(:expected_cycles) do
+      %w(
+        open_loop
+        decr
+        end_loop
+        decr
+        end_loop
+        decr
+        end_loop
+      ).size
+    end
+
+    def self.it_clears_the_cell
+      it 'reduces the value of that cell to zero' do
+        memory.modify_value(3)
+        interpreter.step(expected_cycles)
+        expect(interpreter).to be_finished
+
+        expect(interpreter.cycles).to eq(expected_cycles)
+        expect(memory.current_value).to eq(0)
+      end
+    end
+
+    context 'without optimizing' do
+      it_clears_the_cell
+    end
+
+    context 'with optimizing' do
+      before do
+        compiler.squeeze_operations!
+      end
+
+      it_clears_the_cell
+    end
+
+  end
+end

data/spec/integration/basic_print_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe 'Printing simple text' do
+  let(:lexer) { Brainclusterfuck::Lexer.new(program) }
+  let(:compiler) { Brainclusterfuck::Compiler.new(lexer.tokens) }
+  let(:terminal) { Brainclusterfuck::Terminal.new }
+  let(:memory) { Brainclusterfuck::Memory.new(5) }
+
+  let(:interpreter) do
+    Brainclusterfuck::Interpreter.new(
+      bytecode: compiler.bytecode,
+      terminal: terminal,
+      memory: memory
+    )
+  end
+
+  describe 'printing "!"' do
+    let(:program) { ('+' * 33) + '.' }
+
+    def self.it_prints
+      it 'sends "!" to the terminal object' do
+        interpreter.step(35)
+        expect(interpreter).to be_finished
+        expect(interpreter.cycles).to eq(34) # 33 increments + 1 print
+        expect(terminal.text).to eq('!')
+      end
+    end
+
+    context 'without optimizing' do
+      it_prints
+    end
+
+    context 'when optimizing' do
+      before do
+        compiler.squeeze_operations!
+      end
+
+      it_prints
+    end
+  end
+
+  describe 'printing "X" using multiple memory locations' do
+    let(:program) { '>++++++++[<+++++++++++>-]<.' }
+
+    def self.it_prints_x
+      it 'sends "X" to the terminal object' do
+        interpreter.step(500)
+        expect(interpreter).to be_finished
+        expect(terminal.text).to eq('X')
+      end
+    end
+
+    context 'without optimizing' do
+      it_prints_x
+    end
+
+    context 'when optimizing' do
+      before do
+        compiler.squeeze_operations!
+      end
+
+      it_prints_x
+    end
+  end
+end

data/spec/integration/boundary_conditions_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe 'Boundary conditions' do
+  let(:lexer) { Brainclusterfuck::Lexer.new(program) }
+  let(:compiler) { Brainclusterfuck::Compiler.new(lexer.tokens) }
+  let(:terminal) { Brainclusterfuck::Terminal.new }
+  let(:memory) { Brainclusterfuck::Memory.new(5) }
+
+  let(:interpreter) do
+    Brainclusterfuck::Interpreter.new(
+      bytecode: compiler.bytecode,
+      terminal: terminal,
+      memory: memory
+    )
+  end
+
+  describe 'adjusting pointer out of bounds' do
+    let(:program) { '<>>' }
+
+    def self.it_raises
+      it 'raises an exception' do
+        expect { interpreter.step(3) }.to raise_error(Brainclusterfuck::MemoryError)
+      end
+    end
+
+    context 'without optimizing' do
+      it_raises
+    end
+
+    context 'when optimizing' do
+      before do
+        compiler.squeeze_operations!
+      end
+
+      it_raises
+    end
+  end
+
+  describe 'overflowing memory value' do
+    def self.it_rolls_over
+      it 'rolls over' do
+        interpreter.step(num_steps)
+        expect(memory.current_value).to eq(255)
+      end
+    end
+
+    describe 'going negative' do
+      let(:program) { '-' }
+      let(:num_steps) { 1 }
+
+      context 'without optimizing' do
+        it_rolls_over
+      end
+
+      context 'when optimizing' do
+        before do
+          compiler.squeeze_operations!
+        end
+
+        it_rolls_over
+      end
+    end
+
+    describe 'going positive' do
+      let(:program) { '+' * num_steps }
+      let(:num_steps) { 255 + 256 }
+
+      context 'without optimizing' do
+        it_rolls_over
+      end
+
+      context 'when optimizing' do
+        before do
+          compiler.squeeze_operations!
+        end
+
+        it_rolls_over
+      end
+    end
+  end
+end

data/spec/interpreter_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+require 'brainclusterfuck/interpreter'
+
+describe Brainclusterfuck::Interpreter do
+  let(:bytecode) { double(:bytecode, size: 5) }
+  let(:terminal) { double(:terminal) }
+  let(:memory) { double(:memory) }
+
+  let(:interpreter) do
+    described_class.new(
+      bytecode: bytecode,
+      terminal: terminal,
+      memory: memory
+    )
+  end
+
+  it 'exposes terminal and memory' do
+    expect(interpreter.terminal).to equal(terminal)
+    expect(interpreter.memory).to equal(memory)
+  end
+
+  it 'exposes cycles, starting at 0' do
+    expect(interpreter.cycles).to eq(0)
+  end
+
+  it 'exposes the instruction pointer, starting at 0' do
+    expect(interpreter.instruction_pointer).to eq(0)
+  end
+
+  describe '#step' do
+    it 'raises if step is 0 or negative' do
+      expect { interpreter.step(0) }.to raise_error(ArgumentError)
+      expect { interpreter.step(-1) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an ArgumentError if attempting to execute an unknown opcode' do
+      weird_opcode = Brainclusterfuck::Opcodes::Base.new
+      weird_opcode.stub(cycles: 1)
+      bytecode.should_receive(:[]).with(0).and_return(weird_opcode)
+
+      expect { interpreter.step(1) }.to raise_error(ArgumentError)
+    end
+
+    it 'does nothing when stepping past a fully-executed program' do
+      bytecode.should_receive(:[]).with(0).and_return(nil)
+
+      interpreter.step(1)
+
+      expect(interpreter).to be_finished
+    end
+
+    it 'will step exactly that number of cycles if possible' do
+      bytecode.should_receive(:[]).with(0).and_return(Brainclusterfuck::Opcodes::ModifyValue.new(1, 1))
+      memory.should_receive(:modify_value).with(1)
+
+      interpreter.step(1)
+      expect(interpreter.cycles).to eq(1)
+    end
+
+    it 'will step more than the asked cycles if necessary' do
+      bytecode.should_receive(:[]).with(0).and_return(Brainclusterfuck::Opcodes::ModifyValue.new(1, 5))
+      memory.should_receive(:modify_value).with(1)
+
+      interpreter.step(1)
+      expect(interpreter.cycles).to eq(5)
+    end
+
+    describe 'opcodes' do
+      def set_up_bytecode(hash)
+        hash.each do |index, op|
+          bytecode.stub(:[]).with(index).and_return(op)
+        end
+      end
+
+      it 'handles ModifyValue' do
+        set_up_bytecode(0 => Brainclusterfuck::Opcodes::ModifyValue.new(1, 9))
+        memory.should_receive(:modify_value).with(1)
+
+        interpreter.step(1)
+        expect(interpreter.cycles).to eq(9)
+      end
+
+      it 'handles ModifyValue' do
+        set_up_bytecode(0 => Brainclusterfuck::Opcodes::ModifyPointer.new(1, 9))
+        memory.should_receive(:modify_pointer).with(1)
+
+        interpreter.step(1)
+        expect(interpreter.cycles).to eq(9)
+      end
+
+      it 'handles Print' do
+        set_up_bytecode(0 => Brainclusterfuck::Opcodes::Print.new)
+        memory.stub(current_char: 'x')
+        terminal.should_receive(:print).with('x')
+
+        interpreter.step(1)
+        expect(interpreter.cycles).to eq(1)
+      end
+
+      describe 'loops' do
+        before do
+          set_up_bytecode(
+            0 => Brainclusterfuck::Opcodes::LoopStart.new(1),
+            1 => Brainclusterfuck::Opcodes::ModifyPointer.new(1, 1),
+            2 => Brainclusterfuck::Opcodes::LoopEnd.new(1),
+            3 => Brainclusterfuck::Opcodes::ModifyValue.new(1, 1),
+          )
+        end
+
+        describe 'LoopStart' do
+          it 'stays in the loop when the current value is non-zero' do
+            memory.stub(current_value: 1)
+            memory.should_receive(:modify_pointer).with(1)
+            memory.should_not_receive(:modify_value)
+
+            interpreter.step(2)
+            expect(interpreter.cycles).to eq(2)
+          end
+
+          it 'jumps past the end loop when the current value is zero' do
+            memory.stub(current_value: 0)
+            memory.should_receive(:modify_value).with(1)
+            memory.should_not_receive(:modify_pointer)
+
+            interpreter.step(2)
+            expect(interpreter.cycles).to eq(2)
+          end
+        end
+
+        describe 'LoopEnd' do
+          it 'goes past the loop when the value is zero' do
+            memory.stub(current_value: 1)
+            memory.should_receive(:modify_pointer).with(1) do
+              memory.stub(current_value: 0)
+              memory.should_receive(:modify_value).with(1)
+            end
+
+            interpreter.step(4)
+
+            expect(interpreter.cycles).to eq(4)
+          end
+
+          it 'goes back to the beginning of the loop when the value is non-zero' do
+            memory.stub(current_value: 1)
+            memory.should_receive(:modify_pointer).with(1).twice
+
+            interpreter.step(4)
+            expect(interpreter.cycles).to eq(4)
+          end
+        end
+      end
+    end
+  end
+end