feen 5.0.0.beta2 → 5.0.0.beta3

data/lib/feen/converter/from_fen.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Converter
-    module FromFen
-      # Constants
-      WHITE_TURN = "CHESS/chess"
-      BLACK_TURN = "chess/CHESS"
-      NO_PIECES_IN_HAND = "-"
-      EN_PASSANT_NONE = "-"
-
-      # Castling-related constants
-      CASTLING_SUFFIX_BOTH = "="
-      CASTLING_SUFFIX_KINGSIDE = ">"
-      CASTLING_SUFFIX_QUEENSIDE = "<"
-      CASTLING_SUFFIX_NONE = ""
-
-      # Piece identifiers
-      WHITE_KING = "K"
-      BLACK_KING = "k"
-      WHITE_PAWN = "P"
-      BLACK_PAWN = "p"
-
-      # Board indices
-      WHITE_KING_STARTING_ROW = 7
-      BLACK_KING_STARTING_ROW = 0
-
-      # 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
-      def self.call(fen_string)
-        unless fen_string.is_a?(String) && !fen_string.strip.empty?
-          raise ArgumentError, "FEN must be a non-empty string"
-        end
-
-        parts = fen_string.strip.split
-        raise ArgumentError, "Invalid FEN format: expected at least 4 fields" unless parts.size >= 4
-
-        placement_fen, active_color, castling, en_passant = parts[0..3]
-        board = parse_board(placement_fen)
-
-        apply_castling!(board, castling)
-        apply_en_passant!(board, en_passant)
-
-        piece_placement = format_board(board)
-        games_turn = active_color == "w" ? WHITE_TURN : BLACK_TURN
-
-        "#{piece_placement} #{games_turn} #{NO_PIECES_IN_HAND}"
-      end
-
-      # Parses the FEN piece placement into a 2D board array
-      # @param fen_placement [String] FEN piece placement string
-      # @return [Array<Array<String, nil>>] 2D array representing the board
-      def self.parse_board(fen_placement)
-        fen_placement.split("/").map do |row|
-          cells = []
-          row.each_char do |char|
-            if /[1-8]/.match?(char)
-              cells.concat([nil] * char.to_i)
-            else
-              cells << char
-            end
-          end
-          cells
-        end
-      end
-
-      # Applies castling rights to kings on the board
-      # @param board [Array<Array<String, nil>>] 2D board array
-      # @param castling [String] FEN castling rights string
-      # @return [void]
-      def self.apply_castling!(board, castling)
-        return if castling == EN_PASSANT_NONE
-
-        # Determine suffix for each king
-        wk_suffix = determine_castling_suffix(castling.include?("K"), castling.include?("Q"))
-        bk_suffix = determine_castling_suffix(castling.include?("k"), castling.include?("q"))
-
-        # Apply the suffixes to the kings
-        apply_king_suffix!(board, WHITE_KING, wk_suffix)
-        apply_king_suffix!(board, BLACK_KING, bk_suffix)
-      end
-
-      # Applies a castling suffix to a king on the board
-      # @param board [Array<Array<String, nil>>] 2D board array
-      # @param king_char [String] King character ('K' or 'k')
-      # @param suffix [String] Castling suffix to apply
-      # @return [void]
-      def self.apply_king_suffix!(board, king_char, suffix)
-        return if suffix.empty?
-
-        board.each_with_index do |row, r|
-          row.each_with_index do |cell, c|
-            board[r][c] = "#{king_char}#{suffix}" if cell == king_char
-          end
-        end
-      end
-
-      # Determines the appropriate castling suffix based on kingside and queenside rights
-      # @param kingside [Boolean] Whether kingside castling is allowed
-      # @param queenside [Boolean] Whether queenside castling is allowed
-      # @return [String] The castling suffix
-      def self.determine_castling_suffix(kingside, queenside)
-        if kingside && queenside
-          CASTLING_SUFFIX_BOTH
-        elsif kingside
-          CASTLING_SUFFIX_KINGSIDE
-        elsif queenside
-          CASTLING_SUFFIX_QUEENSIDE
-        else
-          CASTLING_SUFFIX_NONE
-        end
-      end
-
-      # Applies en passant rights to pawns on the board
-      # @param board [Array<Array<String, nil>>] 2D board array
-      # @param en_passant [String] FEN en passant target square
-      # @return [void]
-      def self.apply_en_passant!(board, en_passant)
-        return if en_passant == EN_PASSANT_NONE
-
-        col = en_passant[0].ord - "a".ord
-        row = 8 - en_passant[1].to_i
-
-        if row == 2 # White just moved: check black pawns on row 3
-          apply_en_passant_for_pawn!(board, 3, col, BLACK_PAWN)
-        elsif row == 5 # Black just moved: check white pawns on row 4
-          apply_en_passant_for_pawn!(board, 4, col, WHITE_PAWN)
-        end
-      end
-
-      # Applies en passant rights to pawns at a specific row and column
-      # @param board [Array<Array<String, nil>>] 2D board array
-      # @param pawn_row [Integer] Row where pawns can capture en passant
-      # @param target_col [Integer] Column of the pawn that moved two squares
-      # @param pawn_char [String] Pawn character ('P' or 'p')
-      # @return [void]
-      def self.apply_en_passant_for_pawn!(board, pawn_row, target_col, pawn_char)
-        [-1, 1].each do |dx|
-          x = target_col + dx
-
-          next unless x.between?(0, 7) && board[pawn_row][x] == pawn_char
-
-          # Determine the en passant suffix based on relative position
-          suffix = dx == -1 ? ">" : "<"
-          board[pawn_row][x] = "#{pawn_char}#{suffix}"
-        end
-      end
-
-      # Formats the board array back into FEN piece placement
-      # @param board [Array<Array<String, nil>>] 2D board array
-      # @return [String] FEN piece placement string
-      def self.format_board(board)
-        board.map do |row|
-          format_row(row)
-        end.join("/")
-      end
-
-      # Formats a row of the board into FEN notation
-      # @param row [Array<String, nil>] Row of the board
-      # @return [String] FEN notation for this row
-      def self.format_row(row)
-        row.chunk_while { |a, b| a.nil? == b.nil? }.map do |chunk|
-          chunk.first.nil? ? chunk.size.to_s : chunk.join
-        end.join
-      end
-    end
-  end
-end

data/lib/feen/converter/to_fen.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Converter
-    module ToFen
-      # Constants for game types and formats
-      WHITE_ACTIVE = "CHESS/chess"
-      BLACK_ACTIVE = "chess/CHESS"
-
-      # Constants for FEN components
-      NO_EN_PASSANT = "-"
-      NO_CASTLING = "-"
-      HALF_MOVE_DEFAULT = "0"
-      FULL_MOVE_DEFAULT = "1"
-
-      # Castling-related constants
-      WHITE_KINGSIDE = "K"
-      WHITE_QUEENSIDE = "Q"
-      BLACK_KINGSIDE = "k"
-      BLACK_QUEENSIDE = "q"
-
-      # En passant constants
-      EN_PASSANT_WHITE_RANK = "3"
-      EN_PASSANT_BLACK_RANK = "6"
-
-      # Converts a FEEN string to a standard FEN string for chess positions
-      # @param feen_string [String] FEEN notation string
-      # @return [String] Standard FEN notation string
-      # @raise [ArgumentError] If the FEEN string is invalid or not supported
-      def self.call(feen_string)
-        # Validate input
-        unless feen_string.is_a?(String) && !feen_string.strip.empty?
-          raise ArgumentError, "FEEN must be a non-empty string"
-        end
-
-        # Split into components
-        parts = feen_string.strip.split
-        raise ArgumentError, "Invalid FEEN format: expected 3 fields" unless parts.size == 3
-
-        piece_placement, games_turn, = parts
-
-        # Verify game type is supported
-        unless [WHITE_ACTIVE, BLACK_ACTIVE].include?(games_turn)
-          raise ArgumentError, "Only CHESS/chess FEEN formats are supported"
-        end
-
-        # Extract FEN components
-        castling_rights = extract_castling_rights(piece_placement)
-        en_passant = extract_en_passant(piece_placement)
-        fen_board = convert_board_to_fen(piece_placement)
-        active_color = games_turn.start_with?("CHESS") ? "w" : "b"
-
-        # Construct FEN string
-        "#{fen_board} #{active_color} #{castling_rights} #{en_passant} #{HALF_MOVE_DEFAULT} #{FULL_MOVE_DEFAULT}"
-      end
-
-      # Converts the FEEN board representation to FEN format by removing special markings
-      # @param piece_placement [String] FEEN piece placement string
-      # @return [String] FEN piece placement string
-      def self.convert_board_to_fen(piece_placement)
-        piece_placement.split("/").map do |row|
-          # Remove castling suffixes from kings
-          row_without_king_suffix = row.gsub(/([Kk])([=<>])/) { Regexp.last_match(1) }
-          # Remove en passant suffixes from pawns
-          row_without_suffixes = row_without_king_suffix.gsub(/([Pp])([<>])/) { Regexp.last_match(1) }
-          # Ensure only single character pieces (in case of promoted pieces with prefixes)
-          row_without_suffixes.gsub(/\d+|\w/) { |s| /\d/.match?(s) ? s : s[0] }
-        end.join("/")
-      end
-
-      # Extracts castling rights from FEEN piece placement
-      # @param piece_placement [String] FEEN piece placement string
-      # @return [String] FEN castling rights component
-      def self.extract_castling_rights(piece_placement)
-        castling = ""
-
-        # White castling rights - always in uppercase and first
-        piece_placement.split("/").each do |row|
-          castling += WHITE_KINGSIDE if row.include?("K>") || row.include?("K=")
-          castling += WHITE_QUEENSIDE if row.include?("K<") || row.include?("K=")
-        end
-
-        # Black castling rights - always in lowercase and after white
-        piece_placement.split("/").each do |row|
-          castling += BLACK_KINGSIDE if row.include?("k>") || row.include?("k=")
-          castling += BLACK_QUEENSIDE if row.include?("k<") || row.include?("k=")
-        end
-
-        castling.empty? ? NO_CASTLING : castling
-      end
-
-      # Extracts en passant target square from FEEN piece placement
-      # @param piece_placement [String] FEEN piece placement string
-      # @return [String] FEN en passant target square or "-" if none
-      # @raise [ArgumentError] If multiple en passant markers are detected
-      def self.extract_en_passant(piece_placement)
-        rows = piece_placement.split("/")
-        en_passant_targets = []
-
-        rows.each_with_index do |row, _rank|
-          file_index = 0
-          char_index = 0
-
-          while char_index < row.length
-            current_char = row[char_index]
-
-            if /[1-8]/.match?(current_char)
-              # Skip empty squares
-              file_index += current_char.to_i
-              char_index += 1
-            elsif char_index + 1 < row.length && row[char_index..(char_index + 1)] =~ /([Pp])([<>])/
-              # Found a pawn with en passant marker
-              pawn_type = ::Regexp.last_match(1) # 'P' or 'p'
-              ::Regexp.last_match(2) # '<' or '>'
-
-              # Calculate the file (column) letter
-              file_char = ("a".ord + file_index).chr
-
-              # Calculate the rank (row) number based on pawn type
-              # For white pawn (P) on rank 4 (index 3), the target is rank 3
-              # For black pawn (p) on rank 5 (index 2), the target is rank 6
-              rank_num = if pawn_type == "P"
-                           "3" # White pawn's en passant target is always on rank 3
-                         else
-                           "6" # Black pawn's en passant target is always on rank 6
-                         end
-
-              en_passant_targets << "#{file_char}#{rank_num}"
-
-              # Move past this pawn and its suffix
-              file_index += 1
-              char_index += 2
-            else
-              # Regular piece
-              file_index += 1
-              char_index += 1
-
-              # Skip any suffix attached to this piece
-              char_index += 1 if char_index < row.length && row[char_index] =~ /[<>=]/
-            end
-          end
-        end
-
-        # Only one en passant target should be present in a valid position
-        if en_passant_targets.size > 1
-          raise ArgumentError, "Multiple en passant markers detected: #{en_passant_targets.join(', ')}"
-        end
-
-        en_passant_targets.first || "-"
-      end
-    end
-  end
-end

data/lib/feen/converter.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require_relative File.join("converter", "from_fen")
-require_relative File.join("converter", "to_fen")
-
-module Feen
-  module Converter
-    def self.from_fen(fen_string)
-      FromFen.call(fen_string)
-    end
-
-    def self.to_fen(feen_string)
-      ToFen.call(feen_string)
-    end
-  end
-end

data/lib/feen/sanitizer.rb

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