sashite-pan 3.0.0 → 4.0.0

metadata

@@ -1,20 +1,46 @@
 --- !ruby/object:Gem::Specification
 name: sashite-pan
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 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: sashite-cell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sashite-epin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: |
-  Parse and generate Portable Action Notation (PAN) strings for representing moves
-  in chess, shogi, and other strategy board games. PAN provides a compact,
-  human-readable format for move logging, game transmission, and database storage.
-  Supports simple moves (e2-e4), captures (exd5), and piece drops (*e4) with
-  comprehensive validation and error handling.
+  Parse and generate Portable Action Notation (PAN) strings for representing atomic actions in abstract strategy board games including chess, shogi, xiangqi, and others. PAN provides an intuitive operator-based syntax with six core operators: "-" (move to empty square), "+" (capture), "~" (special moves with side effects), "*" (drop to board), "." (drop with capture), and "=" (in-place transformation), plus "..." (pass turn).
+  Supports coordinates via CELL specification and piece identifiers via EPIN specification. Handles transformations ("e7-e8=Q"), enhanced/diminished states ("+R", "-P"), and style derivation markers ("K'"). Provides comprehensive validation, immutable action objects, and functional API design.
+  Examples: "e2-e4" (move), "d1+f3" (capture), "e1~g1" (castling), "P*e5" (drop), "e7-e8=Q" (promotion), "..." (pass), "+d4" (static capture), "e4=+P" (modify).
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -24,8 +50,15 @@ files:
 - README.md
 - lib/sashite-pan.rb
 - lib/sashite/pan.rb
-- lib/sashite/pan/dumper.rb
-- lib/sashite/pan/parser.rb
+- lib/sashite/pan/action.rb
+- lib/sashite/pan/action/capture.rb
+- lib/sashite/pan/action/drop.rb
+- lib/sashite/pan/action/drop_capture.rb
+- lib/sashite/pan/action/modify.rb
+- lib/sashite/pan/action/move.rb
+- lib/sashite/pan/action/pass.rb
+- lib/sashite/pan/action/special.rb
+- lib/sashite/pan/action/static_capture.rb
 homepage: https://github.com/sashite/pan.rb
 licenses:
 - MIT
@@ -34,7 +67,7 @@ metadata:
   documentation_uri: https://rubydoc.info/github/sashite/pan.rb/main
   homepage_uri: https://github.com/sashite/pan.rb
   source_code_uri: https://github.com/sashite/pan.rb
-  specification_uri: https://sashite.dev/documents/pan/1.0.0/
+  specification_uri: https://sashite.dev/specs/pan/1.0.0/
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -50,8 +83,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.1
 specification_version: 4
-summary: Compact notation for board game moves - parse chess, shogi, and strategy
+summary: Portable Action Notation (PAN) - operator-based notation for abstract strategy
   game actions
 test_files: []

data/lib/sashite/pan/dumper.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Sashite
-  module Pan
-    # Dumper for converting structured move data to PAN strings
-    module Dumper
-      class Error < ::StandardError
-      end
-
-      # Convert structured move data to PAN string
-      #
-      # @param move_data [Hash] Move data with type, source, destination
-      # @return [String] PAN string representation
-      # @raise [Dumper::Error] If the move data is invalid
-      def self.call(move_data)
-        raise Dumper::Error, "Move data cannot be nil" if move_data.nil?
-        raise Dumper::Error, "Move data must be a Hash" unless move_data.is_a?(::Hash)
-
-        validate_move_data(move_data)
-
-        case move_data[:type]
-        when :move
-          dump_simple_move(move_data)
-        when :capture
-          dump_capture_move(move_data)
-        when :drop
-          dump_drop_move(move_data)
-        else
-          raise Dumper::Error, "Invalid move type: #{move_data[:type]}"
-        end
-      end
-
-      private
-
-      # Validate the structure of move data
-      #
-      # @param move_data [Hash] Move data to validate
-      # @raise [Dumper::Error] If move data is invalid
-      def self.validate_move_data(move_data)
-        unless move_data.key?(:type)
-          raise Dumper::Error, "Move data must have :type key"
-        end
-
-        unless move_data.key?(:destination)
-          raise Dumper::Error, "Move data must have :destination key"
-        end
-
-        validate_coordinate(move_data[:destination], "destination")
-
-        case move_data[:type]
-        when :move, :capture
-          unless move_data.key?(:source)
-            raise Dumper::Error, "Move and capture types must have :source key"
-          end
-          validate_coordinate(move_data[:source], "source")
-          validate_different_coordinates(move_data[:source], move_data[:destination])
-        when :drop
-          if move_data.key?(:source)
-            raise Dumper::Error, "Drop type cannot have :source key"
-          end
-        else
-          raise Dumper::Error, "Invalid move type: #{move_data[:type]}"
-        end
-      end
-
-      # Validate a coordinate follows PAN format
-      #
-      # @param coordinate [String] Coordinate to validate
-      # @param field_name [String] Name of the field for error messages
-      # @raise [Dumper::Error] If coordinate is invalid
-      def self.validate_coordinate(coordinate, field_name)
-        if coordinate.nil? || coordinate.empty?
-          raise Dumper::Error, "#{field_name.capitalize} coordinate cannot be nil or empty"
-        end
-
-        unless coordinate.is_a?(::String)
-          raise Dumper::Error, "#{field_name.capitalize} coordinate must be a String"
-        end
-
-        unless coordinate.match?(/\A[a-z][0-9]\z/)
-          raise Dumper::Error, "Invalid #{field_name} coordinate format: #{coordinate}. Must be lowercase letter followed by digit (e.g., 'e4')"
-        end
-      end
-
-      # Validate that source and destination are different
-      #
-      # @param source [String] Source coordinate
-      # @param destination [String] Destination coordinate
-      # @raise [Dumper::Error] If coordinates are the same
-      def self.validate_different_coordinates(source, destination)
-        if source == destination
-          raise Dumper::Error, "Source and destination coordinates cannot be identical: #{source}"
-        end
-      end
-
-      # Generate PAN string for simple move
-      #
-      # @param move_data [Hash] Move data with :source and :destination
-      # @return [String] PAN string in format "source-destination"
-      def self.dump_simple_move(move_data)
-        "#{move_data[:source]}-#{move_data[:destination]}"
-      end
-
-      # Generate PAN string for capture move
-      #
-      # @param move_data [Hash] Move data with :source and :destination
-      # @return [String] PAN string in format "sourcexdestination"
-      def self.dump_capture_move(move_data)
-        "#{move_data[:source]}x#{move_data[:destination]}"
-      end
-
-      # Generate PAN string for drop move
-      #
-      # @param move_data [Hash] Move data with :destination
-      # @return [String] PAN string in format "*destination"
-      def self.dump_drop_move(move_data)
-        "*#{move_data[:destination]}"
-      end
-    end
-  end
-end

data/lib/sashite/pan/parser.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Sashite
-  module Pan
-    # Parser for Portable Action Notation (PAN) strings
-    module Parser
-      class Error < ::StandardError
-      end
-
-      # Regular expression pattern for validating PAN strings
-      PAN_PATTERN = /\A(\*|[a-z][0-9][-x])([a-z][0-9])\z/
-
-      # Parse a PAN string into structured move data
-      #
-      # @param pan_string [String] The PAN string to parse
-      # @return [Hash] Structured move data with type, source, and destination
-      # @raise [Parser::Error] If the PAN string is invalid
-      def self.call(pan_string)
-        raise Parser::Error, "PAN string cannot be nil" if pan_string.nil?
-        raise Parser::Error, "PAN string must be a String" unless pan_string.is_a?(::String)
-        raise Parser::Error, "PAN string cannot be empty" if pan_string.empty?
-
-        validate_format(pan_string)
-        parse_move(pan_string)
-      end
-
-      private
-
-      # Validate the basic format of a PAN string
-      #
-      # @param pan_string [String] The PAN string to validate
-      # @raise [Parser::Error] If format is invalid
-      def self.validate_format(pan_string)
-        unless pan_string.match?(PAN_PATTERN)
-          raise Parser::Error, "Invalid PAN format: #{pan_string}"
-        end
-
-        # Additional validation for source != destination in moves and captures
-        if pan_string.include?('-') || pan_string.include?('x')
-          source = pan_string[0..1]
-          destination = pan_string[-2..-1]
-          if source == destination
-            raise Parser::Error, "Source and destination cannot be identical: #{source}"
-          end
-        end
-      end
-
-      # Parse the move based on its type
-      #
-      # @param pan_string [String] The validated PAN string
-      # @return [Hash] Structured move data
-      def self.parse_move(pan_string)
-        case pan_string
-        when /\A([a-z][0-9])-([a-z][0-9])\z/
-          parse_simple_move($1, $2)
-        when /\A([a-z][0-9])x([a-z][0-9])\z/
-          parse_capture_move($1, $2)
-        when /\A\*([a-z][0-9])\z/
-          parse_drop_move($1)
-        else
-          # This should never happen due to earlier validation
-          raise Parser::Error, "Unexpected PAN format: #{pan_string}"
-        end
-      end
-
-      # Parse a simple move (non-capture)
-      #
-      # @param source [String] Source coordinate
-      # @param destination [String] Destination coordinate
-      # @return [Hash] Move data for simple move
-      def self.parse_simple_move(source, destination)
-        {
-          type: :move,
-          source: source,
-          destination: destination
-        }
-      end
-
-      # Parse a capture move
-      #
-      # @param source [String] Source coordinate
-      # @param destination [String] Destination coordinate
-      # @return [Hash] Move data for capture move
-      def self.parse_capture_move(source, destination)
-        {
-          type: :capture,
-          source: source,
-          destination: destination
-        }
-      end
-
-      # Parse a drop/placement move
-      #
-      # @param destination [String] Destination coordinate
-      # @return [Hash] Move data for drop move
-      def self.parse_drop_move(destination)
-        {
-          type: :drop,
-          destination: destination
-        }
-      end
-    end
-  end
-end