rpxem 0.0.4 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2bacef5ec429991e8efb5c8c66dcf611a8f5c131126e966a4011d9812bf06393
+  data.tar.gz: 5dd82593827ad40ed9116f46cb415a262ab75db652ddb9b1f04d11e8cd61a3a5
+SHA512:
+  metadata.gz: 71d11f62f35da4261e0bdc744a12a599150902f5f093ace19d891a59c7998d98cf050e24bf06989f5453c6bc20aa2c26613a3019dc4882f30781d99af40a43dc
+  data.tar.gz: 2915e99940dd7cbf8300854722c43cb4554278c511540c052ac01f76916e4a032f71fad5b0b7ce0dae0be7983dcc19e78f23310e8044e0f5e3c286d0ab7e6c77

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+cache:
+  directories: vendor/bundle
+before_install:
+  - gem update --system
+  - gem --version

data/README.md

@@ -1,10 +1,11 @@
 # RPxem
 
-[![Build Status](https://travis-ci.org/wktk/rpxem.png)](https://travis-ci.org/wktk/rpxem)
+[![Build Status](https://travis-ci.org/wktk/rpxem.svg?branch=master)](https://travis-ci.org/wktk/rpxem)
 
 RPxem is a Ruby implementation of [Pxem], an esoteric programming language that
 enables you to create programs in 0-byte files.
-[Pxem]: http://cfs.maxn.jp/neta/pxem.php
+
+[Pxem]: https://web.archive.org/web/20120605223423/http://cfs.maxn.jp/neta/pxem.php
 
 ## Installation
 
@@ -73,3 +74,8 @@ Hello, world!
 
 Copyright (c) 2012 wktk.  This software is distributed under the
 MIT License.  See `MIT-LICENSE.txt` for details.
+
+## See also
+
+- Original resource: https://web.archive.org/web/20120605223423/http://cfs.maxn.jp/neta/pxem.php
+- Esolang wiki: https://esolangs.org/wiki/Pxem

data/Rakefile

@@ -1,12 +1,6 @@
-#!/usr/bin/env rake
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-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
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/rpxem

@@ -1,14 +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/wktk/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
+#!/usr/bin/env ruby
+
+if (!ARGV[0] || /^-/ =~ ARGV[0] && !File.exist?(ARGV[0]))
+  require 'rpxem/version'
+  puts "RPxem (#{RPxem::VERSION}) https://github.com/wktk/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

@@ -1,232 +1,233 @@
-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
+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
+      stdin = STDIN.getc
+      @stack.push(stdin ? stdin.ord : -1)
+    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

@@ -1,49 +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|
-        if (!arg.is_a? Integer)
-          raise ArgumentError.new 'Argument must be Integer'
-        elsif (arg != arg.abs)
-          raise ArgumentError.new 'Argument must be positive'
-        end
-      end
-    end
-  end
-end
+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|
+        if (!arg.is_a? Integer)
+          raise ArgumentError.new 'Argument must be Integer'
+        end
+      end
+    end
+  end
+end

data/lib/rpxem/version.rb

@@ -1,3 +1,3 @@
 module RPxem
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'.freeze
 end

data/lib/rpxem.rb

@@ -1,20 +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
+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

@@ -2,20 +2,23 @@
 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, an esoteric programming language that enables you to create programs in 0-byte files.}
+  gem.name          = 'rpxem'
+  gem.version       = RPxem::VERSION
+  gem.authors       = ['k.wakitani']
+  gem.email         = ['k.wakitani@gmail.com']
+
   gem.summary       = %q{Pxem implementation in Ruby}
+  gem.description   = %q{RPxem is a Ruby implementation of Pxem, an esoteric programming language that enables you to create programs in 0-byte files.}
   gem.homepage      = 'https://github.com/wktk/rpxem'
+  gem.license       = 'MIT'
 
   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'
+  gem.add_development_dependency 'bundler', '~> 1.16'
+  gem.add_development_dependency 'rspec', '~> 3.8'
+  gem.add_development_dependency 'rake', '~> 10.0'
+  gem.add_development_dependency 'rdoc', '~> 6.0'
 end

data/spec/rpxem_helper.rb

@@ -1,13 +1,13 @@
-require 'rpxem'
-require 'rspec'
-require 'stringio'
-
-def capture
-  begin
-    $stdout = result = StringIO.new
-    yield
-  ensure
-    $stdout = STDOUT
-  end
-  result.string
-end
+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

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

metadata

@@ -1,74 +1,82 @@
 --- !ruby/object:Gem::Specification
 name: rpxem
 version: !ruby/object:Gem::Version
-  version: 0.0.4
-  prerelease: 
+  version: 0.0.5
 platform: ruby
 authors:
-- wktk
+- k.wakitani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-08 00:00:00.000000000 Z
+date: 2018-09-15 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.8'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
 description: RPxem is a Ruby implementation of Pxem, an esoteric programming language
   that enables you to create programs in 0-byte files.
 email:
-- wktk@wktk.in
+- k.wakitani@gmail.com
 executables:
 - rpxem
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - MIT-LICENSE.txt
 - README.md
@@ -83,28 +91,28 @@ files:
 - spec/rpxem_spec.rb
 - spec/world!.fHello,.pxe
 homepage: https://github.com/wktk/rpxem
-licenses: []
+licenses:
+- MIT
+metadata: {}
 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
+rubygems_version: 2.7.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Pxem implementation in Ruby
 test_files:
 - spec/rpxem_helper.rb