raheui 1.0.0

data/lib/raheui/runner.rb

@@ -0,0 +1,212 @@
+# encoding: utf-8
+module Raheui
+  # Run Aheui code.
+  class Runner
+    # Point class for execution cursor position and delta of it.
+    Point = Struct.new(:x, :y)
+
+    # Numbers of required elements for each command.
+    REQUIRED_STORE_SIZE = [
+      0, 0, 2, 2, 2, 2, 1, 0, 1, 0, # ㄱ ㄲ ㄴ ㄷ ㄸ ㄹ ㅁ ㅂ ㅃ ㅅ
+      1, 0, 2, 0, 1, 0, 2, 2, 0     # ㅆ ㅇ ㅈ ㅉ ㅊ ㅋ ㅌ ㅍ ㅎ
+    ]
+
+    # Delta values of each medial consonant.
+    MEDIAL_DELTAS = [
+      [1, 0], nil, [2, 0], nil,        # ㅏ ㅐ ㅑ ㅒ
+      [-1, 0], nil, [-2, 0], nil,      # ㅓ ㅔ ㅕ ㅖ
+      [0, -1], nil, nil, nil, [0, -2], # ㅗ ㅘ ㅙ ㅚ ㅛ
+      [0, 1], nil, nil, nil, [0, 2],   # ㅜ ㅝ ㅞ ㅟ ㅠ
+      [:+, :-], [:-, :-], [:-, :+]     # ㅡ ㅢ ㅣ
+    ]
+
+    # Numbers of strokes of each final consonant.
+    FINAL_STROKES = [
+      0,                            # No final consonant.
+      2, 4, 4, 2, 5, 5, 3, 5, 7, 9, # ㄱ ㄲ ㄳ ㄴ ㄵ ㄶ ㄷ ㄹ ㄺ ㄻ
+      9, 7, 9, 9, 8, 4, 4, 6, 2, 4, # ㄼ ㄽ ㄾ ㄿ ㅀ ㅁ ㅂ ㅄ ㅅ ㅆ
+      1, 3, 4, 3, 4, 4, 3           # ㅇ ㅈ ㅊ ㅋ ㅌ ㅍ ㅎ
+    ]
+
+    private_constant :REQUIRED_STORE_SIZE, :MEDIAL_DELTAS, :FINAL_STROKES
+
+    # Initialize a Runner. Get a Code instance and initialize Stores.
+    #
+    # code - The Code instance to execute.
+    def initialize(code)
+      @code = code
+    end
+
+    # Run the Aheui Code.
+    #
+    # Returns the Integer exit code.
+    def run
+      reset
+      step until @finished
+      @selected_store.pop || 0
+    end
+
+    private
+
+    # Reset cursor and Stores. Select first Store.
+    #
+    # Returns nothing.
+    def reset
+      @cursor = Point.new(0, 0)
+      @delta = Point.new(0, 1)
+      @stores = Code::FINAL_CONSONANTS.times.map do |consonant|
+        case consonant
+        when 21 then Queue.new # ㅇ
+        when 27 then Port.new  # ㅎ
+        else         Stack.new
+        end
+      end
+      @selected_store = @stores[0]
+      @finished = false
+    end
+
+    # Process current character which cursor points to and move cursor.
+    #
+    # Returns nothing.
+    def step
+      consonants = @code[@cursor.x, @cursor.y]
+      unless consonants.empty?
+        initial, medial, final = consonants
+        @delta.x, @delta.y = delta(medial)
+        if @selected_store.size < REQUIRED_STORE_SIZE[initial]
+          @delta.x, @delta.y = -@delta.x, -@delta.y
+        else
+          process(initial, final)
+        end
+      end
+      move
+    end
+
+    # Process a Korean alphabet.
+    #
+    # initial - An Integer index of initial consonant of the Korean alphabet.
+    # final   - An Integer index of final consonant of the Korean alphabet.
+    #
+    # Returns nothing.
+    def process(initial, final)
+      case initial
+      when 2 # ㄴ
+        operate(:/)
+      when 3 # ㄷ
+        operate(:+)
+      when 4 # ㄸ
+        operate(:*)
+      when 5 # ㄹ
+        operate(:%)
+      when 6 # ㅁ
+        op = @selected_store.pop
+        if final == 21 # ㅇ
+          IO.print_int(op)
+        elsif final == 27 # ㅎ
+          IO.print_chr(op)
+        end
+      when 7 # ㅂ
+        op = if final == 21 # ㅇ
+               IO.read_int
+             elsif final == 27 # ㅎ
+               IO.read_chr
+             else
+               FINAL_STROKES[final]
+             end
+        @selected_store.push(op)
+      when 8 # ㅃ
+        @selected_store.push_dup
+      when 9 # ㅅ
+        @selected_store = @stores[final]
+      when 10 # ㅆ
+        op = @selected_store.pop
+        @stores[final].push(op)
+      when 12 # ㅈ
+        op1 = @selected_store.pop
+        op2 = @selected_store.pop
+        @selected_store.push(op2 >= op1 ? 1 : 0)
+      when 14 # ㅊ
+        op = @selected_store.pop
+        @delta.x, @delta.y = -@delta.x, -@delta.y if op == 0
+      when 16 # ㅌ
+        operate(:-)
+      when 17 # ㅍ
+        @selected_store.swap
+      when 18 # ㅎ
+        @finished = true
+      end
+    end
+
+    # Helper method for basic operators. +, -, *, / and % can be processed.
+    #
+    # method - A Symbol method to execute.
+    #
+    # Examples
+    #
+    #   operate(:+)
+    #
+    #   operate(:-)
+    #
+    #   operate(:*)
+    #
+    #   operate(:/)
+    #
+    #   operate(:%)
+    #
+    # Returns nothing.
+    def operate(method)
+      op1 = @selected_store.pop
+      op2 = @selected_store.pop
+      @selected_store.push([op2, op1].reduce(method))
+    end
+
+    # Get delta x and y position for next move.
+    #
+    # medial - An Integer index of medial consonant of the Korean alphabet.
+    #
+    # Examples
+    #
+    #   delta(0)
+    #   # => [1, 0]
+    #
+    # Returns an Array of Integer delta x and y position.
+    def delta(medial)
+      delta = MEDIAL_DELTAS[medial]
+      if delta
+        x, y = delta
+        x = x == :+ ? @delta.x : -@delta.x if x.is_a? Symbol
+        y = y == :+ ? @delta.y : -@delta.y if y.is_a? Symbol
+        [x, y]
+      else
+        [@delta.x, @delta.y]
+      end
+    end
+
+    # Move cursor to proper position. Wrap the position if it goes to outside of
+    # the code.
+    #
+    # Returns nothing.
+    def move
+      @cursor.x = wrap(@cursor.x + @delta.x, @code.width)
+      @cursor.y = wrap(@cursor.y + @delta.y, @code.height)
+    end
+
+    # Wrap a number to be between 0 and max value excluding max value. If the
+    # number is negative, it goes to max - 1. If the number is bigger than or
+    # equal to max value, it goes to zero.
+    #
+    # num - An Integer to be wrapped.
+    # max - An Integer max value.
+    #
+    # Returns an Integer between 0 and max - 1.
+    def wrap(num, max)
+      if num < 0
+        max - 1
+      elsif num >= max
+        0
+      else
+        num
+      end
+    end
+  end
+end

data/lib/raheui/stack.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Raheui
+  # Stack class for Aheui.
+  class Stack < Store
+    # Delegates push, pop to @store.
+    delegate [:push, :pop] => :@store
+
+    # Swap the last two elements of Stack.
+    def swap
+      @store[-1], @store[-2] = @store[-2], @store[-1] if size > 1
+    end
+  end
+end

data/lib/raheui/store.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Raheui
+  # Base Store class for Aheui. Every child classes should implement push, pop
+  # and swap method.
+  class Store
+    extend Forwardable
+
+    BASE_METHODS = [:push, :pop, :swap]
+    private_constant :BASE_METHODS
+
+    # Delegates size to @store.
+    def_delegator :@store, :size
+
+    # Initialize a Stack.
+    def initialize
+      check_base_methods
+      @store = []
+    end
+
+    # Push the last element to Store.
+    def push_dup
+      push(@store.last) if size > 0
+    end
+
+    private
+
+    # Check whether base methods are implemented.
+    #
+    # Returns nothing.
+    # Raises NotImplementedError if base methods are not implemented.
+    def check_base_methods
+      errors = []
+      BASE_METHODS.each do |method|
+        errors << method unless respond_to?(method)
+      end
+      return if errors.empty?
+      fail NotImplementedError, 'base methods are not implemented:' \
+                                " #{errors.join(', ')}"
+    end
+  end
+end

data/lib/raheui/version.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+module Raheui
+  # Holds the Raheui version information.
+  module Version
+    STRING = '1.0.0'
+  end
+end

data/lib/raheui.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+require 'raheui/version'
+
+require 'forwardable'
+require 'raheui/store'
+require 'raheui/stack'
+require 'raheui/queue'
+require 'raheui/port'
+
+require 'raheui/io'
+require 'raheui/code'
+require 'raheui/runner'
+
+require 'optparse'
+require 'raheui/option'
+require 'raheui/cli'

data/raheui.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'raheui/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'raheui'
+  spec.version       = Raheui::Version::STRING
+  spec.authors       = ['ChaYoung You']
+  spec.email         = ['yousbe@gmail.com']
+  spec.summary       = 'Aheui interpreter in Ruby.'
+  spec.description   = 'Aheui interpreter in Ruby.'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.25.0'
+  spec.add_development_dependency 'simplecov', '~> 0.9'
+end

data/spec/raheui/cli_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Raheui::CLI do
+  include FileHelper
+  include_context 'isolated environment'
+
+  subject(:cli) { described_class.new }
+
+  before(:example) { $stdout = StringIO.new }
+  after(:example) { $stdout = STDOUT }
+
+  it 'runs aheui file passed as an argument' do
+    create_file('helloworld.aheui', %w(밤밣따빠밣밟따뿌
+                                       빠맣파빨받밤뚜뭏
+                                       돋밬탕빠맣붏두붇
+                                       볻뫃박발뚷투뭏붖
+                                       뫃도뫃희멓뭏뭏붘
+                                       뫃봌토범더벌뿌뚜
+                                       뽑뽀멓멓더벓뻐뚠
+                                       뽀덩벐멓뻐덕더벅))
+    expect(cli.run(['helloworld.aheui'])).to be(0)
+    expect($stdout.string).to eq("Hello, world!\n")
+  end
+
+  it 'runs string passed as an stdin argument' do
+    allow($stdin).to receive(:read).once
+                       .and_return(%w(밤밣따빠밣밟따뿌
+                                      빠맣파빨받밤뚜뭏
+                                      돋밬탕빠맣붏두붇
+                                      볻뫃박발뚷투뭏붖
+                                      뫃도뫃희멓뭏뭏붘
+                                      뫃봌토범더벌뿌뚜
+                                      뽑뽀멓멓더벓뻐뚠
+                                      뽀덩벐멓뻐덕더벅).join("\n"))
+    expect(cli.run([])).to be(0)
+    expect($stdout.string).to eq("Hello, world!\n")
+  end
+end

data/spec/raheui/code_spec.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Raheui::Code do
+  shared_examples 'a code' do
+    subject(:code) { Raheui::Code.new(code_str) }
+    let(:consonants) { code.method(:consonants) }
+
+    it 'has width which is maximum line length of code with minimum value 1' do
+      width = code_str.lines.map { |line| line.chomp.size }.max || 1
+      expect(code.width).to be(width)
+    end
+
+    it 'has height which is number of lines with minimum value 1' do
+      height = [code_str.lines.count, 1].max
+      expect(code.height).to be(height)
+    end
+
+    describe '#[]' do
+      it 'returns item at given position' do
+        code_str.lines.each_with_index do |line, y|
+          line.chomp.chars.each_with_index do |ch, x|
+            expect(code[x, y]).to match_array(consonants.call(ch))
+          end
+        end
+      end
+
+      it 'returns item at given negative position' do
+        code_str.lines.each_with_index do |line, y|
+          max_x = line.chomp.chars.count
+          line.chomp.chars.each_with_index do |ch, x|
+            expected = consonants.call(ch)
+            expect(code[x - max_x, y]).to match_array(expected)
+            expect(code[x, y - code.height]).to match_array(expected)
+            expect(code[x - max_x, y - code.height]).to match_array(expected)
+          end
+        end
+      end
+
+      it 'returns an empty array if there is no item at given position' do
+        expect(code[0, code.height]).to match_array([])
+        expect(code[code.width, 0]).to match_array([])
+        expect(code[code.width, code.height]).to match_array([])
+      end
+    end
+  end
+
+  describe Raheui::Code, 'with empty code' do
+    let(:code_str) { '' }
+    it_behaves_like 'a code'
+  end
+
+  describe Raheui::Code, 'with aheui code' do
+    let(:code_str) { '아희' }
+    it_behaves_like 'a code'
+  end
+
+  describe Raheui::Code, 'with hello world code' do
+    let(:code_str) do
+      <<-CODE
+밤밣따빠밣밟따뿌
+빠맣파빨받밤뚜뭏
+돋밬탕빠맣붏두붇
+볻뫃박발뚷투뭏붖
+뫃도뫃희멓뭏뭏붘
+뫃봌토범더벌뿌뚜
+뽑뽀멓멓더벓뻐뚠
+뽀덩벐멓뻐덕더벅
+      CODE
+    end
+
+    it_behaves_like 'a code'
+  end
+
+  describe '#consonants' do
+    subject { Raheui::Code.new('') }
+    let(:consonants) { subject.method(:consonants) }
+    before(:example) do
+      stub_const('INITIAL_CONSONANTS', Raheui::Code::INITIAL_CONSONANTS)
+      stub_const('MEDIAL_CONSONANTS', Raheui::Code::MEDIAL_CONSONANTS)
+      stub_const('FINAL_CONSONANTS', Raheui::Code::FINAL_CONSONANTS)
+    end
+
+    it 'returns consonants of Korean alphabet' do
+      examples = [
+        # 가
+        [0, 0, 0],
+        # 힣
+        [INITIAL_CONSONANTS - 1, MEDIAL_CONSONANTS - 1, FINAL_CONSONANTS - 1]
+      ]
+      examples.concat(10.times.map do
+        [rand(INITIAL_CONSONANTS),
+         rand(MEDIAL_CONSONANTS),
+         rand(FINAL_CONSONANTS)]
+      end.uniq)
+      examples.each do |initial, medial, final|
+        alphabet = (
+          0xAC00 +
+            initial * MEDIAL_CONSONANTS * FINAL_CONSONANTS +
+            medial * FINAL_CONSONANTS +
+            final
+        ).chr(Encoding::UTF_8)
+        expect(consonants.call(alphabet)).to match_array(
+                                               [initial, medial, final])
+      end
+    end
+
+    it 'returns an empty array for non-Korean alphabet' do
+      examples = [
+        *0..127,
+        0xAC00 + INITIAL_CONSONANTS * MEDIAL_CONSONANTS * FINAL_CONSONANTS
+      ]
+      examples.concat(%w(あ 漢 　 å ★).map(&:ord))
+      examples.each do |ch|
+        expect(consonants.call(ch)).to match_array([])
+      end
+    end
+  end
+end

data/spec/raheui/io_spec.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Raheui::IO do
+  describe '.read_int' do
+    let(:value) { rand(-100..100) }
+
+    it { is_expected.to respond_to(:read_int) }
+
+    it 'reads an integer' do
+      allow($stdin).to receive(:gets).with(no_args).once
+                                     .and_return("#{value}\n")
+      expect(subject.read_int).to be(value)
+    end
+  end
+
+  describe '.read_chr' do
+    it { is_expected.to respond_to(:read_chr) }
+
+    it 'reads an ASCII code' do
+      [0, *32..126].each do |value|
+        allow($stdin).to receive(:getc).with(no_args).once
+                                       .and_return(value.chr)
+        expect(subject.read_chr).to be(value)
+      end
+    end
+
+    it 'reads an control character' do
+      [*1..31, *127..159].each do |value|
+        allow($stdin).to receive(:getc).with(no_args).once
+                                       .and_return(value.chr)
+        expect(subject.read_chr).to be(value)
+      end
+    end
+
+    it 'reads an unicode character' do
+      [*10.times.map { rand(160..0xD7FF).chr(Encoding::UTF_8) }.uniq,
+       # Range 0xD800..0xDFFF is used by UTF-16.
+       *10.times.map { rand(0xE000..0x10FFFF).chr(Encoding::UTF_8) }.uniq,
+       '가', 'あ', '漢', '　', 'å', '★'].each do |chr|
+        allow($stdin).to receive(:getc).with(no_args).once
+                                       .and_return(chr)
+        expect(subject.read_chr).to be(chr.ord)
+      end
+    end
+  end
+
+  describe '.print_int' do
+    let(:value) { rand(-100..100) }
+
+    it { is_expected.to respond_to(:print_int) }
+
+    it 'prints an integer' do
+      allow($stdout).to receive(:print).with(value).once
+      expect(subject.print_int(value)).to be_nil
+    end
+  end
+
+  describe '.print_chr' do
+    it { is_expected.to respond_to(:print_chr) }
+
+    it 'prints an ASCII character corresponding character code' do
+      [0, *32..126].each do |value|
+        allow($stdout).to receive(:print).with(value.chr).once
+        expect(subject.print_chr(value)).to be_nil
+      end
+    end
+
+    it 'prints an control character corresponding character code' do
+      [*1..31, *127..159].each do |value|
+        allow($stdout).to receive(:print).with(value.chr(Encoding::UTF_8)).once
+        expect(subject.print_chr(value)).to be_nil
+      end
+    end
+
+    it 'prints an unicode character corresponding character code' do
+      [*10.times.map { rand(160..0xD7FF).chr(Encoding::UTF_8) }.uniq,
+       # Range 0xD800..0xDFFF is used by UTF-16.
+       *10.times.map { rand(0xE000..0x10FFFF).chr(Encoding::UTF_8) }.uniq,
+       '가', 'あ', '漢', '　', 'å', '★'].each do |chr|
+        allow($stdout).to receive(:print).with(chr).once
+        expect(subject.print_chr(chr.ord)).to be_nil
+      end
+    end
+
+    it 'prints an [U+%04X] string when RangeError is raised' do
+      [*10.times.map { rand(0xD800..0xDFFF) }.uniq,
+       0x110000].each do |value|
+        allow($stdout).to receive(:print).with(format('[U+%04X]', value)).once
+        expect(subject.print_chr(value)).to be_nil
+      end
+    end
+  end
+end

data/spec/raheui/option_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Raheui::Option do
+  include ExitCodeMatchers
+
+  subject(:option) { described_class.new }
+
+  before(:example) { $stdout = StringIO.new }
+  after(:example) { $stdout = STDOUT }
+
+  describe 'option' do
+    describe '-h/--help' do
+      it 'exits cleanly' do
+        expect { option.parse(['-h']) }.to exit_with_code(0)
+        expect { option.parse(['--help']) }.to exit_with_code(0)
+      end
+
+      it 'shows help text' do
+        begin
+          option.parse(['--help'])
+        rescue SystemExit # rubocop:disable Lint/HandleExceptions
+        end
+
+        expected_help = <<-END
+Usage: raheui [options] [file]
+    -h, --help                       Print this message.
+    -v, --version                    Print version.
+        END
+
+        expect($stdout.string).to eq(expected_help)
+      end
+    end
+
+    describe '-v/--version' do
+      it 'exits cleanly' do
+        expect { option.parse(['-v']) }.to exit_with_code(0)
+        expect { option.parse(['--version']) }.to exit_with_code(0)
+        expect($stdout.string).to eq("#{Raheui::Version::STRING}\n" * 2)
+      end
+    end
+  end
+end

data/spec/raheui/port_spec.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Raheui::Port do
+  it_behaves_like 'a store'
+end