feen 5.0.0.beta7 → 5.0.0.beta9

data/lib/feen/parser/pieces_in_hand.rb

@@ -1,22 +1,48 @@
 # frozen_string_literal: true
 
-require_relative File.join("pieces_in_hand", "errors")
-require_relative File.join("pieces_in_hand", "pnn_patterns")
-
 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",
+        modifiers_not_allowed: 'Pieces in hand cannot contain modifiers: "%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 and modifiers
+        )
+        /                                       # Mandatory separator
+        (?:                                     # Lowercase section (optional)
+          (?:(?:[2-9]|[1-9]\d+)?[-+]?[a-z]'?)*  # Zero or more lowercase pieces with optional counts and modifiers
+        )
+      \z}x
+
       # Parses the pieces in hand section of a FEEN string.
       #
       # @param pieces_in_hand_str [String] FEEN pieces in hand string in format "UPPERCASE/lowercase"
-      # @return [Array<String>] Array of piece identifiers in full PNN format,
+      # @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("/")
@@ -26,13 +52,10 @@ module Feen
       #   PiecesInHand.parse("3P2B/p")
       #   # => ["B", "B", "P", "P", "P", "p"]
       #
-      # @example Parse complex pieces with counts and modifiers
-      #   PiecesInHand.parse("10P5K3B/2p'+p-pbq")
-      #   # => ["+p", "-p", "B", "B", "B", "K", "K", "K", "K", "K",
-      #   #     "P", "P", "P", "P", "P", "P", "P", "P", "P", "P",
-      #   #     "b", "p'", "p'", "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)
 
@@ -42,7 +65,7 @@ module Feen
         # Split by the separator to get uppercase and lowercase sections
         uppercase_section, lowercase_section = pieces_in_hand_str.split("/", 2)
 
-        # Parse each section separately
+        # Parse each section separately and validate no modifiers
         uppercase_pieces = parse_pieces_section(uppercase_section || "", :uppercase)
         lowercase_pieces = parse_pieces_section(lowercase_section || "", :lowercase)
 
@@ -62,103 +85,36 @@ module Feen
       end
 
       # Validates that the input string matches the expected format according to FEEN specification.
-      # Format must be: "UPPERCASE_PIECES/LOWERCASE_PIECES"
+      # 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)
         # Must contain exactly one "/" separator
         parts_count = str.count("/")
-        raise ::ArgumentError, format(Errors[:invalid_format], str) unless parts_count == 1
-
-        uppercase_section, lowercase_section = str.split("/", 2)
+        raise ::ArgumentError, format(Errors[:missing_separator], parts_count) unless parts_count == 1
 
-        # Each section can be empty, but if not empty, must follow PNN patterns
-        validate_section_format(uppercase_section, :uppercase) unless uppercase_section.empty?
-        validate_section_format(lowercase_section, :lowercase) unless lowercase_section.empty?
-      end
+        # Must match the overall pattern (including potential modifiers for detection)
+        raise ::ArgumentError, format(Errors[:invalid_format], str) unless str.match?(VALID_FORMAT_PATTERN)
 
-      # Validates the format of a specific section (uppercase or lowercase)
-      #
-      # @param section [String] The section to validate
-      # @param case_type [Symbol] Either :uppercase or :lowercase
-      # @raise [ArgumentError] If the section format is invalid
-      # @return [void]
-      private_class_method def self.validate_section_format(section, case_type)
-        return if section.empty?
-
-        # Build the appropriate pattern based on case type
-        case_pattern = case case_type
-                       when :uppercase
-                         PnnPatterns::UPPERCASE_SECTION_PATTERN
-                       when :lowercase
-                         PnnPatterns::LOWERCASE_SECTION_PATTERN
-                       else
-                         raise ArgumentError, "Invalid case type: #{case_type}"
-                       end
-
-        # Validate overall section pattern
-        raise ::ArgumentError, format(Errors[:invalid_format], section) unless section.match?(case_pattern)
-
-        # Validate individual pieces in the section
-        validate_individual_pieces_in_section(section, case_type)
+        # Additional validation: check for any modifiers (forbidden in hand)
+        validate_no_modifiers(str)
       end
 
-      # Validates each individual piece in a section for PNN compliance
+      # Validates that no modifiers are present in the pieces in hand string
       #
-      # @param section [String] FEEN pieces section string
-      # @param case_type [Symbol] Either :uppercase or :lowercase
-      # @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_in_section(section, case_type)
-        position = 0
+      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?(/[+\-']/)
 
-        while position < section.length
-          match = section[position..].match(PnnPatterns::PIECE_WITH_COUNT_PATTERN)
+        # Find the specific invalid piece to provide a better error message
+        invalid_pieces = str.scan(/(?:[2-9]|[1-9]\d+)?[-+]?[a-zA-Z]'?/).grep(/[+\-']/)
 
-          unless match
-            remaining = section[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
-
-          # 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
-
-          # Validate that the piece matches the expected case
-          piece_case = piece_is_uppercase?(piece) ? :uppercase : :lowercase
-          unless piece_case == case_type
-            case_name = case_type == :uppercase ? "uppercase" : "lowercase"
-            raise ::ArgumentError, "#{case_name.capitalize} section contains #{piece_case} piece: '#{piece}'"
-          end
-
-          position += match[0].length
-        end
-      end
-
-      # Determines if a piece belongs to the uppercase group
-      #
-      # @param piece [String] Piece identifier (e.g., "P", "+P", "P'", "+P'")
-      # @return [Boolean] True if the piece's main letter is uppercase
-      private_class_method def self.piece_is_uppercase?(piece)
-        # Extract the main letter (skip prefixes like + or -)
-        main_letter = piece.gsub(/\A[+-]/, "").gsub(/'\z/, "")
-        main_letter.match?(/[A-Z]/)
+        raise ::ArgumentError, format(Errors[:modifiers_not_allowed], invalid_pieces.first)
       end
 
       # Parses a specific section (uppercase or lowercase) and returns expanded pieces
@@ -166,33 +122,55 @@ module Feen
       # @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)
+      private_class_method def self.parse_pieces_section(section, case_type)
         return [] if section.empty?
 
         # Extract pieces with their counts
-        pieces_with_counts = extract_pieces_with_counts_from_section(section)
+        pieces_with_counts = extract_pieces_with_counts_from_section(section, case_type)
 
-        # Expand the pieces into an array (no canonical order validation needed)
+        # Expand the pieces into an array
         expand_pieces(pieces_with_counts)
       end
 
       # Extracts pieces with their counts from a section 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_from_section(section)
+      # @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 < section.length
-          match = section[position..].match(PnnPatterns::PIECE_WITH_COUNT_PATTERN)
+          match = section[position..].match(PIECE_WITH_COUNT_PATTERN)
           break unless match
 
-          count_str, piece = match.captures
+          count_str, piece_with_modifiers = match.captures
           count = count_str ? count_str.to_i : 1
 
+          # Extract just the base piece (remove any modifiers)
+          base_piece = extract_base_piece(piece_with_modifiers)
+
+          # Validate piece is base form only (single letter)
+          unless base_piece.match?(BASE_PIECE_PATTERN)
+            raise ::ArgumentError, "Pieces in hand must be base form only: '#{base_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 = base_piece.match?(/[A-Z]/) ? :uppercase : :lowercase
+          unless piece_case == case_type
+            case_name = case_type == :uppercase ? "uppercase" : "lowercase"
+            raise ::ArgumentError, "Piece '#{base_piece}' has wrong case for #{case_name} section"
+          end
+
           # Add to our result with piece type and count
-          result << { piece: piece, count: count }
+          result << { piece: base_piece, count: count }
 
           # Move position forward
           position += match[0].length
@@ -201,6 +179,18 @@ module Feen
         result
       end
 
+      # Extracts the base piece from a piece string that may contain modifiers
+      #
+      # @param piece_str [String] Piece string potentially with modifiers
+      # @return [String] Base piece without modifiers
+      private_class_method def self.extract_base_piece(piece_str)
+        # Remove prefix modifiers (+ or -)
+        without_prefix = piece_str.gsub(/^[-+]/, "")
+
+        # Remove suffix modifiers (')
+        without_prefix.gsub(/'$/, "")
+      end
+
       # Expands the pieces based on their counts into an array.
       #
       # @param pieces_with_counts [Array<Hash>] Array of pieces with their counts

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.beta7
+  version: 5.0.0.beta9
 platform: ruby
 authors:
 - Cyril Kato
@@ -25,15 +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/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/errors.rb
-- lib/feen/parser/pieces_in_hand/pnn_patterns.rb
 homepage: https://github.com/sashite/feen.rb
 licenses:
 - MIT
@@ -44,6 +39,8 @@ metadata:
   source_code_uri: https://github.com/sashite/feen.rb
   specification_uri: https://sashite.dev/documents/feen/1.0.0/
   rubygems_mfa_required: 'true'
+  keywords: board, board-games, chess, deserialization, feen, fen, game, makruk, notation,
+    serialization, shogi, xiangqi"
 rdoc_options: []
 require_paths:
 - lib

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/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/errors.rb

@@ -1,20 +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'",
-        missing_separator:         "Pieces in hand format must contain exactly one '/' separator. Got: %s",
-        wrong_case_in_section:     "Piece '%<piece>s' has wrong case for %<section>s section",
-        invalid_section_format:    "Invalid format in %<section>s section: %<content>s"
-      }.freeze
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    module PiecesInHand
-      # Patterns for PNN (Piece Name Notation) validation and parsing
-      module PnnPatterns
-        # Basic PNN piece pattern following the specification:
-        # <piece> ::= <letter> | <prefix> <letter> | <letter> <suffix> | <prefix> <letter> <suffix>
-        # <prefix> ::= "+" | "-"
-        # <suffix> ::= "'"
-        # <letter> ::= [a-zA-Z]
-        PNN_PIECE_PATTERN = /\A[-+]?[a-zA-Z]'?\z/
-
-        # Pattern for valid count prefixes according to FEEN specification:
-        # - Cannot be "0" or "1" (use piece without prefix instead)
-        # - Can be 2-9 or any number with 2+ digits
-        VALID_COUNT_PATTERN = /\A(?:[2-9]|\d{2,})\z/
-
-        # Pattern to extract piece with optional count from pieces in hand string
-        # Matches: optional count followed by complete PNN piece
-        # Groups: (count_str, piece_str)
-        # Note: We need to handle the full PNN piece including modifiers
-        PIECE_WITH_COUNT_PATTERN = /(?:([2-9]|\d{2,}))?([-+]?[a-zA-Z]'?)/
-
-        # Pattern for uppercase pieces only (used for uppercase section validation)
-        UPPERCASE_PIECE_PATTERN = /[-+]?[A-Z]'?/
-
-        # Pattern for lowercase pieces only (used for lowercase section validation)
-        LOWERCASE_PIECE_PATTERN = /[-+]?[a-z]'?/
-
-        # Pattern for uppercase section: sequence of uppercase pieces with optional counts
-        # Format: [count]piece[count]piece... where pieces are uppercase
-        UPPERCASE_SECTION_PATTERN = /\A
-          (?:
-            (?:[2-9]|\d{2,})?                                 # Optional count (2-9 or 10+)
-            [-+]?                                             # Optional single prefix (+ or -)
-            [A-Z]                                             # Required uppercase letter
-            '?                                                # Optional single suffix (')
-          )+                                                  # One or more uppercase pieces
-        \z/x
-
-        # Pattern for lowercase section: sequence of lowercase pieces with optional counts
-        # Format: [count]piece[count]piece... where pieces are lowercase
-        LOWERCASE_SECTION_PATTERN = /\A
-          (?:
-            (?:[2-9]|\d{2,})?                                 # Optional count (2-9 or 10+)
-            [-+]?                                             # Optional single prefix (+ or -)
-            [a-z]                                             # Required lowercase letter
-            '?                                                # Optional single suffix (')
-          )+                                                  # One or more lowercase pieces
-        \z/x
-
-        # Complete validation pattern for pieces in hand string with case separation
-        # Based on the FEEN BNF specification with PNN support
-        # Format: "UPPERCASE_PIECES/LOWERCASE_PIECES"
-        # Either section can be empty, but the "/" separator is mandatory
-        VALID_FORMAT_PATTERN = %r{\A
-          (?:
-            (?:                                               # Uppercase section (optional)
-              (?:[2-9]|\d{2,})?                               # Optional count (2-9 or 10+)
-              [-+]?                                           # Optional single prefix (+ or -)
-              [A-Z]                                           # Required uppercase letter
-              '?                                              # Optional single suffix (')
-            )*                                                # Zero or more uppercase pieces
-          )
-          /                                                  # Mandatory separator
-          (?:
-            (?:                                               # Lowercase section (optional)
-              (?:[2-9]|\d{2,})?                               # Optional count (2-9 or 10+)
-              [-+]?                                           # Optional single prefix (+ or -)
-              [a-z]                                           # Required lowercase letter
-              '?                                              # Optional single suffix (')
-            )*                                                # Zero or more lowercase pieces
-          )
-        \z}x
-
-        # Pattern for extracting all pieces globally (used for comprehensive validation)
-        GLOBAL_PIECE_EXTRACTION_PATTERN = /(?:([2-9]|\d{2,}))?([-+]?[a-zA-Z]'?)/
-
-        # Pattern specifically for uppercase pieces with counts (for section parsing)
-        UPPERCASE_PIECE_WITH_COUNT_PATTERN = /(?:([2-9]|\d{2,}))?([-+]?[A-Z]'?)/
-
-        # Pattern specifically for lowercase pieces with counts (for section parsing)
-        LOWERCASE_PIECE_WITH_COUNT_PATTERN = /(?:([2-9]|\d{2,}))?([-+]?[a-z]'?)/
-      end
-    end
-  end
-end