sashite-ggn 0.7.0 → 0.9.0

data/lib/sashite-ggn.rb

@@ -1,126 +1,14 @@
 # frozen_string_literal: true
 
-# Sashité - Abstract Strategy Board Games Notation Library
-#
-# This library provides a comprehensive implementation of the General Gameplay Notation (GGN)
-# 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
-# - PMN (Portable Move Notation): Move sequence representation
-#
-# @author Sashité <https://sashite.com/>
-# @version 1.0.0
-# @see https://sashite.dev/documents/ggn/1.0.0/ GGN Specification
-# @see https://github.com/sashite/ggn.rb Official Ruby implementation
-#
-# @example Basic usage with a chess pawn double move
-#   # Load GGN data from file
-#   require "sashite/ggn"
-#
-#   piece_data = Sashite::Ggn.load_file("chess_moves.json")
-#   engine = piece_data.select("CHESS:P").from("e2").to("e4")
-#
-#   # Check if the move is valid given current board state
-#   board_state = {
-#     "e2" => "CHESS:P",  # White pawn on e2
-#     "e3" => nil,        # Empty square
-#     "e4" => nil         # Empty square
-#   }
-#
-#   transitions = engine.where(board_state, "CHESS")
-#
-#   if transitions.any?
-#     transition = transitions.first
-#     puts "Move is valid!"
-#     puts "Board changes: #{transition.diff}"
-#     # => { "e2" => nil, "e4" => "CHESS:P" }
-#   else
-#     puts "Move is not valid under current conditions"
-#   end
-#
-# @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")
-#
-#   # Board with pawn ready to promote
-#   board_state = {
-#     "e7" => "CHESS:P",  # White pawn on 7th rank
-#     "e8" => nil         # Empty promotion square
-#   }
-#
-#   transitions = engine.where(board_state, "CHESS")
-#
-#   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 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:K").from("e1").to("g1")
-#
-#   # Board state allowing kingside castling
-#   board_state = {
-#     "e1" => "CHESS:K",  # King on starting square
-#     "f1" => nil,        # Empty square
-#     "g1" => nil,        # Empty destination
-#     "h1" => "CHESS:R"   # Rook on starting square
-#   }
-#
-#   transitions = engine.where(board_state, "CHESS")
-#
-#   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
-#   # From file
-#   piece_data = Sashite::Ggn.load_file("moves.json")
-#
-#   # From JSON string
-#   json_string = '{"CHESS:K": {"e1": {"e2": [{"perform": {"e1": null, "e2": "CHESS:K"}}]}}}'
-#   piece_data = Sashite::Ggn.load_string(json_string)
-#
-#   # 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"
-#   }
+require_relative "sashite/ggn"
+
+# Sashité namespace for board game notation libraries
 #
-#   all_moves = piece_data.pseudo_legal_transitions(board_state, "CHESS")
+# Sashité provides a collection of libraries for representing and manipulating
+# board game concepts according to the Sashité Protocol specifications.
 #
-#   all_moves.each do |actor, origin, target, transitions|
-#     puts "#{actor}: #{origin} → #{target} (#{transitions.size} variants)"
-#   end
+# @see https://sashite.dev/protocol/ Sashité Protocol
+# @see https://sashite.dev/specs/ Sashité Specifications
+# @author Sashité
 module Sashite
-  # Base namespace for all Sashité notation libraries.
-  #
-  # Sashité provides a comprehensive suite of specifications and implementations
-  # for representing abstract strategy board games in a rule-agnostic manner.
-  # This allows for unified game engines, cross-game analysis, and hybrid
-  # game variants.
-  #
-  # @see https://sashite.com/ Official Sashité website
-  # @see https://sashite.dev/ Developer documentation and specifications
 end
-
-# Load the main GGN implementation
-require_relative "sashite/ggn"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sashite-ggn
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Cyril Kato
@@ -10,26 +10,81 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: json_schemer
+  name: sashite-cell
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !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 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.
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sashite-hand
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: sashite-lcn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: sashite-qpi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: sashite-stn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A pure functional Ruby implementation of the General Gameplay Notation
+  (GGN) specification v1.0.0. Provides a movement possibility oracle for evaluating
+  pseudo-legal moves in abstract strategy board games. Features include hierarchical
+  move navigation (piece → source → destination → transitions), pre-condition evaluation
+  (must/deny), and state transition support via STN format. Works with Chess, Shogi,
+  Xiangqi, and custom variants.
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -39,14 +94,10 @@ files:
 - README.md
 - lib/sashite-ggn.rb
 - lib/sashite/ggn.rb
-- lib/sashite/ggn/move_validator.rb
 - lib/sashite/ggn/ruleset.rb
 - lib/sashite/ggn/ruleset/source.rb
 - lib/sashite/ggn/ruleset/source/destination.rb
 - lib/sashite/ggn/ruleset/source/destination/engine.rb
-- lib/sashite/ggn/ruleset/source/destination/engine/transition.rb
-- lib/sashite/ggn/schema.rb
-- lib/sashite/ggn/validation_error.rb
 homepage: https://github.com/sashite/ggn.rb
 licenses:
 - MIT
@@ -55,11 +106,8 @@ metadata:
   documentation_uri: https://rubydoc.info/github/sashite/ggn.rb/main
   homepage_uri: https://github.com/sashite/ggn.rb
   source_code_uri: https://github.com/sashite/ggn.rb
-  specification_uri: https://sashite.dev/documents/ggn/1.0.0/
+  specification_uri: https://sashite.dev/specs/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
@@ -76,5 +124,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: General Gameplay Notation (GGN) library for board-to-board game transformations
+summary: General Gameplay Notation (GGN) - movement possibilities for board games
 test_files: []

data/lib/sashite/ggn/move_validator.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-module Sashite
-  module Ggn
-    # Centralized module for move condition validation.
-    # Contains shared logic for validating piece ownership and board positions
-    # in GGN move evaluation.
-    #
-    # This module focuses exclusively on board-based validation since GGN
-    # only handles board-to-board transformations. All methods work with
-    # pieces on the board and use GAN (General Actor Notation) identifiers.
-    module MoveValidator
-      # Separator in GAN (General Actor Notation) identifiers.
-      # Used to split game identifiers from piece identifiers.
-      #
-      # @example GAN format
-      #   "CHESS:K"  # game: "CHESS", piece: "K"
-      #   "shogi:+p" # game: "shogi", piece: "+p"
-      GAN_SEPARATOR = ":"
-
-      private
-
-      # Checks if the correct piece is present at the origin square on the board.
-      #
-      # This method validates that the expected piece is actually present at the
-      # specified origin square, which is a fundamental requirement for any move.
-      #
-      # @param actor [String] GAN identifier of the piece
-      # @param origin [String] Origin square
-      # @param board_state [Hash] Current board state
-      #
-      # @return [Boolean] true if the piece is at the correct position
-      #
-      # @example Valid piece placement
-      #   board_state = { "e1" => "CHESS:K", "e2" => "CHESS:P" }
-      #   piece_on_board_at_origin?("CHESS:K", "e1", board_state)
-      #   # => true
-      #
-      # @example Invalid piece placement
-      #   board_state = { "e1" => "CHESS:Q", "e2" => "CHESS:P" }
-      #   piece_on_board_at_origin?("CHESS:K", "e1", board_state)
-      #   # => false (wrong piece at e1)
-      #
-      # @example Empty square
-      #   board_state = { "e1" => nil, "e2" => "CHESS:P" }
-      #   piece_on_board_at_origin?("CHESS:K", "e1", board_state)
-      #   # => false (no piece at e1)
-      def piece_on_board_at_origin?(actor, origin, board_state)
-        return false unless valid_gan_format?(actor)
-        return false unless origin.is_a?(String) && !origin.empty?
-        return false unless board_state.is_a?(Hash)
-
-        board_state[origin] == actor
-      end
-
-      # Checks if the piece belongs to the current player based on case matching.
-      #
-      # This method implements the corrected ownership logic based on FEEN specification:
-      # - Ownership is determined by case correspondence, not exact string matching
-      # - If active_game is uppercase, the player owns uppercase-cased pieces
-      # - If active_game is lowercase, the player owns lowercase-cased pieces
-      # - This allows for hybrid games where a player may control pieces from different games
-      #
-      # @param actor [String] GAN identifier of the piece
-      # @param active_game [String] Current player's game identifier
-      #
-      # @return [Boolean] true if the piece belongs to the current player
-      #
-      # @example Same game, same case (typical scenario)
-      #   piece_belongs_to_current_player?("CHESS:K", "CHESS")
-      #   # => true (both uppercase)
-      #
-      # @example Different games, same case (hybrid scenario)
-      #   piece_belongs_to_current_player?("MAKRUK:K", "CHESS")
-      #   # => true (both uppercase, player controls both)
-      #
-      # @example Same game, different case
-      #   piece_belongs_to_current_player?("chess:k", "CHESS")
-      #   # => false (different players)
-      #
-      # @example Mixed case active_game (invalid)
-      #   piece_belongs_to_current_player?("CHESS:K", "Chess")
-      #   # => false (invalid active_game format)
-      def piece_belongs_to_current_player?(actor, active_game)
-        return false unless valid_gan_format?(actor)
-        return false unless valid_game_identifier?(active_game)
-
-        game_part, piece_part = actor.split(GAN_SEPARATOR, 2)
-
-        # Determine player ownership based on case correspondence
-        # If active_game is uppercase, player owns uppercase pieces
-        # If active_game is lowercase, player owns lowercase pieces
-        case active_game
-        when active_game.upcase
-          # Current player is the uppercase one
-          game_part == game_part.upcase && piece_part.match?(/\A[-+]?[A-Z]'?\z/)
-        when active_game.downcase
-          # Current player is the lowercase one
-          game_part == game_part.downcase && piece_part.match?(/\A[-+]?[a-z]'?\z/)
-        else
-          # active_game is neither entirely uppercase nor lowercase
-          false
-        end
-      end
-
-      # Validates the GAN format of an identifier.
-      #
-      # A valid GAN identifier must:
-      # - Be a string containing exactly one colon separator
-      # - Have a valid game identifier before the colon
-      # - Have a valid piece identifier after the colon
-      # - Maintain case consistency between game and piece parts
-      #
-      # @param actor [String] Identifier to validate
-      #
-      # @return [Boolean] true if the format is valid
-      #
-      # @example Valid GAN identifiers
-      #   valid_gan_format?("CHESS:K")     # => true
-      #   valid_gan_format?("shogi:+p")    # => true
-      #   valid_gan_format?("MAKRUK:R'")   # => true
-      #
-      # @example Invalid GAN identifiers
-      #   valid_gan_format?("CHESS")       # => false (no colon)
-      #   valid_gan_format?("chess:K")     # => false (case mismatch)
-      #   valid_gan_format?("CHESS:")      # => false (no piece part)
-      def valid_gan_format?(actor)
-        return false unless actor.is_a?(String)
-        return false unless actor.include?(GAN_SEPARATOR)
-
-        parts = actor.split(GAN_SEPARATOR, 2)
-        return false unless parts.length == 2
-
-        game_part, piece_part = parts
-
-        return false unless valid_game_identifier?(game_part)
-        return false unless valid_piece_identifier?(piece_part)
-
-        # Case consistency verification between game and piece
-        game_is_upper = game_part == game_part.upcase
-        piece_match = piece_part.match(/\A[-+]?([A-Za-z])'?\z/)
-        return false unless piece_match
-
-        piece_char = piece_match[1]
-        piece_is_upper = piece_char == piece_char.upcase
-
-        game_is_upper == piece_is_upper
-      end
-
-      # Validates a game identifier.
-      #
-      # Game identifiers must be non-empty strings containing only
-      # alphabetic characters, either all uppercase or all lowercase.
-      # Mixed case is not allowed as it breaks the player distinction.
-      #
-      # @param game_id [String] Game identifier to validate
-      #
-      # @return [Boolean] true if the identifier is valid
-      #
-      # @example Valid game identifiers
-      #   valid_game_identifier?("CHESS")   # => true
-      #   valid_game_identifier?("shogi")   # => true
-      #   valid_game_identifier?("XIANGQI") # => true
-      #
-      # @example Invalid game identifiers
-      #   valid_game_identifier?("Chess")   # => false (mixed case)
-      #   valid_game_identifier?("")        # => false (empty)
-      #   valid_game_identifier?("CHESS1")  # => false (contains digit)
-      def valid_game_identifier?(game_id)
-        return false unless game_id.is_a?(String)
-        return false if game_id.empty?
-
-        # Must be either entirely uppercase or entirely lowercase
-        game_id.match?(/\A[A-Z]+\z/) || game_id.match?(/\A[a-z]+\z/)
-      end
-
-      # Validates a piece identifier (part after the colon).
-      #
-      # Piece identifiers follow the pattern: [optional prefix][letter][optional suffix]
-      # Where:
-      # - Optional prefix: + or -
-      # - Letter: A-Z or a-z (must match game part case)
-      # - Optional suffix: ' (apostrophe)
-      #
-      # @param piece_id [String] Piece identifier to validate
-      #
-      # @return [Boolean] true if the identifier is valid
-      #
-      # @example Valid piece identifiers
-      #   valid_piece_identifier?("K")      # => true
-      #   valid_piece_identifier?("+p")     # => true
-      #   valid_piece_identifier?("R'")     # => true
-      #   valid_piece_identifier?("-Q'")    # => true
-      #
-      # @example Invalid piece identifiers
-      #   valid_piece_identifier?("")       # => false (empty)
-      #   valid_piece_identifier?("++K")    # => false (double prefix)
-      #   valid_piece_identifier?("K''")    # => false (double suffix)
-      def valid_piece_identifier?(piece_id)
-        return false unless piece_id.is_a?(String)
-        return false if piece_id.empty?
-
-        # Format: [optional prefix][letter][optional suffix]
-        piece_id.match?(/\A[-+]?[A-Za-z]'?\z/)
-      end
-    end
-  end
-end

data/lib/sashite/ggn/ruleset/source/destination/engine/transition.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Sashite
-  module Ggn
-    class Ruleset
-      class Source
-        class Destination
-          class Engine
-            # Represents the result of a valid pseudo-legal move evaluation.
-            #
-            # A Transition encapsulates the changes that occur when a move is executed
-            # on the game board. Since GGN focuses exclusively on board-to-board
-            # transformations, a Transition only contains board state changes: pieces
-            # moving, appearing, or disappearing on the board.
-            #
-            # @example Basic move (pawn advance)
-            #   transition = Transition.new("e2" => nil, "e4" => "CHESS:P")
-            #   transition.diff  # => { "e2" => nil, "e4" => "CHESS:P" }
-            #
-            # @example Capture (piece takes enemy piece)
-            #   transition = Transition.new("d4" => nil, "e5" => "CHESS:P")
-            #   transition.diff  # => { "d4" => nil, "e5" => "CHESS:P" }
-            #
-            # @example Complex move (castling with king and rook)
-            #   transition = Transition.new(
-            #     "e1" => nil, "f1" => "CHESS:R", "g1" => "CHESS:K", "h1" => nil
-            #   )
-            #   transition.diff  # => { "e1" => nil, "f1" => "CHESS:R", "g1" => "CHESS:K", "h1" => nil }
-            #
-            # @example Promotion (pawn becomes queen)
-            #   transition = Transition.new("e7" => nil, "e8" => "CHESS:Q")
-            #   transition.diff  # => { "e7" => nil, "e8" => "CHESS:Q" }
-            class Transition
-              # @return [Hash<String, String|nil>] Board state changes after the move.
-              #   Keys are square labels, values are piece identifiers or nil for empty squares.
-              attr_reader :diff
-
-              # Creates a new Transition with the specified board changes.
-              #
-              # @param diff [Hash] Board state changes as keyword arguments.
-              #   Keys should be square labels, values should be piece identifiers or nil.
-              #
-              # @example Creating a simple move transition
-              #   Transition.new("e2" => nil, "e4" => "CHESS:P")
-              #
-              # @example Creating a capture transition
-              #   Transition.new("d4" => nil, "e5" => "CHESS:P")
-              #
-              # @example Creating a complex multi-square transition (castling)
-              #   Transition.new(
-              #     "e1" => nil,        # King leaves e1
-              #     "f1" => "CHESS:R",  # Rook moves to f1
-              #     "g1" => "CHESS:K",  # King moves to g1
-              #     "h1" => nil         # Rook leaves h1
-              #   )
-              #
-              # @example Creating a promotion transition
-              #   Transition.new("e7" => nil, "e8" => "CHESS:Q")
-              #
-              # @example Creating an en passant capture
-              #   Transition.new(
-              #     "d5" => nil,        # Attacking pawn leaves d5
-              #     "e5" => nil,        # Captured pawn removed from e5
-              #     "e6" => "CHESS:P"   # Attacking pawn lands on e6
-              #   )
-              def initialize(**diff)
-                @diff = diff
-
-                freeze
-              end
-
-              # This class remains intentionally simple and rule-agnostic.
-              # Any interpretation of what constitutes a "capture" or "promotion"
-              # is left to higher-level game logic, maintaining GGN's neutrality.
-            end
-          end
-        end
-      end
-    end
-  end
-end