sashite-pnn 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7647996be4986860b8e395fe0ad419a2ecc9677c43752535b54ccbbf8c046b7b
+  data.tar.gz: 3d5566a65d929b5f60169496ecaac21f41855551d415024638ba38d6e941709c
+SHA512:
+  metadata.gz: 72f349c71ce7301eb86351cbab1b83fa5c4b501528a9b28c3ddae4f24209a048a049fcd67aba4966d7184007cf228630d23e513effeccb576a8845a062dc6b39
+  data.tar.gz: 7bdc2954d3f0aa39da0b59bab6dff52967219c368559ef78c86193bb52ec89007ed85463ba4a5cbf2eb882adae10da4369c8725d2e983d5eed41090aa4dc32a9

data/LICENSE.md

@@ -0,0 +1,21 @@
+# The MIT License
+
+Copyright (c) 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,350 @@
+# Pnn.rb
+
+[![Version](https://img.shields.io/github/v/tag/sashite/pnn.rb?label=Version&logo=github)](https://github.com/sashite/pnn.rb/tags)
+[![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/sashite/pnn.rb/main)
+![Ruby](https://github.com/sashite/pnn.rb/actions/workflows/main.yml/badge.svg?branch=main)
+[![License](https://img.shields.io/github/license/sashite/pnn.rb?label=License&logo=github)](https://github.com/sashite/pnn.rb/raw/main/LICENSE.md)
+
+> **PNN** (Piece Name Notation) support for the Ruby language.
+
+## What is PNN?
+
+PNN (Piece Name Notation) extends [PIN (Piece Identifier Notation)](https://sashite.dev/specs/pin/1.0.0/) to provide style-aware piece representation in abstract strategy board games. It adds a derivation marker that distinguishes pieces by their style origin, enabling cross-style game scenarios and piece origin tracking.
+
+This gem implements the [PNN Specification v1.0.0](https://sashite.dev/specs/pnn/1.0.0/), providing a Ruby interface for working with style-aware piece representations through an intuitive object-oriented API.
+
+## Installation
+
+```ruby
+# In your Gemfile
+gem "sashite-pnn"
+```
+
+Or install manually:
+
+```sh
+gem install sashite-pnn
+```
+
+## PNN Format
+
+A PNN record consists of a [PIN](https://sashite.dev/specs/pin/1.0.0/) string with an optional derivation suffix:
+
+```
+<pin>[<suffix>]
+```
+
+Where:
+- `<pin>` is a valid PIN string (`[<state>]<letter>`)
+- `<suffix>` is an optional derivation marker (`'` for foreign style)
+
+Examples:
+- `K` - First player king with native style
+- `K'` - First player king with foreign style
+- `+R` - First player rook with enhanced state and native style
+- `+R'` - First player rook with enhanced state and foreign style
+
+## Basic Usage
+
+### Creating Piece Objects
+
+The primary interface is the `Sashite::Pnn::Piece` class, which represents a single piece in PNN format:
+
+```ruby
+require "sashite/pnn"
+
+# Parse a PNN string into a piece object
+piece = Sashite::Pnn::Piece.parse("k")
+# => #<Sashite::Pnn::Piece letter="k" native=true>
+
+# With derivation marker
+foreign_piece = Sashite::Pnn::Piece.parse("k'")
+# => #<Sashite::Pnn::Piece letter="k" native=false>
+
+# With state modifiers and derivation
+enhanced_foreign = Sashite::Pnn::Piece.parse("+k'")
+# => #<Sashite::Pnn::Piece letter="k" enhanced=true native=false>
+
+# Create directly with constructor
+piece = Sashite::Pnn::Piece.new("k")
+foreign_piece = Sashite::Pnn::Piece.new("k", native: false)
+enhanced_piece = Sashite::Pnn::Piece.new("k", enhanced: true, native: false)
+```
+
+### Converting to PNN String
+
+Convert a piece object back to its PNN string representation:
+
+```ruby
+piece = Sashite::Pnn::Piece.parse("k")
+piece.to_s
+# => "k"
+
+foreign_piece = Sashite::Pnn::Piece.parse("k'")
+foreign_piece.to_s
+# => "k'"
+
+enhanced_foreign = Sashite::Pnn::Piece.parse("+k'")
+enhanced_foreign.to_s
+# => "+k'"
+```
+
+### Style Manipulation
+
+Create new piece instances with different styles:
+
+```ruby
+piece = Sashite::Pnn::Piece.parse("k")
+
+# Convert to foreign style
+foreign = piece.foreignize
+foreign.to_s # => "k'"
+
+# Convert to native style
+native = foreign.nativize
+native.to_s # => "k"
+
+# Toggle style
+toggled = piece.toggle_style
+toggled.to_s # => "k'"
+```
+
+### State Manipulation (inherited from PIN)
+
+All PIN state manipulation methods are available:
+
+```ruby
+piece = Sashite::Pnn::Piece.parse("k")
+
+# Enhanced state (+ prefix)
+enhanced = piece.enhance
+enhanced.to_s # => "+k"
+
+# Diminished state (- prefix)
+diminished = piece.diminish
+diminished.to_s # => "-k"
+
+# Combine with style changes
+enhanced_foreign = piece.enhance.foreignize
+enhanced_foreign.to_s # => "+k'"
+```
+
+### Ownership Changes
+
+Change piece ownership (case conversion):
+
+```ruby
+white_king = Sashite::Pnn::Piece.parse("K")
+black_king = white_king.flip
+black_king.to_s # => "k"
+
+# Works with foreign pieces too
+foreign_white = Sashite::Pnn::Piece.parse("K'")
+foreign_black = foreign_white.flip
+foreign_black.to_s # => "k'"
+```
+
+## Cross-Style Game Examples
+
+### Chess vs. Shōgi Match
+
+In a hybrid game where the first player uses Chess pieces and the second player uses Shōgi pieces:
+
+```ruby
+# First player (Chess style is native)
+white_pawn = Sashite::Pnn::Piece.parse("P") # Chess pawn (native)
+white_shogi_pawn = Sashite::Pnn::Piece.parse("P'") # Shōgi pawn (foreign)
+
+# Second player (Shōgi style is native)
+black_pawn = Sashite::Pnn::Piece.parse("p") # Shōgi pawn (native)
+black_chess_pawn = Sashite::Pnn::Piece.parse("p'") # Chess pawn (foreign)
+
+# Promoted pieces with style
+promoted_shogi = Sashite::Pnn::Piece.parse("+P'") # Promoted Shōgi pawn (foreign to first player)
+```
+
+### Style Conversions During Gameplay
+
+```ruby
+# Capture and style conversion
+enemy_piece = Sashite::Pnn::Piece.parse("p'")  # Enemy's foreign piece
+captured = enemy_piece.flip.nativize           # Convert to our side with native style
+captured.to_s # => "P"
+
+# Promotion with style preservation
+pawn = Sashite::Pnn::Piece.parse("p'")         # Foreign pawn
+promoted = pawn.enhance                        # Promote while keeping foreign style
+promoted.to_s # => "+p'"
+```
+
+## Style Logic
+
+### Native vs Foreign Style
+
+- **No suffix**: Piece has the **native style** of its current side
+- **Apostrophe suffix (`'`)**: Piece has the **foreign style** (opposite side's native style)
+
+### Style Assignment
+
+```ruby
+piece = Sashite::Pnn::Piece.parse("K")
+
+# Check style
+piece.native?    # => true
+piece.foreign?   # => false
+
+# Convert styles
+foreign = piece.foreignize
+foreign.native?  # => false
+foreign.foreign? # => true
+
+native = foreign.nativize
+native.native?   # => true
+native.foreign?  # => false
+```
+
+## State Modifier Methods
+
+The `Sashite::Pnn::Piece` class inherits all PIN functionality and adds style methods:
+
+### Inherited from PIN
+| Method | Description | Example |
+|--------|-------------|---------|
+| `enhance` | Add Enhanced state (`+` prefix) | `k` → `+k` |
+| `unenhance` | Remove Enhanced state | `+k` → `k` |
+| `diminish` | Add Diminished state (`-` prefix) | `k` → `-k` |
+| `undiminish` | Remove Diminished state | `-k` → `k` |
+| `normalize` | Remove all state modifiers | `+k` → `k` |
+| `flip` | Change ownership (case) | `K` → `k`, `k` → `K` |
+
+### PNN-Specific Style Methods
+| Method | Description | Example |
+|--------|-------------|---------|
+| `foreignize` | Convert to foreign style | `k` → `k'` |
+| `nativize` | Convert to native style | `k'` → `k` |
+| `toggle_style` | Toggle between native/foreign | `k` → `k'`, `k'` → `k` |
+
+All methods return new `Sashite::Pnn::Piece` instances, leaving the original unchanged (immutable design).
+
+## API Reference
+
+### Module Methods
+
+- `Sashite::Pnn.valid?(pnn_string)` - Check if a string is valid PNN notation
+- `Sashite::Pnn.parse(pnn_string)` - Parse a PNN string into a piece object
+
+### Sashite::Pnn::Piece Class Methods
+
+- `Sashite::Pnn::Piece.parse(pnn_string)` - Parse a PNN string into a piece object
+- `Sashite::Pnn::Piece.new(letter, **options)` - Create a new piece instance
+
+### Instance Methods
+
+#### Style Queries
+- `#native?` - Check if piece has native style
+- `#foreign?` - Check if piece has foreign style
+
+#### Style Manipulation
+- `#foreignize` - Convert to foreign style
+- `#nativize` - Convert to native style
+- `#toggle_style` - Toggle between native/foreign style
+
+#### Inherited PIN Methods
+All methods from `Sashite::Pin::Piece` are available, including state queries, state manipulation, and conversion methods.
+
+#### Conversion
+- `#to_s` - Convert to PNN string representation
+- `#to_pin` - Convert to underlying PIN representation
+- `#inspect` - Detailed string representation for debugging
+
+## Examples in Common Games
+
+### Single-Style Games
+
+```ruby
+# Western Chess (both players use Chess style)
+white_king = Sashite::Pnn::Piece.parse("K")      # White king
+black_king = Sashite::Pnn::Piece.parse("k")      # Black king
+castling_rook = Sashite::Pnn::Piece.parse("+R")  # Rook that can castle
+
+# Japanese Shōgi (both players use Shōgi style)
+white_king = Sashite::Pnn::Piece.parse("K")      # White king
+promoted_pawn = Sashite::Pnn::Piece.parse("+P")  # Promoted pawn (tokin)
+```
+
+### Cross-Style Games
+
+```ruby
+# Chess vs Shōgi hybrid
+chess_queen = Sashite::Pnn::Piece.parse("Q")     # Chess queen (native to first player)
+shogi_gold = Sashite::Pnn::Piece.parse("G'")     # Shōgi gold (foreign to first player)
+shogi_king = Sashite::Pnn::Piece.parse("k")      # Shōgi king (native to second player)
+chess_knight = Sashite::Pnn::Piece.parse("n'")   # Chess knight (foreign to second player)
+```
+
+## Advanced Usage
+
+### Chaining Operations
+
+```ruby
+piece = Sashite::Pnn::Piece.parse("k")
+
+# Chain multiple operations
+result = piece.enhance.foreignize.flip
+result.to_s # => "+K'"
+
+# Complex transformations
+captured_and_converted = piece.flip.nativize.enhance
+captured_and_converted.to_s # => "+K"
+```
+
+### Validation
+
+All parsing automatically validates input according to the PNN specification:
+
+```ruby
+# Valid PNN strings
+Sashite::Pnn::Piece.parse("k")      # ✓
+Sashite::Pnn::Piece.parse("k'")     # ✓
+Sashite::Pnn::Piece.parse("+p")     # ✓
+Sashite::Pnn::Piece.parse("+p'")    # ✓
+
+# Check validity
+Sashite::Pnn.valid?("k'") # => true
+Sashite::Pnn.valid?("invalid") # => false
+
+# Invalid PNN strings raise ArgumentError
+Sashite::Pnn::Piece.parse("")        # ✗ ArgumentError
+Sashite::Pnn::Piece.parse("k''")     # ✗ ArgumentError
+Sashite::Pnn::Piece.parse("++k")     # ✗ ArgumentError
+```
+
+## Properties of PNN
+
+* **PIN compatibility**: All valid PIN strings are valid PNN strings
+* **Style awareness**: Distinguishes pieces by their style origin
+* **Rule-agnostic**: PNN does not encode legality, validity, or game-specific conditions
+* **Cross-tradition support**: Enables hybrid game scenarios
+* **Immutable objects**: All operations return new instances, ensuring thread safety
+* **Compact format**: Minimal overhead (single character suffix for style)
+
+## Constraints
+
+* PNN inherits all PIN constraints (two players, 26 piece types maximum)
+* Each side must have a defined native style
+* Style assignment is rule-dependent and remains fixed throughout the match
+* Foreign style pieces represent adoption of the opponent's style system
+
+## Documentation
+
+- [Official PNN Specification](https://sashite.dev/specs/pnn/1.0.0/)
+- [PIN Specification](https://sashite.dev/specs/pin/1.0.0/)
+- [API Documentation](https://rubydoc.info/github/sashite/pnn.rb/main)
+
+## License
+
+Available as open source under the [MIT License](https://opensource.org/licenses/MIT).
+
+## About
+
+Maintained by [Sashité](https://sashite.com/) — promoting chess variants and sharing the beauty of board game cultures.

data/lib/sashite/pnn/piece.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "sashite/pin"
+
+module Sashite
+  module Pnn
+    # Represents a piece in PNN (Piece Name Notation) format.
+    #
+    # Extends PIN::Piece to add style awareness through derivation markers.
+    # A PNN piece consists of a PIN string with an optional derivation suffix:
+    # - No suffix: native style
+    # - Apostrophe suffix ('): foreign style
+    #
+    # All instances are immutable - style manipulation methods return new instances.
+    class Piece < ::Sashite::Pin::Piece
+      # PNN validation pattern extending PIN
+      PNN_PATTERN = /\A(?<prefix>[-+])?(?<letter>[a-zA-Z])(?<suffix>'?)\z/
+
+      # Derivation marker for foreign style
+      FOREIGN_SUFFIX = "'"
+
+      # Error messages
+      ERROR_INVALID_PNN = "Invalid PNN string: %s"
+      ERROR_INVALID_NATIVE = "Native must be true or false: %s"
+
+      # @return [Boolean] whether the piece has native style
+      attr_reader :native
+      alias native? native
+
+      # Create a new piece instance with style information
+      #
+      # @param letter [String] single ASCII letter (a-z or A-Z)
+      # @param native [Boolean] whether the piece has native style
+      # @raise [ArgumentError] if parameters are invalid
+      def initialize(letter, native: true, **)
+        raise ::ArgumentError, format(ERROR_INVALID_NATIVE, native) unless [true, false].include?(native)
+
+        @native = native
+        super(letter, **)
+      end
+
+      # Parse a PNN string into a Piece object
+      #
+      # @param pnn_string [String] PNN notation string
+      # @return [Piece] new piece instance
+      # @raise [ArgumentError] if the PNN string is invalid
+      # @example
+      #   Pnn::Piece.parse("k")     # => #<Pnn::Piece letter="k" native=true>
+      #   Pnn::Piece.parse("k'")    # => #<Pnn::Piece letter="k" native=false>
+      #   Pnn::Piece.parse("+R'")   # => #<Pnn::Piece letter="R" enhanced=true native=false>
+      def self.parse(pnn_string)
+        string_value = String(pnn_string)
+        matches = match_pattern(string_value)
+
+        letter = matches[:letter]
+        enhanced = matches[:prefix] == ENHANCED_PREFIX
+        diminished = matches[:prefix] == DIMINISHED_PREFIX
+        native = matches[:suffix] != FOREIGN_SUFFIX
+
+        new(
+          letter,
+          native:     native,
+          enhanced:   enhanced,
+          diminished: diminished
+        )
+      end
+
+      # Convert the piece to its PNN string representation
+      #
+      # @return [String] PNN notation string
+      # @example
+      #   piece.to_s  # => "k"
+      #   piece.to_s  # => "k'"
+      #   piece.to_s  # => "+R'"
+      def to_s
+        pin_string = super
+        suffix = native? ? "" : FOREIGN_SUFFIX
+        "#{pin_string}#{suffix}"
+      end
+
+      # Convert the piece to its underlying PIN representation
+      #
+      # @return [String] PIN notation string without style information
+      def to_pin
+        nativize.to_s
+      end
+
+      # Check if the piece has foreign style
+      #
+      # @return [Boolean] true if foreign style
+      def foreign?
+        !native?
+      end
+
+      # Create a new piece with native style
+      #
+      # @return [Piece] new piece instance with native style
+      # @example
+      #   piece.nativize  # k' => k
+      def nativize
+        return self if native?
+
+        self.class.new(
+          letter,
+          native:     true,
+          enhanced:   enhanced?,
+          diminished: diminished?
+        )
+      end
+
+      # Create a new piece with foreign style
+      #
+      # @return [Piece] new piece instance with foreign style
+      # @example
+      #   piece.foreignize  # k => k'
+      def foreignize
+        return self if foreign?
+
+        self.class.new(
+          letter,
+          native:     false,
+          enhanced:   enhanced?,
+          diminished: diminished?
+        )
+      end
+
+      # Create a new piece with toggled style
+      #
+      # @return [Piece] new piece instance with opposite style
+      # @example
+      #   piece.toggle_style  # k => k', k' => k
+      def toggle_style
+        native? ? foreignize : nativize
+      end
+
+      # Override parent methods to maintain PNN type in return values
+
+      def enhance
+        return self if enhanced?
+
+        self.class.new(
+          letter,
+          native:     native?,
+          enhanced:   true,
+          diminished: false
+        )
+      end
+
+      def unenhance
+        return self unless enhanced?
+
+        self.class.new(
+          letter,
+          native:     native?,
+          enhanced:   false,
+          diminished: diminished?
+        )
+      end
+
+      def diminish
+        return self if diminished?
+
+        self.class.new(
+          letter,
+          native:     native?,
+          enhanced:   false,
+          diminished: true
+        )
+      end
+
+      def undiminish
+        return self unless diminished?
+
+        self.class.new(
+          letter,
+          native:     native?,
+          enhanced:   enhanced?,
+          diminished: false
+        )
+      end
+
+      def normalize
+        return self if normal?
+
+        self.class.new(
+          letter,
+          native: native?
+        )
+      end
+
+      def flip
+        flipped_letter = letter.swapcase
+
+        self.class.new(
+          flipped_letter,
+          native:     native?,
+          enhanced:   enhanced?,
+          diminished: diminished?
+        )
+      end
+
+      # Custom equality comparison including style
+      #
+      # @param other [Object] object to compare with
+      # @return [Boolean] true if pieces are equal
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        super && native? == other.native?
+      end
+
+      # Custom hash implementation including style
+      #
+      # @return [Integer] hash value
+      def hash
+        [super, @native].hash
+      end
+
+      # Match PNN pattern against string
+      #
+      # @param string [String] string to match
+      # @return [MatchData] match data
+      # @raise [ArgumentError] if string doesn't match
+      def self.match_pattern(string)
+        matches = PNN_PATTERN.match(string)
+        return matches if matches
+
+        raise ::ArgumentError, format(ERROR_INVALID_PNN, string)
+      end
+
+      private_class_method :match_pattern
+    end
+  end
+end

data/lib/sashite/pnn.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "pnn/piece"
+
+module Sashite
+  # PNN (Piece Name Notation) implementation for Ruby
+  #
+  # Extends PIN to provide style-aware piece representation in abstract strategy board games.
+  # PNN adds a derivation marker that distinguishes pieces by their style origin, enabling
+  # cross-style game scenarios and piece origin tracking.
+  #
+  # Format: <pin>[<suffix>]
+  # - PIN component: [<state>]<letter> (state modifier + letter)
+  # - Suffix: "'" for foreign style, none for native style
+  #
+  # Examples:
+  #   "K"   - First player king (native style)
+  #   "K'"  - First player king (foreign style)
+  #   "+R"  - First player rook, enhanced state (native style)
+  #   "+R'" - First player rook, enhanced state (foreign style)
+  #   "-p'" - Second player pawn, diminished state (foreign style)
+  #
+  # See: https://sashite.dev/specs/pnn/1.0.0/
+  module Pnn
+    # Regular expression for PNN validation
+    # Matches: optional state modifier, letter, optional derivation marker
+    PNN_REGEX = /\A[-+]?[A-Za-z]'?\z/
+
+    # Check if a string is a valid PNN notation
+    #
+    # @param pnn [String] The string to validate
+    # @return [Boolean] true if valid PNN, false otherwise
+    #
+    # @example
+    #   Sashite::Pnn.valid?("K")    # => true
+    #   Sashite::Pnn.valid?("K'")   # => true
+    #   Sashite::Pnn.valid?("+R'")  # => true
+    #   Sashite::Pnn.valid?("-p'")  # => true
+    #   Sashite::Pnn.valid?("K''")  # => false
+    #   Sashite::Pnn.valid?("++K'") # => false
+    def self.valid?(pnn)
+      return false unless pnn.is_a?(::String)
+
+      pnn.match?(PNN_REGEX)
+    end
+
+    # Parse a PNN string into a Piece object
+    #
+    # @param pnn_string [String] PNN notation string
+    # @return [Pnn::Piece] new piece instance
+    # @raise [ArgumentError] if the PNN string is invalid
+    # @example
+    #   Sashite::Pnn.parse("K")     # => #<Pnn::Piece letter="K" native=true>
+    #   Sashite::Pnn.parse("K'")    # => #<Pnn::Piece letter="K" native=false>
+    #   Sashite::Pnn.parse("+R'")   # => #<Pnn::Piece letter="R" enhanced=true native=false>
+    def self.parse(pnn_string)
+      Piece.parse(pnn_string)
+    end
+  end
+end

data/lib/sashite-pnn.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Sashité namespace for board game notation libraries
+module Sashite
+  # Piece Name Notation (PNN) implementation for Ruby
+  #
+  # PNN extends PIN (Piece Identifier Notation) to provide style-aware piece
+  # representation in abstract strategy board games. PNN adds a derivation marker
+  # that distinguishes pieces by their style origin, enabling cross-style game
+  # scenarios and piece origin tracking.
+  #
+  # Format: <pin>[<suffix>]
+  # - PIN component: [<state>]<letter> (from PIN specification)
+  # - Suffix: "'" for foreign style, none for native style
+  #
+  # @see https://sashite.dev/specs/pnn/1.0.0/ PNN Specification v1.0.0
+  # @see https://sashite.dev/specs/pin/1.0.0/ PIN Specification v1.0.0
+  # @author Sashité
+end
+
+require_relative "sashite/pnn"

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: sashite-pnn
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cyril Kato
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sashite-pin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: A clean, immutable Ruby interface for working with piece identifiers
+  in PNN format. PNN extends PIN notation to provide style-aware piece representation
+  with derivation markers for cross-style games. Features include all four fundamental
+  piece attributes (type, side, state, style), enabling hybrid game scenarios and
+  piece origin tracking. Perfect for game engines, analysis tools, and cross-tradition
+  board game applications.
+email: contact@cyril.email
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/sashite-pnn.rb
+- lib/sashite/pnn.rb
+- lib/sashite/pnn/piece.rb
+homepage: https://github.com/sashite/pnn.rb
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/sashite/pnn.rb/issues
+  documentation_uri: https://rubydoc.info/github/sashite/pnn.rb/main
+  homepage_uri: https://github.com/sashite/pnn.rb
+  source_code_uri: https://github.com/sashite/pnn.rb
+  specification_uri: https://sashite.dev/specs/pnn/1.0.0/
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Modern Ruby implementation of Piece Name Notation (PNN) for abstract strategy
+  games.
+test_files: []