sashite-pan 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddc5404d30aecb881216eeeda12f98c7295f8dd415302f343c8ac0d0434a7289
-  data.tar.gz: a70d32986e8e6c1f90dedd8039562089e1f40b8c64a4dcfb518f0bfdd0592904
+  metadata.gz: eec6ed9599bc268e1ef620b16fb261435b718bd6f95be8b74d82d31047caaf78
+  data.tar.gz: 57b17727d5e48a9a749af2962caa97e7e646ea91130fa9a44bb8eedc9690f7be
 SHA512:
-  metadata.gz: f1ec2c07c1e3ecfbd9dde636595c182178891217eeea5c2724c994b8e8010f2d8ae371e48a5399ef3682ef22b6f9c35550a83123b0e2035dd0603a00c1cf101c
-  data.tar.gz: ca173e3c7ecd0e49e9026a1f8b5ae9b7f8375c7d893e45b20b8ca7723e10dfe8701f4b4ef837414f2436014653b2accc2a9d2fb2b9b71cf9307c88d4840b745b
+  metadata.gz: 1f0b7ff44689f303b3555b3aad7e64b4960a3f1f9a51ed7830312a2110536e9ff834f448c3145271a2206d60669374cab1b1a0637317bc7d391e8a93de3c3dba
+  data.tar.gz: c14bcb71d0703847b7c073c30cb66ea2c785502daf21ecf08cc384576849795944f06df6142d11dde9c09fa1efca612078445a17de255af2cdd4975e076f5e2f

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2020 Cyril Kato
+Copyright (c) 2014-2025 Cyril Kato
 
 MIT License
 

data/README.md

@@ -1,78 +1,296 @@
-# Portable Action Notation
+# Pan.rb
 
-A Ruby interface for data serialization in [PAN](https://developer.sashite.com/specs/portable-action-notation) format.
+[![Version](https://img.shields.io/github/v/tag/sashite/pan.rb?label=Version&logo=github)](https://github.com/sashite/pan.rb/tags)
+[![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/sashite/pan.rb/main)
+![Ruby](https://github.com/sashite/pan.rb/actions/workflows/main.yml/badge.svg?branch=main)
+[![License](https://img.shields.io/github/license/sashite/pan.rb?label=License&logo=github)](https://github.com/sashite/pan.rb/raw/main/LICENSE.md)
 
-## Installation
+> **PAN** (Portable Action Notation) support for the Ruby language.
+
+## What is PAN?
+
+PAN (Portable Action Notation) is a compact, string-based format for representing **executed moves** in abstract strategy board games. PAN serves as a human-readable and space-efficient alternative to PMN (Portable Move Notation), expressing the same semantic information in a condensed textual format.
+
+While PMN uses JSON arrays to describe move sequences, PAN encodes the same information using a delimited string format that is easier to read, write, and transmit in contexts where JSON overhead is undesirable.
 
-Add this line to your application's Gemfile:
+This gem implements the [PAN Specification v1.0.0](https://sashite.dev/documents/pan/1.0.0/), providing a Ruby interface for:
+
+- Converting between PAN strings and PMN format
+- Parsing PAN strings into structured move data
+- Creating PAN strings from move components
+- Validating PAN strings according to the specification
+
+## Installation
 
 ```ruby
-gem 'sashite-pan'
+# In your Gemfile
+gem "sashite-pan"
+```
+
+Or install manually:
+
+```sh
+gem install sashite-pan
+```
+
+## PAN Format
+
+A PAN string represents one or more **actions** that constitute a complete move in a game. The format structure is:
+
+### Single Action
+
 ```
+<source>,<destination>,<piece>[,<hand_piece>]
+```
+
+### Multiple Actions
 
-And then execute:
+```
+<action1>;<action2>[;<action3>...]
+```
 
-    $ bundle
+Where:
 
-Or install it yourself as:
+- **source**: Origin square label, or `*` for drops from hand
+- **destination**: Target square label
+- **piece**: Piece being moved (PNN format with optional modifiers)
+- **hand_piece**: Optional piece added to mover's hand (captures, promotions)
 
-    $ gem install sashite-pan
+## Basic Usage
 
-## Usage
+### Parsing PAN Strings
 
-Working with PAN can be very simple, for example:
+Convert a PAN string into PMN format (array of action hashes):
 
 ```ruby
-require 'sashite/pan'
+require "sashite-pan"
+
+# Simple move
+result = Sashite::Pan.parse("27,18,+P")
+# => [{"src_square"=>"27", "dst_square"=>"18", "piece_name"=>"+P"}]
+
+# Capture with hand piece
+result = Sashite::Pan.parse("36,27,B,P")
+# => [{"src_square"=>"36", "dst_square"=>"27", "piece_name"=>"B", "piece_hand"=>"P"}]
+
+# Drop from hand
+result = Sashite::Pan.parse("*,27,p")
+# => [{"src_square"=>nil, "dst_square"=>"27", "piece_name"=>"p"}]
+
+# Multiple actions (castling)
+result = Sashite::Pan.parse("e1,g1,K;h1,f1,R")
+# => [
+#   {"src_square"=>"e1", "dst_square"=>"g1", "piece_name"=>"K"},
+#   {"src_square"=>"h1", "dst_square"=>"f1", "piece_name"=>"R"}
+# ]
+```
+
+### Safe Parsing
 
-# Emit a PAN string
+Parse a PAN string without raising exceptions:
+
+```ruby
+require "sashite-pan"
 
-actions = [
-  [52, 36, '♙', nil]
+# Valid PAN string
+result = Sashite::Pan.safe_parse("e2,e4,P'")
+# => [{"src_square"=>"e2", "dst_square"=>"e4", "piece_name"=>"P'"}]
+
+# Invalid PAN string
+result = Sashite::Pan.safe_parse("invalid pan string")
+# => nil
+```
+
+### Creating PAN Strings
+
+Convert PMN actions (array of hashes) into a PAN string:
+
+```ruby
+require "sashite-pan"
+
+# Simple move
+pmn_actions = [{"src_square" => "27", "dst_square" => "18", "piece_name" => "+P"}]
+pan_string = Sashite::Pan.dump(pmn_actions)
+# => "27,18,+P"
+
+# Capture with hand piece
+pmn_actions = [{"src_square" => "36", "dst_square" => "27", "piece_name" => "B", "piece_hand" => "P"}]
+pan_string = Sashite::Pan.dump(pmn_actions)
+# => "36,27,B,P"
+
+# Drop from hand
+pmn_actions = [{"src_square" => nil, "dst_square" => "27", "piece_name" => "p"}]
+pan_string = Sashite::Pan.dump(pmn_actions)
+# => "*,27,p"
+
+# Multiple actions (castling)
+pmn_actions = [
+  {"src_square" => "e1", "dst_square" => "g1", "piece_name" => "K"},
+  {"src_square" => "h1", "dst_square" => "f1", "piece_name" => "R"}
 ]
+pan_string = Sashite::Pan.dump(pmn_actions)
+# => "e1,g1,K;h1,f1,R"
+```
 
-Sashite::PAN.dump(*actions) # => '52,36,♙'
+### Safe Dumping
 
-# Parse a PAN string
+Create PAN strings without raising exceptions:
 
-Sashite::PAN.parse('52,36,♙') # => [[52, 36, '♙', nil]]
+```ruby
+require "sashite-pan"
+
+# Valid PMN data
+pmn_actions = [{"src_square" => "e2", "dst_square" => "e4", "piece_name" => "P"}]
+result = Sashite::Pan.safe_dump(pmn_actions)
+# => "e2,e4,P"
+
+# Invalid PMN data
+invalid_data = [{"invalid" => "data"}]
+result = Sashite::Pan.safe_dump(invalid_data)
+# => nil
+```
+
+### Validation
+
+Check if a string is valid PAN notation:
+
+```ruby
+require "sashite-pan"
+
+Sashite::Pan.valid?("27,18,+P")           # => true
+Sashite::Pan.valid?("*,27,p")             # => true
+Sashite::Pan.valid?("e1,g1,K;h1,f1,R")   # => true
+
+Sashite::Pan.valid?("")                   # => false
+Sashite::Pan.valid?("invalid")            # => false
+Sashite::Pan.valid?("27,18")              # => false (missing piece)
 ```
 
 ## Examples
 
+### Shogi Examples
+
 ```ruby
-# Black castles on king-side
+require "sashite-pan"
 
-Sashite::PAN.dump([60, 62, '♔', nil], [63, 61, '♖', nil]) # => '60,62,♔;63,61,♖'
-Sashite::PAN.parse('60,62,♔;63,61,♖') # => [[60, 62, '♔', nil], [63, 61, '♖', nil]]
+# Pawn promotion
+Sashite::Pan.parse("27,18,+P")
+# => [{"src_square"=>"27", "dst_square"=>"18", "piece_name"=>"+P"}]
 
-# Promoting a chess pawn into a knight
+# Bishop captures promoted pawn
+Sashite::Pan.parse("36,27,B,P")
+# => [{"src_square"=>"36", "dst_square"=>"27", "piece_name"=>"B", "piece_hand"=>"P"}]
 
-Sashite::PAN.dump([12, 4, '♘', nil]) # => '12,4,♘'
-Sashite::PAN.parse('12,4,♘') # => [[12, 4, '♘', nil]]
+# Drop pawn from hand
+Sashite::Pan.parse("*,27,p")
+# => [{"src_square"=>nil, "dst_square"=>"27", "piece_name"=>"p"}]
+```
 
-# Capturing a rook and promoting a shogi pawn
+### Chess Examples
 
-Sashite::PAN.dump([33, 24, '+P', 'R']) # => '33,24,+P,R'
-Sashite::PAN.parse('33,24,+P,R') # => [[33, 24, '+P', 'R']]
+```ruby
+require "sashite-pan"
+
+# Kingside castling
+Sashite::Pan.parse("e1,g1,K;h1,f1,R")
+# => [
+#   {"src_square"=>"e1", "dst_square"=>"g1", "piece_name"=>"K"},
+#   {"src_square"=>"h1", "dst_square"=>"f1", "piece_name"=>"R"}
+# ]
+
+# Pawn with state modifier (can be captured en passant)
+Sashite::Pan.parse("e2,e4,P'")
+# => [{"src_square"=>"e2", "dst_square"=>"e4", "piece_name"=>"P'"}]
+
+# En passant capture (multi-step)
+Sashite::Pan.parse("d4,e3,p;e3,e4,p")
+# => [
+#   {"src_square"=>"d4", "dst_square"=>"e3", "piece_name"=>"p"},
+#   {"src_square"=>"e3", "dst_square"=>"e4", "piece_name"=>"p"}
+# ]
+```
 
-# Dropping a shogi pawn
+## Integration with PMN
 
-Sashite::PAN.dump([nil, 42, 'P', nil]) # => '*,42,P'
-Sashite::PAN.parse('*,42,P') # => [[nil, 42, 'P', nil]]
+PAN is designed to work seamlessly with PMN (Portable Move Notation). You can easily convert between the two formats:
 
-# Capturing a white chess pawn en passant
+```ruby
+require "sashite-pan"
+require "portable_move_notation"
+
+# Start with a PAN string
+pan_string = "e2,e4,P';d7,d5,p"
+
+# Convert to PMN format
+pmn_actions = Sashite::Pan.parse(pan_string)
+# => [
+#   {"src_square"=>"e2", "dst_square"=>"e4", "piece_name"=>"P'"},
+#   {"src_square"=>"d7", "dst_square"=>"d5", "piece_name"=>"p"}
+# ]
+
+# Use with PMN library
+move = PortableMoveNotation::Move.new(*pmn_actions.map { |action|
+  PortableMoveNotation::Action.new(**action.transform_keys(&:to_sym))
+})
+
+# Convert back to PAN
+new_pan_string = Sashite::Pan.dump(pmn_actions)
+# => "e2,e4,P';d7,d5,p"
+```
+
+## Use Cases
+
+PAN is optimal for:
+
+- **Move logging and game records**: Compact storage of game moves
+- **Network transmission**: Efficient move data transmission
+- **Command-line interfaces**: Human-readable move input/output
+- **Quick manual entry**: Easy to type and edit move sequences
+- **Storage optimization**: Space-efficient alternative to JSON
+
+PMN is optimal for:
+
+- **Programmatic analysis**: Complex move processing and validation
+- **JSON-based systems**: Direct integration with JSON APIs
+- **Structured data processing**: Schema validation and type checking
+
+## Properties of PAN
 
-Sashite::PAN.dump([33, 32, '♟', nil], [32, 40, '♟', nil]) # => '33,32,♟;32,40,♟'
-Sashite::PAN.parse('33,32,♟;32,40,♟') # => [[33, 32, '♟', nil], [32, 40, '♟', nil]]
+- **Rule-agnostic**: PAN does not encode legality, validity, or game-specific conditions
+- **Space-efficient**: Significantly more compact than equivalent JSON representation
+- **Human-readable**: Easy to read, write, and understand
+- **Lossless conversion**: Perfect bidirectional conversion with PMN format
+
+## Error Handling
+
+The library provides detailed error messages for invalid input:
+
+```ruby
+require "sashite-pan"
+
+begin
+  Sashite::Pan.parse("invalid,pan")  # Missing piece component
+rescue Sashite::Pan::Parser::Error => e
+  puts e.message  # => "Action must have at least 3 components (source, destination, piece)"
+end
+
+begin
+  Sashite::Pan.dump([{"invalid" => "data"}])  # Missing required fields
+rescue Sashite::Pan::Dumper::Error => e
+  puts e.message  # => "Action must have dst_square"
+end
 ```
 
-## License
+## Documentation
+
+- [Official PAN Specification](https://sashite.dev/documents/pan/1.0.0/)
+- [API Documentation](https://rubydoc.info/github/sashite/pan.rb/main)
+- [PMN Specification](https://sashite.dev/documents/pmn/1.0.0/)
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+## License
 
-## About Sashite
+The [gem](https://rubygems.org/gems/sashite-pan) is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-The `sashite-pan` 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/sashite/pan/dumper/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sashite
+  module Pan
+    module Dumper
+      # Error raised when PAN dumping fails
+      class Error < ::StandardError
+      end
+    end
+  end
+end

data/lib/sashite/pan/dumper.rb

@@ -1,33 +1,80 @@
 # frozen_string_literal: true
 
-require_relative 'action'
+require_relative "dumper/error"
 
 module Sashite
-  module PAN
-    # Dumper class
-    class Dumper < Action
-      def self.call(*actions)
-        actions.map { |action_items| new(*action_items).call }
-               .join(separator)
+  module Pan
+    # Dumper for converting PMN format to PAN strings
+    module Dumper
+      # Convert PMN actions to PAN string
+      #
+      # @param pmn_actions [Array<Hash>] Array of PMN action objects
+      # @return [String] PAN string representation
+      # @raise [Dumper::Error] If the PMN data is invalid
+      def self.call(pmn_actions)
+        raise Dumper::Error, "PMN actions cannot be nil" if pmn_actions.nil?
+        raise Dumper::Error, "PMN actions cannot be empty" if pmn_actions.empty?
+        raise Dumper::Error, "PMN actions must be an array" unless pmn_actions.is_a?(::Array)
+
+        pmn_actions.map { |action| dump_action(action) }.join(";")
       end
 
-      def initialize(src_square, dst_square, piece_name, piece_hand)
-        @src_square = src_square.nil? ? drop_char : Integer(src_square)
-        @dst_square = Integer(dst_square)
-        @piece_name = piece_name.to_s
-        @piece_hand = piece_hand&.to_s
+      private
+
+      # Convert a single PMN action to PAN format
+      #
+      # @param action [Hash] PMN action object
+      # @return [String] PAN action string
+      # @raise [Dumper::Error] If the action is invalid
+      def self.dump_action(action)
+        validate_pmn_action(action)
+
+        components = [
+          dump_source_square(action["src_square"]),
+          action["dst_square"],
+          action["piece_name"]
+        ]
+
+        components << action["piece_hand"] if action["piece_hand"]
+
+        components.join(",")
       end
 
-      def call
-        action_items.join(separator)
+      # Validate PMN action structure
+      #
+      # @param action [Hash] PMN action to validate
+      # @raise [Dumper::Error] If action is invalid
+      def self.validate_pmn_action(action)
+        raise Dumper::Error, "Action must be a Hash" unless action.is_a?(::Hash)
+        raise Dumper::Error, "Action must have dst_square" unless action.key?("dst_square")
+        raise Dumper::Error, "Action must have piece_name" unless action.key?("piece_name")
+
+        raise Dumper::Error, "dst_square cannot be nil or empty" if action["dst_square"].nil? || action["dst_square"].empty?
+        raise Dumper::Error, "piece_name cannot be nil or empty" if action["piece_name"].nil? || action["piece_name"].empty?
+
+        validate_piece_identifier(action["piece_name"])
+        validate_piece_identifier(action["piece_hand"]) if action["piece_hand"]
       end
 
-      private
+      # Convert source square, handling drops
+      #
+      # @param src_square [String, nil] Source square or nil for drop
+      # @return [String] "*" for drops, otherwise the square identifier
+      def self.dump_source_square(src_square)
+        src_square.nil? ? "*" : src_square
+      end
 
-      def action_items
-        return [src_square, dst_square, piece_name] if piece_hand.nil?
+      # Validate piece identifier follows PNN specification
+      #
+      # @param piece [String] Piece identifier to validate
+      # @raise [Dumper::Error] If piece identifier is invalid
+      def self.validate_piece_identifier(piece)
+        return if piece.nil?
 
-        [src_square, dst_square, piece_name, piece_hand]
+        # PNN pattern: optional prefix (+/-), letter (a-z/A-Z), optional suffix (')
+        unless piece.match?(/\A[-+]?[a-zA-Z][']?\z/)
+          raise Dumper::Error, "Invalid piece identifier: #{piece}"
+        end
       end
     end
   end

data/lib/sashite/pan/parser/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sashite
+  module Pan
+    module Parser
+      # Error raised when PAN parsing fails
+      class Error < ::StandardError
+      end
+    end
+  end
+end

data/lib/sashite/pan/parser.rb

@@ -1,27 +1,89 @@
 # frozen_string_literal: true
 
-require_relative 'action'
+require_relative "parser/error"
 
 module Sashite
-  module PAN
-    # Parser class
-    class Parser < Action
-      def self.call(serialized_move)
-        serialized_move.split(separator)
-                       .map { |serialized_action| new(serialized_action).call }
+  module Pan
+    # Parser for Portable Action Notation (PAN) strings
+    module Parser
+      # Parse a PAN string into PMN format
+      #
+      # @param pan_string [String] The PAN string to parse
+      # @return [Array<Hash>] Array of PMN action objects
+      # @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 cannot be empty" if pan_string.empty?
+
+        actions = pan_string.split(";").map(&:strip)
+        raise Parser::Error, "No actions found" if actions.empty?
+
+        actions.map { |action| parse_action(action) }
+      end
+
+      private
+
+      # Parse a single action string into a PMN action hash
+      #
+      # @param action_string [String] Single action in PAN format
+      # @return [Hash] PMN action object
+      # @raise [Parser::Error] If the action is invalid
+      def self.parse_action(action_string)
+        components = action_string.split(",").map(&:strip)
+
+        validate_action_components(components)
+
+        {
+          "src_square" => parse_source_square(components[0]),
+          "dst_square" => components[1],
+          "piece_name" => components[2],
+          "piece_hand" => components[3] || nil
+        }.compact
+      end
+
+      # Validate action components structure
+      #
+      # @param components [Array<String>] Components of the action
+      # @raise [Parser::Error] If components are invalid
+      def self.validate_action_components(components)
+        case components.length
+        when 0, 1, 2
+          raise Parser::Error, "Action must have at least 3 components (source, destination, piece)"
+        when 3, 4
+          # Valid number of components
+        else
+          raise Parser::Error, "Action cannot have more than 4 components"
+        end
+
+        components.each_with_index do |component, index|
+          if component.nil? || component.empty?
+            raise Parser::Error, "Component #{index} cannot be empty"
+          end
+        end
+
+        validate_piece_identifier(components[2])
+        validate_piece_identifier(components[3]) if components[3]
       end
 
-      def initialize(serialized_action)
-        action_args = serialized_action.split(separator)
-        src_square  = action_args.fetch(0)
-        @src_square = src_square.eql?(drop_char) ? nil : Integer(src_square)
-        @dst_square = Integer(action_args.fetch(1))
-        @piece_name = action_args.fetch(2)
-        @piece_hand = action_args.fetch(3, nil)
+      # Parse source square, handling drop notation
+      #
+      # @param source [String] Source square or "*" for drop
+      # @return [String, nil] Square identifier or nil for drops
+      def self.parse_source_square(source)
+        source == "*" ? nil : source
       end
 
-      def call
-        [src_square, dst_square, piece_name, piece_hand]
+      # Validate piece identifier follows PNN specification
+      #
+      # @param piece [String] Piece identifier to validate
+      # @raise [Parser::Error] If piece identifier is invalid
+      def self.validate_piece_identifier(piece)
+        return if piece.nil?
+
+        # PNN pattern: optional prefix (+/-), letter (a-z/A-Z), optional suffix (')
+        unless piece.match?(/\A[-+]?[a-zA-Z][']?\z/)
+          raise Parser::Error, "Invalid piece identifier: #{piece}"
+        end
       end
     end
   end

data/lib/sashite/pan.rb

@@ -1,17 +1,61 @@
 # frozen_string_literal: true
 
+require_relative "pan/dumper"
+require_relative "pan/parser"
+
 module Sashite
   # The PAN (Portable Action Notation) module
-  module PAN
-    def self.dump(*actions)
-      Dumper.call(*actions)
+  module Pan
+    # Main interface for PAN operations
+    module_function
+
+    # Parse a PAN string into PMN format
+    #
+    # @param pan_string [String] The PAN string to parse
+    # @return [Array<Hash>] Array of PMN action objects
+    # @raise [Parser::Error] If the PAN string is invalid
+    def parse(pan_string)
+      Parser.call(pan_string)
     end
 
-    def self.parse(string)
-      Parser.call(string)
+    # Convert PMN actions to PAN string
+    #
+    # @param pmn_actions [Array<Hash>] Array of PMN action objects
+    # @return [String] PAN string representation
+    # @raise [Dumper::Error] If the PMN data is invalid
+    def dump(pmn_actions)
+      Dumper.call(pmn_actions)
+    end
+
+    # Validate a PAN string without raising exceptions
+    #
+    # @param pan_string [String] The PAN string to validate
+    # @return [Boolean] True if valid, false otherwise
+    def valid?(pan_string)
+      parse(pan_string)
+      true
+    rescue Parser::Error
+      false
+    end
+
+    # Parse a PAN string without raising exceptions
+    #
+    # @param pan_string [String] The PAN string to parse
+    # @return [Array<Hash>, nil] Array of PMN actions or nil if invalid
+    def safe_parse(pan_string)
+      parse(pan_string)
+    rescue Parser::Error
+      nil
+    end
+
+    # Convert PMN actions to PAN string without raising exceptions
+    #
+    # @param pmn_actions [Array<Hash>] Array of PMN action objects
+    # @return [String, nil] PAN string or nil if invalid
+    def safe_dump(pmn_actions)
+      dump(pmn_actions)
+    rescue Dumper::Error
+      nil
     end
   end
 end
-
-require_relative 'pan/dumper'
-require_relative 'pan/parser'

data/lib/sashite-pan.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-# Sashite namespace
-module Sashite; end
+# Sashité namespace
+module Sashite
+end
 
-require_relative 'sashite/pan'
+require_relative "sashite/pan"

metadata

@@ -1,129 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: sashite-pan
 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-05 00:00:00.000000000 Z
-dependencies:
-- !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 PAN (Portable Action Notation)
-  format.
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby implementation of the Portable Action Notation (PAN) specification.
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -133,17 +19,20 @@ files:
 - README.md
 - lib/sashite-pan.rb
 - lib/sashite/pan.rb
-- lib/sashite/pan/action.rb
 - lib/sashite/pan/dumper.rb
+- lib/sashite/pan/dumper/error.rb
 - lib/sashite/pan/parser.rb
-homepage: https://developer.sashite.com/specs/portable-action-notation
+- lib/sashite/pan/parser/error.rb
+homepage: https://github.com/sashite/pan.rb
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/sashite/pan.rb/issues
-  documentation_uri: https://rubydoc.info/gems/sashite-pan/index
+  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
-post_install_message: 
+  specification_uri: https://sashite.dev/documents/pan/1.0.0/
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -151,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.9
 specification_version: 4
-summary: Data serialization in PAN format.
+summary: Portable Action Notation (PAN) parser and validator for Ruby
 test_files: []

data/lib/sashite/pan/action.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Sashite
-  module PAN
-    # Action class
-    class Action
-      attr_reader :src_square, :dst_square, :piece_name, :piece_hand
-
-      private_class_method def self.separator
-        ';'
-      end
-
-      private
-
-      def separator
-        ','
-      end
-
-      def drop_char
-        '*'
-      end
-    end
-  end
-end