sashite-gan 3.0.0 → 5.0.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sashite-gan
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Cyril Kato
@@ -10,23 +10,40 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pnn
+  name: sashite-pin
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 2.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
-description: A Ruby interface for serialization and deserialization of game actors
-  in GAN format. GAN is a consistent and rule-agnostic format for representing game
-  actors in abstract strategy board games, providing a standardized way to identify
-  pieces with their originating game.
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: sashite-snn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+description: 'A Ruby implementation of GAN (General Actor Notation) v1.0.0 specification
+  for identifying game actors in abstract strategy board games. GAN combines Style
+  Name Notation (SNN) and Piece Identifier Notation (PIN) with a colon separator to
+  provide complete, unambiguous piece identification. Represents all four fundamental
+  piece attributes: Type, Side, State, and Style. Enables cross-style gaming, immutable
+  transformations, and component extraction with to_pin/to_snn methods. Built on sashite-snn
+  and sashite-pin gems.'
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -36,9 +53,7 @@ files:
 - README.md
 - lib/sashite-gan.rb
 - lib/sashite/gan.rb
-- lib/sashite/gan/dumper.rb
-- lib/sashite/gan/parser.rb
-- lib/sashite/gan/validator.rb
+- lib/sashite/gan/actor.rb
 homepage: https://github.com/sashite/gan.rb
 licenses:
 - MIT
@@ -47,7 +62,7 @@ metadata:
   documentation_uri: https://rubydoc.info/github/sashite/gan.rb/main
   homepage_uri: https://github.com/sashite/gan.rb
   source_code_uri: https://github.com/sashite/gan.rb
-  specification_uri: https://sashite.dev/documents/gan/1.0.0/
+  specification_uri: https://sashite.dev/specs/gan/1.0.0/
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -63,7 +78,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: GAN (General Actor Notation) support for the Ruby language.
+summary: GAN (General Actor Notation) implementation for Ruby - board game piece identification
 test_files: []

data/lib/sashite/gan/dumper.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require "pnn"
-
-module Sashite
-  module Gan
-    # Serializes actor components into GAN (General Actor Notation) strings.
-    #
-    # The dumper transforms piece data and game identifiers into properly
-    # formatted GAN strings, ensuring consistency between game ID casing
-    # and piece letter casing according to the GAN specification.
-    #
-    # According to the specification, game IDs must be either all uppercase
-    # or all lowercase, and their casing must match the casing of the piece letter.
-    class Dumper
-      # Pattern for validating game identifiers - must be all uppercase OR all lowercase
-      GAME_ID_PATTERN = /\A([A-Z]+|[a-z]+)\z/
-
-      # Error message templates
-      INVALID_GAME_ID_ERROR = "Game ID must be a non-empty string containing only ASCII letters and must be either all uppercase or all lowercase: %s"
-      CASING_MISMATCH_ERROR = "Game ID casing (%s) must match piece letter casing (%s)"
-
-      # Serializes actor components into a GAN string
-      #
-      # @param game_id [String] The game identifier (e.g., "CHESS", "shogi")
-      # @param piece_params [Hash] Piece parameters as accepted by Pnn.dump:
-      #   @option piece_params [String] :letter The single ASCII letter identifier (required)
-      #   @option piece_params [String, nil] :prefix Optional prefix modifier for the piece ("+", "-")
-      #   @option piece_params [String, nil] :suffix Optional suffix modifier for the piece ("'")
-      # @return [String] A properly formatted GAN notation string (e.g., "CHESS:K'")
-      # @raise [ArgumentError] If game_id is invalid or casing is inconsistent with piece letter
-      # @example Create a GAN string for a white chess king with castling rights
-      #   Dumper.dump(game_id: "CHESS", letter: "K", suffix: "'")
-      #   # => "CHESS:K'"
-      # @example Create a GAN string for a promoted shogi pawn
-      #   Dumper.dump(game_id: "SHOGI", letter: "P", prefix: "+")
-      #   # => "SHOGI:+P"
-      def self.dump(game_id:, **piece_params)
-        game_id = String(game_id)
-        validate_game_id!(game_id)
-
-        # Build the piece string using the PNN gem
-        pnn_string = ::Pnn.dump(**piece_params)
-
-        # Verify casing consistency
-        validate_casing_consistency!(game_id, pnn_string)
-
-        "#{game_id}:#{pnn_string}"
-      end
-
-      # @api private
-      # Validates that the game_id contains only ASCII letters
-      #
-      # @param game_id [String] The game identifier to validate
-      # @return [void]
-      # @raise [ArgumentError] If game_id contains non-letter characters
-      def self.validate_game_id!(game_id)
-        return if game_id.match?(GAME_ID_PATTERN)
-
-        raise ::ArgumentError, format(INVALID_GAME_ID_ERROR, game_id)
-      end
-      private_class_method :validate_game_id!
-
-      # @api private
-      # Validates that the casing of the game_id is consistent with the piece letter
-      #
-      # According to GAN specification, if game_id is uppercase, piece letter must be uppercase,
-      # and if game_id is lowercase, piece letter must be lowercase.
-      #
-      # @param game_id [String] The game identifier
-      # @param pnn_string [String] The PNN string
-      # @return [void]
-      # @raise [ArgumentError] If casing is inconsistent
-      def self.validate_casing_consistency!(game_id, pnn_string)
-        return if casing_consistent?(game_id, pnn_string)
-
-        raise ::ArgumentError, format(CASING_MISMATCH_ERROR, game_id, pnn_string)
-      end
-      private_class_method :validate_casing_consistency!
-
-      # @api private
-      # Verifies that the casing of the game_id matches the casing of the piece letter
-      #
-      # @param game_id [String] The game identifier
-      # @param pnn_string [String] The PNN string
-      # @return [Boolean] True if casing is consistent
-      def self.casing_consistent?(game_id, pnn_string)
-        # Both must be uppercase or both must be lowercase
-        (game_id == game_id.upcase) == (pnn_string == pnn_string.upcase)
-      end
-      private_class_method :casing_consistent?
-    end
-  end
-end

data/lib/sashite/gan/parser.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "pnn"
-
-module Sashite
-  module Gan
-    # Parses GAN strings into their component parts
-    class Parser
-      # GAN regex pattern for parsing
-      PATTERN = /\A(?<game_id>[a-zA-Z]+):(?<pnn_part>[-+]?[a-zA-Z][']?)\z/
-
-      # Parse a GAN string into its components
-      #
-      # @param gan_string [String] The GAN string to parse
-      # @return [Hash] Hash containing the parsed components
-      # @raise [ArgumentError] If the GAN string is invalid
-      def self.parse(gan_string)
-        gan_string = String(gan_string)
-
-        matches = PATTERN.match(gan_string)
-        raise ArgumentError, "Invalid GAN string: #{gan_string}" if matches.nil?
-
-        game_id = matches[:game_id]
-        pnn_part = matches[:pnn_part]
-
-        # Parse the PNN part using the PNN gem
-        pnn_result = Pnn.parse(pnn_part)
-
-        # Verify casing consistency
-        unless casing_consistent?(game_id, pnn_result[:letter])
-          raise ArgumentError, "Game ID casing (#{game_id}) must match piece letter casing (#{pnn_result[:letter]})"
-        end
-
-        # Merge the game_id with the piece parameters for a flatter structure
-        { game_id: game_id }.merge(pnn_result)
-      end
-
-      # Safely parse a GAN string without raising exceptions
-      #
-      # @param gan_string [String] The GAN string to parse
-      # @return [Hash, nil] Hash containing the parsed components or nil if invalid
-      def self.safe_parse(gan_string)
-        parse(gan_string)
-      rescue ArgumentError
-        nil
-      end
-
-      # Verifies that the casing of the game_id matches the casing of the piece letter
-      #
-      # @param game_id [String] The game identifier
-      # @param letter [String] The piece letter
-      # @return [Boolean] True if casing is consistent
-      def self.casing_consistent?(game_id, letter)
-        (game_id == game_id.upcase) == (letter == letter.upcase)
-      end
-    end
-  end
-end

data/lib/sashite/gan/validator.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "pnn"
-
-module Sashite
-  module Gan
-    # Validates GAN strings
-    class Validator
-      # GAN regex pattern for validation
-      PATTERN = /\A([A-Z]+:[-+]?[A-Z][']?|[a-z]+:[-+]?[a-z][']?)\z/
-
-      # Validates if the given string is a valid GAN string
-      #
-      # @param gan_string [String] The GAN string to validate
-      # @return [Boolean] True if the string is a valid GAN string
-      def self.valid?(gan_string)
-        return false unless gan_string.is_a?(String)
-
-        PATTERN.match?(gan_string)
-      end
-    end
-  end
-end