portable_move_notation 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a008ac268dce4d3013e9c3ec9af1d12d9129099e979e89e62cd6329f4468651
-  data.tar.gz: f11d4a3de00b8ef92881424094db881693fc6e119786b84e61e6eda3f20c2ee7
+  metadata.gz: 235dc58e056f7f8191c003a52248c1dadec9baabb5cc0393fd741bc7109abefa
+  data.tar.gz: f694111d3222b01a42e93eb39f72bd6dbaf369639ed8f7a5874dde60d09d66ef
 SHA512:
-  metadata.gz: 5d15617090fdcef46ee3c92ca313febf5b3e9c4f1ecd2ca15a136692fac78f27f0d985f5431d761d4cd479237f3d6daaf8c42cf626847af90d394209f0395c43
-  data.tar.gz: 924ebd086e03da2287d97fb613500bf49b4a3d2797dda5d0495ba67d518e887edbf131a3338bab28943bd0ba4a4a6bd772b71ff2f2d079d27ed6aba115701f11
+  metadata.gz: d294c9796295c57415879911ab0aabfc370aff963f772fd088f1be7f8f9532f93773fe0c1f4748f89534fd20609c1b303e68f0962d4e43e39ee8e48410cda5ad
+  data.tar.gz: 7f2e37453b62b9407240cead2ac809d230fe464f2a9ce2a4877262e5b6531384d564fe43ec20089d22b4b9337b3a3c05507eb9d4acc562de1ca7eb11cc533d22

data/LICENSE.md

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+# The MIT License
 
-Copyright (c) 2019-2020 Cyril Kato
+Copyright (c) 2019-2025 Sashité
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,80 +1,279 @@
-# Portable Move Notation
+# Pmn.rb
 
-A Ruby interface for data serialization in [PMN](https://developer.sashite.com/specs/portable-move-notation) format.
+[![Version](https://img.shields.io/github/v/tag/sashite/pmn.rb?label=Version&logo=github)](https://github.com/sashite/pmn.rb/tags)
+[![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/sashite/pmn.rb/main)
+![Ruby](https://github.com/sashite/pmn.rb/actions/workflows/main.yml/badge.svg?branch=main)
+[![License](https://img.shields.io/github/license/sashite/pmn.rb?label=License&logo=github)](https://github.com/sashite/pmn.rb/raw/main/LICENSE.md)
+
+> **PMN** (Portable Move Notation) support for the Ruby language.
+
+## What is PMN?
+
+PMN (Portable Move Notation) is a rule-agnostic JSON-based format for representing moves in abstract strategy board games. It provides a consistent representation system for game actions across both traditional and non-traditional board games, supporting arbitrary dimensions and hybrid configurations while maintaining neutrality toward game-specific rules.
+
+This gem implements the [PMN Specification v1.0.0](https://sashite.dev/documents/pmn/1.0.0/), providing a Ruby interface for:
+- Serializing game actions to PMN format
+- Parsing PMN data into structured Ruby objects
+- Validating PMN data according to the specification
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'portable_move_notation'
+gem "portable_move_notation"
 ```
 
 And then execute:
 
-    $ bundle
+```sh
+bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install portable_move_notation
+```sh
+gem install portable_move_notation
+```
+
+## PMN Format
+
+A PMN record consists of an array of one or more action items, where each action item is a JSON object with precisely defined fields:
+
+```json
+[
+  {
+    "src_square": <source-coordinate-or-null>,
+    "dst_square": <destination-coordinate>,
+    "piece_name": <piece-identifier>,
+    "piece_hand": <captured-piece-identifier-or-null>
+  },
+  ...
+]
+```
+
+## Basic Usage
 
-## Usage
+### Working with PMN Actions
 
-Working with PMN can be very simple, for example:
+Create individual actions representing piece movement:
 
 ```ruby
-require 'portable_move_notation'
+require "portable_move_notation"
+
+# Create an action representing a chess pawn moving from e2 (52) to e4 (36)
+pawn_move = PortableMoveNotation::Action.new(
+  src_square: 52,
+  dst_square: 36,
+  piece_name: "P",
+  piece_hand: nil
+)
+
+# Generate the PMN representation
+pawn_move.to_h
+# => {"src_square"=>52, "dst_square"=>36, "piece_name"=>"P", "piece_hand"=>nil}
+```
 
-# Emit a PMN string
+### Working with PMN Moves
 
-some_moves = [
-  [52, 36, '♙', nil],
-  [12, 28, '♟', nil],
-  [53, 37, '♙', nil]
-]
+Create compound moves consisting of multiple actions:
+
+```ruby
+require "portable_move_notation"
+require "json"
+
+# Create actions for a kingside castle in chess:
+king_action = PortableMoveNotation::Action.new(
+  src_square: 60,
+  dst_square: 62,
+  piece_name: "K",
+  piece_hand: nil
+)
+
+rook_action = PortableMoveNotation::Action.new(
+  src_square: 63,
+  dst_square: 61,
+  piece_name: "R",
+  piece_hand: nil
+)
+
+# Create a complete move (notice the splat operator for multiple actions)
+castling_move = PortableMoveNotation::Move.new(king_action, rook_action)
+
+# Generate JSON representation
+json_string = castling_move.to_json
+puts json_string
+# => [{"src_square":60,"dst_square":62,"piece_name":"K","piece_hand":null},{"src_square":63,"dst_square":61,"piece_name":"R","piece_hand":null}]
+```
+
+### Parsing PMN Data
+
+Parse PMN data from JSON:
+
+```ruby
+require "portable_move_notation"
+
+# Parse a PMN string (representing a shogi pawn promotion)
+pmn_string = '[{"src_square":27,"dst_square":18,"piece_name":"+P","piece_hand":null}]'
+move = PortableMoveNotation::Move.from_json(pmn_string)
+
+# Access components of the move
+puts move.actions.first.piece_name  # => +P
+puts move.actions.first.src_square  # => 27
+puts move.actions.first.dst_square  # => 18
+```
 
-PortableMoveNotation.dump(*some_moves) # => "52,36,♙.12,28,♟.53,37,♙"
+### Validation
 
-# Parse a PMN string
+Validate PMN data for conformance to the specification:
 
-PortableMoveNotation.parse('52,36,♙.12,28,♟.53,37,♙') # => [[52, 36, "♙", nil], [12, 28, "♟", nil], [53, 37, "♙", nil]]
+```ruby
+require "portable_move_notation"
+require "json"
+
+# Valid PMN data
+valid_data = JSON.parse('[{"dst_square":27,"piece_name":"p"}]')
+PortableMoveNotation::Move.valid?(valid_data) # => true
+
+# Invalid PMN data (missing required field)
+invalid_data = JSON.parse('[{"src_square":27}]')
+PortableMoveNotation::Move.valid?(invalid_data) # => false
 ```
 
-## Examples
+## Examples of Common Chess and Shogi Actions
+
+### Chess: Pawn Move
+
+A white pawn moves from e2 (52) to e4 (36):
 
 ```ruby
-# Black castles on king-side
+action = PortableMoveNotation::Action.new(
+  src_square: 52,
+  dst_square: 36,
+  piece_name: "P",
+  piece_hand: nil
+)
+
+move = PortableMoveNotation::Move.new(action)
+move.to_json
+# => [{"src_square":52,"dst_square":36,"piece_name":"P","piece_hand":null}]
+```
 
-PortableMoveNotation.dump([60, 62, '♔', nil, 63, 61, '♖', nil]) # => "60,62,♔;63,61,♖"
-PortableMoveNotation.parse('60,62,♔;63,61,♖') # => [[60, 62, "♔", nil, 63, 61, "♖", nil]]
+### Chess: Castling Kingside
 
-# Promoting a chess pawn into a knight
+White castles kingside:
 
-PortableMoveNotation.dump([12, 4, '♘', nil]) # => "12,4,♘"
-PortableMoveNotation.parse('12,4,♘') # => [[12, 4, "♘", nil]]
+```ruby
+king_action = PortableMoveNotation::Action.new(
+  src_square: 60,
+  dst_square: 62,
+  piece_name: "K",
+  piece_hand: nil
+)
+
+rook_action = PortableMoveNotation::Action.new(
+  src_square: 63,
+  dst_square: 61,
+  piece_name: "R",
+  piece_hand: nil
+)
+
+castling_move = PortableMoveNotation::Move.new(king_action, rook_action)
+castling_move.to_json
+# => [{"src_square":60,"dst_square":62,"piece_name":"K","piece_hand":null},{"src_square":63,"dst_square":61,"piece_name":"R","piece_hand":null}]
+```
 
-# Capturing a rook and promoting a shogi pawn
+### Shogi: Dropping a Pawn
 
-PortableMoveNotation.dump([33, 24, '+P', 'R']) # => "33,24,+P,R"
-PortableMoveNotation.parse('33,24,+P,R') # => [[33, 24, "+P", "R"]]
+A pawn is dropped onto square 27 from the player's hand:
 
-# Dropping a shogi pawn
+```ruby
+action = PortableMoveNotation::Action.new(
+  src_square: nil,
+  dst_square: 27,
+  piece_name: "p",
+  piece_hand: nil
+)
+
+move = PortableMoveNotation::Move.new(action)
+move.to_json
+# => [{"src_square":null,"dst_square":27,"piece_name":"p","piece_hand":null}]
+```
 
-PortableMoveNotation.dump([nil, 42, 'P', nil]) # => "*,42,P"
-PortableMoveNotation.parse('*,42,P') # => [[nil, 42, "P", nil]]
+### Shogi: Piece Capture and Promotion
 
-# Capturing a white chess pawn en passant
+A bishop (B) captures a promoted pawn (+p) at square 27 and becomes available for dropping:
 
-PortableMoveNotation.dump([48, 32, '♙', nil], [33, 32, '♟', nil, 32, 40, '♟', nil]) # => "48,32,♙.33,32,♟;32,40,♟"
-PortableMoveNotation.parse('48,32,♙.33,32,♟;32,40,♟') # => [[48, 32, "♙", nil], [33, 32, "♟", nil, 32, 40, "♟", nil]]
+```ruby
+action = PortableMoveNotation::Action.new(
+  src_square: 36,
+  dst_square: 27,
+  piece_name: "B",
+  piece_hand: "P"
+)
+
+move = PortableMoveNotation::Move.new(action)
+move.to_json
+# => [{"src_square":36,"dst_square":27,"piece_name":"B","piece_hand":"P"}]
 ```
 
-## License
+### Chess: En Passant Capture
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+After white plays a double pawn move from e2 (52) to e4 (36), black captures en passant:
+
+```ruby
+# First create the initial pawn move
+initial_move = PortableMoveNotation::Action.new(
+  src_square: 52,
+  dst_square: 36,
+  piece_name: "P",
+  piece_hand: nil
+)
+
+# Then create the en passant capture (represented as two actions)
+capture_action1 = PortableMoveNotation::Action.new(
+  src_square: 35,
+  dst_square: 36,
+  piece_name: "p",
+  piece_hand: nil
+)
+
+capture_action2 = PortableMoveNotation::Action.new(
+  src_square: 36,
+  dst_square: 44,
+  piece_name: "p",
+  piece_hand: null
+)
+
+en_passant_move = PortableMoveNotation::Move.new(capture_action1, capture_action2)
+en_passant_move.to_json
+# => [{"src_square":35,"dst_square":36,"piece_name":"p","piece_hand":null},{"src_square":36,"dst_square":44,"piece_name":"p","piece_hand":null}]
+```
+
+## Properties of PMN
+
+* **Rule-agnostic**: PMN does not encode game-specific legality, validity, or conditions.
+* **Arbitrary-dimensional**: PMN supports arbitrary board configurations through a unified coordinate system.
+* **Game-neutral**: PMN provides a common structure applicable to all abstract strategy games with piece movement.
+* **Hybrid-supporting**: PMN facilitates hybrid or cross-game scenarios where multiple game types coexist.
+* **Deterministic**: PMN is designed for deterministic representation of all possible state transitions in piece-placement games.
+
+## Related Specifications
+
+PMN is part of a family of specifications for representing abstract strategy board games:
+
+- [Piece Name Notation (PNN)](https://sashite.dev/documents/pnn/1.0.0/) - Defines the format for representing individual pieces.
+- [Forsyth-Edwards Enhanced Notation (FEEN)](https://sashite.dev/documents/feen/1.0.0/) - Defines the format for representing board positions.
+
+## Documentation
+
+- [Official PMN Specification](https://sashite.dev/documents/pmn/1.0.0/)
+- [API Documentation](https://rubydoc.info/github/sashite/pmn.rb/main)
+
+## License
 
-## About Sashite
+The [gem](https://rubygems.org/gems/portable_move_notation) is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-The `portable_move_notation` gem is maintained by [Sashite](https://sashite.com/).
+## About Sashité
 
-With some [lines of code](https://github.com/sashite/), let's share the beauty of Chinese, Japanese and Western cultures through the game of chess!
+This project is maintained by [Sashité](https://sashite.com/) — promoting chess variants and sharing the beauty of Chinese, Japanese, and Western chess cultures.

data/lib/portable_move_notation/action.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module PortableMoveNotation
+  # Represents an atomic action in PMN format
+  #
+  # An Action is the fundamental unit of PMN, representing a single piece movement
+  # from a source square to a destination square, with optional capture information.
+  #
+  # PMN actions consist of four primary components:
+  # - src_square: Source coordinate (or nil for drops)
+  # - dst_square: Destination coordinate (required)
+  # - piece_name: Identifier of the moving piece (required)
+  # - piece_hand: Identifier of any captured piece (or nil)
+  #
+  # @example Basic piece movement
+  #   Action.new(src_square: 52, dst_square: 36, piece_name: "P")
+  #
+  # @example Piece drop (from outside the board)
+  #   Action.new(src_square: nil, dst_square: 27, piece_name: "p")
+  #
+  # @example Capture with piece becoming available for dropping
+  #   Action.new(src_square: 33, dst_square: 24, piece_name: "+P", piece_hand: "R")
+  #
+  # @see https://sashite.dev/documents/pmn/1.0.0/ PMN Specification
+  # @see https://sashite.dev/documents/pnn/1.0.0/ PNN Specification for piece format
+  class Action
+    # Validates a PMN action hash
+    #
+    # @param action_data [Hash] PMN action data to validate
+    # @return [Boolean] true if valid, false otherwise
+    def self.valid?(action_data)
+      return false unless action_data.is_a?(::Hash)
+      return false unless action_data.key?("dst_square") && action_data.key?("piece_name")
+
+      begin
+        # Use existing validation logic by attempting to create an instance
+        new(
+          src_square: action_data["src_square"],
+          dst_square: action_data["dst_square"],
+          piece_name: action_data["piece_name"],
+          piece_hand: action_data["piece_hand"]
+        )
+        true
+      rescue ::ArgumentError
+        false
+      end
+    end
+
+    # Creates an Action instance from parameters
+    #
+    # @param params [Hash] Action parameters
+    # @return [Action] A new action instance
+    # @raise [KeyError] if required parameters are missing
+    def self.from_params(**params)
+      new(
+        src_square: params[:src_square],
+        dst_square: params.fetch(:dst_square),
+        piece_name: params.fetch(:piece_name),
+        piece_hand: params[:piece_hand]
+      )
+    end
+
+    # The source coordinate of the action, or nil for drops
+    # @return [Integer, nil] Source square coordinate
+    attr_reader :src_square
+
+    # The destination coordinate of the action
+    # @return [Integer] Destination square coordinate
+    attr_reader :dst_square
+
+    # The piece identifier in PNN format
+    # @return [String] Piece name
+    attr_reader :piece_name
+
+    # The identifier of any captured piece that becomes available for dropping, or nil
+    # @return [String, nil] Captured piece identifier
+    attr_reader :piece_hand
+
+    # Initializes a new action
+    #
+    # @param src_square [Integer, nil] Source square (nil for placements from outside the board)
+    # @param dst_square [Integer] Destination square (required)
+    # @param piece_name [String] Piece identifier in PNN format (required)
+    # @param piece_hand [String, nil] Captured piece identifier that becomes droppable, or nil
+    # @raise [ArgumentError] if any validation fails
+    def initialize(dst_square:, piece_name:, src_square: nil, piece_hand: nil)
+      # Input validation
+      validate_square(src_square) unless src_square.nil?
+      validate_square(dst_square)
+      validate_piece_name(piece_name)
+      validate_piece_hand(piece_hand) unless piece_hand.nil?
+
+      @src_square = src_square
+      @dst_square = dst_square
+      @piece_name = piece_name
+      @piece_hand = piece_hand
+
+      freeze
+    end
+
+    # Converts the action to a parameter hash
+    #
+    # @return [Hash] Parameter hash representation of the action
+    def to_params
+      {
+        src_square:,
+        dst_square:,
+        piece_name:,
+        piece_hand:
+      }.compact
+    end
+
+    # Converts the action to a PMN-compatible hash
+    #
+    # This creates a hash with string keys as required by the PMN JSON format
+    #
+    # @return [Hash] PMN-compatible hash representation
+    def to_h
+      {
+        "src_square" => src_square,
+        "dst_square" => dst_square,
+        "piece_name" => piece_name,
+        "piece_hand" => piece_hand
+      }
+    end
+
+    private
+
+    # Validates that a square coordinate is a non-negative integer
+    #
+    # @param square [Object] Value to validate
+    # @raise [ArgumentError] if the value is not a non-negative integer
+    def validate_square(square)
+      return if square.is_a?(::Integer) && square >= 0
+
+      raise ::ArgumentError, "Square must be a non-negative integer"
+    end
+
+    # Validates the piece name format according to PNN specification
+    #
+    # @param piece_name [Object] Piece name to validate
+    # @raise [ArgumentError] if the format is invalid
+    def validate_piece_name(piece_name)
+      return if piece_name.is_a?(::String) && piece_name.match?(/\A[-+]?[a-zA-Z][=<>]?\z/)
+
+      raise ::ArgumentError, "Invalid piece_name format: #{piece_name}"
+    end
+
+    # Validates the piece hand format according to PNN specification
+    #
+    # Piece hand must be a single letter with no modifiers
+    #
+    # @param piece_hand [Object] Piece hand value to validate
+    # @raise [ArgumentError] if the format is invalid
+    def validate_piece_hand(piece_hand)
+      return if piece_hand.is_a?(::String) && piece_hand.match?(/\A[a-zA-Z]\z/)
+
+      raise ::ArgumentError, "Invalid piece_hand format: #{piece_hand}"
+    end
+  end
+end

data/lib/portable_move_notation/move.rb

@@ -1,10 +1,133 @@
 # frozen_string_literal: true
 
 module PortableMoveNotation
-  # Move class
+  # Represents a PMN move - a collection of one or more atomic actions
+  # that together describe a game state transition
+  #
+  # A move may consist of one or more actions, allowing for representation
+  # of complex moves such as castling, en passant captures, or multi-step
+  # actions in various abstract strategy games.
+  #
+  # @example Creating a simple move
+  #   action = Action.new(src_square: 52, dst_square: 36, piece_name: "P")
+  #   move = Move.new(action)
+  #
+  # @example Creating a castling move
+  #   king_action = Action.new(src_square: 60, dst_square: 62, piece_name: "K")
+  #   rook_action = Action.new(src_square: 63, dst_square: 61, piece_name: "R")
+  #   castling = Move.new(king_action, rook_action)
+  #
+  # @see https://sashite.dev/documents/pmn/1.0.0/ PMN Specification
   class Move
-    private_class_method def self.separator
-      '.'
+    # Validates a PMN array data structure
+    #
+    # @param pmn_data [Array] PMN data to validate
+    # @return [Boolean] true if valid, false otherwise
+    def self.valid?(pmn_data)
+      return false unless pmn_data.is_a?(Array) && !pmn_data.empty?
+
+      pmn_data.all? { |action_data| Action.valid?(action_data) }
+    end
+
+    # Creates a Move instance from a JSON string in PMN format
+    #
+    # @param json_string [String] JSON string to parse
+    # @return [Move] A new move instance
+    # @raise [JSON::ParserError] if the JSON string is malformed
+    # @raise [KeyError] if required fields are missing
+    def self.from_json(json_string)
+      json_data = ::JSON.parse(json_string)
+
+      actions = json_data.map do |action_data|
+        Action.new(
+          src_square: action_data["src_square"],
+          dst_square: action_data.fetch("dst_square"),
+          piece_name: action_data.fetch("piece_name"),
+          piece_hand: action_data["piece_hand"]
+        )
+      end
+
+      new(*actions)
+    end
+
+    # Creates a Move instance from an array of PMN action hashes
+    #
+    # @param pmn_array [Array<Hash>] Array of PMN action hashes
+    # @return [Move] A new move instance
+    # @raise [KeyError] if required fields are missing
+    def self.from_pmn(pmn_array)
+      actions = pmn_array.map do |action_data|
+        Action.new(
+          src_square: action_data["src_square"],
+          dst_square: action_data.fetch("dst_square"),
+          piece_name: action_data.fetch("piece_name"),
+          piece_hand: action_data["piece_hand"]
+        )
+      end
+
+      new(*actions)
+    end
+
+    # Creates a Move instance from a parameters hash
+    #
+    # @param params [Hash] Move parameters
+    # @option params [Array<Action, Hash>] :actions List of actions or action params
+    # @return [Move] A new move instance
+    # @raise [KeyError] if the :actions key is missing
+    def self.from_params(**params)
+      actions = Array(params.fetch(:actions)).map do |action_params|
+        if action_params.is_a?(Action)
+          action_params
+        else
+          Action.from_params(**action_params)
+        end
+      end
+
+      new(*actions)
+    end
+
+    # The list of actions that compose this move
+    #
+    # @return [Array<Action>] List of action objects (frozen)
+    attr_reader :actions
+
+    # Initializes a new move with the given actions
+    #
+    # @param actions [Array<Action>] List of actions as splat arguments
+    # @raise [ArgumentError] if actions is not a non-empty array of Action objects
+    def initialize(*actions)
+      validate_actions(*actions)
+      @actions = actions.freeze
+
+      freeze
+    end
+
+    # Converts the move to PMN format (array of hashes)
+    #
+    # @return [Array<Hash>] PMN representation of the move
+    def to_pmn
+      actions.map(&:to_h)
+    end
+
+    # Converts the move to a JSON string
+    #
+    # @return [String] JSON string of the move in PMN format
+    def to_json(*_args)
+      ::JSON.generate(to_pmn)
+    end
+
+    private
+
+    # Validates the actions array
+    #
+    # @param actions [Object] Actions to validate
+    # @raise [ArgumentError] if actions is not a non-empty array of Action objects
+    def validate_actions(*actions)
+      return if !actions.empty? && actions.all?(Action)
+
+      raise ::ArgumentError, "Actions must be a non-empty array of Action objects"
     end
   end
 end
+
+require_relative "action"

data/lib/portable_move_notation.rb

@@ -1,15 +1,9 @@
 # frozen_string_literal: true
 
 # Portable Move Notation module
+#
+# @see https://sashite.dev/documents/pmn/1.0.0/
 module PortableMoveNotation
-  def self.dump(*moves)
-    Dumper.call(*moves)
-  end
-
-  def self.parse(string)
-    Parser.call(string)
-  end
 end
 
-require_relative 'portable_move_notation/dumper'
-require_relative 'portable_move_notation/parser'
+require_relative File.join("portable_move_notation", "move")

metadata

@@ -1,143 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: portable_move_notation
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Cyril Kato
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-06 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: sashite-pan
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.2.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.2.0
-- !ruby/object:Gem::Dependency
-  name: awesome_print
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-thread_safety
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: A Ruby interface for data serialization in PMN (Portable Move Notation)
-  format.
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby interface for serialization and deserialization of moves in PMN
+  format. PMN is a rule-agnostic JSON-based format for representing moves in abstract
+  strategy board games, providing a consistent representation system for game actions
+  across both traditional and non-traditional board games.
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -146,17 +21,18 @@ files:
 - LICENSE.md
 - README.md
 - lib/portable_move_notation.rb
-- lib/portable_move_notation/dumper.rb
+- lib/portable_move_notation/action.rb
 - lib/portable_move_notation/move.rb
-- lib/portable_move_notation/parser.rb
-homepage: https://developer.sashite.com/specs/portable-move-notation
+homepage: https://github.com/sashite/pmn.rb
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/sashite/pmn.rb/issues
-  documentation_uri: https://rubydoc.info/gems/portable_move_notation/index
+  documentation_uri: https://rubydoc.info/github/sashite/pmn.rb/main
+  homepage_uri: https://github.com/sashite/pmn.rb
   source_code_uri: https://github.com/sashite/pmn.rb
-post_install_message: 
+  specification_uri: https://sashite.dev/documents/pmn/1.0.0/
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -164,15 +40,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: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
-summary: Data serialization in PMN format.
+summary: PMN (Portable Move Notation) support for the Ruby language.
 test_files: []

data/lib/portable_move_notation/dumper.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'move'
-
-module PortableMoveNotation
-  # Dumper class
-  class Dumper < Move
-    def self.call(*moves)
-      moves.map { |move| ::Sashite::PAN::Dumper.call(*move.each_slice(4)) }
-           .join(separator)
-    end
-  end
-end
-
-require 'sashite/pan/dumper'

data/lib/portable_move_notation/parser.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'move'
-
-module PortableMoveNotation
-  # Parser class
-  class Parser < Move
-    def self.call(string)
-      string.split(separator)
-            .map { |serialized_move| new(serialized_move).call }
-    end
-
-    attr_reader :serialized_actions
-
-    def initialize(serialized_move)
-      @serialized_actions = serialized_move.split(';')
-    end
-
-    def call
-      serialized_actions.flat_map { |string| action_items(*string.split(',')) }
-    end
-
-    private
-
-    def action_items(*args)
-      src_square = args.fetch(0)
-      src_square = src_square.eql?(drop_char) ? nil : Integer(src_square)
-      dst_square = Integer(args.fetch(1))
-      piece_name = args.fetch(2)
-      piece_hand = args.fetch(3, nil)
-
-      [src_square, dst_square, piece_name, piece_hand]
-    end
-
-    def drop_char
-      '*'
-    end
-  end
-end