feen 5.0.0.beta5 → 5.0.0.beta7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28b60c3d60fd3241172fee9e143c53e6dca04082a2efe7f0fa7559b85dc6eac0
-  data.tar.gz: a15999144de7bcd5637b6efca4ed1c4a8ae7d3757d6d583123dfaf44468d6d35
+  metadata.gz: 0f302aa1f4504f94ed909dcb5f6759c52a8895c85e4bd4cc0c0cbff42ef6fdd4
+  data.tar.gz: eb77d9e6e1d1bae1c13cc0b4997e1b509e06b631001fbc8c60027da234f50494
 SHA512:
-  metadata.gz: 861669bea6101dba5eefcf6062b9e4e0b37152618e7ffa9c1ba963eb37b2f49cad804f4c1bbee31bd030bf4ddd9602563df7e54cc244384d37e1f45ec748c5ff
-  data.tar.gz: 6f00dcfc09fd378fde0fbe3cd36b078718eab1fa27e208d474637ef89853a7543be4027116d623d0e037c340f0deeae90ce337404db09c953faecba852f56ece
+  metadata.gz: 331d90ea031b33aa88292680f98b5c847c467827ad2cd64f39e261c8d052a3cfefdf1f4fe734befc51ffffe7667fbe3b713a08d6952adc86869f3401726f12c5
+  data.tar.gz: 574801b36461caf3e971540430962344442a43027e100d76527df73345374ab624a6a2d7bd80fa9cb3917a85a2e16d4ececbca67325776c134a33d7d400ee5c7

data/README.md

@@ -14,16 +14,30 @@ FEEN (Forsyth–Edwards Enhanced Notation) is a compact, canonical, and rule-agn
 This gem implements the [FEEN Specification v1.0.0](https://sashite.dev/documents/feen/1.0.0/), providing a Ruby interface for:
 
 - Representing positions from various games without knowledge of specific rules
-- Supporting boards of arbitrary dimensions
-- Encoding pieces in hand (as used in Shogi)
+- Supporting boards of arbitrary dimensions (2D, 3D, and beyond)
+- Encoding pieces in hand with full PNN (Piece Name Notation) support
 - Facilitating serialization and deserialization of positions
 - Ensuring canonical representation for consistent data handling
 
+## FEEN Format
+
+A FEEN record consists of three space-separated fields:
+
+```
+<PIECE-PLACEMENT> <PIECES-IN-HAND> <GAMES-TURN>
+```
+
+### Field Details
+
+1. **Piece Placement**: Spatial distribution of pieces on the board using [PNN notation](https://sashite.dev/documents/pnn/1.0.0/)
+2. **Pieces in Hand**: Off-board pieces available for placement, formatted as `"UPPERCASE/lowercase"` and sorted canonically within each section
+3. **Games Turn**: Game identifiers and active player indication
+
 ## Installation
 
 ```ruby
 # In your Gemfile
-gem "feen", ">= 5.0.0.beta5"
+gem "feen", ">= 5.0.0.beta7"
 ```
 
 Or install manually:
@@ -32,14 +46,6 @@ Or install manually:
 gem install feen --pre
 ```
 
-## FEEN Format
-
-A FEEN record consists of three space-separated fields:
-
-```
-<PIECE-PLACEMENT> <PIECES-IN-HAND> <GAMES-TURN>
-```
-
 ## Basic Usage
 
 ### Parsing FEEN Strings
@@ -49,20 +55,20 @@ Convert a FEEN string into a structured Ruby object:
 ```ruby
 require "feen"
 
-feen_string = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
+feen_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess"
 position = Feen.parse(feen_string)
 
 # Result is a hash:
 # {
 #   piece_placement: [
-#     ["r'", "n", "b", "q", "k", "b", "n", "r'"],
+#     ["r", "n", "b", "q", "k", "b", "n", "r"],
 #     ["p", "p", "p", "p", "p", "p", "p", "p"],
 #     ["", "", "", "", "", "", "", ""],
 #     ["", "", "", "", "", "", "", ""],
 #     ["", "", "", "", "", "", "", ""],
 #     ["", "", "", "", "", "", "", ""],
 #     ["P", "P", "P", "P", "P", "P", "P", "P"],
-#     ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
+#     ["R", "N", "B", "Q", "K", "B", "N", "R"]
 #   ],
 #   pieces_in_hand: [],
 #   games_turn: ["CHESS", "chess"]
@@ -77,7 +83,7 @@ Parse a FEEN string without raising exceptions:
 require "feen"
 
 # Valid FEEN string
-result = Feen.safe_parse("r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess")
+result = Feen.safe_parse("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess")
 # => {piece_placement: [...], pieces_in_hand: [...], games_turn: [...]}
 
 # Invalid FEEN string
@@ -94,14 +100,14 @@ require "feen"
 
 # Representation of a chess board in initial position
 piece_placement = [
-  ["r'", "n", "b", "q", "k", "b", "n", "r'"],
+  ["r", "n", "b", "q", "k", "b", "n", "r"],
   ["p", "p", "p", "p", "p", "p", "p", "p"],
   ["", "", "", "", "", "", "", ""],
   ["", "", "", "", "", "", "", ""],
   ["", "", "", "", "", "", "", ""],
   ["", "", "", "", "", "", "", ""],
   ["P", "P", "P", "P", "P", "P", "P", "P"],
-  ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
+  ["R", "N", "B", "Q", "K", "B", "N", "R"]
 ]
 
 result = Feen.dump(
@@ -109,7 +115,7 @@ result = Feen.dump(
   games_turn:      %w[CHESS chess],
   pieces_in_hand:  []
 )
-# => "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
+# => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess"
 ```
 
 ### Validation
@@ -120,16 +126,16 @@ Check if a string is valid FEEN notation and in canonical form:
 require "feen"
 
 # Canonical form
-Feen.valid?("lnsgk3l/5g3/p1ppB2pp/9/8B/2P6/P2PPPPPP/3K3R1/5rSNL N5P2gln2s SHOGI/shogi")
+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 not in canonical order)
+Feen.valid?("8/8/8/8/8/8/8/8 P3K/ CHESS/chess")
+# => false (wrong quantity sorting in uppercase section)
 ```
 
 The `valid?` method performs two levels of validation:
@@ -144,47 +150,126 @@ As FEEN is rule-agnostic, it can represent positions from various board games. H
 ### International Chess
 
 ```ruby
-feen_string = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
+feen_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess"
 ```
 
-In this initial chess position:
-
-- The `'` suffixes on rooks indicate an intermediate state (which might represent castling rights in chess, though FEEN doesn't define this semantics)
-- The third field `CHESS/chess` indicates it's the player with uppercase pieces' turn to move
+In this initial chess position, the third field `CHESS/chess` indicates it's the player with uppercase pieces' turn to move.
 
 ### Shogi (Japanese Chess)
 
 ```ruby
-feen_string = "lnsgk3l/5g3/p1ppB2pp/9/8B/2P6/P2PPPPPP/3K3R1/5rSNL N5P2gln2s SHOGI/shogi"
+feen_string = "lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL / SHOGI/shogi"
+```
+
+**With pieces in hand and promotions:**
+
+```ruby
+feen_string = "lnsgk3l/5g3/p1ppB2pp/9/8B/2P6/P2PPPPPP/3K3R1/5rSNL 5P2G2L/2gln2s SHOGI/shogi"
 ```
 
 In this shogi position:
 
 - The format supports promotions with the `+` prefix (e.g., `+P` for a promoted pawn)
-- The notation allows for pieces in hand, indicated in the second field
+- Pieces in hand are separated by case: `5P2G2L/2gln2s`
+  - **Uppercase section** (Sente): 5 Pawns, 2 Golds, 2 Lances
+  - **Lowercase section** (Gote): 2 golds, lance, knight, 2 silvers
+- Each section is sorted by quantity (descending) then alphabetically
 - `SHOGI/shogi` indicates it's Sente's (Black's, uppercase) turn to move
-- `N5P2gln2s` shows the pieces in hand: Sente has a Knight (N) and 5 Pawns (5P), while Gote has 2 Golds (2g), a Lance (l), a Knight (n), and 2 Silvers (2s), all properly sorted in ASCII lexicographic order
 
 ### Makruk (Thai Chess)
 
 ```ruby
-feen_string = "rnbqkbnr/8/pppppppp/8/8/PPPPPPPP/8/RNBQKBNR - MAKRUK/makruk"
+feen_string = "rnbqkbnr/8/pppppppp/8/8/PPPPPPPP/8/RNBKQBNR / MAKRUK/makruk"
 ```
 
-This initial Makruk position is easily represented in FEEN without needing to know the specific rules of the game.
-
 ### Xiangqi (Chinese Chess)
 
 ```ruby
-feen_string = "rheagaehr/9/1c5c1/s1s1s1s1s/9/9/S1S1S1S1S/1C5C1/9/RHEAGAEHR - XIANGQI/xiangqi"
+feen_string = "rheagaehr/9/1c5c1/s1s1s1s1s/9/9/S1S1S1S1S/1C5C1/9/RHEAGAEHR / XIANGQI/xiangqi"
 ```
 
-In this Xiangqi position:
+## Advanced Features
+
+### Pieces in Hand with Case Separation
 
-- The representation uses single letters for the different pieces
-- The format naturally adapts to the presence of a "river" (empty space in the middle)
+FEEN uses case separation for pieces in hand to distinguish between players using the format `"UPPERCASE_PIECES/LOWERCASE_PIECES"`:
 
-## Advanced Features
+```ruby
+require "feen"
+
+# Parse pieces in hand with case separation
+pieces_in_hand = Feen.parse("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR 3P2B/2pn CHESS/chess")[:pieces_in_hand]
+# => ["B", "B", "P", "P", "P", "n", "p", "p"]  # Sorted alphabetically
+
+# Create FEEN with pieces in hand
+result = Feen.dump(
+  piece_placement: [["k"], ["K"]],
+  pieces_in_hand: ["P", "P", "B", "p", "n"],
+  games_turn: ["TEST", "test"]
+)
+# => "k/K 2BP/np TEST/test"
+```
+
+### Piece Name Notation (PNN) Support
+
+FEEN supports the complete [PNN specification](https://sashite.dev/documents/pnn/1.0.0/) for representing pieces with state modifiers:
+
+#### PNN Modifiers
+
+- **Prefix `+`**: Enhanced state (e.g., promoted pieces in shogi)
+- **Prefix `-`**: Diminished state (e.g., restricted movement)
+- **Suffix `'`**: Intermediate state (e.g., castling rights, en passant eligibility)
+
+#### Examples with PNN
+
+```ruby
+# Shogi position with promoted pieces on board
+piece_placement = [
+  ["", "", "", "", "+P", "", "", "", ""] # Promoted pawn on board
+  # ... other ranks
+]
+
+# Pieces in hand with PNN modifiers - case separated
+pieces_in_hand = ["+P", "+P", "+P", "B'", "B'", "-p", "P"]
+
+result = Feen.dump(
+  piece_placement: piece_placement,
+  pieces_in_hand:  pieces_in_hand,
+  games_turn:      %w[SHOGI shogi]
+)
+# => "8/8/8/8/4+P4/8/8/8/8 3+P2B'P/-p SHOGI/shogi"
+```
+
+### Canonical Pieces in Hand Sorting
+
+FEEN enforces canonical ordering of pieces in hand within each case section according to the specification:
+
+1. **By quantity (descending)**
+2. **By complete PNN representation (alphabetically ascending)**
+
+The dumper organizes pieces by case first, then applies canonical sorting within each section:
+
+```ruby
+# Input pieces in any order
+pieces = ["P", "b", "P", "+P", "B", "p", "+P", "+P"]
+
+result = Feen.dump(
+  piece_placement: [["k"], ["K"]],
+  pieces_in_hand: pieces,
+  games_turn: %w[GAME game]
+)
+# => "k/K 3+P2PB/bp GAME/game"
+# Breakdown:
+# - Uppercase: 3×+P (most frequent), 2×P, 1×B (alphabetical within same quantity)
+# - Lowercase: 1×b, 1×p (alphabetical)
+```
+
+The parser returns pieces in simple alphabetical order for easy handling:
+
+```ruby
+pieces_in_hand = Feen.parse("k/K 3+P2PB/bp GAME/game")[:pieces_in_hand]
+# => ["+P", "+P", "+P", "B", "P", "P", "b", "p"]  # Alphabetically sorted
+```
 
 ### Multi-dimensional Boards
 
@@ -193,7 +278,7 @@ FEEN supports arbitrary-dimensional board configurations:
 ```ruby
 require "feen"
 
-# 3D board
+# 3D board (2×2×3 configuration)
 piece_placement = [
   [
     %w[r n b],
@@ -210,29 +295,100 @@ result = Feen.dump(
   games_turn:      %w[FOO bar],
   pieces_in_hand:  []
 )
-# => "rnb/qkp//PR1/1KQ - FOO/bar"
+# => "rnb/qkp//PR1/1KQ / FOO/bar"
+```
+
+### Hybrid Games
+
+FEEN supports hybrid games mixing different piece sets:
+
+```ruby
+# Chess-Shogi hybrid position
+feen_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR 3+P2B'/p CHESS/shogi"
+```
+
+This represents a position where:
+
+- The board uses chess-style pieces
+- Pieces in hand use shogi-style promotion (`+P`) and intermediate states (`B'`)
+- Chess player to move, against shogi player
+- Case separation shows which player has which pieces
+
+## Round-trip Consistency
+
+FEEN.rb guarantees round-trip consistency - parsing and dumping produces identical canonical strings:
+
+```ruby
+original = "lnsgk3l/5g3/p1ppB2pp/9/8B/2P6/P2PPPPPP/3K3R1/5rSNL 5P2G2L/2gln2s SHOGI/shogi"
+parsed = Feen.parse(original)
+dumped = Feen.dump(**parsed)
+
+original == dumped # => true (guaranteed canonical form)
+```
+
+## Error Handling
+
+### Validation Errors
+
+```ruby
+# Invalid PNN format
+Feen.dump(
+  piece_placement: [["k"]],
+  pieces_in_hand: ["++P"],  # Invalid: double prefix
+  games_turn: %w[GAME game]
+)
+# => ArgumentError: Invalid format at index: 0, value: '++P'
+
+# Invalid games turn
+Feen.dump(
+  piece_placement: [["P"]],
+  pieces_in_hand:  [],
+  games_turn:      %w[BOTH_UPPERCASE ALSO_UPPERCASE] # Both same case
+)
+# => ArgumentError: One variant must be uppercase and the other lowercase
+
+# Invalid pieces in hand format (parsing)
+Feen.parse("8/8/8/8/8/8/8/8 NoSeparator CHESS/chess")
+# => ArgumentError: Invalid pieces in hand format: NoSeparator
 ```
 
-### Piece Modifiers
+### Safe Operations
+
+```ruby
+# Use safe_parse for user input
+user_input = gets.chomp
+position = Feen.safe_parse(user_input)
+
+if position
+  puts "Valid FEEN position!"
+  puts "Pieces in hand: #{position[:pieces_in_hand]}"
+else
+  puts "Invalid FEEN format"
+end
+```
 
-FEEN supports prefixes and suffixes for pieces to denote various states or capabilities:
+## Performance Considerations
 
-- **Prefix `+`**: Enhanced state
-  - Example in shogi: `+P` may represent a promoted pawn
+- **Parsing**: Optimized recursive descent parser with O(n) complexity
+- **Case separation**: Efficient single-pass processing for pieces in hand
+- **Validation**: Round-trip validation ensures canonical form
+- **Memory**: Efficient array-based representation for large boards
+- **Sorting**: In-place canonical sorting for pieces in hand
 
-- **Prefix `-`**: Diminished state
-  - Could represent a piece with limited movement or other restrictions
+## Compatibility
 
-- **Suffix `'`**: Intermediate state
-  - Example in chess: `R'` may represent a rook that has intermediate status (such as castling eligibility)
-  - Example in chess: `P'` may represent a pawn that may be captured _en passant_
+- **Ruby version**: >= 3.2.0
+- **FEEN specification**: v1.0.0 compliant
+- **PNN specification**: v1.0.0 compliant
+- **Thread safety**: All operations are thread-safe (no shared mutable state)
 
-These modifiers have no defined semantics in the FEEN specification itself but provide a flexible framework for representing piece-specific conditions while maintaining FEEN's rule-agnostic nature.
+## Related Specifications
 
-## Documentation
+FEEN is part of a family of specifications for abstract strategy games:
 
-- [Official FEEN Specification](https://sashite.dev/documents/feen/1.0.0/)
-- [API Documentation](https://rubydoc.info/github/sashite/feen.rb/main)
+- [FEEN Specification v1.0.0](https://sashite.dev/documents/feen/1.0.0/) - Board position notation
+- [PNN Specification v1.0.0](https://sashite.dev/documents/pnn/1.0.0/) - Piece name notation
+- [GAN Specification v1.0.0](https://sashite.dev/documents/gan/1.0.0/) - Game-qualified piece identifiers
 
 ## License
 

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

@@ -5,7 +5,7 @@ module Feen
     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 format: '%<value>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

data/lib/feen/dumper/pieces_in_hand.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative File.join("pieces_in_hand", "no_pieces")
 require_relative File.join("pieces_in_hand", "errors")
 
 module Feen
@@ -9,24 +8,102 @@ module Feen
     module PiecesInHand
       # Converts an array of piece identifiers to a FEEN-formatted pieces in hand string
       #
-      # @param piece_chars [Array<String>] Array of single-character piece identifiers
-      # @return [String] FEEN-formatted pieces in hand string
+      # @param piece_chars [Array<String>] Array of piece identifiers (e.g., ["P", "p", "B", "B", "p", "+P"])
+      # @return [String] FEEN-formatted pieces in hand string following the format:
+      #   - Groups pieces by case: uppercase first, then lowercase, separated by "/"
+      #   - Within each group, sorts by quantity (descending), then alphabetically (ascending)
+      #   - Uses count notation for quantities > 1 (e.g., "3P" instead of "PPP")
       # @raise [ArgumentError] If any piece identifier is invalid
       # @example
-      #   PiecesInHand.dump("P", "p", "B")
-      #   # => "BPp"
+      #   PiecesInHand.dump("P", "P", "P", "B", "B", "p", "p", "p", "p", "p")
+      #   # => "3P2B/5p"
+      #
+      #   PiecesInHand.dump("p", "P", "B")
+      #   # => "BP/p"
       #
       #   PiecesInHand.dump
-      #   # => "-"
+      #   # => "/"
       def self.dump(*piece_chars)
-        # If no pieces in hand, return the standardized empty indicator
-        return NoPieces if piece_chars.empty?
-
         # Validate each piece character according to the FEEN specification
         validated_chars = validate_piece_chars(piece_chars)
 
-        # Sort pieces in ASCII lexicographic order and join them
-        validated_chars.sort.join
+        # Group pieces by case
+        uppercase_pieces, lowercase_pieces = group_pieces_by_case(validated_chars)
+
+        # Format each group according to FEEN specification
+        uppercase_formatted = format_pieces_group(uppercase_pieces)
+        lowercase_formatted = format_pieces_group(lowercase_pieces)
+
+        # Combine with separator
+        "#{uppercase_formatted}/#{lowercase_formatted}"
+      end
+
+      # Groups pieces by case (uppercase vs lowercase)
+      #
+      # @param pieces [Array<String>] Array of validated piece identifiers
+      # @return [Array<Array<String>, Array<String>>] Two arrays: [uppercase_pieces, lowercase_pieces]
+      private_class_method def self.group_pieces_by_case(pieces)
+        uppercase_pieces = pieces.select { |piece| piece_is_uppercase?(piece) }
+        lowercase_pieces = pieces.select { |piece| piece_is_lowercase?(piece) }
+
+        [uppercase_pieces, lowercase_pieces]
+      end
+
+      # Determines if a piece belongs to the uppercase group
+      # A piece is considered uppercase if its main letter is uppercase (ignoring prefixes/suffixes)
+      #
+      # @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]/)
+      end
+
+      # Determines if a piece belongs to the lowercase group
+      # A piece is considered lowercase if its main letter is lowercase (ignoring prefixes/suffixes)
+      #
+      # @param piece [String] Piece identifier (e.g., "p", "+p", "p'", "+p'")
+      # @return [Boolean] True if the piece's main letter is lowercase
+      private_class_method def self.piece_is_lowercase?(piece)
+        # Extract the main letter (skip prefixes like + or -)
+        main_letter = piece.gsub(/\A[+-]/, "").gsub(/'\z/, "")
+        main_letter.match?(/[a-z]/)
+      end
+
+      # Formats a group of pieces according to FEEN specification
+      #
+      # @param pieces [Array<String>] Array of pieces from the same case group
+      # @return [String] Formatted string for this group (e.g., "3P2B", "5pq")
+      private_class_method def self.format_pieces_group(pieces)
+        return "" if pieces.empty?
+
+        # Count occurrences of each piece type
+        piece_counts = pieces.each_with_object(Hash.new(0)) do |piece, counts|
+          counts[piece] += 1
+        end
+
+        # Sort by count (descending) then alphabetically (ascending)
+        sorted_pieces = piece_counts.sort do |a, b|
+          piece_a, count_a = a
+          piece_b, count_b = b
+
+          # Primary sort: by count (descending)
+          count_comparison = count_b <=> count_a
+          next count_comparison unless count_comparison.zero?
+
+          # Secondary sort: by piece name (ascending)
+          piece_a <=> piece_b
+        end
+
+        # Format each piece with its count
+        sorted_pieces.map do |piece, count|
+          if count == 1
+            piece
+          else
+            "#{count}#{piece}"
+          end
+        end.join
       end
 
       # Validates all piece characters according to FEEN specification
@@ -41,6 +118,10 @@ module Feen
       end
 
       # Validates a single piece character according to FEEN specification
+      # Supports full PNN notation: [prefix]letter[suffix] where:
+      # - prefix can be "+" or "-"
+      # - letter must be a-z or A-Z
+      # - suffix can be "'"
       #
       # @param char [Object] Piece character candidate
       # @param index [Integer] Index of the character in the original array
@@ -56,8 +137,9 @@ module Feen
           )
         end
 
-        # Validate format (single alphabetic character)
-        unless char.match?(/\A[a-zA-Z]\z/)
+        # Validate format using PNN pattern: [prefix]letter[suffix]
+        # where prefix is +/-, letter is a-zA-Z, suffix is '
+        unless char.match?(/\A[+-]?[a-zA-Z]'?\z/)
           raise ::ArgumentError, format(
             Errors[:invalid_format],
             index: index,

data/lib/feen/dumper.rb

@@ -23,19 +23,19 @@ module Feen
     # @example Creating a FEEN string for chess initial position
     #   Feen::Dumper.dump(
     #     piece_placement: [
-    #       ["r'", "n", "b", "q", "k", "b", "n", "r'"],
+    #       ["r", "n", "b", "q", "k", "b", "n", "r"],
     #       ["p", "p", "p", "p", "p", "p", "p", "p"],
     #       ["", "", "", "", "", "", "", ""],
     #       ["", "", "", "", "", "", "", ""],
     #       ["", "", "", "", "", "", "", ""],
     #       ["", "", "", "", "", "", "", ""],
     #       ["P", "P", "P", "P", "P", "P", "P", "P"],
-    #       ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
+    #       ["R", "N", "B", "Q", "K", "B", "N", "R"]
     #     ],
     #     pieces_in_hand: [],
     #     games_turn: ["CHESS", "chess"]
     #   )
-    #   # => "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
+    #   # => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR - CHESS/chess"
     #
     # @param piece_placement [Array] Board position data structure representing the spatial
     #                                distribution of pieces across the board, where each cell

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

@@ -5,10 +5,15 @@ module Feen
     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",
-        sorting_error:  "Pieces in hand must be in ASCII lexicographic order"
+        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

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

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

data/lib/feen/parser/pieces_in_hand.rb

@@ -1,49 +1,54 @@
 # 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", "piece_count_pattern")
-require_relative File.join("pieces_in_hand", "valid_format_pattern")
+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.
+    # Format: "UPPERCASE_PIECES/LOWERCASE_PIECES"
     module PiecesInHand
       # 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 single-character piece identifiers in the
-      #   format specified in the FEEN string (no prefixes or suffixes), expanded
-      #   based on their counts and sorted in ASCII lexicographic order.
+      # @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,
+      #   expanded based on their counts and sorted alphabetically.
       #   Empty array if no pieces are in hand.
       # @raise [ArgumentError] If the input string is invalid
       #
       # @example Parse no pieces in hand
-      #   PiecesInHand.parse("-")
+      #   PiecesInHand.parse("/")
       #   # => []
       #
-      # @example Parse multiple pieces in hand
-      #   PiecesInHand.parse("BN2Pb")
-      #   # => ["B", "N", "P", "P", "b"]
+      # @example Parse pieces with case separation
+      #   PiecesInHand.parse("3P2B/p")
+      #   # => ["B", "B", "P", "P", "P", "p"]
       #
-      # @example Parse pieces with counts
-      #   PiecesInHand.parse("N5P2b")
-      #   # => ["N", "P", "P", "P", "P", "P", "b", "b"]
+      # @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"]
       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 order
-        pieces_with_counts = extract_pieces_with_counts(pieces_in_hand_str)
-        validate_lexicographic_order(pieces_with_counts)
+        # Split by the separator to get uppercase and lowercase sections
+        uppercase_section, lowercase_section = pieces_in_hand_str.split("/", 2)
 
-        # Expand the pieces into an array and maintain lexicographic ordering
-        expand_pieces(pieces_with_counts)
+        # Parse each section separately
+        uppercase_pieces = parse_pieces_section(uppercase_section || "", :uppercase)
+        lowercase_pieces = parse_pieces_section(lowercase_section || "", :lowercase)
+
+        # 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.
@@ -57,26 +62,130 @@ module Feen
       end
 
       # Validates that the input string matches the expected format according to FEEN specification.
+      # Format must be: "UPPERCASE_PIECES/LOWERCASE_PIECES"
       #
       # @param str [String] Input string to validate
       # @raise [ArgumentError] If format is invalid
       # @return [void]
       private_class_method def self.validate_format(str)
-        return if str == NoPieces || str.match?(ValidFormatPattern)
+        # 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)
+
+        # 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
+
+      # 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)
+      end
+
+      # Validates each individual piece in a section for PNN compliance
+      #
+      # @param section [String] FEEN pieces section string
+      # @param case_type [Symbol] Either :uppercase or :lowercase
+      # @raise [ArgumentError] If any piece is invalid PNN format
+      # @return [void]
+      private_class_method def self.validate_individual_pieces_in_section(section, case_type)
+        position = 0
+
+        while position < section.length
+          match = section[position..].match(PnnPatterns::PIECE_WITH_COUNT_PATTERN)
+
+          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
 
-        raise ::ArgumentError, format(Errors[:invalid_format], str)
+          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]/)
+      end
+
+      # Parses a specific section (uppercase or lowercase) and returns expanded pieces
+      #
+      # @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 pieces with their counts
+        pieces_with_counts = extract_pieces_with_counts_from_section(section)
+
+        # Expand the pieces into an array (no canonical order validation needed)
+        expand_pieces(pieces_with_counts)
       end
 
-      # Extracts pieces with their counts from the FEEN string.
+      # Extracts pieces with their counts from a section string.
       #
-      # @param str [String] FEEN pieces in hand string
+      # @param section [String] FEEN pieces section string
       # @return [Array<Hash>] Array of hashes with :piece and :count keys
-      private_class_method def self.extract_pieces_with_counts(str)
+      private_class_method def self.extract_pieces_with_counts_from_section(section)
         result = []
         position = 0
 
-        while position < str.length
-          match = str[position..].match(PieceCountPattern)
+        while position < section.length
+          match = section[position..].match(PnnPatterns::PIECE_WITH_COUNT_PATTERN)
           break unless match
 
           count_str, piece = match.captures
@@ -92,20 +201,6 @@ module Feen
         result
       end
 
-      # Validates that pieces are in lexicographic ASCII order.
-      #
-      # @param pieces_with_counts [Array<Hash>] Array of pieces with their counts
-      # @raise [ArgumentError] If pieces are not in lexicographic order
-      # @return [void]
-      private_class_method def self.validate_lexicographic_order(pieces_with_counts)
-        pieces = pieces_with_counts.map { |item| item[:piece] }
-
-        # Verify the array is sorted lexicographically
-        return if pieces == pieces.sort
-
-        raise ::ArgumentError, Errors[:sorting_error]
-      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

@@ -26,18 +26,18 @@ module Feen
     # @raise [ArgumentError] If the FEEN string is invalid
     #
     # @example Parsing a standard chess initial position
-    #   feen = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
+    #   feen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR - CHESS/chess"
     #   result = Feen::Parser.parse(feen)
     #   # => {
     #   #      piece_placement: [
-    #   #        ["r'", "n", "b", "q", "k", "b", "n", "r'"],
+    #   #        ["r", "n", "b", "q", "k", "b", "n", "r"],
     #   #        ["p", "p", "p", "p", "p", "p", "p", "p"],
     #   #        ["", "", "", "", "", "", "", ""],
     #   #        ["", "", "", "", "", "", "", ""],
     #   #        ["", "", "", "", "", "", "", ""],
     #   #        ["", "", "", "", "", "", "", ""],
     #   #        ["P", "P", "P", "P", "P", "P", "P", "P"],
-    #   #        ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
+    #   #        ["R", "N", "B", "Q", "K", "B", "N", "R"]
     #   #      ],
     #   #      pieces_in_hand: [],
     #   #      games_turn: ["CHESS", "chess"]
@@ -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 = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - 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

@@ -23,21 +23,21 @@ module Feen
   # @raise [ArgumentError] If any parameter is invalid
   # @example
   #   piece_placement = [
-  #     ["r'", "n", "b", "q", "k", "b", "n", "r'"],
+  #     ["r", "n", "b", "q", "k", "b", "n", "r"],
   #     ["p", "p", "p", "p", "p", "p", "p", "p"],
   #     ["", "", "", "", "", "", "", ""],
   #     ["", "", "", "", "", "", "", ""],
   #     ["", "", "", "", "", "", "", ""],
   #     ["", "", "", "", "", "", "", ""],
   #     ["P", "P", "P", "P", "P", "P", "P", "P"],
-  #     ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
+  #     ["R", "N", "B", "Q", "K", "B", "N", "R"]
   #   ]
   #   Feen.dump(
   #     piece_placement: piece_placement,
   #     pieces_in_hand: [],
   #     games_turn: ["CHESS", "chess"]
   #   )
-  #   # => "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - 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
@@ -51,18 +51,18 @@ module Feen
   #   - :games_turn [Array<String>] - A two-element array with [active_variant, inactive_variant]
   # @raise [ArgumentError] If the FEEN string is invalid
   # @example
-  #   feen_string = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
+  #   feen_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR - CHESS/chess"
   #   Feen.parse(feen_string)
   #   # => {
   #   #      piece_placement: [
-  #   #        ["r'", "n", "b", "q", "k", "b", "n", "r'"],
+  #   #        ["r", "n", "b", "q", "k", "b", "n", "r"],
   #   #        ["p", "p", "p", "p", "p", "p", "p", "p"],
   #   #        ["", "", "", "", "", "", "", ""],
   #   #        ["", "", "", "", "", "", "", ""],
   #   #        ["", "", "", "", "", "", "", ""],
   #   #        ["", "", "", "", "", "", "", ""],
   #   #        ["P", "P", "P", "P", "P", "P", "P", "P"],
-  #   #        ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
+  #   #        ["R", "N", "B", "Q", "K", "B", "N", "R"]
   #   #      ],
   #   #      pieces_in_hand: [],
   #   #      games_turn: ["CHESS", "chess"]
@@ -80,7 +80,7 @@ module Feen
   # @return [Hash, nil] Hash containing the parsed position data or nil if parsing fails
   # @example
   #   # Valid FEEN string
-  #   Feen.safe_parse("r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - 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
@@ -104,7 +104,7 @@ module Feen
   # @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 N5P2gln2s SHOGI/shogi") # => true
+  #   Feen.valid?("lnsgk3l/5g3/p1ppB2pp/9/8B/2P6/P2PPPPPP/3K3R1/5rSNL 2g2s5PNln SHOGI/shogi") # => true
   #
   #   # Invalid syntax
   #   Feen.valid?("invalid feen string") # => false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta5
+  version: 5.0.0.beta7
 platform: ruby
 authors:
 - Cyril Kato
@@ -26,7 +26,6 @@ files:
 - 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
@@ -34,9 +33,7 @@ files:
 - 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/no_pieces.rb
-- lib/feen/parser/pieces_in_hand/piece_count_pattern.rb
-- lib/feen/parser/pieces_in_hand/valid_format_pattern.rb
+- lib/feen/parser/pieces_in_hand/pnn_patterns.rb
 homepage: https://github.com/sashite/feen.rb
 licenses:
 - MIT
@@ -61,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: FEEN (Forsyth–Edwards Enhanced Notation) support for the Ruby language.
 test_files: []

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/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

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    module PiecesInHand
-      # Valid pattern for pieces in hand based on BNF specification.
-      #
-      # The FEEN format specifies these rules for numeric prefixes:
-      # - Cannot start with "0"
-      # - Cannot be exactly "1" (use the letter without prefix instead)
-      # - Can be 2-9 or any number with 2+ digits (10, 11, etc.)
-      #
-      # The pattern matches either:
-      # - A single digit from 2-9
-      # - OR any number with two or more digits (10, 11, 27, 103, etc.)
-      #
-      # @return [Regexp] Regular expression for validating pieces in hand format
-      ValidFormatPattern = /\A
-        (?:
-          -|                                              # No pieces in hand
-          (?:                                             # Or sequence of pieces
-            (?:(?:[2-9]|\d{2,})?[A-Z])*                   # Uppercase pieces (optional)
-            (?:(?:[2-9]|\d{2,})?[a-z])*                   # Lowercase pieces (optional)
-          )
-        )
-      \z/x
-    end
-  end
-end