sashite-snn 1.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3327ae1106ccede78736585e812180c12d7a56852a82ae70b7745e233ef5496
-  data.tar.gz: ba5892640791f51341e52c883f52f9f21bac64e21001052e1fcbc17965a156a7
+  metadata.gz: 517b0310bd57b5d0b931a5f14eb1c4d6257bbd6d4f215c467ff475c8b42542fc
+  data.tar.gz: 2fa5a177d6350dd2501b87eac5a567f5cf48c681439b3af23f2bae1df99579a3
 SHA512:
-  metadata.gz: 1798b7aec7b88cc2baddcd9fa7f3518c2d97bf16343caac92ec84f9bfad3dc0ac20830d95144984ea27795d867e80c008a090f9de7fc8d284ac853f9c326b144
-  data.tar.gz: a6a548c819cf763b914cc1b70ce82ba86d86b7973f0231df5075931788d19fb2732d4138896b347cf6a1842c554116578e59cdfb619408acb370c2c43d469753
+  metadata.gz: 200ef38765b8c581f93c51657699e4b420c26abe1d355227ff47892b493f787ec9c03e7202a91b9466c99c97a95a1b914837e59bb2784ef6568cc2ca3f94dd49
+  data.tar.gz: 6b01e73ad4e61246e8e61a4e0bd85f7b3f0fcb964f7532c42d6c95a2b5b665c64487e032e46cb7b77806b3a410137536812aac3278428b2c31af8d91811597ec

data/README.md

@@ -9,16 +9,16 @@
 
 ## What is SNN?
 
-SNN (Style Name Notation) provides a rule-agnostic format for identifying styles in abstract strategy board games. SNN uses standardized naming conventions with case-based side encoding, enabling clear distinction between different traditions in multi-style gaming environments.
+SNN (Style Name Notation) is a formal, rule-agnostic naming system for identifying **styles** in abstract strategy board games such as chess, shōgi, xiangqi, and their many variants. Each style is represented by a canonical, human-readable ASCII name (e.g., `"Chess"`, `"Shogi"`, `"Xiangqi"`, `"Minishogi"`).
 
-This gem implements the [SNN Specification v1.0.0](https://sashite.dev/specs/snn/1.0.0/), providing a modern Ruby interface with immutable style objects and functional programming principles.
+This gem implements the [SNN Specification v1.0.0](https://sashite.dev/specs/snn/1.0.0/), supporting validation, parsing, and comparison of style names.
 
 ## Installation
 
 ```ruby
 # In your Gemfile
 gem "sashite-snn"
-```
+````
 
 Or install manually:
 
@@ -28,426 +28,128 @@ gem install sashite-snn
 
 ## Usage
 
+### Basic Operations
+
 ```ruby
 require "sashite/snn"
 
-# Parse SNN strings into style objects
-style = Sashite::Snn.parse("CHESS")         # => #<Snn::Style name=:Chess side=:first>
-style.to_s                                  # => "CHESS"
-style.name                                  # => :Chess
-style.side                                  # => :first
+# Parse SNN strings into style name objects
+name = Sashite::Snn.parse("Shogi")             # => #<Snn::Name value="Shogi">
+name.to_s                                      # => "Shogi"
+name.value                                     # => "Shogi"
 
-# Create styles directly
-style = Sashite::Snn.style(:Chess, :first)         # => #<Snn::Style name=:Chess side=:first>
-style = Sashite::Snn::Style.new(:Shogi, :second)   # => #<Snn::Style name=:Shogi side=:second>
+# Create from string or symbol
+name = Sashite::Snn.name("Chess")              # => #<Snn::Name value="Chess">
+name = Sashite::Snn::Name.new(:Xiangqi)        # => #<Snn::Name value="Xiangqi">
 
 # Validate SNN strings
-Sashite::Snn.valid?("CHESS")                # => true
-Sashite::Snn.valid?("chess")                # => true
-Sashite::Snn.valid?("Chess")                # => false (mixed case)
-Sashite::Snn.valid?("123")                  # => false (must start with letter)
-
-# Side manipulation (returns new immutable instances)
-black_chess = style.flip                    # => #<Snn::Style name=:Chess side=:second>
-black_chess.to_s                            # => "chess"
-
-# Name manipulation
-shogi_style = style.with_name(:Shogi)       # => #<Snn::Style name=:Shogi side=:first>
-shogi_style.to_s                            # => "SHOGI"
-
-# Side queries
-style.first_player?                         # => true
-black_chess.second_player?                  # => true
-
-# Name and side comparison
-chess1 = Sashite::Snn.parse("CHESS")
-chess2 = Sashite::Snn.parse("chess")
-shogi = Sashite::Snn.parse("SHOGI")
-
-chess1.same_name?(chess2)                   # => true (both chess)
-chess1.same_side?(shogi)                    # => true (both first player)
-chess1.same_name?(shogi)                    # => false (different styles)
-
-# Functional transformations can be chained
-black_shogi = Sashite::Snn.parse("CHESS").with_name(:Shogi).flip
-black_shogi.to_s                            # => "shogi"
-```
-
-## Format Specification
-
-### Structure
-```
-<style-identifier>
+Sashite::Snn.valid?("Go9x9")                   # => true
+Sashite::Snn.valid?("chess")                   # => false (must start with uppercase)
+Sashite::Snn.valid?("3DChess")                 # => false (invalid character)
 ```
 
-### Components
-
-- **Identifier**: Alphanumeric string starting with a letter
-  - Uppercase: First player styles (`CHESS`, `SHOGI`, `XIANGQI`)
-  - Lowercase: Second player styles (`chess`, `shogi`, `xiangqi`)
-- **Case Consistency**: Entire identifier must be uppercase or lowercase (no mixed case)
-
-### Regular Expression
-```ruby
-# Pattern accessible via Sashite::Snn::Style::SNN_PATTERN
-/\A([A-Z][A-Z0-9]*|[a-z][a-z0-9]*)\z/
-```
-
-### Examples
-- `CHESS` - First player chess style
-- `chess` - Second player chess style
-- `CHESS960` - First player Fischer Random Chess style
-- `SHOGI` - First player shōgi style
-- `shogi` - Second player shōgi style
-- `XIANGQI` - First player xiangqi style
-
-## Game Examples
-
-### Classic Styles
-```ruby
-# Traditional game styles
-chess = Sashite::Snn.style(:Chess, :first)        # => traditional chess
-shogi = Sashite::Snn.style(:Shogi, :first)        # => traditional shōgi
-xiangqi = Sashite::Snn.style(:Xiangqi, :first)    # => traditional xiangqi
-makruk = Sashite::Snn.style(:Makruk, :first)      # => traditional makruk
-
-# Player variations
-white_chess = chess                               # => first player
-black_chess = chess.flip                          # => second player
-black_chess.to_s                                  # => "chess"
-```
+### Normalization and Comparison
 
-### Chess Variants
 ```ruby
-# Fischer Random Chess
-chess960_white = Sashite::Snn.style(:Chess960, :first)
-chess960_black = chess960_white.flip
-chess960_black.to_s                               # => "chess960"
+a = Sashite::Snn.parse("Chess960")
+b = Sashite::Snn.parse("Chess960")
 
-# King of the Hill Chess
-koth = Sashite::Snn.style(:Koth, :first)
-koth.to_s                                         # => "KOTH"
-
-# Three-Check Chess
-threecheck = Sashite::Snn.style(:Threecheck, :first)
+a == b                                         # => true
+a.same_base_name?(Sashite::Snn.parse("Chess")) # => true if both resolve to same SIN
+a.to_s # => "Chess960"
 ```
 
-### Shōgi Variants
-```ruby
-# Traditional Shōgi
-standard_shogi = Sashite::Snn.style(:Shogi, :first)
-
-# Mini Shōgi
-mini_shogi = Sashite::Snn.style(:Minishogi, :first)
-
-# Chu Shōgi
-chu_shogi = Sashite::Snn.style(:Chushogi, :first)
-```
+### Canonical Representation
 
-### Multi-Style Gaming
 ```ruby
-# Cross-tradition match
-def create_hybrid_match
-  styles = [
-    Sashite::Snn.style(:Chess, :first),     # White uses chess pieces
-    Sashite::Snn.style(:Shogi, :second)     # Black uses shōgi pieces
-  ]
-
-  # Each player uses their preferred piece style
-  styles
-end
-
-# Style compatibility check
-def compatible_styles?(style1, style2)
-  # Styles are compatible if they have different sides
-  !style1.same_side?(style2)
-end
-
-chess_white = Sashite::Snn.parse("CHESS")
-shogi_black = Sashite::Snn.parse("shogi")
-puts compatible_styles?(chess_white, shogi_black)  # => true
+# All names are normalized to a canonical format
+name = Sashite::Snn.parse("Minishogi")
+name.value                                    # => "Minishogi"
+name.to_s                                     # => "Minishogi"
 ```
 
-## API Reference
-
-### Main Module Methods
-
-- `Sashite::Snn.valid?(snn_string)` - Check if string is valid SNN notation
-- `Sashite::Snn.parse(snn_string)` - Parse SNN string into Style object
-- `Sashite::Snn.style(name, side)` - Create style instance directly
-
-### Style Class
-
-#### Creation and Parsing
-- `Sashite::Snn::Style.new(name, side)` - Create style instance
-- `Sashite::Snn::Style.parse(snn_string)` - Parse SNN string (same as module method)
-
-#### Attribute Access
-- `#name` - Get style name (symbol with proper capitalization)
-- `#side` - Get player side (:first or :second)
-- `#to_s` - Convert to SNN string representation
-
-#### Name and Case Handling
-
-**Important**: The `name` attribute is always stored with proper capitalization (first letter uppercase, rest lowercase), regardless of the input case when parsing. The display case in `#to_s` is determined by the `side` attribute:
+### Collections and Filtering
 
 ```ruby
-# Both create the same internal name representation
-style1 = Sashite::Snn.parse("CHESS")  # name: :Chess, side: :first
-style2 = Sashite::Snn.parse("chess")  # name: :Chess, side: :second
-
-style1.name    # => :Chess (proper capitalization)
-style2.name    # => :Chess (same capitalization)
+names = %w[Chess Shogi Makruk Antichess Minishogi].map { |n| Sashite::Snn.parse(n) }
 
-style1.to_s    # => "CHESS" (uppercase display)
-style2.to_s    # => "chess" (lowercase display)
+# Filter by prefix
+names.select { |n| n.value.start_with?("Mini") }.map(&:to_s)
+# => ["Minishogi"]
 ```
 
-#### Side Queries
-- `#first_player?` - Check if first player style
-- `#second_player?` - Check if second player style
-
-#### Transformations (immutable - return new instances)
-- `#flip` - Switch player (change side)
-- `#with_name(new_name)` - Create style with different name
-- `#with_side(new_side)` - Create style with different side
-
-#### Comparison Methods
-- `#same_name?(other)` - Check if same style name
-- `#same_side?(other)` - Check if same side
-- `#==(other)` - Full equality comparison
-
-### Style Class Constants
-
-- `Sashite::Snn::Style::FIRST_PLAYER` - Symbol for first player (:first)
-- `Sashite::Snn::Style::SECOND_PLAYER` - Symbol for second player (:second)
-- `Sashite::Snn::Style::VALID_SIDES` - Array of valid sides
-- `Sashite::Snn::Style::SNN_PATTERN` - Regular expression for SNN validation
-
-## Advanced Usage
-
-### Name Normalization Examples
-
-```ruby
-# Parsing different cases results in same name
-white_chess = Sashite::Snn.parse("CHESS")
-black_chess = Sashite::Snn.parse("chess")
-
-# Names are normalized with proper capitalization
-white_chess.name  # => :Chess
-black_chess.name  # => :Chess (same name!)
-
-# Sides are different
-white_chess.side  # => :first
-black_chess.side  # => :second
+## Format Specification
 
-# Display follows side convention
-white_chess.to_s  # => "CHESS"
-black_chess.to_s  # => "chess"
+### Structure
 
-# Same name, different sides
-white_chess.same_name?(black_chess)  # => true
-white_chess.same_side?(black_chess)  # => false
 ```
-
-### Immutable Transformations
-```ruby
-# All transformations return new instances
-original = Sashite::Snn.style(:Chess, :first)
-flipped = original.flip
-renamed = original.with_name(:Shogi)
-
-# Original style is never modified
-puts original.to_s  # => "CHESS"
-puts flipped.to_s   # => "chess"
-puts renamed.to_s   # => "SHOGI"
-
-# Transformations can be chained
-result = original.flip.with_name(:Xiangqi)
-puts result.to_s    # => "xiangqi"
+<uppercase-letter>[<lowercase-letter | digit>]*
 ```
 
-### Game Configuration Management
-```ruby
-class GameConfiguration
-  def initialize
-    @player_styles = {}
-  end
-
-  def set_player_style(player, style_name)
-    side = player == :white ? :first : :second
-    @player_styles[player] = Sashite::Snn.style(style_name, side)
-  end
+### Grammar (BNF)
 
-  def get_player_style(player)
-    @player_styles[player]
-  end
+```bnf
+<snn> ::= <uppercase-letter> <tail>
 
-  def style_mismatch?
-    return false if @player_styles.size < 2
+<tail> ::= ""                                ; Single letter (e.g., "X")
+        | <alphanumeric-char> <tail>         ; Extended name
 
-    styles = @player_styles.values
-    !styles.all? { |style| style.same_name?(styles.first) }
-  end
+<alphanumeric-char> ::= <lowercase-letter> | <digit>
 
-  def cross_tradition_match?
-    return false if @player_styles.size < 2
-
-    style_names = @player_styles.values.map(&:name).uniq
-    style_names.size > 1
-  end
-end
-
-# Usage
-config = GameConfiguration.new
-config.set_player_style(:white, :Chess)
-config.set_player_style(:black, :Shogi)
-
-puts config.cross_tradition_match?  # => true
-puts config.style_mismatch?         # => true
-
-white_style = config.get_player_style(:white)
-puts white_style.to_s               # => "CHESS"
+<uppercase-letter> ::= "A" | "B" | "C" | ... | "Z"
+<lowercase-letter> ::= "a" | "b" | "c" | ... | "z"
+<digit> ::= "0" | "1" | "2" | "3" | ... | "9"
 ```
 
-### Style Analysis
-```ruby
-def analyze_styles(snns)
-  styles = snns.map { |snn| Sashite::Snn.parse(snn) }
-
-  {
-    total: styles.size,
-    by_side: styles.group_by(&:side),
-    by_name: styles.group_by(&:name),
-    unique_names: styles.map(&:name).uniq.size,
-    cross_tradition: styles.map(&:name).uniq.size > 1
-  }
-end
-
-snns = %w[CHESS chess SHOGI shogi XIANGQI xiangqi]
-analysis = analyze_styles(snns)
-puts analysis[:by_side][:first].size   # => 3
-puts analysis[:unique_names]           # => 3
-puts analysis[:cross_tradition]        # => true
-```
+### Regular Expression
 
-### Tournament Style Management
 ```ruby
-class TournamentStyleRegistry
-  def initialize
-    @registered_styles = Set.new
-  end
-
-  def register_style(style_name)
-    # Register both sides of a style
-    first_player_style = Sashite::Snn.style(style_name, :first)
-    second_player_style = first_player_style.flip
-
-    @registered_styles.add(first_player_style)
-    @registered_styles.add(second_player_style)
-
-    [first_player_style, second_player_style]
-  end
-
-  def valid_pairing?(style1, style2)
-    @registered_styles.include?(style1) &&
-    @registered_styles.include?(style2) &&
-    !style1.same_side?(style2)
-  end
-
-  def available_styles_for_side(side)
-    @registered_styles.select { |style| style.side == side }
-  end
-
-  def supported_traditions
-    @registered_styles.map(&:name).uniq
-  end
-end
-
-# Usage
-registry = TournamentStyleRegistry.new
-registry.register_style(:Chess)
-registry.register_style(:Shogi)
-
-chess_white = Sashite::Snn.parse("CHESS")
-shogi_black = Sashite::Snn.parse("shogi")
-
-puts registry.valid_pairing?(chess_white, shogi_black)  # => true
-puts registry.supported_traditions                      # => [:Chess, :Shogi]
+/\A[A-Z][a-z0-9]*\z/
 ```
 
-## Protocol Mapping
-
-Following the [Game Protocol](https://sashite.dev/game-protocol/):
+## Design Principles
 
-| Protocol Attribute | SNN Encoding | Examples | Notes |
-|-------------------|--------------|----------|-------|
-| **Style** | Alphanumeric identifier | `CHESS`, `SHOGI`, `XIANGQI` | Name is always stored with proper capitalization |
-| **Side** | Case encoding | `CHESS` = First player, `chess` = Second player | Case is determined by side during rendering |
+* **Human-readable**: Names like `"Shogi"` or `"Chess960"` are intuitive and descriptive.
+* **Canonical**: One valid name per game style within a given context.
+* **ASCII-only**: Compatible with all systems.
+* **Scalable**: Supports unlimited distinct names for current and future game variants.
 
-**Name Convention**: All style names are internally represented with proper capitalization (first letter uppercase, rest lowercase). The display case is determined by the `side` attribute: first player styles display as uppercase, second player styles as lowercase.
+## Integration with SIN
 
-**Canonical principle**: Identical styles must have identical SNN representations.
+SNN names serve as the formal source for SIN character identifiers. For example:
 
-## Properties
+| SNN       | SIN     |
+| --------- | ------- |
+| `Chess`   | `C`/`c` |
+| `Shogi`   | `S`/`s` |
+| `Xiangqi` | `X`/`x` |
+| `Makruk`  | `M`/`m` |
 
-* **Rule-Agnostic**: Independent of specific game mechanics
-* **Cross-Style Support**: Enables multi-tradition gaming environments
-* **Canonical Representation**: Consistent naming for equivalent styles
-* **Name Normalization**: Consistent proper capitalization representation internally
-* **Immutable**: All style instances are frozen and transformations return new objects
-* **Functional**: Pure functions with no side effects
+Multiple SNN names may map to the same SIN character (e.g., `"Chess"` and `"Chess960"` both → `C`), but SNN provides unambiguous naming within broader contexts.
 
-## Implementation Notes
-
-### Name Normalization Convention
-
-SNN follows a strict name normalization convention:
-
-1. **Internal Storage**: All style names are stored with proper capitalization (first letter uppercase, rest lowercase)
-2. **Input Flexibility**: Both `"CHESS"` and `"chess"` are valid input during parsing
-3. **Case Semantics**: Input case determines the `side` attribute, not the `name`
-4. **Display Logic**: Output case is computed from `side` during rendering
-
-This design ensures:
-- Consistent internal representation regardless of input format
-- Clear separation between style identity (name) and ownership (side)
-- Predictable behavior when comparing styles of the same name
-
-### Example Flow
+## Examples
 
 ```ruby
-# Input: "chess" (lowercase)
-# ↓ Parsing
-# name: :Chess (normalized with proper capitalization)
-# side: :second (inferred from lowercase input)
-# ↓ Display
-# SNN: "chess" (final representation)
+Sashite::Snn.parse("Chess")       # => #<Snn::Name value="Chess">
+Sashite::Snn.parse("Chess960")    # => #<Snn::Name value="Chess960">
+Sashite::Snn.valid?("Minishogi")  # => true
+Sashite::Snn.valid?("miniShogi")  # => false
 ```
 
-This ensures that `parse(snn).to_s == snn` for all valid SNN strings while maintaining internal consistency.
-
-## System Constraints
-
-- **Alphanumeric identifiers** starting with a letter
-- **Exactly 2 players** (uppercase/lowercase distinction)
-- **Case consistency** within each identifier (no mixed case)
+## API Reference
 
-## Related Specifications
+### Main Module
 
-- [Game Protocol](https://sashite.dev/game-protocol/) - Conceptual foundation for abstract strategy board games
-- [PIN](https://sashite.dev/specs/pin/) - Piece Identifier Notation (ASCII piece representation)
-- [PNN](https://sashite.dev/specs/pnn/) - Piece Name Notation (style-aware piece representation)
-- [CELL](https://sashite.dev/specs/cell/) - Board position coordinates
-- [HAND](https://sashite.dev/specs/hand/) - Reserve location notation
-- [PMN](https://sashite.dev/specs/pmn/) - Portable Move Notation
+* `Sashite::Snn.valid?(str)` – Returns `true` if the string is valid SNN.
+* `Sashite::Snn.parse(str)` – Returns a `Sashite::Snn::Name` object.
+* `Sashite::Snn.name(sym_or_str)` – Alias for constructing a name.
 
-## Documentation
+### `Sashite::Snn::Name`
 
-- [Official SNN Specification v1.0.0](https://sashite.dev/specs/snn/1.0.0/)
-- [SNN Examples Documentation](https://sashite.dev/specs/snn/1.0.0/examples/)
-- [Game Protocol Foundation](https://sashite.dev/game-protocol/)
-- [API Documentation](https://rubydoc.info/github/sashite/snn.rb/main)
+* `#value` – Returns the canonical string value.
+* `#to_s` – Returns the string representation.
+* `#==`, `#eql?`, `#hash` – Value-based equality.
+* `#same_base_name?(other)` – Optional helper for SIN mapping equivalence.
 
 ## Development
 

data/lib/sashite/snn/name.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Sashite
+  module Snn
+    # Represents a style name in SNN (Style Name Notation) format.
+    #
+    # SNN provides a canonical naming system for abstract strategy game styles.
+    # Each name must start with an uppercase ASCII letter, followed by zero or more
+    # lowercase letters or digits.
+    #
+    # All instances are immutable.
+    class Name
+      # SNN validation pattern matching the specification
+      SNN_PATTERN = /\A[A-Z][a-z0-9]*\z/
+
+      # Error messages
+      ERROR_INVALID_NAME = "Invalid SNN string: %s"
+
+      # @return [String] the canonical style name
+      attr_reader :value
+
+      # Create a new style name instance
+      #
+      # @param name [String, Symbol] the style name (e.g., "Shogi", :Chess960)
+      # @raise [ArgumentError] if the name does not match SNN pattern
+      def initialize(name)
+        string_value = name.to_s
+        self.class.validate_format(string_value)
+
+        @value = string_value.freeze
+        freeze
+      end
+
+      # Parse an SNN string into a Name object
+      #
+      # @param string [String] the SNN-formatted style name
+      # @return [Name] a new Name instance
+      # @raise [ArgumentError] if the string is invalid
+      #
+      # @example
+      #   Sashite::Snn::Name.parse("Shogi") # => #<Snn::Name value="Shogi">
+      def self.parse(string)
+        new(string)
+      end
+
+      # Check whether the given string is a valid SNN name
+      #
+      # @param string [String] input string to validate
+      # @return [Boolean] true if valid, false otherwise
+      #
+      # @example
+      #   Sashite::Snn::Name.valid?("Chess")    # => true
+      #   Sashite::Snn::Name.valid?("chess")    # => false
+      def self.valid?(string)
+        string.is_a?(::String) && string.match?(SNN_PATTERN)
+      end
+
+      # Returns the string representation of the name
+      #
+      # @return [String]
+      def to_s
+        value
+      end
+
+      # Equality based on normalized string value
+      #
+      # @param other [Object]
+      # @return [Boolean]
+      def ==(other)
+        other.is_a?(self.class) && value == other.value
+      end
+
+      # Required for correct Set/hash behavior
+      alias eql? ==
+
+      # Hash based on class and value
+      #
+      # @return [Integer]
+      def hash
+        [self.class, value].hash
+      end
+
+      # Validate that the string is in proper SNN format
+      #
+      # @param str [String]
+      # @raise [ArgumentError] if invalid
+      def self.validate_format(str)
+        raise ::ArgumentError, format(ERROR_INVALID_NAME, str.inspect) unless str.match?(SNN_PATTERN)
+      end
+    end
+  end
+end

data/lib/sashite/snn.rb

@@ -1,63 +1,59 @@
 # frozen_string_literal: true
 
-require_relative "snn/style"
+require_relative "snn/name"
 
 module Sashite
   # SNN (Style Name Notation) implementation for Ruby
   #
-  # Provides a rule-agnostic format for identifying styles in abstract strategy board games.
-  # SNN uses standardized naming conventions with case-based side encoding, enabling clear
-  # distinction between different traditions in multi-style gaming environments.
+  # Provides a formal naming system for identifying styles in abstract strategy board games.
+  # SNN uses canonical, human-readable ASCII names beginning with an uppercase letter.
+  # It supports unlimited unique style identifiers with consistent, rule-agnostic semantics.
   #
-  # Format: <style-identifier>
-  # - Uppercase identifier: First player styles (CHESS, SHOGI, XIANGQI)
-  # - Lowercase identifier: Second player styles (chess, shogi, xiangqi)
-  # - Case consistency: Entire identifier must be uppercase or lowercase
+  # Format: <uppercase-letter>[<lowercase-letter | digit>]*
   #
   # Examples:
-  #   "CHESS"  - First player chess style
-  #   "chess"  - Second player chess style
-  #   "SHOGI"  - First player shōgi style
-  #   "shogi"  - Second player shōgi style
+  #   "Chess"       - Standard Western chess
+  #   "Shogi"       - Japanese chess
+  #   "Minishogi"   - 5×5 compact shōgi variant
+  #   "Chess960"    - Fischer random chess
   #
   # See: https://sashite.dev/specs/snn/1.0.0/
   module Snn
-    # Check if a string is a valid SNN notation
+    # Check if a string is valid SNN notation
     #
     # @param snn_string [String] the string to validate
     # @return [Boolean] true if valid SNN, false otherwise
     #
-    # @example Validate various SNN formats
-    #   Sashite::Snn.valid?("CHESS") # => true
-    #   Sashite::Snn.valid?("Chess") # => false
+    # @example Validate SNN strings
+    #   Sashite::Snn.valid?("Chess")     # => true
+    #   Sashite::Snn.valid?("minishogi") # => false
+    #   Sashite::Snn.valid?("Go9x9")     # => true
     def self.valid?(snn_string)
-      Style.valid?(snn_string)
+      Name.valid?(snn_string)
     end
 
-    # Parse an SNN string into a Style object
+    # Parse an SNN string into a Name object
     #
-    # @param snn_string [String] SNN notation string
-    # @return [Snn::Style] parsed style object with name and side attributes
-    # @raise [ArgumentError] if the SNN string is invalid
-    # @example Parse different SNN formats
-    #   Sashite::Snn.parse("CHESS") # => #<Snn::Style name=:Chess side=:first>
-    #   Sashite::Snn.parse("chess") # => #<Snn::Style name=:Chess side=:second>
-    #   Sashite::Snn.parse("SHOGI") # => #<Snn::Style name=:Shogi side=:first>
+    # @param snn_string [String] the name string
+    # @return [Snn::Name] a parsed name object
+    # @raise [ArgumentError] if the name is invalid
+    #
+    # @example Parse valid SNN names
+    #   Sashite::Snn.parse("Shogi")    # => #<Snn::Name value="Shogi">
     def self.parse(snn_string)
-      Style.parse(snn_string)
+      Name.parse(snn_string)
     end
 
-    # Create a new style instance
+    # Create a new Name instance directly
+    #
+    # @param value [String, Symbol] style name to construct
+    # @return [Snn::Name] new name instance
+    # @raise [ArgumentError] if name format is invalid
     #
-    # @param name [Symbol] style name (with proper capitalization)
-    # @param side [Symbol] player side (:first or :second)
-    # @return [Snn::Style] new immutable style instance
-    # @raise [ArgumentError] if parameters are invalid
-    # @example Create styles directly
-    #   Sashite::Snn.style(:Chess, :first)  # => #<Snn::Style name=:Chess side=:first>
-    #   Sashite::Snn.style(:Shogi, :second) # => #<Snn::Style name=:Shogi side=:second>
-    def self.style(name, side)
-      Style.new(name, side)
+    # @example
+    #   Sashite::Snn.name("Xiangqi") # => #<Snn::Name value="Xiangqi">
+    def self.name(value)
+      Name.new(value)
     end
   end
 end

data/lib/sashite-snn.rb

@@ -5,9 +5,9 @@ require_relative "sashite/snn"
 # Sashité namespace for board game notation libraries
 #
 # Sashité provides a collection of libraries for representing and manipulating
-# board game concepts according to the Game Protocol specifications.
+# board game concepts according to the Sashité Protocol specifications.
 #
-# @see https://sashite.dev/game-protocol/ Game Protocol Foundation
+# @see https://sashite.dev/protocol/ Sashité Protocol
 # @see https://sashite.dev/specs/ Sashité Specifications
 # @author Sashité
 module Sashite

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sashite-snn
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Cyril Kato
@@ -10,12 +10,12 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |
-  SNN (Style Name Notation) provides a rule-agnostic format for identifying styles
-  in abstract strategy board games. This gem implements the SNN Specification v1.0.0 with
-  a modern Ruby interface featuring immutable style objects and functional programming
-  principles. SNN uses standardized naming conventions with case-based side encoding,
-  enabling clear distinction between different traditions in multi-style gaming environments.
-  Perfect for cross-tradition matches, game engines, and hybrid gaming systems.
+  SNN (Style Name Notation) provides a rule-agnostic, scalable naming system for identifying
+  abstract strategy board game styles. This gem implements the SNN Specification v1.0.0 with
+  a modern Ruby interface featuring immutable style name objects and functional programming
+  principles. SNN uses canonical ASCII names (e.g., "Shogi", "Go9x9") to unambiguously refer
+  to game styles across variants and traditions. Ideal for engines, protocols, and tools that
+  need clear and extensible style identifiers.
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -25,7 +25,7 @@ files:
 - README.md
 - lib/sashite-snn.rb
 - lib/sashite/snn.rb
-- lib/sashite/snn/style.rb
+- lib/sashite/snn/name.rb
 homepage: https://github.com/sashite/snn.rb
 licenses:
 - MIT
@@ -34,7 +34,7 @@ metadata:
   documentation_uri: https://rubydoc.info/github/sashite/snn.rb/main
   homepage_uri: https://github.com/sashite/snn.rb
   source_code_uri: https://github.com/sashite/snn.rb
-  specification_uri: https://sashite.dev/documents/snn/1.0.0/
+  specification_uri: https://sashite.dev/specs/snn/1.0.0/
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -52,5 +52,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: SNN (Style Name Notation) implementation for Ruby with immutable style objects
+summary: SNN (Style Name Notation) implementation for Ruby with immutable style name
+  objects
 test_files: []

data/lib/sashite/snn/style.rb

@@ -1,263 +0,0 @@
-# frozen_string_literal: true
-
-module Sashite
-  module Snn
-    # Represents a style in SNN (Style Name Notation) format.
-    #
-    # A style consists of an alphanumeric identifier with case-based side encoding:
-    # - Uppercase identifier: first player (CHESS, SHOGI, XIANGQI)
-    # - Lowercase identifier: second player (chess, shogi, xiangqi)
-    #
-    # All instances are immutable - transformation methods return new instances.
-    # This follows the Game Protocol's style model with Name and Side attributes.
-    class Style
-      # SNN validation pattern matching the specification
-      SNN_PATTERN = /\A(?<identifier>[A-Z][A-Z0-9]*|[a-z][a-z0-9]*)\z/
-
-      # Pattern for proper name capitalization (first letter uppercase, rest lowercase/digits)
-      PROPER_NAME_PATTERN = /\A[A-Z][a-z0-9]*\z/
-
-      # Player side constants
-      FIRST_PLAYER = :first
-      SECOND_PLAYER = :second
-
-      # Valid sides
-      VALID_SIDES = [FIRST_PLAYER, SECOND_PLAYER].freeze
-
-      # Error messages
-      ERROR_INVALID_SNN = "Invalid SNN string: %s"
-      ERROR_INVALID_NAME = "Name must be a symbol with proper capitalization (first letter uppercase, rest lowercase), got: %s"
-      ERROR_INVALID_SIDE = "Side must be :first or :second, got: %s"
-
-      # @return [Symbol] the style name (with proper capitalization)
-      attr_reader :name
-
-      # @return [Symbol] the player side (:first or :second)
-      attr_reader :side
-
-      # Create a new style instance
-      #
-      # @param name [Symbol] style name (with proper capitalization)
-      # @param side [Symbol] player side (:first or :second)
-      # @raise [ArgumentError] if parameters are invalid
-      def initialize(name, side)
-        self.class.validate_name(name)
-        self.class.validate_side(side)
-
-        @name = name
-        @side = side
-
-        freeze
-      end
-
-      # Parse an SNN string into a Style object
-      #
-      # @param snn_string [String] SNN notation string
-      # @return [Style] parsed style object with normalized name and inferred side
-      # @raise [ArgumentError] if the SNN string is invalid
-      # @example Parse SNN strings with case normalization
-      #   Sashite::Snn::Style.parse("CHESS") # => #<Snn::Style name=:Chess side=:first>
-      #   Sashite::Snn::Style.parse("chess") # => #<Snn::Style name=:Chess side=:second>
-      #   Sashite::Snn::Style.parse("SHOGI") # => #<Snn::Style name=:Shogi side=:first>
-      def self.parse(snn_string)
-        string_value = String(snn_string)
-        matches = match_pattern(string_value)
-
-        identifier = matches[:identifier]
-
-        # Determine side from case
-        style_side = identifier == identifier.upcase ? FIRST_PLAYER : SECOND_PLAYER
-
-        # Normalize name to proper capitalization
-        style_name = normalize_name(identifier)
-
-        new(style_name, style_side)
-      end
-
-      # Check if a string is a valid SNN notation
-      #
-      # @param snn_string [String] the string to validate
-      # @return [Boolean] true if valid SNN, false otherwise
-      #
-      # @example Validate SNN strings
-      #   Sashite::Snn::Style.valid?("CHESS") # => true
-      #   Sashite::Snn::Style.valid?("chess") # => true
-      #   Sashite::Snn::Style.valid?("Chess") # => false
-      def self.valid?(snn_string)
-        return false unless snn_string.is_a?(::String)
-
-        snn_string.match?(SNN_PATTERN)
-      end
-
-      # Convert the style to its SNN string representation
-      #
-      # @return [String] SNN notation string with case based on side
-      # @example Display different sides
-      #   style.to_s  # => "CHESS" (first player)
-      #   style.to_s  # => "chess" (second player)
-      #   style.to_s  # => "SHOGI" (first player)
-      def to_s
-        first_player? ? name.to_s.upcase : name.to_s.downcase
-      end
-
-      # Create a new style with opposite ownership (side)
-      #
-      # @return [Style] new immutable style instance with flipped side
-      # @example Flip player sides
-      #   style.flip  # (:Chess, :first) => (:Chess, :second)
-      def flip
-        self.class.new(name, opposite_side)
-      end
-
-      # Create a new style with a different name (keeping same side)
-      #
-      # @param new_name [Symbol] new name (with proper capitalization)
-      # @return [Style] new immutable style instance with different name
-      # @example Change style name
-      #   style.with_name(:Shogi)  # (:Chess, :first) => (:Shogi, :first)
-      def with_name(new_name)
-        self.class.validate_name(new_name)
-        return self if name == new_name
-
-        self.class.new(new_name, side)
-      end
-
-      # Create a new style with a different side (keeping same name)
-      #
-      # @param new_side [Symbol] :first or :second
-      # @return [Style] new immutable style instance with different side
-      # @example Change player side
-      #   style.with_side(:second)  # (:Chess, :first) => (:Chess, :second)
-      def with_side(new_side)
-        self.class.validate_side(new_side)
-        return self if side == new_side
-
-        self.class.new(name, new_side)
-      end
-
-      # Check if the style belongs to the first player
-      #
-      # @return [Boolean] true if first player
-      def first_player?
-        side == FIRST_PLAYER
-      end
-
-      # Check if the style belongs to the second player
-      #
-      # @return [Boolean] true if second player
-      def second_player?
-        side == SECOND_PLAYER
-      end
-
-      # Check if this style has the same name as another
-      #
-      # @param other [Style] style to compare with
-      # @return [Boolean] true if both styles have the same name
-      # @example Compare style names
-      #   chess1.same_name?(chess2)  # (:Chess, :first) and (:Chess, :second) => true
-      def same_name?(other)
-        return false unless other.is_a?(self.class)
-
-        name == other.name
-      end
-
-      # Check if this style belongs to the same side as another
-      #
-      # @param other [Style] style to compare with
-      # @return [Boolean] true if both styles belong to the same side
-      def same_side?(other)
-        return false unless other.is_a?(self.class)
-
-        side == other.side
-      end
-
-      # Custom equality comparison
-      #
-      # @param other [Object] object to compare with
-      # @return [Boolean] true if both objects are styles with identical name and side
-      def ==(other)
-        return false unless other.is_a?(self.class)
-
-        name == other.name && side == other.side
-      end
-
-      # Alias for == to ensure Set functionality works correctly
-      alias eql? ==
-
-      # Custom hash implementation for use in collections
-      #
-      # @return [Integer] hash value based on class, name, and side
-      def hash
-        [self.class, name, side].hash
-      end
-
-      # Validate that the name is a valid symbol with proper capitalization
-      #
-      # @param name [Symbol] the name to validate
-      # @raise [ArgumentError] if invalid
-      def self.validate_name(name)
-        return if valid_name?(name)
-
-        raise ::ArgumentError, format(ERROR_INVALID_NAME, name.inspect)
-      end
-
-      # Validate that the side is a valid symbol
-      #
-      # @param side [Symbol] the side to validate
-      # @raise [ArgumentError] if invalid
-      def self.validate_side(side)
-        return if VALID_SIDES.include?(side)
-
-        raise ::ArgumentError, format(ERROR_INVALID_SIDE, side.inspect)
-      end
-
-      # Check if a name is valid (symbol with proper capitalization)
-      #
-      # @param name [Object] the name to check
-      # @return [Boolean] true if valid
-      def self.valid_name?(name)
-        return false unless name.is_a?(::Symbol)
-
-        name_string = name.to_s
-        return false if name_string.empty?
-
-        # Must match proper capitalization pattern
-        name_string.match?(PROPER_NAME_PATTERN)
-      end
-
-      # Normalize identifier to proper capitalization symbol
-      #
-      # @param identifier [String] the identifier to normalize
-      # @return [Symbol] normalized name symbol
-      def self.normalize_name(identifier)
-        # Convert to proper capitalization: first letter uppercase, rest lowercase
-        normalized = identifier.downcase
-        normalized[0] = normalized[0].upcase if normalized.length > 0
-        normalized.to_sym
-      end
-
-      # Match SNN 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 = SNN_PATTERN.match(string)
-        return matches if matches
-
-        raise ::ArgumentError, format(ERROR_INVALID_SNN, string)
-      end
-
-      private_class_method :valid_name?, :normalize_name, :match_pattern
-
-      private
-
-      # Get the opposite side
-      #
-      # @return [Symbol] the opposite side
-      def opposite_side
-        first_player? ? SECOND_PLAYER : FIRST_PLAYER
-      end
-    end
-  end
-end