feen 5.0.0.beta6 → 5.0.0.beta8

data/lib/feen/parser/pieces_in_hand.rb

@@ -1,57 +1,76 @@
 # frozen_string_literal: true
 
-require_relative File.join("pieces_in_hand", "errors")
-require_relative File.join("pieces_in_hand", "no_pieces")
-require_relative File.join("pieces_in_hand", "pnn_patterns")
-require_relative File.join("pieces_in_hand", "canonical_sorter")
-
 module Feen
   module Parser
     # Handles parsing of the pieces in hand section of a FEEN string.
     # Pieces in hand represent pieces available for dropping onto the board.
-    # This implementation supports full PNN notation including prefixes and suffixes.
+    # According to FEEN specification, pieces in hand MUST be in base form only (no modifiers).
+    # Format: "UPPERCASE_PIECES/LOWERCASE_PIECES"
     module PiecesInHand
+      # Error messages for validation
+      Errors = {
+        invalid_type:      "Pieces in hand must be a string, got %s",
+        empty_string:      "Pieces in hand string cannot be empty",
+        invalid_format:    "Invalid pieces in hand format: %s",
+        missing_separator: "Pieces in hand format must contain exactly one '/' separator. Got: %s"
+      }.freeze
+
+      # Base piece pattern: single letter only (no modifiers allowed in hand)
+      BASE_PIECE_PATTERN = /\A[a-zA-Z]\z/
+
+      # Valid count pattern: 2-9 or any number with 2+ digits (no 0, 1, or leading zeros)
+      VALID_COUNT_PATTERN = /\A(?:[2-9]|[1-9]\d+)\z/
+
+      # Pattern for piece with optional count in pieces in hand
+      PIECE_WITH_COUNT_PATTERN = /(?:([2-9]|[1-9]\d+))?([a-zA-Z])/
+
+      # Complete validation pattern for pieces in hand string
+      VALID_FORMAT_PATTERN = %r{\A
+        (?:                                               # Uppercase section (optional)
+          (?:(?:[2-9]|[1-9]\d+)?[A-Z])*                  # Zero or more uppercase pieces with optional counts
+        )
+        /                                                 # Mandatory separator
+        (?:                                               # Lowercase section (optional)
+          (?:(?:[2-9]|[1-9]\d+)?[a-z])*                  # Zero or more lowercase pieces with optional counts
+        )
+      \z}x
+
       # Parses the pieces in hand section of a FEEN string.
       #
-      # @param pieces_in_hand_str [String] FEEN pieces in hand string
-      # @return [Array<String>] Array of piece identifiers in full PNN format,
-      #   expanded based on their counts and sorted according to FEEN specification:
-      #   1. By quantity (descending)
-      #   2. By complete PNN representation (alphabetically ascending)
+      # @param pieces_in_hand_str [String] FEEN pieces in hand string in format "UPPERCASE/lowercase"
+      # @return [Array<String>] Array of piece identifiers in base form only,
+      #   expanded based on their counts and sorted alphabetically.
       #   Empty array if no pieces are in hand.
-      # @raise [ArgumentError] If the input string is invalid
+      # @raise [ArgumentError] If the input string is invalid or contains modifiers
       #
       # @example Parse no pieces in hand
-      #   PiecesInHand.parse("-")
+      #   PiecesInHand.parse("/")
       #   # => []
       #
-      # @example Parse pieces with modifiers
-      #   PiecesInHand.parse("3+P2B'Pn")
-      #   # => ["+P", "+P", "+P", "B'", "B'", "P", "n"]
+      # @example Parse pieces with case separation
+      #   PiecesInHand.parse("3P2B/p")
+      #   # => ["B", "B", "P", "P", "P", "p"]
       #
-      # @example Parse complex pieces with counts and modifiers
-      #   PiecesInHand.parse("10P5K3B2p'+P-pBRbq")
-      #   # => ["P", "P", "P", "P", "P", "P", "P", "P", "P", "P",
-      #   #     "K", "K", "K", "K", "K",
-      #   #     "B", "B", "B",
-      #   #     "p'", "p'",
-      #   #     "+P", "-p", "B", "R", "b", "q"]
+      # @example Invalid - modifiers not allowed in hand
+      #   PiecesInHand.parse("+P/p")
+      #   # => ArgumentError: Pieces in hand cannot contain modifiers: '+P'
       def self.parse(pieces_in_hand_str)
-        # Validate input
         validate_input_type(pieces_in_hand_str)
         validate_format(pieces_in_hand_str)
 
         # Handle the no-pieces case early
-        return [] if pieces_in_hand_str == NoPieces
+        return [] if pieces_in_hand_str == "/"
 
-        # Extract pieces with their counts and validate the format
-        pieces_with_counts = extract_pieces_with_counts(pieces_in_hand_str)
+        # Split by the separator to get uppercase and lowercase sections
+        uppercase_section, lowercase_section = pieces_in_hand_str.split("/", 2)
 
-        # Validate canonical ordering according to FEEN specification
-        validate_canonical_order(pieces_with_counts)
+        # Parse each section separately and validate no modifiers
+        uppercase_pieces = parse_pieces_section(uppercase_section || "", :uppercase)
+        lowercase_pieces = parse_pieces_section(lowercase_section || "", :lowercase)
 
-        # Expand the pieces into an array maintaining the canonical order
-        expand_pieces(pieces_with_counts)
+        # Combine all pieces and sort them alphabetically
+        all_pieces = uppercase_pieces + lowercase_pieces
+        all_pieces.sort
       end
 
       # Validates that the input is a non-empty string.
@@ -65,126 +84,87 @@ module Feen
       end
 
       # Validates that the input string matches the expected format according to FEEN specification.
-      # This includes validation of individual PNN pieces and overall structure.
+      # Format must be: "UPPERCASE_PIECES/LOWERCASE_PIECES" with base pieces only (no modifiers).
       #
       # @param str [String] Input string to validate
-      # @raise [ArgumentError] If format is invalid
+      # @raise [ArgumentError] If format is invalid or contains modifiers
       # @return [void]
       private_class_method def self.validate_format(str)
-        return if str == NoPieces
+        # Must contain exactly one "/" separator
+        parts_count = str.count("/")
+        raise ::ArgumentError, format(Errors[:missing_separator], parts_count) unless parts_count == 1
 
-        # First, validate overall structure using the updated pattern
-        raise ::ArgumentError, format(Errors[:invalid_format], str) unless str.match?(PnnPatterns::VALID_FORMAT_PATTERN)
+        # Must match the overall pattern
+        raise ::ArgumentError, format(Errors[:invalid_format], str) unless str.match?(VALID_FORMAT_PATTERN)
 
-        # Additional validation: ensure each piece component is valid PNN
-        # This catches cases like "++P" that might pass the overall pattern
-        validate_individual_pieces(str)
+        # Additional validation: check for any modifiers (forbidden in hand)
+        validate_no_modifiers(str)
       end
 
-      # Validates each individual piece in the string for PNN compliance
+      # Validates that no modifiers are present in the pieces in hand string
       #
-      # @param str [String] FEEN pieces in hand string
-      # @raise [ArgumentError] If any piece is invalid PNN format
+      # @param str [String] Input string to validate
+      # @raise [ArgumentError] If modifiers are found
       # @return [void]
-      private_class_method def self.validate_individual_pieces(str)
-        original_string = str
-        position = 0
-
-        while position < str.length
-          match = str[position..].match(PnnPatterns::PIECE_WITH_COUNT_PATTERN)
-
-          unless match
-            # Find the problematic part
-            remaining = str[position..]
-            raise ::ArgumentError, format(Errors[:invalid_format], remaining)
-          end
-
-          count_str, piece = match.captures
-
-          # Skip empty matches (shouldn't happen with our pattern, but safety check)
-          if piece.nil? || piece.empty?
-            position += 1
-            next
-          end
-
-          # Validate the piece follows PNN specification
-          unless piece.match?(PnnPatterns::PNN_PIECE_PATTERN)
-            raise ::ArgumentError, format(Errors[:invalid_pnn_piece], piece)
-          end
+      private_class_method def self.validate_no_modifiers(str)
+        # Check for any modifier characters that are forbidden in pieces in hand
+        return unless str.match?(/[+\-']/)
 
-          # Validate count format (no "0" or "1" prefixes allowed)
-          if count_str && !count_str.match?(PnnPatterns::VALID_COUNT_PATTERN)
-            raise ::ArgumentError, format(Errors[:invalid_count], count_str)
-          end
-
-          position += match[0].length
-        end
+        # Find the specific invalid piece to provide a better error message
+        invalid_pieces = str.scan(/(?:[2-9]|[1-9]\d+)?[+\-']?[a-zA-Z]'?/).grep(/[+\-']/)
 
-        # Final check: verify that we can reconstruct the string correctly
-        # by re-extracting all pieces and comparing with original
-        reconstructed_pieces = extract_pieces_with_counts(original_string)
-        reconstructed = reconstructed_pieces.map do |item|
-          count = item[:count]
-          piece = item[:piece]
-          count == 1 ? piece : "#{count}#{piece}"
-        end.join
-
-        # If reconstruction doesn't match original, there's an invalid format
-        return if reconstructed == original_string
-        # Find the first discrepancy to provide better error message
-        # This will catch cases like "++P" where we extract "+P" but original has extra "+"
-        unless original_string.length > reconstructed.length
-          raise ::ArgumentError, format(Errors[:invalid_format], original_string)
-        end
-
-        # There are extra characters - find what's invalid
-        original_string.sub(reconstructed, "")
-        # Try to identify the problematic piece
-        problematic_part = find_problematic_piece(original_string, reconstructed)
-        raise ::ArgumentError, format(Errors[:invalid_pnn_piece], problematic_part)
+        raise ::ArgumentError, "Pieces in hand cannot contain modifiers: '#{invalid_pieces.first}'"
       end
 
-      # Finds the problematic piece in the original string by comparing with reconstruction
+      # Parses a specific section (uppercase or lowercase) and returns expanded pieces
       #
-      # @param original [String] Original input string
-      # @param reconstructed [String] Reconstructed string from extracted pieces
-      # @return [String] The problematic piece or sequence
-      private_class_method def self.find_problematic_piece(original, reconstructed)
-        # Simple heuristic: find the first part that doesn't match
-        min_length = [original.length, reconstructed.length].min
-
-        # Find first difference
-        diff_pos = 0
-        diff_pos += 1 while diff_pos < min_length && original[diff_pos] == reconstructed[diff_pos]
-
-        # If difference is at start, likely extra prefix
-        # Look for a sequence that starts with invalid pattern like "++"
-        if (diff_pos == 0) && original.match?(/\A\+\+/)
-          return "++P" # Common case
-        end
+      # @param section [String] The section string to parse
+      # @param case_type [Symbol] Either :uppercase or :lowercase (for validation)
+      # @return [Array<String>] Array of expanded pieces from this section
+      private_class_method def self.parse_pieces_section(section, case_type)
+        return [] if section.empty?
 
-        # Extract a reasonable chunk around the problematic area
-        start_pos = [0, diff_pos - 2].max
-        end_pos = [original.length, diff_pos + 4].min
-        original[start_pos...end_pos]
+        # Extract pieces with their counts
+        pieces_with_counts = extract_pieces_with_counts_from_section(section, case_type)
+
+        # Expand the pieces into an array
+        expand_pieces(pieces_with_counts)
       end
 
-      # Extracts pieces with their counts from the FEEN string.
-      # Supports full PNN notation including prefixes and suffixes.
+      # Extracts pieces with their counts from a section string.
       #
-      # @param str [String] FEEN pieces in hand string
+      # @param section [String] FEEN pieces section string
+      # @param case_type [Symbol] Either :uppercase or :lowercase
       # @return [Array<Hash>] Array of hashes with :piece and :count keys
-      private_class_method def self.extract_pieces_with_counts(str)
+      # @raise [ArgumentError] If pieces don't match the expected case or contain modifiers
+      private_class_method def self.extract_pieces_with_counts_from_section(section, case_type)
         result = []
         position = 0
 
-        while position < str.length
-          match = str[position..].match(PnnPatterns::PIECE_WITH_COUNT_PATTERN)
+        while position < section.length
+          match = section[position..].match(PIECE_WITH_COUNT_PATTERN)
           break unless match
 
           count_str, piece = match.captures
           count = count_str ? count_str.to_i : 1
 
+          # Validate piece is base form only (single letter)
+          unless piece.match?(BASE_PIECE_PATTERN)
+            raise ::ArgumentError, "Pieces in hand must be base form only: '#{piece}'"
+          end
+
+          # Validate count format
+          if count_str && !count_str.match?(VALID_COUNT_PATTERN)
+            raise ::ArgumentError, "Invalid count format: '#{count_str}'. Count cannot be '0' or '1', use the piece without count instead"
+          end
+
+          # Validate that the piece matches the expected case
+          piece_case = piece.match?(/[A-Z]/) ? :uppercase : :lowercase
+          unless piece_case == case_type
+            case_name = case_type == :uppercase ? "uppercase" : "lowercase"
+            raise ::ArgumentError, "Piece '#{piece}' has wrong case for #{case_name} section"
+          end
+
           # Add to our result with piece type and count
           result << { piece: piece, count: count }
 
@@ -195,24 +175,10 @@ module Feen
         result
       end
 
-      # Validates that pieces are in canonical order according to FEEN specification:
-      # 1. By quantity (descending)
-      # 2. By complete PNN representation (alphabetically ascending)
-      #
-      # @param pieces_with_counts [Array<Hash>] Array of pieces with their counts
-      # @raise [ArgumentError] If pieces are not in canonical order
-      # @return [void]
-      private_class_method def self.validate_canonical_order(pieces_with_counts)
-        return if pieces_with_counts.size <= 1
-
-        CanonicalSorter.validate_order(pieces_with_counts)
-      end
-
       # Expands the pieces based on their counts into an array.
-      # Maintains the canonical ordering from the input.
       #
       # @param pieces_with_counts [Array<Hash>] Array of pieces with their counts
-      # @return [Array<String>] Array of expanded pieces in canonical order
+      # @return [Array<String>] Array of expanded pieces
       private_class_method def self.expand_pieces(pieces_with_counts)
         pieces_with_counts.flat_map do |item|
           Array.new(item[:count], item[:piece])

data/lib/feen/parser.rb

@@ -21,12 +21,12 @@ module Feen
     # @param feen_string [String] Complete FEEN notation string
     # @return [Hash] Hash containing the parsed position data with the following keys:
     #   - :piece_placement [Array] - Hierarchical array structure representing the board
-    #   - :pieces_in_hand [Array<String>] - Pieces available for dropping onto the board
+    #   - :pieces_in_hand [Array<String>] - Pieces available for dropping onto the board (base form only)
     #   - :games_turn [Array<String>] - A two-element array with [active_variant, inactive_variant]
     # @raise [ArgumentError] If the FEEN string is invalid
     #
     # @example Parsing a standard chess initial position
-    #   feen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR - CHESS/chess"
+    #   feen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess"
     #   result = Feen::Parser.parse(feen)
     #   # => {
     #   #      piece_placement: [
@@ -76,7 +76,7 @@ module Feen
     # @return [Hash, nil] Hash containing the parsed position data or nil if parsing fails
     #
     # @example Parsing a valid FEEN string
-    #   feen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR - CHESS/chess"
+    #   feen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess"
     #   result = Feen::Parser.safe_parse(feen)
     #   # => {piece_placement: [...], pieces_in_hand: [...], games_turn: [...]}
     #

data/lib/feen.rb

@@ -16,11 +16,12 @@ module Feen
   #
   # @param piece_placement [Array] Board position data structure representing the spatial
   #                               distribution of pieces across the board
-  # @param pieces_in_hand [Array<String>] Pieces available for dropping onto the board
+  # @param pieces_in_hand [Array<String>] Pieces available for dropping onto the board.
+  #                                      MUST be in base form only (no modifiers allowed)
   # @param games_turn [Array<String>] A two-element array where the first element is the
   #                                  active player's variant and the second is the inactive player's variant
   # @return [String] FEEN notation string
-  # @raise [ArgumentError] If any parameter is invalid
+  # @raise [ArgumentError] If any parameter is invalid or pieces_in_hand contains modifiers
   # @example
   #   piece_placement = [
   #     ["r", "n", "b", "q", "k", "b", "n", "r"],
@@ -37,7 +38,7 @@ module Feen
   #     pieces_in_hand: [],
   #     games_turn: ["CHESS", "chess"]
   #   )
-  #   # => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR - CHESS/chess"
+  #   # => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess"
   def self.dump(piece_placement:, pieces_in_hand:, games_turn:)
     Dumper.dump(piece_placement:, pieces_in_hand:, games_turn:)
   end
@@ -47,11 +48,11 @@ module Feen
   # @param feen_string [String] Complete FEEN notation string
   # @return [Hash] Hash containing the parsed position data with the following keys:
   #   - :piece_placement [Array] - Hierarchical array structure representing the board
-  #   - :pieces_in_hand [Array<String>] - Pieces available for dropping onto the board
+  #   - :pieces_in_hand [Array<String>] - Pieces available for dropping onto the board (base form only)
   #   - :games_turn [Array<String>] - A two-element array with [active_variant, inactive_variant]
   # @raise [ArgumentError] If the FEEN string is invalid
   # @example
-  #   feen_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR - CHESS/chess"
+  #   feen_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess"
   #   Feen.parse(feen_string)
   #   # => {
   #   #      piece_placement: [
@@ -80,7 +81,7 @@ module Feen
   # @return [Hash, nil] Hash containing the parsed position data or nil if parsing fails
   # @example
   #   # Valid FEEN string
-  #   Feen.safe_parse("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR - CHESS/chess")
+  #   Feen.safe_parse("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess")
   #   # => {piece_placement: [...], pieces_in_hand: [...], games_turn: [...]}
   #
   #   # Invalid FEEN string
@@ -100,17 +101,27 @@ module Feen
   # This approach guarantees that the string not only follows FEEN syntax
   # but is also in its most compact, canonical representation.
   #
+  # According to FEEN specification:
+  # - Pieces in hand must be in base form only (no modifiers like +, -, ')
+  # - Pieces in hand must be sorted canonically within each case section:
+  #   1. By quantity (descending)
+  #   2. By piece letter (alphabetically ascending)
+  # - Case separation is enforced (uppercase/lowercase)
+  #
   # @param feen_string [String] FEEN string to validate
   # @return [Boolean] True if the string is a valid and canonical FEEN string
   # @example
   #   # Canonical form
-  #   Feen.valid?("lnsgk3l/5g3/p1ppB2pp/9/8B/2P6/P2PPPPPP/3K3R1/5rSNL 2g2s5PNln SHOGI/shogi") # => true
+  #   Feen.valid?("lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL / SHOGI/shogi") # => true
   #
   #   # Invalid syntax
   #   Feen.valid?("invalid feen string") # => false
   #
-  #   # Valid syntax but non-canonical form (pieces in hand not in lexicographic order)
-  #   Feen.valid?("lnsgk3l/5g3/p1ppB2pp/9/8B/2P6/P2PPPPPP/3K3R1/5rSNL N5P2gn2sl SHOGI/shogi") # => false
+  #   # Valid syntax but non-canonical form (pieces in hand with modifiers)
+  #   Feen.valid?("8/8/8/8/8/8/8/8 +P/ FOO/bar") # => false
+  #
+  #   # Valid syntax but non-canonical form (wrong ordering in pieces in hand)
+  #   Feen.valid?("8/8/8/8/8/8/8/8 P3K/ FOO/bar") # => false
   def self.valid?(feen_string)
     # First check: Basic syntax validation
     begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta6
+  version: 5.0.0.beta8
 platform: ruby
 authors:
 - Cyril Kato
@@ -25,20 +25,10 @@ files:
 - lib/feen/dumper/games_turn.rb
 - lib/feen/dumper/piece_placement.rb
 - lib/feen/dumper/pieces_in_hand.rb
-- lib/feen/dumper/pieces_in_hand/errors.rb
-- lib/feen/dumper/pieces_in_hand/no_pieces.rb
 - lib/feen/parser.rb
 - lib/feen/parser/games_turn.rb
-- lib/feen/parser/games_turn/errors.rb
-- lib/feen/parser/games_turn/valid_games_turn_pattern.rb
 - lib/feen/parser/piece_placement.rb
 - lib/feen/parser/pieces_in_hand.rb
-- lib/feen/parser/pieces_in_hand/canonical_sorter.rb
-- lib/feen/parser/pieces_in_hand/errors.rb
-- lib/feen/parser/pieces_in_hand/no_pieces.rb
-- lib/feen/parser/pieces_in_hand/piece_count_pattern.rb
-- lib/feen/parser/pieces_in_hand/pnn_patterns.rb
-- lib/feen/parser/pieces_in_hand/valid_format_pattern.rb
 homepage: https://github.com/sashite/feen.rb
 licenses:
 - MIT

data/lib/feen/dumper/pieces_in_hand/errors.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Dumper
-    module PiecesInHand
-      Errors = {
-        invalid_type:   "Piece at index: %<index>s must be a String, got type: %<type>s",
-        invalid_format: "Piece at index: %<index>s has an invalid PNN format: '%<value>s'. Expected format: [prefix]letter[suffix] where prefix is + or -, suffix is ', and letter is a-z or A-Z"
-      }.freeze
-    end
-  end
-end

data/lib/feen/dumper/pieces_in_hand/no_pieces.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Dumper
-    module PiecesInHand
-      # Character used to represent no pieces in hand
-      NoPieces = "-"
-    end
-  end
-end

data/lib/feen/parser/games_turn/errors.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    module GamesTurn
-      # Error messages for games turn parsing
-      Errors = {
-        invalid_type:   "Games turn must be a string, got %s",
-        empty_string:   "Games turn string cannot be empty",
-        invalid_format: "Invalid games turn format. Expected format: UPPERCASE/lowercase or lowercase/UPPERCASE"
-      }.freeze
-    end
-  end
-end

data/lib/feen/parser/games_turn/valid_games_turn_pattern.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    module GamesTurn
-      # Complete pattern matching the BNF specification with named groups
-      # <games-turn> ::= <game-id-uppercase> "/" <game-id-lowercase>
-      #                | <game-id-lowercase> "/" <game-id-uppercase>
-      ValidGamesTurnPattern = %r{
-        \A                    # Start of string
-        (?:                   # Non-capturing group for alternatives
-          (?<uppercase_first>[A-Z]+)  # Named group: uppercase identifier first
-          /                           # Separator
-          (?<lowercase_second>[a-z]+) # Named group: lowercase identifier second
-          |                           # OR
-          (?<lowercase_first>[a-z]+)  # Named group: lowercase identifier first
-          /                           # Separator
-          (?<uppercase_second>[A-Z]+) # Named group: uppercase identifier second
-        )
-        \z                    # End of string
-      }x
-    end
-  end
-end

data/lib/feen/parser/pieces_in_hand/canonical_sorter.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    module PiecesInHand
-      # Handles canonical ordering validation for pieces in hand according to FEEN specification
-      module CanonicalSorter
-        # Validates that pieces are in canonical order according to FEEN specification:
-        # 1. By quantity (descending)
-        # 2. By complete PNN representation (alphabetically ascending)
-        #
-        # @param pieces_with_counts [Array<Hash>] Array of pieces with their counts
-        # @raise [ArgumentError] If pieces are not in canonical order
-        # @return [void]
-        def self.validate_order(pieces_with_counts)
-          return if pieces_with_counts.size <= 1
-
-          # Create the expected canonical order
-          canonical_order = sort_canonically(pieces_with_counts)
-
-          # Compare with actual order
-          pieces_with_counts.each_with_index do |piece_data, index|
-            canonical_piece = canonical_order[index]
-
-            next if piece_data[:piece] == canonical_piece[:piece] &&
-                    piece_data[:count] == canonical_piece[:count]
-
-            raise ::ArgumentError, format(
-              Errors[:canonical_order_violation],
-              actual:   format_pieces_sequence(pieces_with_counts),
-              expected: format_pieces_sequence(canonical_order)
-            )
-          end
-        end
-
-        # Sorts pieces according to canonical FEEN order
-        #
-        # @param pieces_with_counts [Array<Hash>] Array of pieces with their counts
-        # @return [Array<Hash>] Canonically sorted array
-        def self.sort_canonically(pieces_with_counts)
-          pieces_with_counts.sort do |a, b|
-            # Primary sort: by quantity (descending)
-            count_comparison = b[:count] <=> a[:count]
-            next count_comparison unless count_comparison.zero?
-
-            # Secondary sort: by complete PNN representation (alphabetically ascending)
-            a[:piece] <=> b[:piece]
-          end
-        end
-
-        # Formats a pieces sequence for error messages
-        #
-        # @param pieces_with_counts [Array<Hash>] Array of pieces with their counts
-        # @return [String] Formatted string representation
-        private_class_method def self.format_pieces_sequence(pieces_with_counts)
-          pieces_with_counts.map do |item|
-            count = item[:count]
-            piece = item[:piece]
-
-            if count == 1
-              piece
-            else
-              "#{count}#{piece}"
-            end
-          end.join
-        end
-      end
-    end
-  end
-end

data/lib/feen/parser/pieces_in_hand/errors.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    module PiecesInHand
-      # Error messages for validation
-      Errors = {
-        invalid_type:              "Pieces in hand must be a string, got %s",
-        empty_string:              "Pieces in hand string cannot be empty",
-        invalid_format:            "Invalid pieces in hand format: %s",
-        invalid_pnn_piece:         "Invalid PNN piece format: '%s'. Expected format: [prefix]letter[suffix] where prefix is + or -, suffix is ', and letter is a-z or A-Z",
-        invalid_count:             "Invalid count format: '%s'. Count cannot be '0' or '1', use the piece without count instead",
-        canonical_order_violation: "Pieces in hand must be in canonical order (by quantity descending, then alphabetically). Got: '%<actual>s', expected: '%<expected>s'"
-      }.freeze
-    end
-  end
-end

data/lib/feen/parser/pieces_in_hand/no_pieces.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    module PiecesInHand
-      # Character used to represent no pieces in hand
-      NoPieces = "-"
-    end
-  end
-end

data/lib/feen/parser/pieces_in_hand/piece_count_pattern.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    module PiecesInHand
-      # Regex to extract piece counts from pieces in hand string
-      # Matches either:
-      # - A single piece character with no count (e.g., "P")
-      # - A count followed by a piece character (e.g., "5P")
-      PieceCountPattern = /(?:([2-9]|\d{2,}))?([A-Za-z])/
-    end
-  end
-end