feen 5.0.0.beta8 → 5.0.0.beta10

data/lib/feen/parser/pieces_in_hand.rb

@@ -1,47 +1,48 @@
 # frozen_string_literal: true
 
+require "pnn"
+
 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.
-    # According to FEEN specification, pieces in hand MUST be in base form only (no modifiers).
+    # According to FEEN v1.0.0 specification, pieces in hand MAY include PNN modifiers.
     # Format: "UPPERCASE_PIECES/LOWERCASE_PIECES"
     module PiecesInHand
       # Error messages for validation
-      Errors = {
+      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"
+        missing_separator: "Pieces in hand format must contain exactly one '/' separator. Got: %s",
+        invalid_pnn:       "Invalid PNN piece notation: '%s'",
+        invalid_count:     "Invalid count format: '%s'. Count cannot be '0' or '1'"
       }.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])/
+      # Pattern for piece with optional count in pieces in hand (with full PNN support)
+      PIECE_WITH_COUNT_PATTERN = /(?:([2-9]|[1-9]\d+))?([-+]?[a-zA-Z]'?)/
 
-      # Complete validation pattern for pieces in hand string
+      # Complete validation pattern for pieces in hand string (with PNN modifier support)
       VALID_FORMAT_PATTERN = %r{\A
-        (?:                                               # Uppercase section (optional)
-          (?:(?:[2-9]|[1-9]\d+)?[A-Z])*                  # Zero or more uppercase pieces with optional counts
+        (?:                                     # 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
+        /                                       # 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 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 or contains modifiers
+      # @return [Array<String>] Array of piece identifiers (may include PNN modifiers),
+      #   expanded based on their counts. Pieces are returned in the order they appear
+      #   in the canonical FEEN string (not sorted alphabetically).
+      # @raise [ArgumentError] If the input string is invalid
       #
       # @example Parse no pieces in hand
       #   PiecesInHand.parse("/")
@@ -49,11 +50,11 @@ module Feen
       #
       # @example Parse pieces with case separation
       #   PiecesInHand.parse("3P2B/p")
-      #   # => ["B", "B", "P", "P", "P", "p"]
+      #   # => ["P", "P", "P", "B", "B", "p"]
       #
-      # @example Invalid - modifiers not allowed in hand
-      #   PiecesInHand.parse("+P/p")
-      #   # => ArgumentError: Pieces in hand cannot contain modifiers: '+P'
+      # @example Parse pieces with PNN modifiers
+      #   PiecesInHand.parse("2+B5BK3-P-P'3+P'9PR2SS'/bp")
+      #   # => ["+B", "+B", "B", "B", "B", "B", "B", "K", "-P", "-P", "-P", "-P'", "+P'", "+P'", "+P'", "P", "P", "P", "P", "P", "P", "P", "P", "P", "R", "S", "S", "S'", "b", "p"]
       def self.parse(pieces_in_hand_str)
         validate_input_type(pieces_in_hand_str)
         validate_format(pieces_in_hand_str)
@@ -64,13 +65,13 @@ 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 and validate no modifiers
+        # 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
+        # Combine all pieces in order (uppercase first, then lowercase)
+        # Do NOT sort - preserve the canonical order from the FEEN string
+        uppercase_pieces + lowercase_pieces
       end
 
       # Validates that the input is a non-empty string.
@@ -79,41 +80,23 @@ module Feen
       # @raise [ArgumentError] If input is not a string or is empty
       # @return [void]
       private_class_method def self.validate_input_type(str)
-        raise ::ArgumentError, format(Errors[:invalid_type], str.class) unless str.is_a?(::String)
-        raise ::ArgumentError, Errors[:empty_string] if str.empty?
+        raise ArgumentError, format(ERRORS[:invalid_type], str.class) unless str.is_a?(::String)
+        raise ArgumentError, ERRORS[:empty_string] if str.empty?
       end
 
       # Validates that the input string matches the expected format according to FEEN specification.
-      # Format must be: "UPPERCASE_PIECES/LOWERCASE_PIECES" with base pieces only (no modifiers).
+      # Format must be: "UPPERCASE_PIECES/LOWERCASE_PIECES" with optional PNN modifiers.
       #
       # @param str [String] Input string to validate
-      # @raise [ArgumentError] If format is invalid or contains modifiers
+      # @raise [ArgumentError] If format is invalid
       # @return [void]
       private_class_method def self.validate_format(str)
         # Must contain exactly one "/" separator
         parts_count = str.count("/")
-        raise ::ArgumentError, format(Errors[:missing_separator], parts_count) unless parts_count == 1
+        raise ArgumentError, format(ERRORS[:missing_separator], parts_count) unless parts_count == 1
 
         # Must match the overall pattern
-        raise ::ArgumentError, format(Errors[:invalid_format], str) unless str.match?(VALID_FORMAT_PATTERN)
-
-        # Additional validation: check for any modifiers (forbidden in hand)
-        validate_no_modifiers(str)
-      end
-
-      # Validates that no modifiers are present in the pieces in hand string
-      #
-      # @param str [String] Input string to validate
-      # @raise [ArgumentError] If modifiers are found
-      # @return [void]
-      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?(/[+\-']/)
-
-        # Find the specific invalid piece to provide a better error message
-        invalid_pieces = str.scan(/(?:[2-9]|[1-9]\d+)?[+\-']?[a-zA-Z]'?/).grep(/[+\-']/)
-
-        raise ::ArgumentError, "Pieces in hand cannot contain modifiers: '#{invalid_pieces.first}'"
+        raise ArgumentError, format(ERRORS[:invalid_format], str) unless str.match?(VALID_FORMAT_PATTERN)
       end
 
       # Parses a specific section (uppercase or lowercase) and returns expanded pieces
@@ -136,7 +119,7 @@ module Feen
       # @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
-      # @raise [ArgumentError] If pieces don't match the expected case or contain modifiers
+      # @raise [ArgumentError] If pieces contain invalid PNN notation
       private_class_method def self.extract_pieces_with_counts_from_section(section, case_type)
         result = []
         position = 0
@@ -145,28 +128,30 @@ module Feen
           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
 
-          # 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}'"
+          # Validate PNN format using the PNN gem
+          # @see https://rubygems.org/gems/pnn
+          unless ::Pnn.valid?(piece_with_modifiers)
+            raise ::ArgumentError, format(ERRORS[:invalid_pnn], piece_with_modifiers)
           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"
+            raise ::ArgumentError, format(ERRORS[:invalid_count], count_str)
           end
 
-          # Validate that the piece matches the expected case
-          piece_case = piece.match?(/[A-Z]/) ? :uppercase : :lowercase
+          # Validate that the piece matches the expected case (based on base letter)
+          base_letter = extract_base_letter(piece_with_modifiers)
+          piece_case = base_letter.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"
+            raise ::ArgumentError, "Piece '#{piece_with_modifiers}' has wrong case for #{case_name} section"
           end
 
           # Add to our result with piece type and count
-          result << { piece: piece, count: count }
+          result << { piece: piece_with_modifiers, count: count }
 
           # Move position forward
           position += match[0].length
@@ -175,13 +160,21 @@ module Feen
         result
       end
 
+      # Extracts the base letter from a PNN piece identifier
+      #
+      # @param piece [String] PNN piece identifier (e.g., "+P'", "-R", "K")
+      # @return [String] Base letter (e.g., "P", "R", "K")
+      private_class_method def self.extract_base_letter(piece)
+        piece.match(/[a-zA-Z]/)[0]
+      end
+
       # Expands the pieces based on their counts into an array.
       #
       # @param pieces_with_counts [Array<Hash>] Array of pieces with their counts
-      # @return [Array<String>] Array of expanded pieces
+      # @return [Array<String>] Array of expanded pieces preserving order
       private_class_method def self.expand_pieces(pieces_with_counts)
         pieces_with_counts.flat_map do |item|
-          Array.new(item[:count], item[:piece])
+          ::Array.new(item[:count], item[:piece])
         end
       end
     end

data/lib/feen/parser/style_turn.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "sashite-snn"
+
+module Feen
+  module Parser
+    # Handles parsing of the style turn section of a FEEN string
+    module StyleTurn
+      # Error messages for style turn parsing
+      ERRORS = {
+        invalid_type:   "Style turn must be a string, got %s",
+        empty_string:   "Style turn string cannot be empty",
+        invalid_format: "Invalid style turn format. Expected format: UPPERCASE/lowercase or lowercase/UPPERCASE",
+        invalid_snn:    "Invalid SNN notation in style turn: %s"
+      }.freeze
+
+      # Pattern matching the FEEN specification for style turn
+      # <style-turn> ::= <style-id-uppercase> "/" <style-id-lowercase>
+      #                | <style-id-lowercase> "/" <style-id-uppercase>
+      VALID_STYLE_TURN_PATTERN = %r{
+        \A                                    # Start of string
+        (?:                                   # Non-capturing group for alternatives
+          (?<uppercase_first>[A-Z][A-Z0-9]*) # Named group: uppercase style identifier first
+          /                                   # Separator
+          (?<lowercase_second>[a-z][a-z0-9]*) # Named group: lowercase style identifier second
+          |                                   # OR
+          (?<lowercase_first>[a-z][a-z0-9]*) # Named group: lowercase style identifier first
+          /                                   # Separator
+          (?<uppercase_second>[A-Z][A-Z0-9]*) # Named group: uppercase style identifier second
+        )
+        \z                                    # End of string
+      }x
+
+      # Parses the style turn section of a FEEN string
+      #
+      # @param style_turn_str [String] FEEN style turn string
+      # @return [Array<String>] Array containing [active_style, inactive_style]
+      # @raise [ArgumentError] If the input string is invalid
+      #
+      # @example Valid style turn string with uppercase first
+      #   StyleTurn.parse("CHESS/shogi")
+      #   # => ["CHESS", "shogi"]
+      #
+      # @example Valid style turn string with lowercase first
+      #   StyleTurn.parse("chess/SHOGI")
+      #   # => ["chess", "SHOGI"]
+      #
+      # @example Valid style turn with numeric identifiers
+      #   StyleTurn.parse("CHESS960/makruk")
+      #   # => ["CHESS960", "makruk"]
+      def self.parse(style_turn_str)
+        validate_input_type(style_turn_str)
+
+        match = VALID_STYLE_TURN_PATTERN.match(style_turn_str)
+        raise ::ArgumentError, ERRORS[:invalid_format] unless match
+
+        style_identifiers = extract_style_identifiers(match)
+        validate_snn_compliance(style_identifiers)
+
+        style_identifiers
+      end
+
+      # Validates that the input is a non-empty string
+      #
+      # @param str [String] Input string to validate
+      # @raise [ArgumentError] If input is not a string or is empty
+      # @return [void]
+      private_class_method def self.validate_input_type(str)
+        raise ::ArgumentError, format(ERRORS[:invalid_type], str.class) unless str.is_a?(::String)
+        raise ::ArgumentError, ERRORS[:empty_string] if str.empty?
+      end
+
+      # Extracts style identifiers from regexp match captures
+      #
+      # @param match [MatchData] Regexp match data with named captures
+      # @return [Array<String>] Array containing [active_style, inactive_style]
+      private_class_method def self.extract_style_identifiers(match)
+        captures = match.named_captures
+
+        if captures["uppercase_first"]
+          [captures["uppercase_first"], captures["lowercase_second"]]
+        else
+          [captures["lowercase_first"], captures["uppercase_second"]]
+        end
+      end
+
+      # Validates that both style identifiers comply with SNN specification
+      #
+      # @param identifiers [Array<String>] Array of style identifiers to validate
+      # @raise [ArgumentError] If any identifier is invalid SNN notation
+      # @return [void]
+      private_class_method def self.validate_snn_compliance(identifiers)
+        identifiers.each do |identifier|
+          # Validate using the sashite-snn gem
+          # @see https://rubygems.org/gems/sashite-snn
+          raise ::ArgumentError, format(ERRORS[:invalid_snn], identifier) unless ::Sashite::Snn.valid?(identifier)
+        end
+      end
+    end
+  end
+end

data/lib/feen/parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative File.join("parser", "games_turn")
+require_relative File.join("parser", "style_turn")
 require_relative File.join("parser", "piece_placement")
 require_relative File.join("parser", "pieces_in_hand")
 
@@ -21,8 +21,8 @@ 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 (base form only)
-    #   - :games_turn [Array<String>] - A two-element array with [active_variant, inactive_variant]
+    #   - :pieces_in_hand [Array<String>] - Pieces available for dropping onto the board (may include modifiers)
+    #   - :style_turn [Array<String>] - A two-element array with [active_style, inactive_style]
     # @raise [ArgumentError] If the FEEN string is invalid
     #
     # @example Parsing a standard chess initial position
@@ -40,7 +40,7 @@ module Feen
     #   #        ["R", "N", "B", "Q", "K", "B", "N", "R"]
     #   #      ],
     #   #      pieces_in_hand: [],
-    #   #      games_turn: ["CHESS", "chess"]
+    #   #      style_turn: ["CHESS", "chess"]
     #   #    }
     def self.parse(feen_string)
       feen_string = String(feen_string)
@@ -52,18 +52,18 @@ module Feen
       raise ::ArgumentError, INVALID_FORMAT_ERROR unless match
 
       # Capture the three distinct parts
-      piece_placement_string, pieces_in_hand_string, games_turn_string = match.captures
+      piece_placement_string, pieces_in_hand_string, style_turn_string = match.captures
 
       # Parse each field using the appropriate submodule
       piece_placement = PiecePlacement.parse(piece_placement_string)
       pieces_in_hand = PiecesInHand.parse(pieces_in_hand_string)
-      games_turn = GamesTurn.parse(games_turn_string)
+      style_turn = StyleTurn.parse(style_turn_string)
 
       # Create a structured representation of the position
       {
         piece_placement:,
         pieces_in_hand:,
-        games_turn:
+        style_turn:
       }
     end
 
@@ -78,7 +78,7 @@ module Feen
     # @example Parsing a valid FEEN string
     #   feen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess"
     #   result = Feen::Parser.safe_parse(feen)
-    #   # => {piece_placement: [...], pieces_in_hand: [...], games_turn: [...]}
+    #   # => {piece_placement: [...], pieces_in_hand: [...], style_turn: [...]}
     #
     # @example Parsing an invalid FEEN string
     #   feen = "invalid feen string"

data/lib/feen.rb

@@ -17,11 +17,11 @@ 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.
-  #                                      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
+  #                                      May include PNN modifiers (per FEEN v1.0.0 specification)
+  # @param style_turn [Array<String>] A two-element array where the first element is the
+  #                                  active player's style and the second is the inactive player's style
   # @return [String] FEEN notation string
-  # @raise [ArgumentError] If any parameter is invalid or pieces_in_hand contains modifiers
+  # @raise [ArgumentError] If any parameter is invalid
   # @example
   #   piece_placement = [
   #     ["r", "n", "b", "q", "k", "b", "n", "r"],
@@ -36,11 +36,11 @@ module Feen
   #   Feen.dump(
   #     piece_placement: piece_placement,
   #     pieces_in_hand: [],
-  #     games_turn: ["CHESS", "chess"]
+  #     style_turn: ["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:)
+  def self.dump(piece_placement:, pieces_in_hand:, style_turn:)
+    Dumper.dump(piece_placement:, pieces_in_hand:, style_turn:)
   end
 
   # Parses a FEEN string into position components.
@@ -48,8 +48,8 @@ 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 (base form only)
-  #   - :games_turn [Array<String>] - A two-element array with [active_variant, inactive_variant]
+  #   - :pieces_in_hand [Array<String>] - Pieces available for dropping onto the board (may include modifiers)
+  #   - :style_turn [Array<String>] - A two-element array with [active_style, inactive_style]
   # @raise [ArgumentError] If the FEEN string is invalid
   # @example
   #   feen_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess"
@@ -66,7 +66,7 @@ module Feen
   #   #        ["R", "N", "B", "Q", "K", "B", "N", "R"]
   #   #      ],
   #   #      pieces_in_hand: [],
-  #   #      games_turn: ["CHESS", "chess"]
+  #   #      style_turn: ["CHESS", "chess"]
   #   #    }
   def self.parse(feen_string)
     Parser.parse(feen_string)
@@ -82,7 +82,7 @@ module Feen
   # @example
   #   # Valid FEEN string
   #   Feen.safe_parse("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / CHESS/chess")
-  #   # => {piece_placement: [...], pieces_in_hand: [...], games_turn: [...]}
+  #   # => {piece_placement: [...], pieces_in_hand: [...], style_turn: [...]}
   #
   #   # Invalid FEEN string
   #   Feen.safe_parse("invalid feen string")
@@ -101,12 +101,15 @@ 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)
+  # According to FEEN v1.0.0 specification:
+  # - Pieces in hand may include PNN modifiers (prefixes and suffixes)
+  # - Pieces in hand must be sorted canonically according to the sorting algorithm:
+  #   1. By player (uppercase/lowercase separated by '/')
+  #   2. By quantity (descending)
+  #   3. By base letter (ascending)
+  #   4. By prefix (specific order: '-', '+', then no prefix)
+  #   5. By suffix (specific order: no suffix, then "'")
+  # - Style identifiers must follow SNN specification with semantic casing
   #
   # @param feen_string [String] FEEN string to validate
   # @return [Boolean] True if the string is a valid and canonical FEEN string
@@ -117,24 +120,21 @@ module Feen
   #   # Invalid syntax
   #   Feen.valid?("invalid feen string") # => 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
+  #
+  #   # Canonical form with modifiers in pieces in hand
+  #   Feen.valid?("8/8/8/8/8/8/8/8 2+B5BK3-P-P'3+P'9PR2SS'/ FOO/bar") # => true
   def self.valid?(feen_string)
     # First check: Basic syntax validation
-    begin
-      parsed_data = parse(feen_string)
-    rescue ::ArgumentError
-      return false
-    end
+    parsed_data = safe_parse(feen_string)
+    return false if parsed_data.nil?
 
     # Second check: Canonicity validation through round-trip conversion
     # Generate a fresh FEEN string from the parsed data
     canonical_feen = dump(**parsed_data)
 
-    # Compare the original string with the canonical form
-    feen_string == canonical_feen
+    # Compare the canonical form with the original string
+    canonical_feen == feen_string
   end
 end

metadata

@@ -1,17 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta8
+  version: 5.0.0.beta10
 platform: ruby
 authors:
 - Cyril Kato
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pnn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: sashite-snn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: A Ruby interface for data serialization and deserialization in FEEN format.
   FEEN is a compact, canonical, and rule-agnostic textual format for representing
-  static board positions in two-player piece-placement games like Chess, Shogi, Xiangqi,
+  static board positions in two-player piece-placement games like Chess, Shōgi, Xiangqi,
   and others.
 email: contact@cyril.email
 executables: []
@@ -22,13 +50,13 @@ files:
 - README.md
 - lib/feen.rb
 - lib/feen/dumper.rb
-- lib/feen/dumper/games_turn.rb
 - lib/feen/dumper/piece_placement.rb
 - lib/feen/dumper/pieces_in_hand.rb
+- lib/feen/dumper/style_turn.rb
 - lib/feen/parser.rb
-- lib/feen/parser/games_turn.rb
 - lib/feen/parser/piece_placement.rb
 - lib/feen/parser/pieces_in_hand.rb
+- lib/feen/parser/style_turn.rb
 homepage: https://github.com/sashite/feen.rb
 licenses:
 - MIT

data/lib/feen/dumper/games_turn.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Dumper
-    # Handles conversion of games turn data to FEEN notation string
-    module GamesTurn
-      # Error messages for validation
-      ERRORS = {
-        invalid_type:  "%s must be a String, got %s",
-        empty_string:  "%s cannot be empty",
-        invalid_chars: "%s must contain only alphabetic characters (a-z, A-Z)",
-        mixed_case:    "%s has mixed case: %s",
-        same_casing:   "One variant must be uppercase and the other lowercase"
-      }.freeze
-
-      # Converts the active and inactive variant identifiers to a FEEN-formatted games turn string
-      #
-      # @param active_variant [String] Identifier for the player to move and their game variant
-      # @param inactive_variant [String] Identifier for the opponent and their game variant
-      # @return [String] FEEN-formatted games turn string
-      # @raise [ArgumentError] If the variant identifiers are invalid
-      #
-      # @example Valid games turn
-      #   GamesTurn.dump("CHESS", "chess")
-      #   # => "CHESS/chess"
-      #
-      # @example Invalid - same casing
-      #   GamesTurn.dump("CHESS", "SHOGI")
-      #   # => ArgumentError: One variant must be uppercase and the other lowercase
-      def self.dump(active_variant, inactive_variant)
-        validate_variants(active_variant, inactive_variant)
-        "#{active_variant}/#{inactive_variant}"
-      end
-
-      # Validates the game variant identifiers
-      #
-      # @param active [String] The active player's variant identifier
-      # @param inactive [String] The inactive player's variant identifier
-      # @raise [ArgumentError] If the variant identifiers are invalid
-      # @return [void]
-      private_class_method def self.validate_variants(active, inactive)
-        # Validate basic type, presence and format
-        [["Active variant", active], ["Inactive variant", inactive]].each do |name, variant|
-          # Type validation
-          raise ArgumentError, format(ERRORS[:invalid_type], name, variant.class) unless variant.is_a?(String)
-
-          # Empty validation
-          raise ArgumentError, format(ERRORS[:empty_string], name) if variant.empty?
-
-          # Character validation
-          raise ArgumentError, format(ERRORS[:invalid_chars], name) unless variant.match?(/\A[a-zA-Z]+\z/)
-
-          # Mixed case validation
-          unless variant == variant.upcase || variant == variant.downcase
-            raise ArgumentError, format(ERRORS[:mixed_case], name, variant)
-          end
-        end
-
-        # Casing difference validation
-        active_is_uppercase = active == active.upcase
-        inactive_is_uppercase = inactive == inactive.upcase
-
-        # Both variants must have different casing
-        return unless active_is_uppercase == inactive_is_uppercase
-
-        raise ArgumentError, ERRORS[:same_casing]
-      end
-    end
-  end
-end