feen 4.0.3 → 5.0.0.beta0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98cae677c862ba15d503bd607228abfd3aa06f7b4524c30f1a8890f446978784
-  data.tar.gz: ce5628e2b182d15d7e51567b67550338308a87508bf4422cae6e710b04aa6e33
+  metadata.gz: 53d90951a531e63bc118104956d29e7c71c90075ab4d42d57506ec5197a783cb
+  data.tar.gz: 2cbf73113cc4a429420c3c4e0f30c448380a397bf39f264e617fa85119193f7f
 SHA512:
-  metadata.gz: b294ea3521b0e34fbce443942d7c9aec06388f290025977d6995312f0a01492aedd498ea6a9e41b5eb19f9762ae79a6970a512f192fda2ab09ec890cd77c606d
-  data.tar.gz: 6dd225e8abcf4189f4124225a35d26c1f1faf39e804204f2467bf11350539394f9ea52eeabb3835d1d3ab232c74b1136e341f21669b469a126395473034bdac7
+  metadata.gz: 3919811f24c5ad1f82dfd257eeefe3515efbcb6fd433a1feb20597e4c6a0fbe6a24c33bef56ea7f612e87fac3124b6334b261c1e987a02f7ecf43a6da745f950
+  data.tar.gz: 7b16a8ecd4d80444d1ee14477be61906f3c9503f0a05083dc191822d8a663a6a4fee379c6b0d40fd9bec509c98f0ae863282e1512a6035b7f0624279cb774da0

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)
@@ -10,7 +10,13 @@
 
 ## Overview
 
-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 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.
+
+A __FEEN__ string consists of a single line of ASCII text containing three data fields, separated by a space. These are:
+
+1. Piece placement
+2. Side to move
+3. Pieces in hand
 
 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).
 
@@ -23,7 +29,7 @@ More exotic variants may be also supported, like: [Dai dai shogi](https://en.wik
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "feen"
+gem "feen", ">= 5.0.0.beta0"
 ```
 
 And then execute:
@@ -35,20 +41,32 @@ 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:  {
+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",
@@ -56,11 +74,25 @@ FEEN.dump(
     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

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

@@ -7,20 +7,20 @@ require_relative File.join("feen", "parser")
 # deserialization in FEEN format.
 #
 # @see https://developer.sashite.com/specs/fen-easy-extensible-notation
-module FEEN
+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:,
-      shape:,
-      side_id:,
-      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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 4.0.3
+  version: 5.0.0.beta0
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-24 00:00:00.000000000 Z
+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
@@ -20,14 +20,12 @@ 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
+- 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
@@ -44,9 +42,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       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.4.6
 signing_key: 

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