brainclusterfuck 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,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in brainclusterfuck.gemspec
+gemspec
+
+group [:test, :development] do
+  gem 'should_not', '~> 1.0'
+end

data/LICENSE.mit

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mark Rushakoff
+
+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,29 @@
+# Brainclusterfuck
+
+A clean interface to controlling arrays of specialized Brainfuck VMs
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'brainclusterfuck'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install brainclusterfuck
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/brainclusterfuck.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'brainclusterfuck/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "brainclusterfuck"
+  spec.version       = Brainclusterfuck::VERSION
+  spec.authors       = ["Mark Rushakoff"]
+  spec.email         = ["mark.rushakoff@gmail.com"]
+  spec.description   = %q{Provides a clean interface to arrays of Brainfuck VMs, primarily to use for asynchronous processing.}
+  spec.summary       = %q{Clean API to arrays of Brainfuck VMs}
+  spec.homepage      = "http://github.com/mark-rushakoff/brainclusterfuck"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.13"
+end

data/lib/brainclusterfuck/cells.rb

@@ -0,0 +1,9 @@
+module Brainclusterfuck
+  class Cells
+    attr_reader :size
+
+    def initialize(size)
+      @size = size.to_i
+    end
+  end
+end

data/lib/brainclusterfuck/compiler.rb

@@ -0,0 +1,66 @@
+require 'brainclusterfuck/opcode/modify_value'
+require 'brainclusterfuck/opcode/modify_pointer'
+
+module Brainclusterfuck
+  class Compiler
+    attr_reader :bytecode
+    def initialize(tokens)
+      raise "No tokens supplied" if tokens.size == 0
+
+      @bytecode = tokens.map do |token|
+        process_token(token)
+      end
+    end
+
+    # Merge consecutive modify value or modify pointer operations
+    def squeeze_operations!
+      compressed = [@bytecode.shift]
+
+      @bytecode.each do |opcode|
+        last = compressed[-1]
+        if opcode.can_squeeze_with?(last)
+          compressed[-1] = opcode.squeeze_with(last)
+        else
+          compressed << opcode
+        end
+      end
+
+      @bytecode = compressed
+    end
+
+    private
+    def process_token(token)
+      case token
+      when :v_incr
+        Opcode::ModifyValue.new(1, 1)
+      when :v_decr
+        Opcode::ModifyValue.new(-1, 1)
+      when :p_incr
+        Opcode::ModifyPointer.new(1, 1)
+      when :p_decr
+        Opcode::ModifyPointer.new(-1, 1)
+      when :print
+        Opcode::Print.new
+      else
+        raise "Don't know how to handle token: #{token}"
+      end
+    end
+
+    def compress_bytecode(bytecode)
+      compressed = [bytecode.shift]
+
+      bytecode.each do |op, value|
+        case op
+        when :modify_value, :modify_pointer
+          if compressed[-1][0] == op
+            compressed[-1][1] += value
+          else
+            compressed << [op, value]
+          end
+        end
+      end
+
+      compressed
+    end
+  end
+end

data/lib/brainclusterfuck/lexer.rb

@@ -0,0 +1,38 @@
+module Brainclusterfuck
+  class Lexer
+    attr_reader :instruction_chars, :tokens
+
+    def initialize(instruction_string)
+      @instruction_chars = sanitize(instruction_string).split('').freeze
+      @tokens = tokenize(@instruction_chars)
+    end
+
+    private
+    def sanitize(string)
+      string.gsub(/[^\[\]+\-><\.]/, '')
+    end
+
+    def tokenize(instruction_chars)
+      instruction_chars.map do |c|
+        case c
+        when '+'
+          :v_incr
+        when '-'
+          :v_decr
+        when '>'
+          :p_incr
+        when '<'
+          :p_decr
+        when '.'
+          :print
+        when '['
+          :loop
+        when ']'
+          :end_loop
+        else
+          raise 'wtf?'
+        end
+      end
+    end
+  end
+end

data/lib/brainclusterfuck/opcode/modify_pointer.rb

@@ -0,0 +1,27 @@
+module Brainclusterfuck
+  class Opcode
+    class ModifyPointer < Opcode
+      attr_reader :modify_by
+
+      def initialize(modify_by, cycles)
+        @modify_by = modify_by.to_i
+        @cycles = cycles.to_i
+      end
+
+      def ==(other)
+        other.is_a?(ModifyPointer) &&
+          other.modify_by == modify_by &&
+          other.cycles == cycles
+      end
+
+      def can_squeeze_with?(other)
+        other.is_a?(ModifyPointer)
+      end
+
+      def squeeze_with(other)
+        raise "Cannot squeeze: #{self}, #{other}" unless can_squeeze_with?(other)
+        ModifyPointer.new(modify_by + other.modify_by, cycles + other.cycles)
+      end
+    end
+  end
+end

data/lib/brainclusterfuck/opcode/modify_value.rb

@@ -0,0 +1,27 @@
+module Brainclusterfuck
+  class Opcode
+    class ModifyValue < Opcode
+      attr_reader :modify_by
+
+      def initialize(modify_by, cycles)
+        @modify_by = modify_by.to_i
+        @cycles = cycles.to_i
+      end
+
+      def ==(other)
+        other.is_a?(ModifyValue) &&
+          other.modify_by == modify_by &&
+          other.cycles == cycles
+      end
+
+      def can_squeeze_with?(other)
+        other.is_a?(ModifyValue)
+      end
+
+      def squeeze_with(other)
+        raise "Cannot squeeze: #{self}, #{other}" unless can_squeeze_with?(other)
+        ModifyValue.new(modify_by + other.modify_by, cycles + other.cycles)
+      end
+    end
+  end
+end

data/lib/brainclusterfuck/opcode/print.rb

@@ -0,0 +1,13 @@
+module Brainclusterfuck
+  class Opcode
+    class Print < Opcode
+      def initialize
+        @cycles = 1
+      end
+
+      def ==(other)
+        other.is_a?(Print)
+      end
+    end
+  end
+end

data/lib/brainclusterfuck/opcode.rb

@@ -0,0 +1,11 @@
+require 'brainclusterfuck/opcode/modify_value'
+
+module Brainclusterfuck
+  class Opcode
+    attr_reader :cycles
+
+    def can_squeeze_with?(other)
+      false
+    end
+  end
+end

data/lib/brainclusterfuck/terminal.rb

@@ -0,0 +1,9 @@
+module Brainclusterfuck
+  class Terminal
+    attr_reader :text
+
+    def initialize
+      @text = ''
+    end
+  end
+end

data/lib/brainclusterfuck/version.rb

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

data/lib/brainclusterfuck/vm.rb

@@ -0,0 +1,11 @@
+module Brainclusterfuck
+  class VM
+    attr_reader :instructions, :cells, :terminal
+
+    def initialize(opts)
+      @instructions = opts.fetch(:instructions)
+      @cells = opts.fetch(:cells)
+      @terminal = opts.fetch(:terminal)
+    end
+  end
+end

data/lib/brainclusterfuck.rb

@@ -0,0 +1,5 @@
+require "brainclusterfuck/version"
+
+module Brainclusterfuck
+  # Your code goes here...
+end

data/spec/cells_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'brainclusterfuck/cells'
+
+describe Brainclusterfuck::Cells do
+  it 'initializes with a size' do
+    expect(Brainclusterfuck::Cells.new(5).size).to eq(5)
+  end
+end

data/spec/compiler_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'brainclusterfuck/compiler'
+require 'brainclusterfuck/opcode'
+
+describe Brainclusterfuck::Compiler do
+  it 'raises if there are no tokens' do
+    expect { Brainclusterfuck::Compiler.new([]) }.to raise_error
+  end
+
+  it 'converts tokens to the correct operations' do
+    compiler = Brainclusterfuck::Compiler.new([:v_incr, :p_incr, :v_decr, :p_decr])
+    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)
+    ])
+  end
+
+  describe '#squeeze_operations' do
+    it 'compresses the 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)
+      ])
+    end
+
+    it 'correctly retains cycles' do
+      tokens = (Array.new(3) { :v_incr }).
+        concat([:v_decr]).
+        concat(Array.new(6) { :p_decr }).
+        concat(Array.new(2) { :p_incr })
+
+      compiler = Brainclusterfuck::Compiler.new(tokens)
+      compiler.squeeze_operations!
+
+      expect(compiler.bytecode).to eq([
+        Brainclusterfuck::Opcode::ModifyValue.new(2, 4),
+        Brainclusterfuck::Opcode::ModifyPointer.new(-4, 8)
+      ])
+    end
+
+    it 'does not squeeze prints' do
+      compiler = Brainclusterfuck::Compiler.new(Array.new(3) { :print })
+      compiler.squeeze_operations!
+
+      expect(compiler.bytecode).to eq([
+        Brainclusterfuck::Opcode::Print.new,
+        Brainclusterfuck::Opcode::Print.new,
+        Brainclusterfuck::Opcode::Print.new
+      ])
+    end
+  end
+end

data/spec/lexer_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'brainclusterfuck/lexer'
+require 'set'
+
+describe Brainclusterfuck::Lexer do
+  describe '#instruction_chars' do
+    it 'strips out everything except the valid brainfuck instructions and keeps the order' do
+      all_ascii_chars = (0..255).map { |n| n.chr }.join('')
+
+      lexer = Brainclusterfuck::Lexer.new(all_ascii_chars)
+
+      ordered_valid_chars = %w([ ] + - > < .).sort_by { |c| c.ord }
+      expect(lexer.instruction_chars).to eq(ordered_valid_chars)
+    end
+  end
+
+  describe '#tokens' do
+    it 'tokenizes the input correctly' do
+      # and doesn't validate the input
+      lexer = Brainclusterfuck::Lexer.new('+>][<-.')
+      expect(lexer.tokens).to eq([
+        :v_incr,
+        :p_incr,
+        :end_loop,
+        :loop,
+        :p_decr,
+        :v_decr,
+        :print
+      ])
+    end
+  end
+end

data/spec/opcode/modify_pointer_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'brainclusterfuck/opcode/modify_pointer'
+
+describe Brainclusterfuck::Opcode::ModifyPointer do
+  it 'stores the modify by and cycle count' do
+    op = described_class.new(5, 8)
+
+    expect(op.modify_by).to eq(5)
+    expect(op.cycles).to eq(8)
+  end
+
+  it 'has correct equality behavior' do
+    expect(described_class.new(1, 2)).to eq(described_class.new(1, 2))
+    expect(described_class.new(1, 2)).not_to eq(described_class.new(1, 3))
+  end
+
+  describe 'squeezing' do
+    it 'can squeeze with another ModifyPointer' do
+      op1 = described_class.new(1, 1)
+      op2 = described_class.new(1, 1)
+
+      expect(op1.can_squeeze_with?(op2)).to eq(true)
+      expect(op1.squeeze_with(op2)).to eq(described_class.new(2, 2))
+    end
+
+    it 'cannot squeeze with a generic opcode' do
+      op = described_class.new(1, 1)
+      expect(op.can_squeeze_with?(Brainclusterfuck::Opcode.new)).to eq(false)
+    end
+
+    it 'raises if trying to squeeze with an incompatible object' do
+      op = described_class.new(1, 1)
+
+      expect { op.squeeze_with(Brainclusterfuck::Opcode.new) }.to raise_error
+    end
+  end
+end

data/spec/opcode/modify_value_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'brainclusterfuck/opcode/modify_value'
+
+describe Brainclusterfuck::Opcode::ModifyValue do
+  it 'stores the modify by and cycle count' do
+    op = described_class.new(5, 8)
+
+    expect(op.modify_by).to eq(5)
+    expect(op.cycles).to eq(8)
+  end
+
+  it 'has correct equality behavior' do
+    expect(described_class.new(1, 2)).to eq(described_class.new(1, 2))
+    expect(described_class.new(1, 2)).not_to eq(described_class.new(1, 3))
+  end
+
+  describe 'squeezing' do
+    it 'can squeeze with another ModifyValue' do
+      op1 = described_class.new(1, 1)
+      op2 = described_class.new(1, 1)
+
+      expect(op1.can_squeeze_with?(op2)).to eq(true)
+      expect(op1.squeeze_with(op2)).to eq(described_class.new(2, 2))
+    end
+
+    it 'cannot squeeze with a generic opcode' do
+      op = described_class.new(1, 1)
+      expect(op.can_squeeze_with?(Brainclusterfuck::Opcode.new)).to eq(false)
+    end
+
+    it 'raises if trying to squeeze with an incompatible object' do
+      op = described_class.new(1, 1)
+
+      expect { op.squeeze_with(Brainclusterfuck::Opcode.new) }.to raise_error
+    end
+  end
+end

data/spec/opcode/print_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'brainclusterfuck/opcode/print'
+
+describe Brainclusterfuck::Opcode::Print do
+  it 'has 1 cycle' do
+    expect(described_class.new.cycles).to eq(1)
+  end
+
+  it 'has correct equality behavior' do
+    expect(described_class.new).to eq(described_class.new)
+    expect(described_class.new).not_to eq(Brainclusterfuck::Opcode.new)
+  end
+end

data/spec/opcode_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'brainclusterfuck/opcode'
+
+describe Brainclusterfuck::Opcode do
+  describe '#can_squeeze_with?' do
+    it 'is false' do
+      expect(described_class.new.can_squeeze_with?(described_class.new)).to eq(false)
+    end
+  end
+end

data/spec/should_not_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'brainclusterfuck'
+
+describe Brainclusterfuck do
+  it 'has a version number' do
+   expect(Brainclusterfuck::VERSION).not_to be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/terminal_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'brainclusterfuck/terminal'
+
+describe Brainclusterfuck::Terminal do
+  it 'starts with empty text' do
+    expect(Brainclusterfuck::Terminal.new.text).to eq('')
+  end
+end

data/spec/vm_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'brainclusterfuck/vm'
+
+describe Brainclusterfuck::VM do
+  let(:instructions) { double(:instructions) }
+  let(:cells) { double(:cells) }
+  let(:terminal) { double(:terminal) }
+
+  let(:vm) do
+    Brainclusterfuck::VM.new(
+      instructions: instructions,
+      cells: cells,
+      terminal: terminal
+    )
+  end
+
+  it 'correctly reads from its option hash' do
+    expect(vm.instructions).to eq(instructions)
+    expect(vm.cells).to eq(cells)
+    expect(vm.terminal).to eq(terminal)
+  end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: brainclusterfuck
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mark Rushakoff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+description: Provides a clean interface to arrays of Brainfuck VMs, primarily to use
+  for asynchronous processing.
+email:
+- mark.rushakoff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.mit
+- README.md
+- Rakefile
+- brainclusterfuck.gemspec
+- lib/brainclusterfuck.rb
+- lib/brainclusterfuck/cells.rb
+- lib/brainclusterfuck/compiler.rb
+- lib/brainclusterfuck/lexer.rb
+- lib/brainclusterfuck/opcode.rb
+- lib/brainclusterfuck/opcode/modify_pointer.rb
+- lib/brainclusterfuck/opcode/modify_value.rb
+- lib/brainclusterfuck/opcode/print.rb
+- lib/brainclusterfuck/terminal.rb
+- lib/brainclusterfuck/version.rb
+- lib/brainclusterfuck/vm.rb
+- spec/cells_spec.rb
+- spec/compiler_spec.rb
+- spec/lexer_spec.rb
+- spec/opcode/modify_pointer_spec.rb
+- spec/opcode/modify_value_spec.rb
+- spec/opcode/print_spec.rb
+- spec/opcode_spec.rb
+- spec/should_not_spec.rb
+- spec/spec_helper.rb
+- spec/terminal_spec.rb
+- spec/vm_spec.rb
+homepage: http://github.com/mark-rushakoff/brainclusterfuck
+licenses:
+- MIT
+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.25
+signing_key: 
+specification_version: 3
+summary: Clean API to arrays of Brainfuck VMs
+test_files:
+- spec/cells_spec.rb
+- spec/compiler_spec.rb
+- spec/lexer_spec.rb
+- spec/opcode/modify_pointer_spec.rb
+- spec/opcode/modify_value_spec.rb
+- spec/opcode/print_spec.rb
+- spec/opcode_spec.rb
+- spec/should_not_spec.rb
+- spec/spec_helper.rb
+- spec/terminal_spec.rb
+- spec/vm_spec.rb