feen 4.0.3 → 5.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98cae677c862ba15d503bd607228abfd3aa06f7b4524c30f1a8890f446978784
-  data.tar.gz: ce5628e2b182d15d7e51567b67550338308a87508bf4422cae6e710b04aa6e33
+  metadata.gz: 2fa56bccbb1911f15569f2f5643646986cbf83661efba3165c69978e7c85fd56
+  data.tar.gz: 13d706d1bfe1c09f6d015d0a8f28af621754677711074ec60ec96e395f1a1061
 SHA512:
-  metadata.gz: b294ea3521b0e34fbce443942d7c9aec06388f290025977d6995312f0a01492aedd498ea6a9e41b5eb19f9762ae79a6970a512f192fda2ab09ec890cd77c606d
-  data.tar.gz: 6dd225e8abcf4189f4124225a35d26c1f1faf39e804204f2467bf11350539394f9ea52eeabb3835d1d3ab232c74b1136e341f21669b469a126395473034bdac7
+  metadata.gz: 5479cbd02c902aa8c45cc12ecfab31c7b7283eb1f8ec60b110c889505a7ebbcf76fa7b0d2e6ad44c60da954312fa85ae03cd4981d929207b0612754f1d62a033
+  data.tar.gz: b6268ce619808bf2c2f889261b55007edbfc030bc37b8edea7f73f505de55e8c0fc1cd4a268e8e2bdc71fe21c9fa33f904c8b26a23b92b471e406e109494bd97

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,24 +6,18 @@
 [![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__ (FEN Easy Extensible Notation) support for the Ruby language.
+> __FEEN__ (Forsyth–Edwards Expanded Notation) support for the Ruby language.
 
 ## 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.
-
-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)
+This is an implementation of [FEEN](https://github.com/sashite/specs/blob/main/forsyth-edwards-expanded-notation.md), a flexible and minimalist format for describing chess variant positions.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "feen"
+gem "feen", ">= 5.0.0.beta1"
 ```
 
 And then execute:
@@ -35,20 +29,30 @@ 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:
+
+- **Board shape**: An array of integers. For instance, it would be `[10, 9]` for a Xiangqi board. Or it would be `[8, 8]` for a Chess board.
+- **Piece placement**: Describes the placement of pieces on the board with a hash that references each piece on the board.
+- **Side to move**: A char that indicates who moves next. In chess, "`w`" would mean that White can play a move.
+
+#### Example
+
+From 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(
+  board_shape:     [9, 9],
+  side_to_move:    "s",
+  piece_placement: {
     3  => "s",
     4  => "k",
     5  => "s",
@@ -56,11 +60,22 @@ 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"
+# => "3sks3/9/4+P4/9/7+B1/9/9/9/9 s"
+```
+
+### Deserialization
+
+Serialized positions can be converted back to fields.
+
+#### Example
+
+```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("3sks3/9/4+P4/9/7+B1/9/9/9/9 s")
+# {:board_shape=>[9, 9],
+#  :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 => "車",
@@ -44,13 +44,13 @@ module FEEN
     #       88 => "傌",
     #       89 => "俥"
     #     }
-    #   ).to_s # => "車,馬,象,士,將,士,象,馬,車/9/1,砲,5,砲,1/卒,1,卒,1,卒,1,卒,1,卒/9/9/兵,1,兵,1,兵,1,兵,1,兵/1,炮,5,炮,1/9/俥,傌,相,仕,帥,仕,相,傌,俥"
-    class Square
+    #   ).to_s # => "車馬象士將士象馬車/9/1砲5砲1/卒1卒1卒1卒1卒/9/9/兵1兵1兵1兵1兵/1炮5炮1/9/俥傌相仕帥仕相傌俥"
+    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.
@@ -79,6 +79,7 @@ module FEEN
           .map { |square| square.nil? ? 1 : square }
           .join(",")
           .gsub(/1,[1,]*1/) { |str| str.split(",").length }
+          .delete(",")
       end
     end
   end

data/lib/feen/dumper.rb

@@ -1,25 +1,21 @@
 # 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")
 
-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 board_shape [Array] The shape of the board.
+    # @param side_to_move [String] Identify the active side.
+    # @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": {
+    #     "board_shape": [9, 9],
+    #     "side_to_move": "s",
+    #     "piece_placement": {
     #        3 => "s",
     #        4 => "k",
     #        5 => "s",
@@ -27,14 +23,13 @@ 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"
+    #   # => "3sks3/9/4+P4/9/7+B1/9/9/9/9 s"
     #
     # @return [String] The FEEN string representing the position.
-    def self.call(in_hand:, shape:, side_id:, square:)
+    def self.call(board_shape:, side_to_move:, piece_placement:)
       [
-        Square.new(shape, square).to_s,
-        Turn.dump(side_id),
-        InHand.dump(in_hand)
+        PiecePlacement.new(board_shape, piece_placement).to_s,
+        side_to_move
       ].join(" ")
     end
   end

data/lib/feen/parser/board_shape.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Feen
+  module Parser
+    # The BoardShape class.
+    #
+    # @example Parse the shape of a shogiban
+    #   BoardShape.new("3sks3/9/4+P4/9/7+B1/9/9/9/9").to_a # => [9, 9]
+    class BoardShape
+      # @param board_str [String] The flatten board.
+      def initialize(board_str, regex: /\+?[a-z]/i)
+        @board_str = board_str
+        @regex = regex
+      end
+
+      # @return [Array] The size of each dimension of the board.
+      def to_a
+        indexes(@board_str, @board_str.scan(%r{/+}).sort.fetch(-1))
+      end
+
+      private
+
+      def indexes(string, separator)
+        if separator.empty?
+          last_index = string.scan(/(\d+|#{@regex})/).inject(0) do |counter, match|
+            sub_string = match[0]
+            number = sub_string.match?(/\d+/) ? Integer(sub_string) : 1
+            counter + number
+          end
+
+          return [last_index]
+        end
+
+        sub_strings = string.split(separator)
+        [sub_strings.length] + indexes(sub_strings.fetch(0), separator[1..])
+      end
+    end
+  end
+end

data/lib/feen/parser.rb

@@ -1,11 +1,8 @@
 # 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")
 
-module FEEN
+module Feen
   # The parser module.
   module Parser
     # Parse a FEEN string into position params.
@@ -13,12 +10,11 @@ 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("3sks3/9/4+P4/9/7+B1/9/9/9/9 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": {
+    #   #      "board_shape": [9, 9],
+    #   #      "side_to_move": "s",
+    #   #      "piece_placement": {
     #   #         3 => "s",
     #   #         4 => "k",
     #   #         5 => "s",
@@ -27,15 +23,29 @@ module FEEN
     #   #      }
     #
     # @return [Hash] The position params representing the position.
-    def self.call(feen)
-      square_str, side_id_str, in_hand_str = feen.split
+    def self.call(feen, regex: /\+?[a-z]/i)
+      piece_placement_str, side_to_move_str = 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_str, regex:).to_a,
+        piece_placement: piece_placement(piece_placement_str, regex:),
+        side_to_move:    side_to_move_str
       }
     end
+
+    def self.piece_placement(string, regex:)
+      hash = {}
+      index = 0
+      string.scan(/(\d+|#{regex})/) do |match|
+        if /\d+/.match?(match[0])
+          index += match[0].to_i
+        else
+          hash[index] = match[0]
+          index += 1
+        end
+      end
+      hash
+    end
+    private_class_method :piece_placement
   end
 end

data/lib/feen.rb

@@ -6,21 +6,19 @@ 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/fen-easy-extensible-notation
-module FEEN
+# @see https://github.com/sashite/specs/blob/main/forsyth-edwards-expanded-notation.md
+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 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": {
+  #     "board_shape": [9, 9],
+  #     "side_to_move": "s",
+  #     "piece_placement": {
   #        3 => "s",
   #        4 => "k",
   #        5 => "s",
@@ -28,15 +26,14 @@ 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"
+  #   # => "3sks3/9/4+P4/9/7+B1/9/9/9/9 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:)
     Dumper.call(
-      in_hand:,
-      shape:,
-      side_id:,
-      square:
+      board_shape:,
+      side_to_move:,
+      piece_placement:
     )
   end
 
@@ -45,12 +42,11 @@ 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("3sks3/9/4+P4/9/7+B1/9/9/9/9 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": {
+  #   #      "board_shape": [9, 9],
+  #   #      "side_to_move": "s",
+  #   #      "piece_placement": {
   #   #         3 => "s",
   #   #         4 => "k",
   #   #         5 => "s",
@@ -59,7 +55,7 @@ module FEEN
   #   #      }
   #
   # @return [Hash] The position params representing the position.
-  def self.parse(feen)
-    Parser.call(feen)
+  def self.parse(feen, regex: /\+?[a-z]/i)
+    Parser.call(feen, regex:)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 4.0.3
+  version: 5.0.0.beta1
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-24 00:00:00.000000000 Z
+date: 2023-04-27 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,9 @@ 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/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
 homepage: https://github.com/sashite/feen.rb
 licenses:
 - MIT
@@ -44,9 +39,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/in_hand.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module FEEN
-  module Dumper
-    # The pieces in hand module.
-    module InHand
-      # 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"
-      #
-      # @example Dump an empty list of pieces in hand
-      #   dump([])
-      #   # => "-"
-      #
-      # @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/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/in_hand.rb

@@ -1,27 +0,0 @@
-# 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"]
-      #
-      # @example Parse an empty list of serialized pieces in hand
-      #   parse("-")
-      #   # => []
-      #
-      # @return [Array] The list of pieces in hand grouped by players.
-      def self.parse(piece_names_str)
-        return [] if piece_names_str == "-"
-
-        piece_names_str.split(",")
-      end
-    end
-  end
-end

data/lib/feen/parser/shape.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module FEEN
-  module Parser
-    # The shape 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
-      end
-
-      # @return [Array] The size of each dimension of the board.
-      def to_a
-        indexes(@board, @board.scan(%r{/+}).sort.fetch(-1))
-      end
-
-      private
-
-      def indexes(string, separator)
-        if separator.empty?
-          last_index = string.split(",").inject(0) do |counter, sub_string|
-            number = sub_string.match?(/[0-9]+/) ? Integer(sub_string) : 1
-            counter + number
-          end
-
-          return [last_index]
-        end
-
-        sub_strings = string.split(separator)
-        [sub_strings.length] + indexes(sub_strings.fetch(0), separator[1..])
-      end
-    end
-  end
-end

data/lib/feen/parser/square.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module FEEN
-  module Parser
-    # 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
-    #   # => [
-    #   #      nil, nil, nil, "s", "k", "s", nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, "+P", nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, "+B", nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil
-    #   #    ]
-    #
-    # @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"
-    #   #    }
-    class Square
-      # @param board [String] The flatten board.
-      def initialize(board)
-        @board = board
-      end
-
-      # @return [Array] The list of squares on the board.
-      def to_a
-        @board
-          .split(%r{[/,]+})
-          .flat_map { |str| row(str) }
-      end
-
-      # @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 => v)
-          end
-      end
-
-      private
-
-      def row(string)
-        string.match?(/[0-9]+/) ? ::Array.new(Integer(string)) : string
-      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