sashite-ggn 0.5.0 → 0.7.0

data/lib/sashite/ggn/schema.rb

@@ -6,8 +6,11 @@ module Sashite
     #
     # This schema defines the structure and constraints for GGN documents,
     # which describe pseudo-legal moves in abstract strategy board games.
-    # GGN is rule-agnostic and focuses on basic movement constraints rather
-    # than game-specific legality (e.g., check, ko, repetition).
+    # GGN is rule-agnostic and focuses exclusively on board-to-board transformations:
+    # pieces moving, capturing, or transforming on the game board.
+    #
+    # The schema has been updated to reflect GGN's focus on board transformations only.
+    # Hand management, piece drops, and captures-to-hand are outside the scope of GGN.
     #
     # @example Basic GGN document structure
     #   {
@@ -23,15 +26,28 @@ module Sashite
     #     }
     #   }
     #
-    # @example Complex move with capture and piece gain
+    # @example Complex move with multiple conditions
     #   {
-    #     "OGI:P": {
-    #       "e4": {
-    #         "e5": [
+    #     "CHESS:P": {
+    #       "d5": {
+    #         "e6": [
     #           {
-    #             "require": { "e5": "enemy" },
-    #             "perform": { "e4": null, "e5": "OGI:P" },
-    #             "gain": "OGI:P"
+    #             "require": { "e5": "chess:p", "e6": "empty" },
+    #             "perform": { "d5": null, "e5": null, "e6": "CHESS:P" }
+    #           }
+    #         ]
+    #       }
+    #     }
+    #   }
+    #
+    # @example Multi-square move (castling)
+    #   {
+    #     "CHESS:K": {
+    #       "e1": {
+    #         "g1": [
+    #           {
+    #             "require": { "f1": "empty", "g1": "empty", "h1": "CHESS:R" },
+    #             "perform": { "e1": null, "f1": "CHESS:R", "g1": "CHESS:K", "h1": null }
     #           }
     #         ]
     #       }
@@ -45,7 +61,7 @@ module Sashite
       "$schema": "https://json-schema.org/draft/2020-12/schema",
       "$id": "https://sashite.dev/schemas/ggn/1.0.0/schema.json",
       "title": "General Gameplay Notation (GGN)",
-      "description": "JSON Schema for pseudo-legal moves in abstract board games using the GGN format.",
+      "description": "JSON Schema for pseudo-legal moves in abstract board games using the GGN format. GGN focuses exclusively on board-to-board transformations.",
       "type": "object",
 
       # Optional schema reference property
@@ -66,82 +82,85 @@ module Sashite
           "type": "object",
           "minProperties": 1,
 
-          # Source squares: where the piece starts (or "*" for drops)
-          "additionalProperties": {
-            "type": "object",
-            "minProperties": 1,
+          # Source squares: where the piece starts (regular board squares only)
+          "patternProperties": {
+            ".+": {
+              "type": "object",
+              "minProperties": 1,
 
-            # Destination squares: where the piece can move to
-            "additionalProperties": {
-              "type": "array",
-              "minItems": 0,
-
-              # Array of conditional transitions for this source->destination pair
-              "items": {
-                "type": "object",
-                "properties": {
-                  # Conditions that MUST be satisfied before the move (logical AND)
-                  "require": {
-                    "type": "object",
-                    "minProperties": 1,
-                    "additionalProperties": {
-                      "type": "string",
-                      # Occupation states: "empty", "enemy", or exact GAN identifier
-                      "pattern": "^empty$|^enemy$|([A-Z]+:[-+]?[A-Z][']?|[a-z]+:[-+]?[a-z][']?)$"
-                    }
-                  },
+              # Destination squares: where the piece can move to (regular board squares only)
+              "patternProperties": {
+                ".+": {
+                  "type": "array",
+                  "minItems": 1,
 
-                  # Conditions that MUST NOT be satisfied before the move (logical OR)
-                  "prevent": {
+                  # Array of conditional transitions for this source->destination pair
+                  "items": {
                     "type": "object",
-                    "minProperties": 1,
-                    "additionalProperties": {
-                      "type": "string",
-                      # Same occupation states as require
-                      "pattern": "^empty$|^enemy$|([A-Z]+:[-+]?[A-Z][']?|[a-z]+:[-+]?[a-z][']?)$"
-                    }
-                  },
+                    "properties": {
+                      # Conditions that MUST be satisfied before the move (logical AND)
+                      "require": {
+                        "type": "object",
+                        "minProperties": 1,
+                        "patternProperties": {
+                          ".+": {
+                            "type": "string",
+                            # Occupation states: "empty", "enemy", or exact GAN identifier
+                            "pattern": "^(empty|enemy|[A-Z]+:[-+]?[A-Z][']?|[a-z]+:[-+]?[a-z][']?)$"
+                          }
+                        },
+                        "additionalProperties": false
+                      },
 
-                  # Board state changes after the move (REQUIRED field)
-                  "perform": {
-                    "type": "object",
-                    "minProperties": 1,
-                    "additionalProperties": {
-                      "anyOf": [
-                        {
-                          # Square contains a piece (GAN identifier)
-                          "type": "string",
-                          "pattern": "^([A-Z]+:[-+]?[A-Z][']?|[a-z]+:[-+]?[a-z][']?)$"
+                      # Conditions that MUST NOT be satisfied before the move (logical OR)
+                      "prevent": {
+                        "type": "object",
+                        "minProperties": 1,
+                        "patternProperties": {
+                          ".+": {
+                            "type": "string",
+                            # Same occupation states as require
+                            "pattern": "^(empty|enemy|[A-Z]+:[-+]?[A-Z][']?|[a-z]+:[-+]?[a-z][']?)$"
+                          }
                         },
-                        {
-                          # Square becomes empty (null)
-                          "type": "null"
-                        }
-                      ]
-                    }
-                  },
+                        "additionalProperties": false
+                      },
 
-                  # Piece added to player's hand (base GAN only, no modifiers)
-                  "gain": {
-                    "type": ["string", "null"],
-                    # Base form GAN pattern (no prefixes/suffixes for hand pieces)
-                    "pattern": "^([A-Z]+:[A-Z]|[a-z]+:[a-z])$"
-                  },
+                      # Board state changes after the move (REQUIRED field)
+                      # This is the core of GGN: describing board transformations
+                      "perform": {
+                        "type": "object",
+                        "minProperties": 1,
+                        "patternProperties": {
+                          ".+": {
+                            "anyOf": [
+                              {
+                                # Square contains a piece (GAN identifier)
+                                "type": "string",
+                                "pattern": "^([A-Z]+:[-+]?[A-Z][']?|[a-z]+:[-+]?[a-z][']?)$"
+                              },
+                              {
+                                # Square becomes empty (null)
+                                "type": "null"
+                              }
+                            ]
+                          }
+                        },
+                        "additionalProperties": false
+                      }
+                    },
 
-                  # Piece removed from player's hand (base GAN only, no modifiers)
-                  "drop": {
-                    "type": ["string", "null"],
-                    # Base form GAN pattern (no prefixes/suffixes for hand pieces)
-                    "pattern": "^([A-Z]+:[A-Z]|[a-z]+:[a-z])$"
+                    # Only "perform" is mandatory; "require" and "prevent" are optional
+                    # NOTE: "gain" and "drop" fields are no longer supported in GGN
+                    "required": ["perform"],
+                    "additionalProperties": false
                   }
-                },
-
-                # Only "perform" is mandatory; other fields are optional
-                "required": ["perform"],
-                "additionalProperties": false
-              }
+                }
+              },
+              "additionalProperties": false
             }
-          }
+          },
+          "additionalProperties": false
         }
       },
 

data/lib/sashite/ggn/validation_error.rb

@@ -8,22 +8,47 @@ module Sashite
     # the JSON Schema, contain malformed data, or encounter processing errors
     # during parsing and evaluation of pseudo-legal moves.
     #
+    # Since GGN focuses exclusively on board-to-board transformations, validation
+    # errors typically relate to:
+    # - Invalid board position representations
+    # - Malformed GAN identifiers or square labels
+    # - Logical contradictions in require/prevent conditions
+    # - Missing or invalid perform actions
+    #
     # Common scenarios that raise ValidationError:
     # - Invalid JSON syntax in GGN files
     # - Schema validation failures (missing required fields, invalid patterns)
     # - File system errors (file not found, permission denied)
     # - Malformed GAN identifiers or square labels
     # - Logical contradictions in require/prevent conditions
+    # - Invalid board transformation specifications
     #
     # @example Handling validation errors during file loading
     #   begin
-    #     piece = Sashite::Ggn.load_file('invalid_moves.json')
+    #     piece_data = Sashite::Ggn.load_file('invalid_moves.json')
     #   rescue Sashite::Ggn::ValidationError => e
     #     puts "GGN validation failed: #{e.message}"
     #     # Handle the error appropriately
     #   end
     #
+    # @example Handling validation errors during move evaluation
+    #   begin
+    #     transitions = engine.where(board_state, 'CHESS')
+    #   rescue Sashite::Ggn::ValidationError => e
+    #     puts "Move evaluation failed: #{e.message}"
+    #     # Handle invalid board state or parameters
+    #   end
+    #
+    # @example Handling schema validation errors
+    #   begin
+    #     Sashite::Ggn.validate!(ggn_data)
+    #   rescue Sashite::Ggn::ValidationError => e
+    #     puts "Schema validation failed: #{e.message}"
+    #     # The data doesn't conform to GGN specification
+    #   end
+    #
     # @see Sashite::Ggn.load_file Main method that can raise this exception
+    # @see Sashite::Ggn.validate! Schema validation method
     # @see Sashite::Ggn::Schema JSON Schema used for validation
     class ValidationError < ::StandardError
     end

data/lib/sashite/ggn.rb

@@ -12,20 +12,30 @@ module Sashite
   # General Gameplay Notation (GGN) module for parsing, validating, and working with
   # JSON documents that describe pseudo-legal moves in abstract strategy board games.
   #
-  # GGN is a rule-agnostic format that focuses on basic movement constraints rather
-  # than game-specific legality rules. It answers the fundamental question: "Can this
-  # piece, currently on this square, reach that square?" while remaining neutral about
-  # higher-level game rules like check, ko, repetition, or castling paths.
+  # GGN is a rule-agnostic format that focuses exclusively on board-to-board transformations.
+  # It answers the fundamental question: "Can this piece, currently on this square, reach
+  # that square?" while remaining neutral about higher-level game rules like check, ko,
+  # repetition, or castling paths.
   #
   # = Key Features
   #
   # - **Rule-agnostic**: Works with any abstract strategy board game
+  # - **Board-focused**: Describes only board transformations, no hand management
   # - **Pseudo-legal** focus: Describes basic movement constraints only
   # - **JSON-based**: Structured, machine-readable format
-  # - **Validation** support: Built-in schema validation
+  # - **Validation** support: Built-in schema validation and logical consistency checks
   # - **Performance** optimized: Optional validation for large datasets
   # - **Cross-game** compatible: Supports hybrid games and variants
   #
+  # = Validation Levels
+  #
+  # When `validate: true` (default), performs:
+  # - JSON Schema validation against GGN specification
+  # - Logical contradiction detection in require/prevent conditions
+  # - Implicit requirement duplication detection
+  #
+  # When `validate: false`, skips all validations for maximum performance.
+  #
   # = Related Specifications
   #
   # GGN works alongside other Sashité specifications:
@@ -45,16 +55,18 @@ module Sashite
       # 1. Reads the JSON file from the filesystem with proper encoding
       # 2. Parses the JSON content into a Ruby Hash with error handling
       # 3. Optionally validates the structure against the GGN JSON Schema
-      # 4. Creates and returns a Ruleset instance for querying moves
+      # 4. Optionally performs logical consistency validation
+      # 5. Creates and returns a Ruleset instance for querying moves
       #
       # @param filepath [String, Pathname] Path to the GGN JSON file to load.
       #   Supports both relative and absolute paths.
-      # @param validate [Boolean] Whether to validate against GGN schema (default: true).
-      #   Set to false to skip validation for improved performance on large documents.
+      # @param validate [Boolean] Whether to perform all validations (default: true).
+      #   When false, skips JSON schema validation AND internal logical validations
+      #   for maximum performance.
       # @param encoding [String] File encoding to use when reading (default: 'UTF-8').
       #   Most GGN files should use UTF-8 encoding.
       #
-      # @return [Ruleset] A Ruleset instance containing the parsed and validated GGN data.
+      # @return [Ruleset] A Ruleset instance containing the parsed GGN data.
       #   Use this instance to query pseudo-legal moves for specific pieces and positions.
       #
       # @raise [ValidationError] If any of the following conditions occur:
@@ -62,6 +74,7 @@ module Sashite
       #   - File contains invalid JSON syntax
       #   - File permissions prevent reading
       #   - When validation is enabled: data doesn't conform to GGN schema
+      #   - When validation is enabled: logical contradictions or implicit duplications found
       #
       # @example Loading a chess piece definition with full validation
       #   begin
@@ -80,15 +93,15 @@ module Sashite
       #     engine = destinations.to('e2')
       #
       #     board_state = { 'e1' => 'CHESS:K', 'e2' => nil }
-      #     result = engine.evaluate(board_state, {}, 'CHESS')
-      #     puts "King can move from e1 to e2" if result
+      #     transitions = engine.where(board_state, 'CHESS')
+      #     puts "King can move from e1 to e2" if transitions.any?
       #   rescue Sashite::Ggn::ValidationError => e
       #     puts "Failed to process move: #{e.message}"
       #   end
       #
       # @example Loading large datasets without validation for performance
       #   begin
-      #     # Skip validation for large files to improve loading performance
+      #     # Skip all validations for large files to improve loading performance
       #     large_dataset = Sashite::Ggn.load_file('data/all_variants.json', validate: false)
       #     puts "Loaded GGN data without validation"
       #   rescue Sashite::Ggn::ValidationError => e
@@ -122,8 +135,8 @@ module Sashite
         # Validate against GGN schema if requested
         validate_schema(data, file_path) if validate
 
-        # Create and return Ruleset instance
-        Ruleset.new(data)
+        # Create and return Ruleset instance with validation option
+        Ruleset.new(data, validate: validate)
       end
 
       # Loads GGN data directly from a JSON string.
@@ -132,7 +145,8 @@ module Sashite
       # database, API response, or embedded in your application) rather than a file.
       #
       # @param json_string [String] JSON string containing GGN data
-      # @param validate [Boolean] Whether to validate against GGN schema (default: true)
+      # @param validate [Boolean] Whether to perform all validations (default: true).
+      #   When false, skips JSON schema validation AND internal logical validations.
       #
       # @return [Ruleset] A Ruleset instance containing the parsed GGN data
       #
@@ -163,8 +177,8 @@ module Sashite
         # Validate against GGN schema if requested
         validate_schema(data, "<string>") if validate
 
-        # Create and return Ruleset instance
-        Ruleset.new(data)
+        # Create and return Ruleset instance with validation option
+        Ruleset.new(data, validate: validate)
       end
 
       # Loads GGN data from a Ruby Hash.
@@ -173,7 +187,8 @@ module Sashite
       # and want to create a GGN Ruleset instance with optional validation.
       #
       # @param data [Hash] Ruby Hash containing GGN data structure
-      # @param validate [Boolean] Whether to validate against GGN schema (default: true)
+      # @param validate [Boolean] Whether to perform all validations (default: true).
+      #   When false, skips JSON schema validation AND internal logical validations.
       #
       # @return [Ruleset] A Ruleset instance containing the GGN data
       #
@@ -181,16 +196,16 @@ module Sashite
       #
       # @example Creating from existing Hash data
       #   ggn_data = {
-      #     "SHOGI:K" => {
-      #       "5i" => {
-      #         "4i" => [{ "require" => { "4i" => "empty" }, "perform" => { "5i" => nil, "4i" => "SHOGI:K" } }],
-      #         "6i" => [{ "require" => { "6i" => "empty" }, "perform" => { "5i" => nil, "6i" => "SHOGI:K" } }]
+      #     "CHESS:K" => {
+      #       "e1" => {
+      #         "e2" => [{ "require" => { "e2" => "empty" }, "perform" => { "e1" => nil, "e2" => "CHESS:K" } }],
+      #         "f1" => [{ "require" => { "f1" => "empty" }, "perform" => { "e1" => nil, "f1" => "CHESS:K" } }]
       #       }
       #     }
       #   }
       #
       #   piece_data = Sashite::Ggn.load_hash(ggn_data)
-      #   shogi_king = piece_data.select('SHOGI:K')
+      #   chess_king = piece_data.select('CHESS:K')
       def load_hash(data, validate: true)
         unless data.is_a?(Hash)
           raise ValidationError, "Expected Hash, got #{data.class}"
@@ -199,14 +214,16 @@ module Sashite
         # Validate against GGN schema if requested
         validate_schema(data, "<hash>") if validate
 
-        # Create and return Ruleset instance
-        Ruleset.new(data)
+        # Create and return Ruleset instance with validation option
+        Ruleset.new(data, validate: validate)
       end
 
       # Validates a data structure against the GGN JSON Schema.
       #
       # This method can be used independently to validate GGN data without
       # creating a Ruleset instance. Useful for pre-validation or testing.
+      # Note: This only performs JSON Schema validation, not the internal
+      # logical consistency checks that Ruleset.new performs.
       #
       # @param data [Hash] The data structure to validate
       # @param context [String] Context information for error messages (default: "<data>")
@@ -229,6 +246,9 @@ module Sashite
 
       # Checks if a data structure is valid GGN format.
       #
+      # Note: This only performs JSON Schema validation, not the internal
+      # logical consistency checks that Ruleset.new performs.
+      #
       # @param data [Hash] The data structure to validate
       #
       # @return [Boolean] true if valid, false otherwise
@@ -246,6 +266,9 @@ module Sashite
 
       # Returns detailed validation errors for a data structure.
       #
+      # Note: This only performs JSON Schema validation, not the internal
+      # logical consistency checks that Ruleset.new performs.
+      #
       # @param data [Hash] The data structure to validate
       #
       # @return [Array<String>] Array of validation error messages (empty if valid)

data/lib/sashite-ggn.rb

@@ -6,6 +6,10 @@
 # specification, which is a rule-agnostic, JSON-based format for describing pseudo-legal
 # moves in abstract strategy board games.
 #
+# GGN focuses exclusively on board-to-board transformations: pieces moving, capturing,
+# or transforming on the game board. Hand management, drops, and captures-to-hand are
+# outside the scope of this specification.
+#
 # GGN works alongside other Sashité specifications:
 # - GAN (General Actor Notation): Unique piece identifiers
 # - FEEN (Forsyth-Edwards Enhanced Notation): Board position representation
@@ -30,59 +34,56 @@
 #     "e4" => nil         # Empty square
 #   }
 #
-#   result = engine.evaluate(board_state, {}, "CHESS")
+#   transitions = engine.where(board_state, "CHESS")
 #
-#   if result
+#   if transitions.any?
+#     transition = transitions.first
 #     puts "Move is valid!"
-#     puts "Board changes: #{result.diff}"
+#     puts "Board changes: #{transition.diff}"
 #     # => { "e2" => nil, "e4" => "CHESS:P" }
-#     puts "Piece gained: #{result.gain}" # => nil (no capture)
-#     puts "Piece dropped: #{result.drop}" # => nil (not a drop move)
 #   else
 #     puts "Move is not valid under current conditions"
 #   end
 #
-# @example Piece drops in Shogi
-#   # Shogi allows captured pieces to be dropped back onto the board
-#   piece_data = Sashite::Ggn.load_file("shogi_moves.json")
-#   engine = piece_data.select("SHOGI:P").from("*").to("5e")
-#
-#   # Player has captured pawns available
-#   captures = { "SHOGI:P" => 2 }
+# @example Piece promotion with multiple variants
+#   # Chess pawn promotion offers multiple choices
+#   piece_data = Sashite::Ggn.load_file("chess_moves.json")
+#   engine = piece_data.select("CHESS:P").from("e7").to("e8")
 #
-#   # Current board state (5th file is clear of unpromoted pawns)
+#   # Board with pawn ready to promote
 #   board_state = {
-#     "5e" => nil,     # Target square is empty
-#     "5a" => nil, "5b" => nil, "5c" => nil, "5d" => nil,
-#     "5f" => nil, "5g" => nil, "5h" => nil, "5i" => nil
+#     "e7" => "CHESS:P",  # White pawn on 7th rank
+#     "e8" => nil         # Empty promotion square
 #   }
 #
-#   result = engine.evaluate(board_state, captures, "SHOGI")
+#   transitions = engine.where(board_state, "CHESS")
 #
-#   if result
-#     puts "Pawn drop is valid!"
-#     puts "Board changes: #{result.diff}"  # => { "5e" => "SHOGI:P" }
-#     puts "Piece dropped from hand: #{result.drop}"  # => "SHOGI:P"
+#   transitions.each_with_index do |transition, i|
+#     promoted_piece = transition.diff["e8"]
+#     puts "Promotion choice #{i + 1}: #{promoted_piece}"
 #   end
+#   # Output: CHESS:Q, CHESS:R, CHESS:B, CHESS:N
 #
-# @example Captures with piece promotion
-#   # A chess pawn capturing and promoting to queen
+# @example Complex multi-square moves like castling
+#   # Castling involves both king and rook movement
 #   piece_data = Sashite::Ggn.load_file("chess_moves.json")
-#   engine = piece_data.select("CHESS:P").from("g7").to("h8")
+#   engine = piece_data.select("CHESS:K").from("e1").to("g1")
 #
-#   # Board with enemy piece on h8
+#   # Board state allowing kingside castling
 #   board_state = {
-#     "g7" => "CHESS:P",  # Our pawn ready to promote
-#     "h8" => "chess:r"   # Enemy rook (lowercase = opponent)
+#     "e1" => "CHESS:K",  # King on starting square
+#     "f1" => nil,        # Empty square
+#     "g1" => nil,        # Empty destination
+#     "h1" => "CHESS:R"   # Rook on starting square
 #   }
 #
-#   result = engine.evaluate(board_state, {}, "CHESS")
+#   transitions = engine.where(board_state, "CHESS")
 #
-#   if result
-#     puts "Pawn promotes and captures!"
-#     puts "Final position: #{result.diff}"
-#     # => { "g7" => nil, "h8" => "CHESS:Q" }
-#     puts "Captured piece: #{result.gain}"  # => nil (no capture _in hand_)
+#   if transitions.any?
+#     transition = transitions.first
+#     puts "Castling is possible!"
+#     puts "Final position: #{transition.diff}"
+#     # => { "e1" => nil, "f1" => "CHESS:R", "g1" => "CHESS:K", "h1" => nil }
 #   end
 #
 # @example Loading GGN data from different sources
@@ -96,6 +97,19 @@
 #   # From Hash
 #   ggn_hash = { "CHESS:K" => { "e1" => { "e2" => [{ "perform" => { "e1" => nil, "e2" => "CHESS:K" } }] } } }
 #   piece_data = Sashite::Ggn.load_hash(ggn_hash)
+#
+# @example Generating all possible moves
+#   # Get all pseudo-legal moves for the current position
+#   board_state = {
+#     "e1" => "CHESS:K", "d1" => "CHESS:Q", "a1" => "CHESS:R",
+#     "e2" => "CHESS:P", "d2" => "CHESS:P"
+#   }
+#
+#   all_moves = piece_data.pseudo_legal_transitions(board_state, "CHESS")
+#
+#   all_moves.each do |actor, origin, target, transitions|
+#     puts "#{actor}: #{origin} → #{target} (#{transitions.size} variants)"
+#   end
 module Sashite
   # Base namespace for all Sashité notation libraries.
   #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sashite-ggn
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Cyril Kato
@@ -24,10 +24,12 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.4.0
 description: A Ruby implementation of the General Gameplay Notation (GGN) specification.
-  GGN is a rule-agnostic, JSON-based format for describing pseudo-legal moves in abstract
-  strategy board games. This library provides parsing, validation, and evaluation
-  capabilities for GGN documents, enabling game engines to work with movement rules
-  across different board games including Chess, Shogi, Xiangqi, and custom variants.
+  GGN is a rule-agnostic, JSON-based format for describing pseudo-legal board-to-board
+  transformations in abstract strategy board games. This library provides parsing,
+  validation, and evaluation capabilities for GGN documents, focusing exclusively
+  on piece movements, captures, and transformations on the game board. Features flexible
+  validation system for both safety and performance. Supports Chess, Shogi, Xiangqi,
+  and custom variants without hand management or piece drops.
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -55,6 +57,9 @@ metadata:
   source_code_uri: https://github.com/sashite/ggn.rb
   specification_uri: https://sashite.dev/documents/ggn/1.0.0/
   rubygems_mfa_required: 'true'
+  keywords: board-game, chess, game, gameplay, json, makruk, notation, performance,
+    pseudo-legal-move, rule-agnostic, serialization, shogi, strategy, validation,
+    xiangqi
 rdoc_options: []
 require_paths:
 - lib
@@ -71,5 +76,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: General Gameplay Notation (GGN) parser and validator for Ruby
+summary: General Gameplay Notation (GGN) library for board-to-board game transformations
 test_files: []