feen 5.0.0.beta1 → 5.0.0.beta2

data/lib/feen/parser/pieces_in_hand.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Feen
+  module Parser
+    # Handles parsing of the pieces in hand section of a FEEN string
+    module PiecesInHand
+      NO_PIECES = "-"
+      ERRORS = {
+        invalid_type:       "Pieces in hand must be a string, got %s",
+        empty_string:       "Pieces in hand string cannot be empty",
+        invalid_chars:      "Invalid characters in pieces in hand: %s",
+        invalid_identifier: "Invalid piece identifier at position %d"
+      }.freeze
+
+      # Parses the pieces in hand section of a FEEN string
+      #
+      # @param pieces_in_hand_str [String] FEEN pieces in hand string
+      # @return [Array<Hash>] Array of pieces in hand
+      # @raise [ArgumentError] If the input string is invalid
+      def self.parse(pieces_in_hand_str)
+        validate_pieces_in_hand_string(pieces_in_hand_str)
+
+        # Handle the special case of no pieces in hand
+        return [] if pieces_in_hand_str == NO_PIECES
+
+        pieces = []
+        i = 0
+
+        while i < pieces_in_hand_str.length
+          # Vérifier que le caractère est une lettre
+          raise ArgumentError, format(ERRORS[:invalid_identifier], i) unless pieces_in_hand_str[i].match?(/[a-zA-Z]/)
+
+          pieces << { id: pieces_in_hand_str[i] }
+          i += 1
+
+        end
+
+        # Vérifier que les pièces sont triées par ordre lexicographique
+        raise ArgumentError, "Pieces in hand must be in ASCII lexicographic order" unless pieces_sorted?(pieces)
+
+        pieces
+      end
+
+      # Validates the pieces in hand string for syntax
+      #
+      # @param str [String] FEEN pieces in hand string
+      # @raise [ArgumentError] If the string is invalid
+      # @return [void]
+      def self.validate_pieces_in_hand_string(str)
+        raise ArgumentError, format(ERRORS[:invalid_type], str.class) unless str.is_a?(String)
+
+        raise ArgumentError, ERRORS[:empty_string] if str.empty?
+
+        # Check for the special case of no pieces in hand
+        return if str == NO_PIECES
+
+        # Check for valid characters (only letters)
+        valid_chars = /\A[a-zA-Z]+\z/
+        return if str.match?(valid_chars)
+
+        invalid_chars = str.scan(/[^a-zA-Z]/).uniq.join(", ")
+        raise ArgumentError, format(ERRORS[:invalid_chars], invalid_chars)
+      end
+
+      # Checks if pieces are sorted in ASCII lexicographic order
+      #
+      # @param pieces [Array<Hash>] Array of piece hashes
+      # @return [Boolean] True if pieces are sorted
+      def self.pieces_sorted?(pieces)
+        piece_ids = pieces.map { |piece| piece[:id] }
+        piece_ids == piece_ids.sort
+      end
+    end
+  end
+end

data/lib/feen/parser.rb

@@ -1,51 +1,52 @@
 # frozen_string_literal: true
 
-require_relative File.join("parser", "board_shape")
+require_relative File.join("parser", "games_turn")
+require_relative File.join("parser", "piece_placement")
+require_relative File.join("parser", "pieces_in_hand")
 
 module Feen
-  # The parser module.
+  # Module responsible for parsing FEEN notation strings into internal data structures
   module Parser
-    # Parse a FEEN string into position params.
+    # Parses a complete FEEN string into a structured representation
     #
-    # @param feen [String] The FEEN string representing a position.
-    #
-    # @example Parse a classic Tsume Shogi problem
-    #   call("3sks3/9/4+P4/9/7+B1/9/9/9/9 s")
-    #   # => {
-    #   #      "board_shape": [9, 9],
-    #   #      "side_to_move": "s",
-    #   #      "piece_placement": {
-    #   #         3 => "s",
-    #   #         4 => "k",
-    #   #         5 => "s",
-    #   #        22 => "+P",
-    #   #        43 => "+B"
-    #   #      }
-    #
-    # @return [Hash] The position params representing the position.
-    def self.call(feen, regex: /\+?[a-z]/i)
-      piece_placement_str, side_to_move_str = feen.split
+    # @param feen_string [String] Complete FEEN notation string
+    # @return [Hash] Hash containing the parsed position data
+    # @raise [ArgumentError] If the FEEN string is invalid
+    def self.parse(feen_string)
+      validate_feen_string(feen_string)
+
+      # Split the FEEN string into its three fields
+      fields = feen_string.strip.split(/\s+/)
+
+      raise ArgumentError, "Invalid FEEN format: expected 3 fields, got #{fields.size}" unless fields.size == 3
+
+      # Parse each field using the appropriate submodule
+      piece_placement = PiecePlacement.parse(fields[0])
+      games_turn = GamesTurn.parse(fields[1])
+      pieces_in_hand = PiecesInHand.parse(fields[2])
 
+      # Return a structured representation of the position
       {
-        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
+        piece_placement: piece_placement,
+        games_turn:      games_turn,
+        pieces_in_hand:  pieces_in_hand
       }
     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
+    # Validates the FEEN string for basic format
+    #
+    # @param feen_string [String] FEEN string to validate
+    # @raise [ArgumentError] If the FEEN string is fundamentally invalid
+    # @return [void]
+    def self.validate_feen_string(feen_string)
+      raise ArgumentError, "FEEN must be a string, got #{feen_string.class}" unless feen_string.is_a?(String)
+
+      raise ArgumentError, "FEEN string cannot be empty" if feen_string.empty?
+
+      # Check for at least two spaces (three fields)
+      return unless feen_string.count(" ") < 2
+
+      raise ArgumentError, "Invalid FEEN format: must contain at least two spaces separating three fields"
     end
-    private_class_method :piece_placement
   end
 end

data/lib/feen/sanitizer.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Feen
+  # Provides methods for sanitizing and validating chess-related notation strings
+  module Sanitizer
+    # Cleans a FEN (Forsyth-Edwards Notation) string by removing invalid castling rights
+    # and en passant targets based on the current position.
+    #
+    # The method performs the following validations:
+    # - Verifies that kings and rooks are in correct positions for castling rights
+    # - Verifies that en passant captures are actually possible
+    #
+    # @param fen_string [String] The FEN string to clean
+    # @return [String] A sanitized FEN string with invalid castling rights and en passant targets removed
+    # @raise [ArgumentError] If the FEN string is malformed (less than 4 parts)
+    #
+    # @example Clean a valid FEN string (unchanged)
+    #   fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+    #   Feen::Sanitizer.clean_fen(fen) # => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+    #
+    # @example Remove invalid castling rights when king has moved
+    #   fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQ1BNR w KQkq - 0 1"
+    #   Feen::Sanitizer.clean_fen(fen) # => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQ1BNR w kq - 0 1"
+    #
+    # @example Remove invalid castling rights when rook has moved
+    #   fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/1NBQKBNR w KQkq - 0 1"
+    #   Feen::Sanitizer.clean_fen(fen) # => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/1NBQKBNR w Kkq - 0 1"
+    #
+    # @example Remove invalid en passant target when no capturing pawn exists
+    #   fen = "rnbqkbnr/pppp1ppp/8/4p3/8/8/PPPPPPPP/RNBQKBNR w KQkq e6 0 2"
+    #   Feen::Sanitizer.clean_fen(fen) # => "rnbqkbnr/pppp1ppp/8/4p3/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 2"
+    #
+    # @example Keep valid en passant target when capturing is possible
+    #   fen = "rnbqkbnr/pppp1ppp/8/3Pp3/8/8/PPP1PPPP/RNBQKBNR w KQkq e6 0 2"
+    #   Feen::Sanitizer.clean_fen(fen) # => "rnbqkbnr/pppp1ppp/8/3Pp3/8/8/PPP1PPPP/RNBQKBNR w KQkq e6 0 2"
+    def self.clean_fen(fen_string)
+      parts = fen_string.strip.split
+      return fen_string unless parts.size >= 4
+
+      board, active_color, castling, en_passant, *rest = parts
+
+      # Parse board into a 2D array for easier access
+      board_matrix = []
+      board.split("/").each do |row|
+        current_row = []
+        row.each_char do |c|
+          if /[1-8]/.match?(c)
+            c.to_i.times { current_row << nil }
+          else
+            current_row << c
+          end
+        end
+        board_matrix << current_row
+      end
+
+      # Clean castling rights
+      new_castling = castling.dup
+      new_castling = clean_castling_rights(new_castling, board_matrix)
+
+      # Clean en passant target
+      new_en_passant = clean_en_passant_target(en_passant, board_matrix, active_color)
+
+      ([board, active_color, new_castling, new_en_passant] + rest).join(" ")
+    end
+
+    # Validates and cleans castling rights based on the position of kings and rooks
+    #
+    # @param castling [String] The castling rights string from FEN
+    # @param board [Array<Array<String, nil>>] 2D array representing the board
+    # @return [String] Cleaned castling rights or "-" if none are valid
+    # @api private
+    private_class_method def self.clean_castling_rights(castling, board)
+      return "-" if castling == "-"
+
+      new_castling = castling.dup
+
+      # White castling rights
+      new_castling.gsub!(/[KQ]/, "") unless board[7][4] == "K"
+      new_castling.delete!("K") unless board[7][7] == "R"
+      new_castling.delete!("Q") unless board[7][0] == "R"
+
+      # Black castling rights
+      new_castling.gsub!(/[kq]/, "") unless board[0][4] == "k"
+      new_castling.delete!("k") unless board[0][7] == "r"
+      new_castling.delete!("q") unless board[0][0] == "r"
+
+      new_castling.empty? ? "-" : new_castling
+    end
+
+    # Validates and cleans en passant target based on the position of pawns
+    #
+    # @param en_passant [String] The en passant target square from FEN
+    # @param board [Array<Array<String, nil>>] 2D array representing the board
+    # @param active_color [String] The active color ("w" or "b")
+    # @return [String] Cleaned en passant target or "-" if invalid
+    # @api private
+    private_class_method def self.clean_en_passant_target(en_passant, board, active_color)
+      return "-" if en_passant == "-"
+
+      file = en_passant[0].ord - "a".ord
+      rank = en_passant[1].to_i
+
+      # Validate en passant square coordinates
+      return "-" unless file.between?(0, 7) && [3, 6].include?(rank)
+
+      # For white's move (after black pawn double advance)
+      if active_color == "w" && rank == 6
+        # Check for white pawns on the 5th rank (index 3) that can capture
+        return en_passant if [file - 1, file + 1].any? { |f| f.between?(0, 7) && board[3][f] == "P" }
+      # For black's move (after white pawn double advance)
+      elsif active_color == "b" && rank == 3
+        # Check for black pawns on the 4th rank (index 4) that can capture
+        return en_passant if [file - 1, file + 1].any? { |f| f.between?(0, 7) && board[4][f] == "p" }
+      end
+
+      "-" # Invalid en passant square
+    end
+  end
+end

data/lib/feen.rb

@@ -1,61 +1,110 @@
 # frozen_string_literal: true
 
+require_relative File.join("feen", "converter")
 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.
 #
-# @see https://github.com/sashite/specs/blob/main/forsyth-edwards-expanded-notation.md
+# @see https://sashite.dev/documents/feen/1.0.0/
 module Feen
   # Dumps position params into a FEEN string.
   #
-  # @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(
-  #     "board_shape": [9, 9],
-  #     "side_to_move": "s",
-  #     "piece_placement": {
-  #        3 => "s",
-  #        4 => "k",
-  #        5 => "s",
-  #       22 => "+P",
-  #       43 => "+B"
-  #     }
-  #   )
-  #   # => "3sks3/9/4+P4/9/7+B1/9/9/9/9 s"
-  #
-  # @return [String] The FEEN string representing the position.
-  def self.dump(board_shape:, side_to_move:, piece_placement:)
-    Dumper.call(
-      board_shape:,
-      side_to_move:,
-      piece_placement:
-    )
+  # @param position [Hash] Hash containing the position data
+  # @option position [Array] :piece_placement Board position data
+  # @option position [Hash] :games_turn Games and turn data
+  # @option position [Array<Hash>] :pieces_in_hand Pieces in hand data
+  # @return [String] FEEN notation string
+  # @raise [ArgumentError] If the position data is invalid
+  # @example
+  #   position = {
+  #     piece_placement: [[{id: 'r'}, {id: 'n'}, {id: 'b'}, {id: 'q'}, {id: 'k'}, {id: 'b'}, {id: 'n'}, {id: 'r'}],
+  #                       [{id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}],
+  #                       [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],
+  #                       [{id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}],
+  #                       [{id: 'R'}, {id: 'N'}, {id: 'B'}, {id: 'Q'}, {id: 'K'}, {id: 'B'}, {id: 'N'}, {id: 'R'}]],
+  #     games_turn: {
+  #       active_player: 'CHESS',
+  #       inactive_player: 'chess',
+  #       uppercase_game: 'CHESS',
+  #       lowercase_game: 'chess'
+  #     },
+  #     pieces_in_hand: []
+  #   }
+  #   Feen.dump(position) # => "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -"
+  def self.dump(position)
+    Dumper.dump(position)
   end
 
   # Parses a FEEN string into position params.
   #
-  # @param feen [String] The FEEN string representing a position.
-  #
-  # @example Parse a classic Tsume Shogi problem
-  #   parse("3sks3/9/4+P4/9/7+B1/9/9/9/9 s")
+  # @param feen_string [String] FEEN notation string
+  # @return [Hash] Hash containing the parsed position data
+  # @raise [ArgumentError] If the FEEN string is invalid
+  # @example
+  #   feen_string = "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -"
+  #   Feen.parse(feen_string)
   #   # => {
-  #   #      "board_shape": [9, 9],
-  #   #      "side_to_move": "s",
-  #   #      "piece_placement": {
-  #   #         3 => "s",
-  #   #         4 => "k",
-  #   #         5 => "s",
-  #   #        22 => "+P",
-  #   #        43 => "+B"
-  #   #      }
+  #   #      piece_placement: [[{id: 'r'}, {id: 'n'}, {id: 'b'}, {id: 'q'}, {id: 'k', suffix: '='}, {id: 'b'}, {id: 'n'}, {id: 'r'}],
+  #   #                        [{id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}],
+  #   #                        [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],
+  #   #                        [{id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}],
+  #   #                        [{id: 'R'}, {id: 'N'}, {id: 'B'}, {id: 'Q'}, {id: 'K', suffix: '='}, {id: 'B'}, {id: 'N'}, {id: 'R'}]],
+  #   #      games_turn: {
+  #   #        active_player: 'CHESS',
+  #   #        inactive_player: 'chess',
+  #   #        uppercase_game: 'CHESS',
+  #   #        lowercase_game: 'chess',
+  #   #        active_player_casing: :uppercase
+  #   #      },
+  #   #      pieces_in_hand: []
+  #   #    }
+  def self.parse(feen_string)
+    Parser.parse(feen_string)
+  end
+
+  # Validates if the given string is a valid FEEN string
+  #
+  # @param feen_string [String] FEEN string to validate
+  # @return [Boolean] True if the string is a valid FEEN string, false otherwise
+  # @example
+  #   Feen.valid?("rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -") # => true
+  #   Feen.valid?("invalid feen string") # => false
+  def self.valid?(feen_string)
+    parse(feen_string)
+    true
+  rescue ::ArgumentError
+    false
+  end
+
+  # Converts a FEN string to a FEEN string for chess positions
+  #
+  # @param fen_string [String] Standard FEN notation string for chess
+  # @return [String] Equivalent FEEN notation string
+  # @raise [ArgumentError] If the FEN string is invalid
+  # @example
+  #   Feen.from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
+  #   # => "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -"
+  def self.from_fen(fen_string)
+    Converter.from_fen(fen_string)
+  end
+
+  # Converts a FEEN string to a FEN string for chess positions
   #
-  # @return [Hash] The position params representing the position.
-  def self.parse(feen, regex: /\+?[a-z]/i)
-    Parser.call(feen, regex:)
+  # @param feen_string [String] FEEN notation string
+  # @return [String] Equivalent FEN notation string
+  # @raise [ArgumentError] If the FEEN string is invalid
+  # @example
+  #   Feen.to_fen("rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -")
+  #   # => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+  def self.to_fen(feen_string)
+    Converter.to_fen(feen_string)
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta1
+  version: 5.0.0.beta2
 platform: ruby
 authors:
 - Cyril Kato
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby interface for data serialization and deserialization in FEEN format.
 email: contact@cyril.email
@@ -19,16 +18,23 @@ files:
 - LICENSE.md
 - README.md
 - lib/feen.rb
+- lib/feen/converter.rb
+- lib/feen/converter/from_fen.rb
+- lib/feen/converter/to_fen.rb
 - lib/feen/dumper.rb
+- lib/feen/dumper/games_turn.rb
 - lib/feen/dumper/piece_placement.rb
+- lib/feen/dumper/pieces_in_hand.rb
 - lib/feen/parser.rb
-- lib/feen/parser/board_shape.rb
+- lib/feen/parser/games_turn.rb
+- lib/feen/parser/piece_placement.rb
+- lib/feen/parser/pieces_in_hand.rb
+- lib/feen/sanitizer.rb
 homepage: https://github.com/sashite/feen.rb
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -36,15 +42,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: FEEN support for the Ruby language.
 test_files: []

data/lib/feen/parser/board_shape.rb

@@ -1,39 +0,0 @@
-# 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