feen 2.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53ffebf45c7d54e896af8ea265e9a3e6be43f5d3367f8f4d75a3be35ede0769c
-  data.tar.gz: b942b667c90dadea80c7dfadb87872a3024c3a15dbaf866814c530957ad12fd3
+  metadata.gz: 730da5cc06535403835733403b2e86d03435337bd7cd36e5af2d47a1442f199f
+  data.tar.gz: f3a1b2a952dccbc9bb5eeb15dcfc920d3ea270abb301ed29c098da5260a4c3e4
 SHA512:
-  metadata.gz: 921e336e081f5d238e05750f245e81aa5d1b10a8b7fd5eddd1eec95518d3b210c77a4d14ecf3d53f6098217c3113a3dba27abaafddc5cb981f7f3d304bc00202
-  data.tar.gz: 840842f00f4da13daefefac0389a616296c692e8da099da0c37959e5ea6e1ae2fcb5fbb3a3e0643bbd903874f61d11b1ef398db30e29ee1c432654492ffdd305
+  metadata.gz: c001a2c2c8c7f88aba144ca878c45e11fde53b5c71ff3afa4caf8b05724d4a90dd6addfa32e29a4132b099818b4b6dd1dd0a55ab54b629af48b7113095d6cb54
+  data.tar.gz: 52f11c59367bc9d7dab6d21ad969cec1f7dd672f7fdab175f577d9076b7443e911b22b63c798198aae176f3939c4142f8eaa4cda1aa775464dbf0ba929f953ae

data/README.md

@@ -38,39 +38,22 @@ require "feen"
 
 # Dump a classic Tsume Shogi problem
 FEEN.dump(
-  "active_side_id": 0,
-  "board": {
-    "3": "s",
-    "4": "k" ,
-    "5": "s",
-    "22": "+P",
-    "43": "+B"
-  },
-  "indexes": [9, 9],
-  "pieces_in_hand_grouped_by_sides": [
-    %w[S],
-    %w[r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
-  ]
+  "in_hand": %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
+  "shape": [9, 9],
+  "side_id": 0,
+  "square": {
+     3 => "s",
+     4 => "k",
+     5 => "s",
+    22 => "+P",
+    43 => "+B"
+  }
 )
-# => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S/b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s"
+# => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s"
 
 # Parse a classic Tsume Shogi problem
-FEEN.parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S/b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s")
-# => {
-#      "active_side_id": 0,
-#      "board": {
-#        "3": "s",
-#        "4": "k" ,
-#        "5": "s",
-#        "22": "+P",
-#        "43": "+B"
-#      },
-#      "indexes": [9, 9],
-#      "pieces_in_hand_grouped_by_sides": [
-#        %w[S],
-#        %w[r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
-#      ]
-#    }
+FEEN.parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s")
+# => {:square=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"}, :shape=>[9, 9], :in_hand=>["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"], :side_id=>0}
 ```
 
 ## License

data/lib/feen.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "feen/dumper"
-require_relative "feen/parser"
+require_relative File.join("feen", "dumper")
+require_relative File.join("feen", "parser")
 
 # This module provides a Ruby interface for data serialization and
 # deserialization in FEEN format.
@@ -10,37 +10,33 @@ require_relative "feen/parser"
 module FEEN
   # @example Dumps position params into a FEEN string.
   #
-  # @param active_side_id [Integer] The identifier of the player who must play.
-  # @param board [Hash] The indexes of each piece on the board.
-  # @param indexes [Array] The shape of the board.
-  # @param pieces_in_hand_grouped_by_sides [Array] The list of pieces in hand
-  #   grouped by players.
+  # @param in_hand [Array] The list of pieces in hand.
+  # @param shape [Array] The shape of the board.
+  # @param side_id [Integer] The identifier of the player who must play.
+  # @param square [Hash] The index of each piece on the board.
   #
   # @example Dump a classic Tsume Shogi problem
   #   dump(
-  #     "active_side_id": 0,
-  #     "board": {
-  #       "3": "s",
-  #       "4": "k" ,
-  #       "5": "s",
-  #       "22": "+P",
-  #       "43": "+B"
-  #     },
-  #     "indexes": [9, 9],
-  #     "pieces_in_hand_grouped_by_sides": [
-  #       %w[S],
-  #       %w[r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
-  #     ]
+  #     "in_hand": %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
+  #     "shape": [9, 9],
+  #     "side_id": 0,
+  #     "square": {
+  #        3 => "s",
+  #        4 => "k",
+  #        5 => "s",
+  #       22 => "+P",
+  #       43 => "+B"
+  #     }
   #   )
-  #   # => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S/b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s"
+  #   # => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s"
   #
   # @return [String] The FEEN string representing the position.
-  def self.dump(active_side_id:, board: {}, indexes:, pieces_in_hand_grouped_by_sides:)
+  def self.dump(in_hand:, shape:, side_id:, square:)
     Dumper.call(
-      active_side_id: active_side_id,
-      board: board,
-      indexes: indexes,
-      pieces_in_hand_grouped_by_sides: pieces_in_hand_grouped_by_sides
+      in_hand: in_hand,
+      shape: shape,
+      side_id: side_id,
+      square: square
     )
   end
 
@@ -49,22 +45,18 @@ module FEEN
   # @param feen [String] The FEEN string representing a position.
   #
   # @example Parse a classic Tsume Shogi problem
-  #   parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S/b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s")
+  #   parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s")
   #   # => {
-  #   #      "active_side_id": 0,
-  #   #      "board": {
-  #   #        "3": "s",
-  #   #        "4": "k" ,
-  #   #        "5": "s",
-  #   #        "22": "+P",
-  #   #        "43": "+B"
-  #   #      },
-  #   #      "indexes": [9, 9],
-  #   #      "pieces_in_hand_grouped_by_sides": [
-  #   #        %w[S],
-  #   #        %w[r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
-  #   #      ]
-  #   #    }
+  #   #      "in_hand": ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
+  #   #      "shape": [9, 9],
+  #   #      "side_id": 0,
+  #   #      "square": {
+  #   #         3 => "s",
+  #   #         4 => "k",
+  #   #         5 => "s",
+  #   #        22 => "+P",
+  #   #        43 => "+B"
+  #   #      }
   #
   # @return [Hash] The position params representing the position.
   def self.parse(feen)

data/lib/feen/dumper.rb

@@ -1,44 +1,40 @@
 # frozen_string_literal: true
 
-require_relative "dumper/board"
-require_relative "dumper/pieces_in_hand"
-require_relative "dumper/turn"
+require_relative File.join("dumper", "in_hand")
+require_relative File.join("dumper", "square")
+require_relative File.join("dumper", "turn")
 
 module FEEN
   # The dumper module.
   module Dumper
     # Dump position params into a FEEN string.
     #
-    # @param active_side_id [Integer] The identifier of the player who must play.
-    # @param board [Hash] The indexes of each piece on the board.
-    # @param indexes [Array] The shape of the board.
-    # @param pieces_in_hand_grouped_by_sides [Array] The list of pieces in hand
-    #   grouped by players.
+    # @param in_hand [Array] The list of pieces in hand.
+    # @param shape [Array] The shape of the board.
+    # @param side_id [Integer] The identifier of the player who must play.
+    # @param square [Hash] The index of each piece on the board.
     #
     # @example Dump a classic Tsume Shogi problem
     #   call(
-    #     "active_side_id": 0,
-    #     "board": {
-    #       "3": "s",
-    #       "4": "k" ,
-    #       "5": "s",
-    #       "22": "+P",
-    #       "43": "+B"
-    #     },
-    #     "indexes": [9, 9],
-    #     "pieces_in_hand_grouped_by_sides": [
-    #       %w[S],
-    #       %w[r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
-    #     ]
+    #     "in_hand": %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
+    #     "shape": [9, 9],
+    #     "side_id": 0,
+    #     "square": {
+    #        3 => "s",
+    #        4 => "k",
+    #        5 => "s",
+    #       22 => "+P",
+    #       43 => "+B"
+    #     }
     #   )
-    #   # => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S/b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s"
+    #   # => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s"
     #
     # @return [String] The FEEN string representing the position.
-    def self.call(active_side_id:, board:, indexes:, pieces_in_hand_grouped_by_sides:)
+    def self.call(in_hand:, shape:, side_id:, square:)
       [
-        Board.new(*indexes, **board).to_s,
-        Turn.dump(active_side_id, pieces_in_hand_grouped_by_sides.length),
-        PiecesInHand.dump(*pieces_in_hand_grouped_by_sides)
+        Square.new(shape, square).to_s,
+        Turn.dump(side_id),
+        InHand.dump(in_hand)
       ].join(" ")
     end
   end

data/lib/feen/dumper/in_hand.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FEEN
+  module Dumper
+    # The pieces in hand class.
+    #
+    # @example Serialize a list of pieces in hand grouped by sides
+    #   PiecesInHand.dump(%w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p])
+    #   # => "S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s"
+    module InHand
+      # Serialize pieces in hand lists into a string.
+      #
+      # @param piece_names [Array] A list of pieces in hand.
+      #
+      # @return [String] A string representing the pieces in hand.
+      def self.dump(piece_names)
+        return "-" if piece_names.empty?
+
+        piece_names.sort.join("/")
+      end
+    end
+  end
+end

data/lib/feen/dumper/square.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module FEEN
+  module Dumper
+    # The square class.
+    #
+    # @example Dump an empty board of Xiangqi
+    #   Board.new([10, 9]).to_s # => "9/9/9/9/9/9/9/9/9/9"
+    #
+    # @example Dump the Xiangqi starting position board
+    #   Board.new(
+    #     [10, 9],
+    #     {
+    #        0 => "車",
+    #        1 => "馬",
+    #        2 => "象",
+    #        3 => "士",
+    #        4 => "將",
+    #        5 => "士",
+    #        6 => "象",
+    #        7 => "馬",
+    #        8 => "車",
+    #       19 => "砲",
+    #       25 => "砲",
+    #       27 => "卒",
+    #       29 => "卒",
+    #       31 => "卒",
+    #       33 => "卒",
+    #       35 => "卒",
+    #       54 => "兵",
+    #       56 => "兵",
+    #       58 => "兵",
+    #       60 => "兵",
+    #       62 => "兵",
+    #       64 => "炮",
+    #       70 => "炮",
+    #       81 => "俥",
+    #       82 => "傌",
+    #       83 => "相",
+    #       84 => "仕",
+    #       85 => "帥",
+    #       86 => "仕",
+    #       87 => "相",
+    #       88 => "傌",
+    #       89 => "俥"
+    #     }
+    #   ).to_s # => "車,馬,象,士,將,士,象,馬,車/9/1,砲,5,砲,1/卒,1,卒,1,卒,1,卒,1,卒/9/9/兵,1,兵,1,兵,1,兵,1,兵/1,炮,5,炮,1/9/俥,傌,相,仕,帥,仕,相,傌,俥"
+    class Square
+      # @param indexes [Array] The shape of the board.
+      # @param board [Hash] The index of each piece on the board.
+      def initialize(indexes, board)
+        @indexes = indexes
+        @squares = Array.new(length) { |i| board.fetch(i, nil) }
+      end
+
+      # @return [String] The string representing the board.
+      def to_s
+        unflatten(@squares, @indexes)
+      end
+
+      private
+
+      def length
+        @indexes.inject(:*)
+      end
+
+      def unflatten(squares, remaining_indexes)
+        return row(squares) if remaining_indexes.length == 1
+
+        squares
+          .each_slice(squares.length / remaining_indexes.fetch(0))
+          .to_a
+          .map { |sub_squares| unflatten(sub_squares, remaining_indexes[1..]) }
+          .join("/" * remaining_indexes.length.pred)
+      end
+
+      def row(squares)
+        squares
+          .map { |square| square.nil? ? 1 : square }
+          .join(",")
+          .gsub(/1,[1,]*1/) { |str| str.split(",").length }
+      end
+    end
+  end
+end

data/lib/feen/dumper/turn.rb

@@ -4,15 +4,14 @@ module FEEN
   module Dumper
     # The turn module.
     module Turn
-      # @param active_side_id [Integer] The identifier of the active player.
-      # @param sides_count [Integer] The number of players.
+      # @param side_id [Integer] The identifier of the active player.
       #
       # @example Dump the number that identify the player who have to play
-      #   dump(0, 2) # => "0"
+      #   dump(0) # => "0"
       #
       # @return [String] The number that identify the player who have to play.
-      def self.dump(active_side_id, sides_count)
-        String(Integer(active_side_id) % Integer(sides_count))
+      def self.dump(side_id)
+        String(side_id)
       end
     end
   end

data/lib/feen/parser.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "parser/board"
-require_relative "parser/pieces_in_hand"
-require_relative "parser/shape"
-require_relative "parser/turn"
+require_relative File.join("parser", "in_hand")
+require_relative File.join("parser", "shape")
+require_relative File.join("parser", "square")
+require_relative File.join("parser", "turn")
 
 module FEEN
   # The parser module.
@@ -13,41 +13,28 @@ module FEEN
     # @param feen [String] The FEEN string representing a position.
     #
     # @example Parse a classic Tsume Shogi problem
-    #   call("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S/b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s")
+    #   call("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s")
     #   # => {
-    #   #      "active_side_id": 0,
-    #   #      "board": {
-    #   #        "3": "s",
-    #   #        "4": "k" ,
-    #   #        "5": "s",
-    #   #        "22": "+P",
-    #   #        "43": "+B"
-    #   #      },
-    #   #      "indexes": [9, 9],
-    #   #      "pieces_in_hand_grouped_by_sides": [
-    #   #        %w[S],
-    #   #        %w[r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
-    #   #      ]
-    #   #    }
+    #   #      "in_hand": ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
+    #   #      "shape": [9, 9],
+    #   #      "side_id": 0,
+    #   #      "square": {
+    #   #         3 => "s",
+    #   #         4 => "k",
+    #   #         5 => "s",
+    #   #        22 => "+P",
+    #   #        43 => "+B"
+    #   #      }
     #
     # @return [Hash] The position params representing the position.
     def self.call(feen)
-      params(*feen.split(" "))
-    end
+      square_str, side_id_str, in_hand_str = feen.split(" ")
 
-    # Parse the FEEN string's three fields and return the position params.
-    #
-    # @param board [String] The flatten board.
-    # @param active_side_id [String] The active side identifier.
-    # @param in_hand [String] The captured actors.
-    #
-    # @return [Hash] The position params representing the position.
-    private_class_method def self.params(board, active_side_id, in_hand)
       {
-        active_side_id: Turn.parse(active_side_id),
-        board: Board.new(board).to_h,
-        indexes: Shape.new(board).to_a,
-        pieces_in_hand_grouped_by_sides: PiecesInHand.parse(in_hand)
+        in_hand: InHand.parse(in_hand_str),
+        shape: Shape.new(square_str).to_a,
+        side_id: Turn.parse(side_id_str),
+        square: Square.new(square_str).to_h
       }
     end
   end

data/lib/feen/parser/in_hand.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module FEEN
+  module Parser
+    # The pieces in hand module.
+    module InHand
+      # The list of pieces in hand grouped by players.
+      #
+      # @param piece_names_str [String] The serialized list of pieces in hand.
+      #
+      # @example Parse a list of serialized pieces in hand
+      #   parse("S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s")
+      #   # => ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"]
+      #
+      # @return [Array] The list of pieces in hand grouped by players.
+      def self.parse(piece_names_str)
+        piece_names_str.split(",")
+      end
+    end
+  end
+end

data/lib/feen/parser/{board.rb → square.rb}

@@ -2,7 +2,7 @@
 
 module FEEN
   module Parser
-    # The board class.
+    # The square class.
     #
     # @example Parse a Shogi problem board and return an array
     #   Board.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_a
@@ -21,13 +21,13 @@ module FEEN
     # @example Parse a Shogi problem board and return a hash
     #   Board.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_h
     #   # => {
-    #   #      "3": "s",
-    #   #      "4": "k" ,
-    #   #      "5": "s",
-    #   #      "22": "+P",
-    #   #      "43": "+B"
+    #   #       3 => "s",
+    #   #       4 => "k",
+    #   #       5 => "s",
+    #   #      22 => "+P",
+    #   #      43 => "+B"
     #   #    }
-    class Board
+    class Square
       # @param board [String] The flatten board.
       def initialize(board)
         @board = board
@@ -40,14 +40,14 @@ module FEEN
           .flat_map { |str| row(str) }
       end
 
-      # @return [Hash] The indexes of each piece on the board.
+      # @return [Hash] The index of each piece on the board.
       def to_h
         to_a
           .each_with_index
           .inject({}) do |h, (v, i)|
             next h if v.nil?
 
-            h.merge(i.to_s.to_sym => v)
+            h.merge(i => v)
           end
       end
 

data/lib/feen/parser/turn.rb

@@ -4,15 +4,15 @@ module FEEN
   module Parser
     # The turn module.
     module Turn
-      # @param active_side_id [String] The identifier of bottom-side and
+      # @param side_id [String] The identifier of bottom-side and
       #   top-side.
       #
       # @example Parse the number that identify the player who have to play
       #   parse("0") # => 0
       #
       # @return [Integer] The number that identify the player who have to play.
-      def self.parse(active_side_id)
-        Integer(active_side_id)
+      def self.parse(side_id)
+        Integer(side_id)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-24 00:00:00.000000000 Z
+date: 2020-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: brutal
@@ -132,13 +132,13 @@ files:
 - README.md
 - lib/feen.rb
 - lib/feen/dumper.rb
-- lib/feen/dumper/board.rb
-- lib/feen/dumper/pieces_in_hand.rb
+- lib/feen/dumper/in_hand.rb
+- lib/feen/dumper/square.rb
 - lib/feen/dumper/turn.rb
 - lib/feen/parser.rb
-- lib/feen/parser/board.rb
-- lib/feen/parser/pieces_in_hand.rb
+- lib/feen/parser/in_hand.rb
 - lib/feen/parser/shape.rb
+- lib/feen/parser/square.rb
 - lib/feen/parser/turn.rb
 homepage: https://developer.sashite.com/specs/forsyth-edwards-expanded-notation
 licenses:
@@ -155,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/feen/dumper/board.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module FEEN
-  module Dumper
-    # The board class.
-    #
-    # @example Dump an empty board of Xiangqi
-    #   Board.new(10, 9).to_s # => "9/9/9/9/9/9/9/9/9/9"
-    #
-    # @example Dump the Xiangqi starting position board
-    #   Board.new(10, 9,
-    #     "0": "車",
-    #     "1": "馬",
-    #     "2": "象",
-    #     "3": "士",
-    #     "4": "將",
-    #     "5": "士",
-    #     "6": "象",
-    #     "7": "馬",
-    #     "8": "車",
-    #     "19": "砲",
-    #     "25": "砲",
-    #     "27": "卒",
-    #     "29": "卒",
-    #     "31": "卒",
-    #     "33": "卒",
-    #     "35": "卒",
-    #     "54": "兵",
-    #     "56": "兵",
-    #     "58": "兵",
-    #     "60": "兵",
-    #     "62": "兵",
-    #     "64": "炮",
-    #     "70": "炮",
-    #     "81": "俥",
-    #     "82": "傌",
-    #     "83": "相",
-    #     "84": "仕",
-    #     "85": "帥",
-    #     "86": "仕",
-    #     "87": "相",
-    #     "88": "傌",
-    #     "89": "俥").to_s # => "車,馬,象,士,將,士,象,馬,車/9/1,砲,5,砲,1/卒,1,卒,1,卒,1,卒,1,卒/9/9/兵,1,兵,1,兵,1,兵,1,兵/1,炮,5,炮,1/9/俥,傌,相,仕,帥,仕,相,傌,俥"
-    class Board
-      # @param indexes [Array] The shape of the board.
-      # @param board [Hash] The indexes of each piece on the board.
-      def initialize(*indexes, **board)
-        @indexes = indexes
-        @squares = Array.new(length) { |i| board.fetch(i.to_s.to_sym, nil) }
-      end
-
-      # @return [String] The string representing the board.
-      def to_s
-        unflatten(@squares, *@indexes)
-      end
-
-      private
-
-      def length
-        @indexes.inject(:*)
-      end
-
-      def unflatten(squares, *remaining_indexes)
-        return row(*squares) if remaining_indexes.length == 1
-
-        squares
-          .each_slice(squares.length / remaining_indexes.fetch(0))
-          .to_a
-          .map { |sub_squares| unflatten(sub_squares, *remaining_indexes[1..]) }
-          .join("/" * remaining_indexes.length.pred)
-      end
-
-      def row(*squares)
-        squares
-          .map { |square| square.nil? ? 1 : square }
-          .join(",")
-          .gsub(/1,[1,]*1/) { |str| str.split(",").length }
-      end
-    end
-  end
-end

data/lib/feen/dumper/pieces_in_hand.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module FEEN
-  module Dumper
-    # The pieces in hand class.
-    #
-    # @example Serialize a list of pieces in hand grouped by sides
-    #   PiecesInHand.dump(
-    #     %w[S],
-    #     %w[r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
-    #   )
-    #   # => "S/b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s"
-    class PiecesInHand
-      # Serialize pieces in hand lists into a string.
-      #
-      # @param pieces_in_hand_grouped_by_sides [Array] The list of pieces in hand
-      #   grouped by players.
-      #
-      # @return [String] A string representing the pieces in hand of both
-      #   players.
-      def self.dump(*pieces_in_hand_grouped_by_sides)
-        pieces_in_hand_grouped_by_sides.map { |pieces| new(*pieces).to_s }.join("/")
-      end
-
-      # @param pieces [Array] A list of pieces in hand.
-      def initialize(*pieces)
-        @pieces = pieces.sort
-      end
-
-      # @return [String] A string representing the pieces in hand.
-      def to_s
-        @pieces.join(",")
-      end
-    end
-  end
-end

data/lib/feen/parser/pieces_in_hand.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module FEEN
-  module Parser
-    # The pieces in hand module.
-    module PiecesInHand
-      # The list of pieces in hand grouped by players.
-      #
-      # @param pieces_in_hand_grouped_by_sides_str [String] The serialized list of
-      #   pieces in hand grouped by players.
-      #
-      # @example Parse a list of serialized pieces in hand
-      #   parse("S/b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s")
-      #   # => [
-      #   #      %w[S],
-      #   #      %w[b g g g g n n n n p p p p p p p p p p p p p p p p p r r s]
-      #   #    ]
-      #
-      # @return [Array] The list of pieces in hand grouped by players.
-      def self.parse(pieces_in_hand_grouped_by_sides_str)
-        pieces_in_hand_grouped_by_sides_str
-          .split("/", -1)
-          .map { |pieces_in_hand_str| pieces_in_hand_str.split(",") }
-      end
-    end
-  end
-end