jkf 0.5.0 → 0.5.2

data/lib/jkf/converter/kifuable.rb

@@ -1,188 +1,188 @@
-module Jkf::Converter
-  # Intersection of KIF and KI2
-  module Kifuable
-    protected
-
-    def convert_initial(initial)
-      result = convert_handicap(initial["preset"])
-      footer = ""
-
-      data = initial["data"]
-      if data
-        result += convert_teban(data, 1)
-        if hands = data["hands"]
-          result += convert_hands(hands, 1) if hands[1]
-          footer += convert_hands(hands, 0) if hands[0]
-        end
-        footer += convert_teban(data, 0)
+module Jkf
+  module Converter
+    # Intersection of KIF and KI2
+    module Kifuable
+      protected
+
+      def convert_initial(initial)
+        result = convert_handicap(initial['preset'])
+        footer = ''
+
+        data = initial['data']
+        if data
+          result += convert_teban(data, 1)
+          if (hands = data['hands'])
+            result += convert_hands(hands, 1) if hands[1]
+            footer += convert_hands(hands, 0) if hands[0]
+          end
+          footer += convert_teban(data, 0)
 
-        result += convert_board(data["board"]) if data["board"]
+          result += convert_board(data['board']) if data['board']
+        end
+        result + footer
       end
-      result + footer
-    end
 
-    def convert_handicap(preset)
-      preset == "OTHER" ? "" : "手合割：#{preset2str(preset)}\n"
-    end
+      def convert_handicap(preset)
+        preset == 'OTHER' ? '' : "手合割：#{preset2str(preset)}\n"
+      end
 
-    def convert_teban(data, color)
-      data["color"] == color ? "#{@players[color]}手番\n" : ""
-    end
+      def convert_teban(data, color)
+        data['color'] == color ? "#{@players[color]}手番\n" : ''
+      end
 
-    def convert_hands(hands, color)
-      "#{@players[color]}手の持駒：" + convert_motigoma(hands[color])
-    end
+      def convert_hands(hands, color)
+        "#{@players[color]}手の持駒：" + convert_motigoma(hands[color])
+      end
 
-    def convert_board(board)
-      result = "  ９ ８ ７ ６ ５ ４ ３ ２ １\n+---------------------------+\n"
-      9.times do |y|
-        line = "|"
-        9.times do |x|
-          line += convert_board_piece(board[8 - x][y])
+      def convert_board(board)
+        result = "  ９ ８ ７ ６ ５ ４ ３ ２ １\n+---------------------------+\n"
+        9.times do |y|
+          line = '|'
+          9.times do |x|
+            line += convert_board_piece(board[8 - x][y])
+          end
+          line += "|#{n2kan(y + 1)}\n"
+          result += line
         end
-        line += "|#{n2kan(y + 1)}\n"
-        result += line
+        result + "+---------------------------+\n"
       end
-      result + "+---------------------------+\n"
-    end
 
-    def convert_comments(comments)
-      comments.map { |comment| "*#{comment}\n" }.join
-    end
+      def convert_comments(comments)
+        comments.map { |comment| "*#{comment}\n" }.join
+      end
 
-    def convert_motigoma(pieces)
-      pieces.to_a.reverse.map do |(piece, num)|
-        if num > 0
-          str = csa2kind(piece)
-          if num > 1
-            str += n2kan(num / 10) if num / 10 > 0
-            num %= 10
-            str += n2kan(num)
+      def convert_motigoma(pieces)
+        pieces.to_a.reverse.filter_map do |(piece, num)|
+          if num > 0
+            str = csa2kind(piece)
+            if num > 1
+              str += n2kan(num / 10) if num / 10 > 0
+              num %= 10
+              str += n2kan(num)
+            end
+            str
           end
-          str
-        end
-      end.compact.join("　") + "　\n"
-    end
+        end.join('　') + "　\n"
+      end
 
-    def convert_board_piece(piece)
-      result = ""
+      def convert_board_piece(piece)
+        result = ''
 
-      if piece == {}
-        result = " ・"
-      else
-        result += piece["color"] == 0 ? " " : "v"
-        result += csa2kind(piece["kind"])
+        if piece == {}
+          result = ' ・'
+        else
+          result += piece['color'] == 0 ? ' ' : 'v'
+          result += csa2kind(piece['kind'])
+        end
+
+        result
       end
 
-      result
-    end
+      def convert_special(special, index)
+        result = "まで#{index + 1}手"
+
+        if special == 'TORYO' || special.include?('ILLEGAL')
+          turn = @players[index % 2]
+          result += "で#{turn}手の"
+          result += { 'TORYO' => '勝ち',
+                      'ILLEGAL_ACTION' => '反則勝ち',
+                      'ILLEGAL_MOVE' => '反則負け' }[special]
+        else
+          turn = @players[(index + 1) % 2]
+          result += case special
+                    when 'TIME_UP' then "で時間切れにより#{turn}手の勝ち"
+                    when 'CHUDAN' then 'で中断'
+                    when 'JISHOGI' then 'で持将棋'
+                    when 'SENNICHITE' then 'で千日手'
+                    when 'TSUMI' then 'で詰み'
+                    when 'FUZUMI' then 'で不詰'
+                    end
+        end
 
-    def convert_special(special, index)
-      result = "まで#{index + 1}手"
-
-      if special == "TORYO" || special =~ /ILLEGAL/
-        turn = @players[index % 2]
-        result += "で#{turn}手の"
-        result += case special
-                  when "TORYO" then "勝ち"
-                  when "ILLEGAL_ACTION" then "反則勝ち"
-                  when "ILLEGAL_MOVE" then "反則負け"
-                  end
-      else
-        turn = @players[(index + 1) % 2]
-        result += case special
-                  when "TIME_UP" then "で時間切れにより#{turn}手の勝ち"
-                  when "CHUDAN" then "で中断"
-                  when "JISHOGI" then "で持将棋"
-                  when "SENNICHITE" then "で千日手"
-                  when "TSUMI" then "で詰み"
-                  when "FUZUMI" then "で不詰"
-                  end
-      end
-
-      result + "\n"
-    end
+        result + "\n"
+      end
 
-    def convert_piece_with_pos(move)
-      result = if move["to"]
-                 n2zen(move["to"]["x"]) + n2kan(move["to"]["y"])
-               elsif move["same"]
-                 "同　"
-               end
-      result += csa2kind(move["piece"])
-      result += "成" if move["promote"]
-      result
-    end
+      def convert_piece_with_pos(move)
+        result = if move['to']
+                   n2zen(move['to']['x']) + n2kan(move['to']['y'])
+                 elsif move['same']
+                   '同　'
+                 end
+        result += csa2kind(move['piece'])
+        result += '成' if move['promote']
+        result
+      end
 
-    def convert_forks(forks, index)
-      result = "\n"
-      result = "変化：%4d手\n" % [index] # ki2の場合\nなし
-      forks.each do |moves|
-        result += convert_moves(moves, index)
+      def convert_forks(forks, index)
+        result = "\n"
+        result = "変化：%4d手\n" % [index] # ki2の場合\nなし
+        forks.each do |moves|
+          result += convert_moves(moves, index)
+        end
+        result
       end
-      result
-    end
 
-    def reset!
-      @forks = []
-      @header2 = []
-    end
+      def reset!
+        @forks = []
+        @header2 = []
+      end
 
-    def setup_players!(jkf)
-      players_flag = :sengo
-      jkf["header"] && jkf["header"].keys.detect { |key| key =~ /[上下]手/ } && players_flag = :uwasimo
-      @players = if players_flag == :uwasimo
-                   ["下", "上"]
-                 else
-                   ["先", "後"]
-                 end
-    end
+      def setup_players!(jkf)
+        players_flag = :sengo
+        jkf['header']&.keys&.detect { |key| key =~ /[上下]手/ } && players_flag = :uwasimo
+        @players = if players_flag == :uwasimo
+                     ['下', '上']
+                   else
+                     ['先', '後']
+                   end
+      end
 
-    def n2zen(n)
-      "０１２３４５６７８９"[n]
-    end
+      def n2zen(n)
+        '０１２３４５６７８９'[n]
+      end
 
-    def n2kan(n)
-      "〇一二三四五六七八九"[n]
-    end
+      def n2kan(n)
+        '〇一二三四五六七八九'[n]
+      end
 
-    def csa2kind(csa)
-      {
-        "FU" => "歩",
-        "KY" => "香",
-        "KE" => "桂",
-        "GI" => "銀",
-        "KI" => "金",
-        "KA" => "角",
-        "HI" => "飛",
-        "OU" => "玉",
-        "TO" => "と",
-        "NY" => "成香",
-        "NK" => "成桂",
-        "NG" => "成銀",
-        "UM" => "馬",
-        "RY" => "龍"
-      }[csa]
-    end
+      def csa2kind(csa)
+        {
+          'FU' => '歩',
+          'KY' => '香',
+          'KE' => '桂',
+          'GI' => '銀',
+          'KI' => '金',
+          'KA' => '角',
+          'HI' => '飛',
+          'OU' => '玉',
+          'TO' => 'と',
+          'NY' => '成香',
+          'NK' => '成桂',
+          'NG' => '成銀',
+          'UM' => '馬',
+          'RY' => '龍'
+        }[csa]
+      end
 
-    def preset2str(preset)
-      {
-        "HIRATE" => "平手",
-        "KY" => "香落ち",
-        "KY_R" => "右香落ち",
-        "KA" => "角落ち",
-        "HI" => "飛車落ち",
-        "HIKY" => "飛香落ち",
-        "2" => "二枚落ち",
-        "3" => "三枚落ち",
-        "4" => "四枚落ち",
-        "5" => "五枚落ち",
-        "5_L" => "左五枚落ち",
-        "6" => "六枚落ち",
-        "8" => "八枚落ち",
-        "10" => "十枚落ち",
-        "OTHER" => "その他"
-      }[preset]
+      def preset2str(preset)
+        {
+          'HIRATE' => '平手',
+          'KY' => '香落ち',
+          'KY_R' => '右香落ち',
+          'KA' => '角落ち',
+          'HI' => '飛車落ち',
+          'HIKY' => '飛香落ち',
+          '2' => '二枚落ち',
+          '3' => '三枚落ち',
+          '4' => '四枚落ち',
+          '5' => '五枚落ち',
+          '5_L' => '左五枚落ち',
+          '6' => '六枚落ち',
+          '8' => '八枚落ち',
+          '10' => '十枚落ち',
+          'OTHER' => 'その他'
+        }[preset]
+      end
     end
   end
 end

data/lib/jkf/converter.rb

@@ -1,14 +1,12 @@
 module Jkf
-  # Define converter namespace
   module Converter
-    # Convert error
     class ConvertError < StandardError; end
   end
 end
 
-require "json"
-require "jkf/converter/base"
-require "jkf/converter/kifuable"
-require "jkf/converter/kif"
-require "jkf/converter/ki2"
-require "jkf/converter/csa"
+require 'json'
+require_relative 'converter/base'
+require_relative 'converter/kifuable'
+require_relative 'converter/kif'
+require_relative 'converter/ki2'
+require_relative 'converter/csa'

data/lib/jkf/parser/base.rb

@@ -1,118 +1,104 @@
-module Jkf::Parser
-  # Base of Parser
-  class Base
-    # start parse
-    #
-    # @param [String] input
-    #
-    # @return [Hash] JKF
-    def parse(input)
-      @input = input.clone
-
-      @current_pos = 0
-      @reported_pos = 0
-      @cached_pos = 0
-      @cached_pos_details = { line: 1, column: 1, seenCR: false }
-      @max_fail_pos = 0
-      @max_fail_expected = []
-      @silent_fails = 0
-
-      @result = parse_root
-
-      if success? && @current_pos == @input.size
-        return @result
-      else
-        fail(type: "end", description: "end of input") if failed? && @current_pos < input.size
-        raise ParseError
+require 'strscan'
+
+module Jkf
+  module Parser
+    # Base of Parser
+    class Base
+      # start parse
+      #
+      # @param [String] input
+      #
+      # @return [Hash] JKF
+      def parse(input)
+        @scanner = StringScanner.new(input.dup)
+        @reported_pos = 0
+        @max_fail_pos = 0
+
+        @result = parse_root
+
+        if success? && @scanner.eos?
+          @result
+        else
+          record_failure(type: 'end', description: 'end of input') if failed? && @scanner.pos < input.size
+          raise ParseError
+        end
       end
-    end
 
-    protected
+      protected
 
-    def success?
-      @result != :failed
-    end
+      def success?
+        @result != :failed
+      end
 
-    def failed?; !success?; end
-
-    # match regexp
-    def match_regexp(reg)
-      ret = nil
-      if matched = reg.match(@input[@current_pos])
-        ret = matched.to_s
-        @current_pos += ret.size
-      else
-        ret = :failed
-        fail(type: "class", value: reg.inspect, description: reg.inspect) if @silent_fails == 0
+      def failed?; !success?; end
+
+      def match_regexp(reg)
+        matched = @scanner.scan(reg)
+        unless matched
+          record_failure(type: 'class', value: reg.inspect, description: reg.inspect)
+          return :failed
+        end
+        matched
       end
-      ret
-    end
 
-    # match string
-    def match_str(str)
-      ret = nil
-      if @input[@current_pos, str.size] == str
-        ret = str
-        @current_pos += str.size
-      else
-        ret = :failed
-        fail(type: "literal", value: str, description: "\"#{str}\"") if @slient_fails == 0
+      def match_str(str)
+        matched = @scanner.scan(str)
+        unless matched
+          record_failure(type: 'literal', value: str, description: str.inspect)
+          return :failed
+        end
+        matched
       end
-      ret
-    end
 
-    # match space
-    def match_space
-      match_str(" ")
-    end
+      # match space
+      def match_space
+        match_str(' ')
+      end
 
-    # match space one or more
-    def match_spaces
-      stack = []
-      matched = match_space
-      while matched != :failed
-        stack << matched
+      # match space one or more
+      def match_spaces
+        stack = []
         matched = match_space
+        while matched != :failed
+          stack << matched
+          matched = match_space
+        end
+        stack
       end
-      stack
-    end
 
-    # match digit
-    def match_digit
-      match_regexp(/^\d/)
-    end
+      # match digit
+      def match_digit
+        match_regexp(/\d/)
+      end
 
-    # match digits
-    def match_digits
-      stack = []
-      matched = match_digit
-      while matched != :failed
-        stack << matched
+      # match digits
+      def match_digits
+        stack = []
         matched = match_digit
+        while matched != :failed
+          stack << matched
+          matched = match_digit
+        end
+        stack
       end
-      stack
-    end
 
-    # match digit one ore more
-    def match_digits!
-      matched = match_digits
-      if matched.empty?
-        :failed
-      else
-        matched
+      # match digit one ore more
+      def match_digits!
+        matched = match_digits
+        if matched.empty?
+          :failed
+        else
+          matched
+        end
       end
-    end
 
-    # record failure
-    def fail(expected)
-      return if @current_pos < @max_fail_pos
+      def record_failure(_expected)
+        return if @scanner.pos < @max_fail_pos
 
-      if @current_pos > @max_fail_pos
-        @max_fail_pos = @current_pos
-        @max_fail_expected = []
-      end
+        return unless @scanner.pos > @max_fail_pos
 
-      @max_fail_expected << expected
+        @max_fail_pos = @scanner.pos
+      end
     end
   end
 end