sashite-ggn 0.2.0 → 0.5.0

data/lib/sashite/ggn.rb

@@ -1,10 +1,322 @@
-require_relative 'ggn/gameplay'
+# frozen_string_literal: true
+
+require 'json'
+require 'json_schemer'
+require 'pathname'
+
+require_relative File.join("ggn", "ruleset")
+require_relative File.join("ggn", "schema")
+require_relative File.join("ggn", "validation_error")
 
 module Sashite
-  module GGN
-    # Loads a document from the current io stream.
-    def self.new
-      Gameplay.new
+  # 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.
+  #
+  # = Key Features
+  #
+  # - **Rule-agnostic**: Works with any abstract strategy board game
+  # - **Pseudo-legal** focus: Describes basic movement constraints only
+  # - **JSON-based**: Structured, machine-readable format
+  # - **Validation** support: Built-in schema validation
+  # - **Performance** optimized: Optional validation for large datasets
+  # - **Cross-game** compatible: Supports hybrid games and variants
+  #
+  # = Related Specifications
+  #
+  # 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/ Official GGN Specification
+  # @see https://sashite.dev/schemas/ggn/1.0.0/schema.json JSON Schema
+  module Ggn
+    class << self
+      # Loads and validates a GGN JSON file from the filesystem.
+      #
+      # This method provides a complete pipeline for loading GGN data:
+      # 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
+      #
+      # @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 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.
+      #   Use this instance to query pseudo-legal moves for specific pieces and positions.
+      #
+      # @raise [ValidationError] If any of the following conditions occur:
+      #   - File doesn't exist or cannot be read
+      #   - File contains invalid JSON syntax
+      #   - File permissions prevent reading
+      #   - When validation is enabled: data doesn't conform to GGN schema
+      #
+      # @example Loading a chess piece definition with full validation
+      #   begin
+      #     piece_data = Sashite::Ggn.load_file('data/chess_pieces.json')
+      #     chess_king_source = piece_data.select('CHESS:K')
+      #     puts "Loaded chess king movement rules successfully"
+      #   rescue Sashite::Ggn::ValidationError => e
+      #     puts "Failed to load chess pieces: #{e.message}"
+      #   end
+      #
+      # @example Complete workflow with move evaluation
+      #   begin
+      #     piece_data = Sashite::Ggn.load_file('data/chess.json')
+      #     source = piece_data.select('CHESS:K')
+      #     destinations = source.from('e1')
+      #     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
+      #   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
+      #     large_dataset = Sashite::Ggn.load_file('data/all_variants.json', validate: false)
+      #     puts "Loaded GGN data without validation"
+      #   rescue Sashite::Ggn::ValidationError => e
+      #     puts "Failed to load dataset: #{e.message}"
+      #   end
+      #
+      # @example Handling different file encodings
+      #   # Load a GGN file with specific encoding
+      #   piece_data = Sashite::Ggn.load_file('legacy_data.json', encoding: 'ISO-8859-1')
+      #
+      # @note Performance Considerations
+      #   For large GGN files (>1MB), consider setting validate: false to improve
+      #   loading performance. However, this comes with the risk of processing
+      #   malformed data. In production environments, validate at least once
+      #   before deploying with validation disabled.
+      #
+      # @note Thread Safety
+      #   This method is thread-safe for concurrent reads of different files.
+      #   However, avoid concurrent access to the same file if it might be
+      #   modified during reading.
+      def load_file(filepath, validate: true, encoding: 'UTF-8')
+        # Convert to Pathname for consistent file operations and better error handling
+        file_path = normalize_filepath(filepath)
+
+        # Validate file accessibility before attempting to read
+        validate_file_access(file_path)
+
+        # Parse JSON content with comprehensive error handling
+        data = parse_json_file(file_path, encoding)
+
+        # Validate against GGN schema if requested
+        validate_schema(data, file_path) if validate
+
+        # Create and return Ruleset instance
+        Ruleset.new(data)
+      end
+
+      # Loads GGN data directly from a JSON string.
+      #
+      # This method is useful when you have GGN data as a string (e.g., from a
+      # 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)
+      #
+      # @return [Ruleset] A Ruleset instance containing the parsed GGN data
+      #
+      # @raise [ValidationError] If the JSON is invalid or doesn't conform to GGN schema
+      #
+      # @example Loading GGN data from a string
+      #   ggn_json = '{"CHESS:P": {"e2": {"e4": [{"require": {"e3": "empty", "e4": "empty"}, "perform": {"e2": null, "e4": "CHESS:P"}}]}}}'
+      #
+      #   begin
+      #     piece_data = Sashite::Ggn.load_string(ggn_json)
+      #     pawn_source = piece_data.select('CHESS:P')
+      #     puts "Loaded pawn with move from e2 to e4"
+      #   rescue Sashite::Ggn::ValidationError => e
+      #     puts "Invalid GGN data: #{e.message}"
+      #   end
+      #
+      # @example Loading from API response without validation
+      #   api_response = fetch_ggn_from_api()
+      #   piece_data = Sashite::Ggn.load_string(api_response.body, validate: false)
+      def load_string(json_string, validate: true)
+        # Parse JSON string with error handling
+        begin
+          data = ::JSON.parse(json_string)
+        rescue ::JSON::ParserError => e
+          raise ValidationError, "Invalid JSON string: #{e.message}"
+        end
+
+        # Validate against GGN schema if requested
+        validate_schema(data, "<string>") if validate
+
+        # Create and return Ruleset instance
+        Ruleset.new(data)
+      end
+
+      # Loads GGN data from a Ruby Hash.
+      #
+      # This method is useful when you already have parsed JSON data as a Hash
+      # 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)
+      #
+      # @return [Ruleset] A Ruleset instance containing the GGN data
+      #
+      # @raise [ValidationError] If the data doesn't conform to GGN schema (when validation enabled)
+      #
+      # @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" } }]
+      #       }
+      #     }
+      #   }
+      #
+      #   piece_data = Sashite::Ggn.load_hash(ggn_data)
+      #   shogi_king = piece_data.select('SHOGI:K')
+      def load_hash(data, validate: true)
+        unless data.is_a?(Hash)
+          raise ValidationError, "Expected Hash, got #{data.class}"
+        end
+
+        # Validate against GGN schema if requested
+        validate_schema(data, "<hash>") if validate
+
+        # Create and return Ruleset instance
+        Ruleset.new(data)
+      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.
+      #
+      # @param data [Hash] The data structure to validate
+      # @param context [String] Context information for error messages (default: "<data>")
+      #
+      # @return [true] If validation passes
+      #
+      # @raise [ValidationError] If validation fails with detailed error information
+      #
+      # @example Validating data before processing
+      #   begin
+      #     Sashite::Ggn.validate!(my_data)
+      #     puts "Data is valid GGN format"
+      #   rescue Sashite::Ggn::ValidationError => e
+      #     puts "Validation failed: #{e.message}"
+      #   end
+      def validate!(data, context: "<data>")
+        validate_schema(data, context)
+        true
+      end
+
+      # Checks if a data structure is valid GGN format.
+      #
+      # @param data [Hash] The data structure to validate
+      #
+      # @return [Boolean] true if valid, false otherwise
+      #
+      # @example Checking validity without raising exceptions
+      #   if Sashite::Ggn.valid?(my_data)
+      #     puts "Data is valid"
+      #   else
+      #     puts "Data is invalid"
+      #   end
+      def valid?(data)
+        schemer = ::JSONSchemer.schema(Schema)
+        schemer.valid?(data)
+      end
+
+      # Returns detailed validation errors for a data structure.
+      #
+      # @param data [Hash] The data structure to validate
+      #
+      # @return [Array<String>] Array of validation error messages (empty if valid)
+      #
+      # @example Getting detailed validation errors
+      #   errors = Sashite::Ggn.validation_errors(invalid_data)
+      #   if errors.any?
+      #     puts "Validation errors found:"
+      #     errors.each { |error| puts "  - #{error}" }
+      #   end
+      def validation_errors(data)
+        schemer = ::JSONSchemer.schema(Schema)
+        schemer.validate(data).map(&:to_s)
+      end
+
+      private
+
+      # Normalizes filepath input to Pathname instance
+      def normalize_filepath(filepath)
+        case filepath
+        when ::Pathname
+          filepath
+        when String
+          ::Pathname.new(filepath)
+        else
+          raise ValidationError, "Invalid filepath type: #{filepath.class}. Expected String or Pathname."
+        end
+      end
+
+      # Validates that a file exists and is readable
+      def validate_file_access(file_path)
+        unless file_path.exist?
+          raise ValidationError, "File not found: #{file_path}"
+        end
+
+        unless file_path.readable?
+          raise ValidationError, "File not readable: #{file_path}"
+        end
+
+        unless file_path.file?
+          raise ValidationError, "Path is not a file: #{file_path}"
+        end
+      end
+
+      # Parses JSON file with proper error handling and encoding
+      def parse_json_file(file_path, encoding)
+        # Read file with specified encoding
+        content = file_path.read(encoding: encoding)
+
+        # Parse JSON content
+        ::JSON.parse(content)
+      rescue ::JSON::ParserError => e
+        raise ValidationError, "Invalid JSON in file #{file_path}: #{e.message}"
+      rescue ::Encoding::UndefinedConversionError => e
+        raise ValidationError, "Encoding error in file #{file_path}: #{e.message}. Try a different encoding."
+      rescue ::SystemCallError => e
+        raise ValidationError, "Failed to read file #{file_path}: #{e.message}"
+      end
+
+      # Validates data against GGN schema with detailed error reporting
+      def validate_schema(data, context)
+        schemer = ::JSONSchemer.schema(Schema)
+
+        return if schemer.valid?(data)
+
+        # Collect all validation errors for comprehensive feedback
+        errors = schemer.validate(data).map(&:to_s)
+        error_summary = errors.size == 1 ? "1 validation error" : "#{errors.size} validation errors"
+
+        raise ValidationError, "Invalid GGN data in #{context}: #{error_summary}: #{errors.join('; ')}"
+      end
     end
   end
 end

data/lib/sashite-ggn.rb

@@ -1 +1,112 @@
-require 'sashite/ggn'
+# 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 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
+#   }
+#
+#   result = engine.evaluate(board_state, {}, "CHESS")
+#
+#   if result
+#     puts "Move is valid!"
+#     puts "Board changes: #{result.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 }
+#
+#   # Current board state (5th file is clear of unpromoted pawns)
+#   board_state = {
+#     "5e" => nil,     # Target square is empty
+#     "5a" => nil, "5b" => nil, "5c" => nil, "5d" => nil,
+#     "5f" => nil, "5g" => nil, "5h" => nil, "5i" => nil
+#   }
+#
+#   result = engine.evaluate(board_state, captures, "SHOGI")
+#
+#   if result
+#     puts "Pawn drop is valid!"
+#     puts "Board changes: #{result.diff}"  # => { "5e" => "SHOGI:P" }
+#     puts "Piece dropped from hand: #{result.drop}"  # => "SHOGI:P"
+#   end
+#
+# @example Captures with piece promotion
+#   # A chess pawn capturing and promoting to queen
+#   piece_data = Sashite::Ggn.load_file("chess_moves.json")
+#   engine = piece_data.select("CHESS:P").from("g7").to("h8")
+#
+#   # Board with enemy piece on h8
+#   board_state = {
+#     "g7" => "CHESS:P",  # Our pawn ready to promote
+#     "h8" => "chess:r"   # Enemy rook (lowercase = opponent)
+#   }
+#
+#   result = engine.evaluate(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_)
+#   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)
+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,98 +1,60 @@
 --- !ruby/object:Gem::Specification
 name: sashite-ggn
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
-- Cyril Wack
-autorequire: 
+- Cyril Kato
 bindir: bin
 cert_chain: []
-date: 2014-06-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: json_schemer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :development
+        version: 2.4.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10'
-description: A Ruby interface for GGN (General Gameplay Notation) objects.
-email:
-- contact@cyril.io
+        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.
+email: contact@cyril.email
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".ruby-version"
-- ".travis.yml"
-- Gemfile
 - LICENSE.md
 - README.md
-- Rakefile
-- VERSION.semver
 - lib/sashite-ggn.rb
 - lib/sashite/ggn.rb
-- lib/sashite/ggn/ability.rb
-- lib/sashite/ggn/gameplay.rb
-- lib/sashite/ggn/object.rb
-- lib/sashite/ggn/pattern.rb
-- lib/sashite/ggn/square.rb
-- lib/sashite/ggn/state.rb
-- lib/sashite/ggn/subject.rb
-- lib/sashite/ggn/verb.rb
-- sashite-ggn.gemspec
-- test/_test_helper.rb
-- test/test_ggn.rb
-- test/test_ggn_ability.rb
-- test/test_ggn_gameplay.rb
-- test/test_ggn_object.rb
-- test/test_ggn_pattern.rb
-- test/test_ggn_square.rb
-- test/test_ggn_state.rb
-- test/test_ggn_subject.rb
-- test/test_ggn_verb.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
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/sashite/ggn.rb/issues
+  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/
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -100,26 +62,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
-summary: Some mappers for GGN objects
-test_files:
-- test/_test_helper.rb
-- test/test_ggn.rb
-- test/test_ggn_ability.rb
-- test/test_ggn_gameplay.rb
-- test/test_ggn_object.rb
-- test/test_ggn_pattern.rb
-- test/test_ggn_square.rb
-- test/test_ggn_state.rb
-- test/test_ggn_subject.rb
-- test/test_ggn_verb.rb
+summary: General Gameplay Notation (GGN) parser and validator for Ruby
+test_files: []

data/.gitignore

@@ -1,22 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-*.bundle
-*.so
-*.o
-*.a
-mkmf.log

data/.ruby-version

@@ -1 +0,0 @@
-2.1.2

data/.travis.yml

@@ -1,3 +0,0 @@
-language: ruby
-rvm:
-  - 2.1.2

data/Gemfile

@@ -1,2 +0,0 @@
-source 'https://rubygems.org'
-gemspec

data/Rakefile

@@ -1,7 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-
-Rake::TestTask.new do |t|
-end
-
-task default: :test

data/VERSION.semver

@@ -1 +0,0 @@
-0.2.0

data/lib/sashite/ggn/ability.rb

@@ -1,11 +0,0 @@
-require_relative 'subject'
-require_relative 'verb'
-require_relative 'object'
-
-module Sashite
-  module GGN
-    class Ability
-      attr_accessor :subject, :verb, :object
-    end
-  end
-end

data/lib/sashite/ggn/gameplay.rb

@@ -1,9 +0,0 @@
-require_relative 'pattern'
-
-module Sashite
-  module GGN
-    class Gameplay
-      attr_accessor :patterns
-    end
-  end
-end

data/lib/sashite/ggn/object.rb

@@ -1,9 +0,0 @@
-require_relative 'square'
-
-module Sashite
-  module GGN
-    class Object
-      attr_accessor :src_square, :dst_square, :promotable_into_actors
-    end
-  end
-end