feen 4.0.2 → 5.0.0.beta0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59e59d257cf32a7580d7a751f27046a94dc4cc042237d165a2a941d34928c0c5
-  data.tar.gz: d17e95bad6d8868e37f1a2dab71d198f44b9fd742400bb70d3f314b8e79c2155
+  metadata.gz: 53d90951a531e63bc118104956d29e7c71c90075ab4d42d57506ec5197a783cb
+  data.tar.gz: 2cbf73113cc4a429420c3c4e0f30c448380a397bf39f264e617fa85119193f7f
 SHA512:
-  metadata.gz: d32ac92d63927327f269559bbafe824265504981178ace24f748ec3201f274669802ea3658c813df3747d5b66cbfb183de92fa9aa57444b807a6f3a5989d1fc7
-  data.tar.gz: 6352db3b19a703f15102ccba19bb8491605307575a901d862fa19df550558af37610d9ed720afe865975f4e7701b85efae55fcfbab9539786c03c1ec7d780921
+  metadata.gz: 3919811f24c5ad1f82dfd257eeefe3515efbcb6fd433a1feb20597e4c6a0fbe6a24c33bef56ea7f612e87fac3124b6334b261c1e987a02f7ecf43a6da745f950
+  data.tar.gz: 7b16a8ecd4d80444d1ee14477be61906f3c9503f0a05083dc191822d8a663a6a4fee379c6b0d40fd9bec509c98f0ae863282e1512a6035b7f0624279cb774da0

data/LICENSE.md

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+# The MIT License
 
-Copyright (c) 2020-2021 Sashite
+Copyright (c) 2020-2023 Sashité
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,4 +1,4 @@
-# FEEN.rb
+# Feen.rb
 
 [![Version](https://img.shields.io/github/v/tag/sashite/feen.rb?label=Version&logo=github)](https://github.com/sashite/feen.rb/releases)
 [![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/sashite/feen.rb/main)
@@ -6,69 +6,101 @@
 [![RuboCop](https://github.com/sashite/feen.rb/workflows/RuboCop/badge.svg?branch=main)](https://github.com/sashite/feen.rb/actions?query=workflow%3Arubocop+branch%3Amain)
 [![License](https://img.shields.io/github/license/sashite/feen.rb?label=License&logo=github)](https://github.com/sashite/feen.rb/raw/main/LICENSE.md)
 
-> __FEEN__ (Forsyth–Edwards Expanded Notation) support for the Ruby language.
+> __FEEN__ (FEN Easy Extensible Notation) support for the Ruby language.
 
 ## Overview
 
-This is an implementation of [FEEN](https://developer.sashite.com/specs/forsyth-edwards-expanded-notation), a generic format that can be used for serializing and deserializing chess positions.
+This is an implementation of [FEEN](https://developer.sashite.com/specs/fen-easy-extensible-notation), a generic format that can be used for serializing and deserializing positions.
 
-The main chess variants are supported, including [Chess](https://en.wikipedia.org/wiki/Chess), [Janggi](https://en.wikipedia.org/wiki/Janggi), [Makruk](https://en.wikipedia.org/wiki/Makruk), [Shogi](https://en.wikipedia.org/wiki/Shogi), [Xiangqi](https://en.wikipedia.org/wiki/Xiangqi).
+A __FEEN__ string consists of a single line of ASCII text containing three data fields, separated by a space. These are:
 
-More exotic variants are also supported, like: [Dai dai shogi](https://en.wikipedia.org/wiki/Dai_dai_shogi), [Four-player chess](https://en.wikipedia.org/wiki/Four-player_chess), or [Three-dimensional chess](https://en.wikipedia.org/wiki/Three-dimensional_chess) 🖖
+1. Piece placement
+2. Side to move
+3. Pieces in hand
 
-![3D chess on Star Trek (from the episode "Court Martial")](https://github.com/sashite/feen.rb/raw/master/star-trek-chess.jpg)
+The main chess variants may be supported, including [Chess](https://en.wikipedia.org/wiki/Chess), [Janggi](https://en.wikipedia.org/wiki/Janggi), [Makruk](https://en.wikipedia.org/wiki/Makruk), [Shogi](https://en.wikipedia.org/wiki/Shogi), [Xiangqi](https://en.wikipedia.org/wiki/Xiangqi).
+
+More exotic variants may be also supported, like: [Dai dai shogi](https://en.wikipedia.org/wiki/Dai_dai_shogi), [Four-player chess](https://en.wikipedia.org/wiki/Four-player_chess), or [Three-dimensional chess](https://en.wikipedia.org/wiki/Three-dimensional_chess) 🖖
+
+![3D chess on Star Trek (from the episode "Court Martial")](https://github.com/sashite/feen.rb/raw/main/star-trek-chess.jpg)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "feen"
+gem "feen", ">= 5.0.0.beta0"
 ```
 
 And then execute:
 
 ```sh
-bundle
+bundle install
 ```
 
 Or install it yourself as:
 
 ```sh
-gem install feen
+gem install feen --pre
 ```
 
 ## Usage
 
+### Serialization
+
+A position can be serialized by filling in these fields:
+
+- **Piece placement**: Describes the placement of pieces on the board with a hash that references each piece on the board. The keys could be numbers, or strings of characters representing coordinates.
+- **Side to move**: A char that indicates who moves next. In chess, "`w`" would mean that White must move, and "`b`" that Black must move. In Shogi, "`s`" could mean that Sente must move, and "`g`" that Gote must move. In Xiangqi, "`r`" could mean that Red must move, and "`b`" that Black must move.
+- **Pieces in hand**: An array of all captured pieces that remain _in hand_, like in Shogi.
+- **Board shape**: An array of integers. For instance, it would be `[10, 9]` in Xiangqi. And it would be `[8, 8]` in Chess.
+
+#### Examples
+
+##### A classic Tsume Shogi problem
+
 ```ruby
 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,
-  square: {
-    3 => "s",
-    4 => "k",
-    5 => "s",
+Feen.dump(
+  side_to_move:    "s",
+  pieces_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],
+  board_shape:     [9, 9],
+  piece_placement: {
+    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 s S,b,g*4,n*4,p*17,r*2,s"
+```
+
+### Deserialization
+
+Serialized positions can be converted back to fields.
+
+#### Examples
+
+##### A classic Tsume Shogi problem
+
+```ruby
+require "feen"
 
-# 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")
-# => {: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}
+Feen.parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 s S,b,g*4,n*4,p*17,r*2,s")
+# {:board_shape=>[9, 9],
+#  :pieces_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"],
+#  :piece_placement=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"},
+#  :side_to_move=>"s"}
 ```
 
 ## License
 
 The code is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-## About Sashite
+## About Sashité
 
-This [gem](https://rubygems.org/gems/feen) is maintained by [Sashite](https://sashite.com/).
+This [gem](https://rubygems.org/gems/feen) is maintained by [Sashité](https://sashite.com/).
 
 With some [lines of code](https://github.com/sashite/), let's share the beauty of Chinese, Japanese and Western cultures through the game of chess!

data/lib/feen/dumper/{square.rb → piece_placement.rb}

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-module FEEN
+module Feen
   module Dumper
-    # The square class.
+    # The PiecePlacement class.
     #
     # @example Dump an empty board of Xiangqi
-    #   Board.new([10, 9]).to_s # => "9/9/9/9/9/9/9/9/9/9"
+    #   PiecePlacement.new([10, 9]).to_s # => "9/9/9/9/9/9/9/9/9/9"
     #
     # @example Dump the Xiangqi starting position board
-    #   Board.new(
+    #   PiecePlacement.new(
     #     [10, 9],
     #     {
     #        0 => "車",
@@ -45,12 +45,12 @@ module FEEN
     #       89 => "俥"
     #     }
     #   ).to_s # => "車,馬,象,士,將,士,象,馬,車/9/1,砲,5,砲,1/卒,1,卒,1,卒,1,卒,1,卒/9/9/兵,1,兵,1,兵,1,兵,1,兵/1,炮,5,炮,1/9/俥,傌,相,仕,帥,仕,相,傌,俥"
-    class Square
+    class PiecePlacement
       # @param indexes [Array] The shape of the board.
-      # @param board [Hash] The index of each piece on the board.
-      def initialize(indexes, board)
+      # @param piece_placement [Hash] The index of each piece on the board.
+      def initialize(indexes, piece_placement = {})
         @indexes = indexes
-        @squares = Array.new(length) { |i| board.fetch(i, nil) }
+        @squares = ::Array.new(length) { |i| piece_placement.fetch(i, nil) }
       end
 
       # @return [String] The string representing the board.

data/lib/feen/dumper/{in_hand.rb → pieces_in_hand.rb}

@@ -1,26 +1,27 @@
 # frozen_string_literal: true
 
-module FEEN
+module Feen
   module Dumper
-    # The pieces in hand module.
-    module InHand
+    # A module that serializes pieces in hand lists into a string.
+    module PiecesInHand
       # Serialize pieces in hand lists into a string.
       #
       # @param piece_names [Array] A list of pieces in hand.
       #
       # @example Dump a list of pieces in hand
       #   dump(["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"
+      #   # => "S,b,g*4,n*4,p*17,r*2,s"
       #
       # @example Dump an empty list of pieces in hand
       #   dump([])
-      #   # => "-"
+      #   # => nil
       #
-      # @return [String] A string representing the pieces in hand.
+      # @return [String, nil] A serialized list of pieces in hand.
       def self.dump(piece_names)
-        return "-" if piece_names.empty?
+        return if piece_names.empty?
 
-        piece_names.sort.join(",")
+        hash = piece_names.group_by(&:itself).transform_values(&:count)
+        hash.map { |k, v| v > 1 ? "#{k}*#{v}" : k }.sort.join(",")
       end
     end
   end

data/lib/feen/dumper.rb

@@ -1,25 +1,24 @@
 # frozen_string_literal: true
 
-require_relative File.join("dumper", "in_hand")
-require_relative File.join("dumper", "square")
-require_relative File.join("dumper", "turn")
+require_relative File.join("dumper", "piece_placement")
+require_relative File.join("dumper", "pieces_in_hand")
 
-module FEEN
+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 square [Hash] The index of each piece on the board.
+    # @param side_to_move [String] Identify the active side.
+    # @param pieces_in_hand [Array, nil] The list of pieces in hand.
+    # @param board_shape [Array] The shape of the board.
+    # @param piece_placement [Hash] The index of each piece on the board.
     #
     # @example Dump a classic Tsume Shogi problem
     #   call(
-    #     "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": {
+    #     "side_to_move": "s",
+    #     "pieces_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],
+    #     "board_shape": [9, 9],
+    #     "piece_placement": {
     #        3 => "s",
     #        4 => "k",
     #        5 => "s",
@@ -27,15 +26,17 @@ module FEEN
     #       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 s S,b,g*4,n*4,p*17,r*2,s"
     #
     # @return [String] The FEEN string representing the position.
-    def self.call(in_hand:, shape:, side_id:, square:)
-      [
-        Square.new(shape, square).to_s,
-        Turn.dump(side_id),
-        InHand.dump(in_hand)
-      ].join(" ")
+    def self.call(board_shape:, side_to_move:, piece_placement:, pieces_in_hand: nil)
+      array = [
+        PiecePlacement.new(board_shape, piece_placement).to_s,
+        side_to_move
+      ]
+
+      array << PiecesInHand.dump(pieces_in_hand) if Array(pieces_in_hand).any?
+      array.join(" ")
     end
   end
 end

data/lib/feen/parser/{shape.rb → board_shape.rb}

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-module FEEN
+module Feen
   module Parser
-    # The shape class.
+    # The BoardShape class.
     #
     # @example Parse the shape of a shogiban
-    #   Shape.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_a # => [9, 9]
-    class Shape
-      # @param board [String] The flatten board.
-      def initialize(board)
-        @board = board
+    #   BoardShape.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_a # => [9, 9]
+    class BoardShape
+      # @param board_str [String] The flatten board.
+      def initialize(board_str)
+        @board_str = board_str
       end
 
       # @return [Array] The size of each dimension of the board.
       def to_a
-        indexes(@board, @board.scan(%r{/+}).sort.fetch(-1))
+        indexes(@board_str, @board_str.scan(%r{/+}).sort.fetch(-1))
       end
 
       private

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module FEEN
+module Feen
   module Parser
-    # The square class.
+    # The PiecePlacement 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
+    #   PiecePlacement.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_a
     #   # => [
     #   #      nil, nil, nil, "s", "k", "s", nil, nil, nil,
     #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
@@ -19,7 +19,7 @@ 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
+    #   PiecePlacement.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_h
     #   # => {
     #   #       3 => "s",
     #   #       4 => "k",
@@ -27,15 +27,15 @@ module FEEN
     #   #      22 => "+P",
     #   #      43 => "+B"
     #   #    }
-    class Square
-      # @param board [String] The flatten board.
-      def initialize(board)
-        @board = board
+    class PiecePlacement
+      # @param piece_placement_str [String] The placement of pieces on the board.
+      def initialize(piece_placement_str)
+        @piece_placement_str = piece_placement_str
       end
 
-      # @return [Array] The list of squares on the board.
+      # @return [Array] The list of pieces on the board.
       def to_a
-        @board
+        @piece_placement_str
           .split(%r{[/,]+})
           .flat_map { |str| row(str) }
       end

data/lib/feen/parser/{in_hand.rb → pieces_in_hand.rb}

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-module FEEN
+module Feen
   module Parser
     # The pieces in hand module.
-    module InHand
+    module PiecesInHand
       # The list of pieces in hand grouped by players.
       #
-      # @param piece_names_str [String] The serialized list of pieces in hand.
+      # @param pieces_in_hand [String, nil] 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")
+      #   parse("S,b,g*4,n*4,p*17,r*2,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"]
       #
       # @example Parse an empty list of serialized pieces in hand
@@ -17,10 +17,17 @@ module FEEN
       #   # => []
       #
       # @return [Array] The list of pieces in hand grouped by players.
-      def self.parse(piece_names_str)
-        return [] if piece_names_str == "-"
+      def self.parse(pieces_in_hand)
+        return if pieces_in_hand.nil?
 
-        piece_names_str.split(",")
+        pieces_in_hand.split(",").flat_map do |piece|
+          if piece.include?("*")
+            letter, count = piece.split("*")
+            [letter] * count.to_i
+          else
+            piece
+          end
+        end.sort
       end
     end
   end

data/lib/feen/parser.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-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")
+require_relative File.join("parser", "board_shape")
+require_relative File.join("parser", "pieces_in_hand")
+require_relative File.join("parser", "piece_placement")
 
-module FEEN
+module Feen
   # The parser module.
   module Parser
     # Parse a FEEN string into position params.
@@ -13,12 +12,12 @@ 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 s S,b,g*4,n*4,p*17,r*2,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,
-    #   #      "square": {
+    #   #      "side_to_move": "s",
+    #   #      "pieces_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"],
+    #   #      "board_shape": [9, 9],
+    #   #      "piece_placement": {
     #   #         3 => "s",
     #   #         4 => "k",
     #   #         5 => "s",
@@ -28,13 +27,13 @@ module FEEN
     #
     # @return [Hash] The position params representing the position.
     def self.call(feen)
-      square_str, side_id_str, in_hand_str = feen.split
+      piece_placement, side_to_move, pieces_in_hand = feen.split
 
       {
-        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
+        board_shape:     BoardShape.new(piece_placement).to_a,
+        pieces_in_hand:  PiecesInHand.parse(pieces_in_hand),
+        piece_placement: PiecePlacement.new(piece_placement).to_h,
+        side_to_move:
       }
     end
   end

data/lib/feen.rb

@@ -6,21 +6,21 @@ require_relative File.join("feen", "parser")
 # This module provides a Ruby interface for data serialization and
 # deserialization in FEEN format.
 #
-# @see https://developer.sashite.com/specs/forsyth-edwards-expanded-notation
-module FEEN
+# @see https://developer.sashite.com/specs/fen-easy-extensible-notation
+module Feen
   # 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 square [Hash] The index of each piece on the board.
+  # @param pieces_in_hand [Array, nil] The list of pieces in hand.
+  # @param board_shape [Array] The shape of the board.
+  # @param side_to_move [String] The identifier of the player who must play.
+  # @param piece_placement [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,
-  #     "square": {
+  #     "side_to_move": "s",
+  #     "pieces_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],
+  #     "board_shape": [9, 9],
+  #     "piece_placement": {
   #        3 => "s",
   #        4 => "k",
   #        5 => "s",
@@ -28,15 +28,15 @@ module FEEN
   #       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 s S,b,g*4,n*4,p*17,r*2,s"
   #
   # @return [String] The FEEN string representing the position.
-  def self.dump(in_hand:, shape:, side_id:, square:)
+  def self.dump(board_shape:, side_to_move:, piece_placement:, pieces_in_hand: nil)
     Dumper.call(
-      in_hand: in_hand,
-      shape: shape,
-      side_id: side_id,
-      square: square
+      pieces_in_hand:,
+      board_shape:,
+      side_to_move:,
+      piece_placement:
     )
   end
 
@@ -45,12 +45,12 @@ 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 s S,b,g*4,n*4,p*17,r*2,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,
-  #   #      "square": {
+  #   #      "pieces_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"],
+  #   #      "board_shape": [9, 9],
+  #   #      "side_to_move": "s",
+  #   #      "piece_placement": {
   #   #         3 => "s",
   #   #         4 => "k",
   #   #         5 => "s",

metadata

@@ -1,155 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 4.0.2
+  version: 5.0.0.beta0
 platform: ruby
 authors:
 - Cyril Kato
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-13 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: brutal
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-md
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-thread_safety
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2023-04-25 00:00:00.000000000 Z
+dependencies: []
 description: A Ruby interface for data serialization and deserialization in FEEN format.
 email: contact@cyril.email
 executables: []
@@ -160,22 +20,18 @@ files:
 - README.md
 - lib/feen.rb
 - lib/feen/dumper.rb
-- lib/feen/dumper/in_hand.rb
-- lib/feen/dumper/square.rb
-- lib/feen/dumper/turn.rb
+- lib/feen/dumper/piece_placement.rb
+- lib/feen/dumper/pieces_in_hand.rb
 - lib/feen/parser.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
+- lib/feen/parser/board_shape.rb
+- lib/feen/parser/piece_placement.rb
+- lib/feen/parser/pieces_in_hand.rb
+homepage: https://github.com/sashite/feen.rb
 licenses:
 - MIT
 metadata:
-  bug_tracker_uri: https://github.com/sashite/feen.rb/issues
-  documentation_uri: https://rubydoc.info/gems/feen/index
-  source_code_uri: https://github.com/sashite/feen.rb
-post_install_message:
+  rubygems_mfa_required: 'true'
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -183,15 +39,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.2.22
-signing_key:
+rubygems_version: 3.4.6
+signing_key: 
 specification_version: 4
 summary: FEEN support for the Ruby language.
 test_files: []

data/lib/feen/dumper/turn.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module FEEN
-  module Dumper
-    # The turn module.
-    module Turn
-      # @param side_id [Integer] The identifier of the active player.
-      #
-      # @example Dump the number that identify the player who have to play
-      #   dump(0) # => "0"
-      #
-      # @return [String] The number that identify the player who have to play.
-      def self.dump(side_id)
-        String(side_id)
-      end
-    end
-  end
-end

data/lib/feen/parser/turn.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module FEEN
-  module Parser
-    # The turn module.
-    module Turn
-      # @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(side_id)
-        Integer(side_id)
-      end
-    end
-  end
-end