feen 3.1.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abb8a5158f3723e03a49a81c8770ac85bde5d0a88386d7fb9a40739736c1fefe
-  data.tar.gz: 43d49d36468e55b84df7020ba7ea5ae5b3b73ed34ca640593e1ba05e094260f4
+  metadata.gz: 730da5cc06535403835733403b2e86d03435337bd7cd36e5af2d47a1442f199f
+  data.tar.gz: f3a1b2a952dccbc9bb5eeb15dcfc920d3ea270abb301ed29c098da5260a4c3e4
 SHA512:
-  metadata.gz: b447df75705569f2017bf8647ea4f6564661e6ea3467343662c16e7a4a68052eddf8952263badbd33c40132e2c4b9323481eecd882ce3be0fc44660a572d0805
-  data.tar.gz: 98db4cc2b5565fcaadd95e3e1f5b3c0facf04560088ac84209daa107000d0a829702a23b31b1544f4b2cb923330eb259c12a585a4da7fa564d87485de96cb915
+  metadata.gz: c001a2c2c8c7f88aba144ca878c45e11fde53b5c71ff3afa4caf8b05724d4a90dd6addfa32e29a4132b099818b4b6dd1dd0a55ab54b629af48b7113095d6cb54
+  data.tar.gz: 52f11c59367bc9d7dab6d21ad969cec1f7dd672f7fdab175f577d9076b7443e911b22b63c798198aae176f3939c4142f8eaa4cda1aa775464dbf0ba929f953ae

data/README.md

@@ -38,25 +38,22 @@ require "feen"
 
 # Dump a classic Tsume Shogi problem
 FEEN.dump(
+  "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,
-  "board": {
+  "square": {
      3 => "s",
      4 => "k",
      5 => "s",
     22 => "+P",
     43 => "+B"
-  },
-  "indexes": [9, 9],
-  "hands": [
-    %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]
-  ]
+  }
 )
-# => "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")
-# => {:board=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"}, :indexes=>[9, 9], :hands=>[["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}
+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 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 board [Hash] The indexes of each piece on the board.
-  # @param indexes [Array] The shape of the board.
-  # @param hands [Array] The list of pieces in hand
-  #   grouped by players.
+  # @param square [Hash] The index of each piece on the board.
   #
   # @example Dump a classic Tsume Shogi problem
   #   dump(
+  #     "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,
-  #     "board": {
+  #     "square": {
   #        3 => "s",
   #        4 => "k",
   #        5 => "s",
   #       22 => "+P",
   #       43 => "+B"
-  #     },
-  #     "hands": [
-  #       %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]
-  #     ],
-  #     "indexes": [9, 9]
+  #     }
   #   )
-  #   # => "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(board:, hands:, indexes:, side_id:)
+  def self.dump(in_hand:, shape:, side_id:, square:)
     Dumper.call(
-      board: board,
-      hands: hands,
-      indexes: indexes,
-      side_id: side_id
+      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")
   #   # => {
+  #   #      "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,
-  #   #      "board": {
+  #   #      "square": {
   #   #         3 => "s",
   #   #         4 => "k",
   #   #         5 => "s",
   #   #        22 => "+P",
   #   #        43 => "+B"
-  #   #      },
-  #   #      "hands": [
-  #   #        %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]
-  #   #      ],
-  #   #      "indexes": [9, 9]
-  #   #    }
+  #   #      }
   #
   # @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 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 board [Hash] The indexes of each piece on the board.
-    # @param indexes [Array] The shape of the board.
-    # @param hands [Array] The list of pieces in hand
-    #   grouped by players.
+    # @param square [Hash] The index of each piece on the board.
     #
     # @example Dump a classic Tsume Shogi problem
     #   call(
-    #     "board": {
+    #     "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"
-    #     },
-    #     "hands": [
-    #       %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]
-    #     ],
-    #     "indexes": [9, 9],
-    #     "side_id": 0
+    #     }
     #   )
-    #   # => "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(board:, hands:, indexes:, side_id:)
+    def self.call(in_hand:, shape:, side_id:, square:)
       [
-        Board.new(indexes, board).to_s,
-        Turn.dump(side_id, hands.length),
-        PiecesInHand.dump(hands)
+        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/{board.rb → square.rb}

@@ -2,7 +2,7 @@
 
 module FEEN
   module Dumper
-    # The board class.
+    # 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"
@@ -45,9 +45,9 @@ module FEEN
     #       89 => "俥"
     #     }
     #   ).to_s # => "車,馬,象,士,將,士,象,馬,車/9/1,砲,5,砲,1/卒,1,卒,1,卒,1,卒,1,卒/9/9/兵,1,兵,1,兵,1,兵,1,兵/1,炮,5,炮,1/9/俥,傌,相,仕,帥,仕,相,傌,俥"
-    class Board
+    class Square
       # @param indexes [Array] The shape of the board.
-      # @param board [Hash] The indexes of each piece on 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) }

data/lib/feen/dumper/turn.rb

@@ -5,14 +5,13 @@ module FEEN
     # The turn module.
     module Turn
       # @param side_id [Integer] The identifier of the active player.
-      # @param sides_count [Integer] The number of players.
       #
       # @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(side_id, sides_count)
-        String(Integer(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,32 +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")
     #   # => {
-    #   #      "board": {
+    #   #      "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"
-    #   #      },
-    #   #      "hands": [
-    #   #        %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]
-    #   #      ],
-    #   #      "indexes": [9, 9],
-    #   #      "side_id": 0
-    #   #    }
+    #   #      }
     #
     # @return [Hash] The position params representing the position.
     def self.call(feen)
-      board, side_id, in_hand = feen.split(" ")
+      square_str, side_id_str, in_hand_str = feen.split(" ")
 
       {
-        board: Board.new(board).to_h,
-        indexes: Shape.new(board).to_a,
-        hands: PiecesInHand.parse(in_hand),
-        side_id: Turn.parse(side_id)
+        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
@@ -27,7 +27,7 @@ module FEEN
     #   #      22 => "+P",
     #   #      43 => "+B"
     #   #    }
-    class Board
+    class Square
       # @param board [String] The flatten board.
       def initialize(board)
         @board = board
@@ -40,7 +40,7 @@ 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-20 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:

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 hands [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(hands)
-        hands.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 hands_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(hands_str)
-        hands_str
-          .split("/", -1)
-          .map { |pieces_in_hand_str| pieces_in_hand_str.split(",") }
-      end
-    end
-  end
-end