rpxem 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+TODO.txt
+_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 rpxem.gemspec
+gemspec

data/MIT-LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 wktk
+
+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,61 @@
+# RPxem
+
+[![Build Status](https://travis-ci.org/wktk/rpxem.png)](https://travis-ci.org/wktk/rpxem)
+
+RPxem is a Ruby implementation of [Pxem], a esoteric programming language that
+enables you to create programs in 0-byte files.
+[Pxem]: http://cfs.maxn.jp/neta/pxem.php
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rpxem'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rpxem
+
+## Usage
+
+### Using in Ruby
+
+Require `RPxem`:
+
+    require 'rpxem'
+
+Open and execute your Pxem **file**:
+
+    path_to_pxem_file = '~/Hello, world!.pxe'
+    RPxem.open(path_to_pxem_file) #=> Hello, world!
+
+Execute your Pxem **code**:
+
+    file_name = 'world!.fHello,.pxe'
+    file_cont = ' Pxem '
+    RPxem.run(file_name, file_cont) #=> Hello, Pxem world!
+
+### Using from CLI
+
+This program also runs as a command-line Pxem interpreter called `rpxem`:
+
+    $ touch "Hello, world!.pxe"
+    $ rpxem "Hello, world!.pxe"
+    Hello, world!
+
+## 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 wktk.  This software is distributed under the
+MIT License.  See `MIT-LICENSE.txt` for details.

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+task :default => [:spec]
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.rspec_opts = ['-cfs']
+  end
+rescue LoadError => e
+end

data/bin/rpxem

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+if (!ARGV[0] || /^-/ =~ ARGV[0] && !File.exist?(ARGV[0]))
+  require 'rpxem/version'
+  puts "RPxem (#{RPxem::VERSION}) https://github.com/wtkt/rpxem"
+  puts 'Usage: rpxem path-to-pxem-file.pxe'
+  puts 'Report bugs to <https://github.com/wktk/rpxem/issues>.'
+elsif (!File.exist?(ARGV[0]) || !source = open(ARGV[0]).read)
+  puts "Can't load file: #{ARGV[0]}"
+  puts "Try `rpxem --help' for more infomation."
+else
+  require 'rpxem'
+  RPxem.run(File::basename(ARGV[0]), source)
+end

data/lib/rpxem/interpreter.rb

@@ -0,0 +1,232 @@
+require 'rpxem/stack'
+require 'rpxem/version'
+require 'scanf'
+
+module RPxem
+  class Interpreter
+    attr_accessor :mapping
+    attr_reader   :stack, :temp
+
+    def initialize(mapping={})
+      @mapping = default_mapping().merge(mapping)
+    end
+
+    # Open and execute a Pxem file
+    def open(file, stack=RPxem::Stack.new, temp=nil)
+      run(File.basename(file), File.open(file).read, stack, temp)
+    end
+
+    # Execute a Pxem code
+    def run(filename, source='', stack=RPxem::Stack.new, temp=nil)
+      @filename, @source, @stack, @temp = filename.each_byte.to_a, source, stack, temp
+      buffer, @cursor, length = RPxem::Stack.new, 0, @filename.length
+
+      while (@cursor < length)
+        char = @filename[@cursor]
+        @cursor += 1
+        if (@cursor < length && 46 == char && name = @mapping[@filename[@cursor].chr.downcase])
+          @stack.push(*buffer)
+          buffer = RPxem::Stack.new
+          __send__(name)
+          @cursor += 1
+        else
+          buffer.unshift(char)
+        end
+      end
+
+      return @stack
+    end
+
+    def default_mapping
+      {
+        # I/O
+        'p' => 'output_all',
+        'o' => 'output',
+        'n' => 'output_num',
+        'i' => 'input',
+        '_' => 'input_num',
+
+        # Stack
+        'c' => 'copy',
+        's' => 'throw_away',
+        'v' => 'reverse',
+
+        # File contents
+        'f' => 'read_file',
+        'e' => 'emurate',
+
+        # Rand
+        'r' => 'rand',
+
+        # Loop
+        'w' => 'w',
+        'x' => 'x',
+        'y' => 'y',
+        'z' => 'z',
+        'a' => 'a',
+
+        # Temporary area
+        't' => 'to_temp',
+        'm' => 'from_temp',
+
+        # Do nothing
+        'd' => 'void',
+
+        # Math
+        '+' => 'addition',
+        '-' => 'subtraction',
+        '!' => 'multiplication',
+        '$' => 'quotient',
+        '%' => 'surplus',
+      }
+    end
+
+  private
+
+    # .p:
+    def output_all
+      while output; end
+    end
+
+    # .o:
+    def output
+      putc @stack.pop unless @stack.empty?
+    end
+
+    # .n:
+    def output_num
+      print @stack.pop
+    end
+
+    # .i:
+    def input
+      @stack.push(*STDIN.getc.ord)
+    end
+
+    # ._:
+    def input_num
+      @stack.push(*scanf('%d'))
+    end
+
+    # .c:
+    def copy
+      @stack.push(@stack.last)
+    end
+
+    # .s:
+    def throw_away
+      @stack.pop
+    end
+
+    # .v:
+    def reverse
+      @stack.reverse!
+    end
+
+    # .f:
+    def read_file
+      @stack.push(*@source.each_byte.to_a.reverse)
+    end
+
+    # .e:
+    def emurate
+      @stack.push(*clone.run(@source, @source, @stack.clone))
+    end
+
+    # .r:
+    def rand
+      @stack.push((super * @stack.pop).to_i)
+    end
+
+    # .w:
+    def w
+      jump if (!@stack.empty? && 0 == @stack.pop)
+    end
+
+    # .x:
+    def x
+      jump if (2 <= @stack.size && @stack.pop >= @stack.pop)
+    end
+
+    # .y:
+    def y
+      jump if (2 <= @stack.size && @stack.pop <= @stack.pop)
+    end
+
+    # .z:
+    def z
+      jump if (2 <= @stack.size && @stack.pop == @stack.pop)
+    end
+
+    # Jump forward to correspondent .a
+    def jump
+      count = 1
+      while (count.nonzero?)
+        @cursor += 1
+        if (46 == @filename[@cursor])
+          if (['w','x','y','z'].include? @filename[@cursor+1].chr.downcase)
+            count += 1
+          elsif ('a' == @filename[@cursor+1].chr.downcase)
+            count -= 1
+  				end
+        end
+      end
+      @cursor += 1
+    end
+
+    # .a:
+    def a
+      @cursor -= 2
+      count = -1
+      while (count.nonzero?)
+        if (46 == @filename[@cursor])
+          if (['w','x','y','z'].include? @filename[@cursor+1].chr.downcase)
+            count += 1
+          elsif ('a' == @filename[@cursor+1].chr.downcase)
+            count -= 1
+  				end
+        end
+        @cursor -= 1
+      end
+    end
+
+    # .t:
+    def to_temp
+      @temp = @stack.pop
+    end
+
+    # .m:
+    def from_temp
+      @stack.push(@temp) if @temp
+    end
+
+    # .d:
+    def void
+    end
+
+    # .+:
+    def addition
+      @stack.push(@stack.pop + @stack.pop) if 2 <= @stack.size
+    end
+
+    # .-: 
+    def subtraction
+      @stack.push((@stack.pop - @stack.pop).abs) if 2 <= @stack.size
+    end
+
+    # .!:
+    def multiplication
+      @stack.push(@stack.pop * @stack.pop) if 2 <= @stack.size
+    end
+
+    # .$:
+    def quotient
+      @stack.push((f=@stack.pop)>(s=@stack.pop)? f/s : s/f) if 2 <= @stack.size
+    end
+
+    # .%:
+    def surplus
+      @stack.push((f=@stack.pop)>(s=@stack.pop)? f%s : s%f) if 2 <= @stack.size
+    end
+  end
+end

data/lib/rpxem/stack.rb

@@ -0,0 +1,47 @@
+module RPxem
+  class Stack < Array
+    def initialize(*args, &block)
+      super(*args, &block)
+      simple_check(*self)
+    end
+
+    def push(*args, &block)
+      simple_check(*args)
+      super(*args, &block)
+    end
+
+    def unshift(*args, &block)
+      simple_check(*args)
+      super(*args, &block)
+    end
+
+    def <<(*args, &block)
+      simple_check(*args)
+      super(*args, &block)
+    end
+
+    def []=(*args, &block)
+      super(*args, &block)
+      simple_check(*self)
+    end
+
+    def insert(*args, &block)
+      super(*args, &block)
+      simple_check(*self)
+    end
+
+    def map!(*args, &block)
+      super(*args, &block)
+      simple_check(*self)
+    end
+
+  private
+    def simple_check(*args)
+      args.each do |arg|
+        raise ArgumentError.new 'Argument must be Fixnum'   if (arg.class != Fixnum)
+        raise ArgumentError.new 'Argument must be positive' if (arg != arg.abs)
+        raise ArgumentError.new 'Argument must be integer'  if (!arg.integer?)
+      end
+    end
+  end
+end

data/lib/rpxem/version.rb

@@ -0,0 +1,3 @@
+module RPxem
+  VERSION = '0.0.1'
+end

data/lib/rpxem.rb

@@ -0,0 +1,20 @@
+require 'rpxem/interpreter'
+require 'rpxem/version'
+
+module RPxem
+  class << self
+    def new(options={})
+      RPxem::Interpreter.new(options)
+    end
+
+  private
+    def method_missing(name, *args, &block)
+      return super unless new.respond_to?(name)
+      new.__send__(name, *args, &block)
+    end
+
+    def respond_to?(name)
+      new.respond_to?(name) || super(name)
+    end
+  end
+end

data/rpxem.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rpxem/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['wktk']
+  gem.email         = ['wktk@wktk.in']
+  gem.description   = %q{RPxem is a Ruby implementation of Pxem, a esoteric programming language that enables you to create programs in 0-byte files.}
+  gem.summary       = %q{Pxem implementation in Ruby}
+  gem.homepage      = 'https://github.com/wktk/rpxem'
+
+  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          = 'rpxem'
+  gem.require_paths = ['lib']
+  gem.version       = RPxem::VERSION
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rdoc'
+end

data/spec/rpxem_helper.rb

@@ -0,0 +1,13 @@
+require 'rpxem'
+require 'rspec'
+require 'stringio'
+
+def capture
+  begin
+    $stdout = result = StringIO.new
+    yield
+  ensure
+    $stdout = STDOUT
+  end
+  result.string
+end

data/spec/rpxem_spec.rb

@@ -0,0 +1,196 @@
+require 'rpxem_helper'
+
+describe RPxem do
+  describe 'delegation' do
+    it 'RPxem.new => RPxem::Interpreter.new' do
+      RPxem.new.class.should == RPxem::Interpreter.new.class
+    end
+
+    it 'RPxem.run => #<RPxem::Interpreter>.run' do
+      RPxem.run('hoge.d').should == RPxem::Interpreter.new.run('hoge.d')
+    end
+  end
+
+  describe RPxem::Stack do
+    before do
+      @stack = RPxem::Stack.new
+    end
+
+    it 'should be Fixnum' do
+      expect{ @stack.push('a') }.to raise_error ArgumentError
+    end
+
+    it 'should be positive' do
+      expect{ @stack.push(-1) }.to raise_error ArgumentError
+    end
+
+    it 'can be zero' do
+      expect{ @stack.push(0) }.not_to raise_error
+    end
+
+    it 'should be integer' do
+      expect{ @stack.unshift(0.1) }.to raise_error ArgumentError
+    end
+
+    it 'can check in #new' do
+      expect{ RPxem::Stack.new([1, 2, 'san']) }.to raise_error ArgumentError
+    end
+  end
+
+  describe RPxem::Interpreter do
+    before do
+      @pxem = RPxem.new
+    end
+
+    describe 'initializing' do
+      it 'can set initial stack' do
+        capture{ @pxem.run('.p', '', RPxem::Stack.new([99, 98, 97])) }.should == 'abc'
+      end
+
+      it 'can open file' do
+        testfile = File.join(File.dirname(__FILE__), 'world!.fHello,.pxe')
+        capture{ @pxem.open(testfile) }.should == 'Hello, Pxem world!'
+      end
+
+      it 'can merge command mapping' do
+        pxem = RPxem.new({'q' => 'output_all', 'c' => 'output_all'})
+        capture{ pxem.run('Hi.q') }.should == 'Hi'
+        capture{ pxem.run('Hi.c') }.should == 'Hi'
+      end
+    end
+
+    describe 'get result' do
+      it 'should return remaining stack' do
+        @pxem.run('Hi.d').should == [105, 72]
+      end
+
+      it 'can read stack' do
+        @pxem.run('a.d')
+        @pxem.stack.should == [97]
+      end
+
+      it 'can read temp area' do
+        @pxem.run('a.t')
+        @pxem.temp.should == 97
+      end
+    end
+
+    describe 'Pxem commands' do
+      describe 'I/O' do
+        it '.p' do
+          capture{ @pxem.run('Hello, world!.p') }.should == 'Hello, world!'
+        end
+
+        it '.o' do
+          capture{ @pxem.run('Hi.o') }.should == 'H'
+        end
+
+        it '.n' do
+          capture{ @pxem.run('Hi.n') }.should == '72'
+        end
+
+        #it '.i' do
+        #end
+
+        #it '._' do
+        #end
+      end
+
+      describe 'Stack' do
+        it '.c' do
+          @pxem.run('Hi.c').should == [105, 72, 72]
+        end
+
+        it '.s' do
+          @pxem.run('Hi.s').should == [105]
+        end
+
+        it '.v' do
+          @pxem.run('Hi.v').should == [72, 105]
+        end
+      end
+
+      describe 'File' do
+        it '.f' do
+          @pxem.run('.f', 'File').should == [101, 108, 105, 70]
+        end
+
+        it '.e' do
+          @pxem.run('.e', 'File.d').should == [101, 108, 105, 70]
+        end
+      end
+
+      describe 'Rand' do
+        it '.r' do
+          @pxem.run('d.r').first.should be_within(100).of(0)
+        end
+      end
+
+      describe 'Loop' do
+        it '.w' do
+          capture{ @pxem.run('a.whoge.paa.-.a') }.should == 'hoge'
+        end
+
+        it '.x' do
+          capture{ @pxem.run('e.xhog.pba.a') }.should == 'hoge'
+        end
+
+        it '.y' do
+          capture{ @pxem.run('e.yhog.pab.a') }.should == 'hoge'
+        end
+
+        it '.z' do
+          capture{ @pxem.run('e.zhog.paa.a') }.should == 'hoge'
+        end
+
+        it '.a' do
+          capture{ @pxem.run('e.zhog.pe.zhog.paa.aaa.a') } == 'hogehoge'
+        end
+      end
+
+      describe 'Temporary area' do
+        it '.t' do
+          @pxem.run('a.t')
+          @pxem.temp.should == 97
+        end
+
+        it '.m' do
+          @pxem.run('a.t.m.m').should == [97, 97]
+        end
+      end
+
+      describe '.d' do
+        it '.d' do
+          @pxem.run('Hi.d').should == [105, 72]
+        end
+      end
+
+      describe 'Math' do
+        it '.+' do
+          @pxem.run('ab.+').should == [98 + 97]
+          @pxem.run('ba.+').should == [98 + 97]
+        end
+
+        it '.-' do
+          @pxem.run('ab.-').should == [98 - 97]
+          @pxem.run('ba.-').should == [98 - 97]
+        end
+
+        it '.!' do
+          @pxem.run('ab.!').should == [98 * 97]
+          @pxem.run('ba.!').should == [98 * 97]
+        end
+
+        it '.$' do
+          @pxem.run('ab.$').should == [98 / 97]
+          @pxem.run('ba.$').should == [98 / 97]
+        end
+
+        it '.%' do
+          @pxem.run('ab.%').should == [98 % 97]
+          @pxem.run('ba.%').should == [98 % 97]
+        end
+      end
+    end
+  end
+end

data/spec/world!.fHello,.pxe

@@ -0,0 +1 @@
+ Pxem 

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: rpxem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- wktk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-03 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: 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: rdoc
+  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'
+description: RPxem is a Ruby implementation of Pxem, a esoteric programming language
+  that enables you to create programs in 0-byte files.
+email:
+- wktk@wktk.in
+executables:
+- rpxem
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE.txt
+- README.md
+- Rakefile
+- bin/rpxem
+- lib/rpxem.rb
+- lib/rpxem/interpreter.rb
+- lib/rpxem/stack.rb
+- lib/rpxem/version.rb
+- rpxem.gemspec
+- spec/rpxem_helper.rb
+- spec/rpxem_spec.rb
+- spec/world!.fHello,.pxe
+homepage: https://github.com/wktk/rpxem
+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.23
+signing_key: 
+specification_version: 3
+summary: Pxem implementation in Ruby
+test_files:
+- spec/rpxem_helper.rb
+- spec/rpxem_spec.rb
+- spec/world!.fHello,.pxe