sashite-snn 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fb3b57b1f252e95f7e7d3e8484d6729b90ca6f13dfd19705c9ac61d6095cf25
-  data.tar.gz: 296ec73c256baf0ea7999b74b7933b0e95f92b2b7488e3d5efb69b43b7132951
+  metadata.gz: 517b0310bd57b5d0b931a5f14eb1c4d6257bbd6d4f215c467ff475c8b42542fc
+  data.tar.gz: 2fa5a177d6350dd2501b87eac5a567f5cf48c681439b3af23f2bae1df99579a3
 SHA512:
-  metadata.gz: 1e7b8270ca459703a6bd41f47424af55452f8c287567abc8bdf0e85acc69914f20a1830361ce10e3f0e157c137e3f31f60149481274b24e6dedb597d109927d6
-  data.tar.gz: 9a684bb46685f7a77fbade6caaf2d642f31a6b31b142e1fb5a47512e8a4133fa50adf0f24c8b551d87c67232c23db6c5436e95d819a38ac72e069f37da63aff5
+  metadata.gz: 200ef38765b8c581f93c51657699e4b420c26abe1d355227ff47892b493f787ec9c03e7202a91b9466c99c97a95a1b914837e59bb2784ef6568cc2ca3f94dd49
+  data.tar.gz: 6b01e73ad4e61246e8e61a4e0bd85f7b3f0fcb964f7532c42d6c95a2b5b665c64487e032e46cb7b77806b3a410137536812aac3278428b2c31af8d91811597ec

data/README.md

@@ -9,16 +9,16 @@
 
 ## What is SNN?
 
-SNN (Style Name Notation) provides a compact, ASCII-based format for identifying **styles** in abstract strategy board games. SNN uses single-character identifiers with case encoding to represent both style identity and player assignment simultaneously.
+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 rule-agnostic notation system for style identification in board games.
+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:
 
@@ -33,392 +33,123 @@ gem install sashite-snn
 ```ruby
 require "sashite/snn"
 
-# Parse SNN strings into style objects
-style = Sashite::Snn.parse("C")           # => #<Snn::Style letter=:C side=:first>
-style.to_s                                # => "C"
-style.letter                              # => :C
-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(:C, :first)           # => #<Snn::Style letter=:C side=:first>
-style = Sashite::Snn::Style.new(:c, :second)     # => #<Snn::Style letter=:c 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?("C")                 # => true
-Sashite::Snn.valid?("c")                 # => true
-Sashite::Snn.valid?("1")                 # => false (not a letter)
-Sashite::Snn.valid?("CC")                # => false (not single character)
+Sashite::Snn.valid?("Go9x9")                   # => true
+Sashite::Snn.valid?("chess")                   # => false (must start with uppercase)
+Sashite::Snn.valid?("3DChess")                 # => false (invalid character)
 ```
 
-### Style Transformations
+### Normalization and Comparison
 
 ```ruby
-# All transformations return new immutable instances
-style = Sashite::Snn.parse("C")
-
-# Flip player assignment
-flipped = style.flip                      # => #<Snn::Style letter=:c side=:second>
-flipped.to_s                              # => "c"
-
-# Change letter
-changed = style.with_letter(:S)           # => #<Snn::Style letter=:S side=:first>
-changed.to_s                              # => "S"
+a = Sashite::Snn.parse("Chess960")
+b = Sashite::Snn.parse("Chess960")
 
-# Change side
-other_side = style.with_side(:second)     # => #<Snn::Style letter=:c side=:second>
-other_side.to_s                           # => "c"
-
-# Chain transformations
-result = style.flip.with_letter(:M)       # => #<Snn::Style letter=:m side=:second>
-result.to_s                               # => "m"
+a == b                                         # => true
+a.same_base_name?(Sashite::Snn.parse("Chess")) # => true if both resolve to same SIN
+a.to_s # => "Chess960"
 ```
 
-### Player and Style Queries
+### Canonical Representation
 
 ```ruby
-style = Sashite::Snn.parse("C")
-opposite = Sashite::Snn.parse("s")
-
-# Player identification
-style.first_player?                       # => true
-style.second_player?                      # => false
-opposite.first_player?                    # => false
-opposite.second_player?                   # => true
-
-# Letter comparison
-chess1 = Sashite::Snn.parse("C")
-chess2 = Sashite::Snn.parse("c")
-shogi = Sashite::Snn.parse("S")
-
-chess1.same_letter?(chess2)               # => true (both use letter C)
-chess1.same_side?(shogi)                  # => true (both first player)
-chess1.same_letter?(shogi)                # => false (different letters)
+# All names are normalized to a canonical format
+name = Sashite::Snn.parse("Minishogi")
+name.value                                    # => "Minishogi"
+name.to_s                                     # => "Minishogi"
 ```
 
-### Style Collections
+### Collections and Filtering
 
 ```ruby
-# Working with multiple styles
-styles = %w[C c S s M m].map { |snn| Sashite::Snn.parse(snn) }
-
-# Filter by player
-first_player_styles = styles.select(&:first_player?)
-first_player_styles.map(&:to_s)          # => ["C", "S", "M"]
+names = %w[Chess Shogi Makruk Antichess Minishogi].map { |n| Sashite::Snn.parse(n) }
 
-# Group by letter family
-by_letter = styles.group_by { |s| s.letter.to_s.upcase }
-by_letter["C"].size                       # => 2 (both C and c)
-
-# Find specific combinations
-chess_styles = styles.select { |s| s.letter.to_s.upcase == "C" }
-chess_styles.map(&:to_s)                  # => ["C", "c"]
+# Filter by prefix
+names.select { |n| n.value.start_with?("Mini") }.map(&:to_s)
+# => ["Minishogi"]
 ```
 
 ## Format Specification
 
 ### Structure
+
 ```
-<style-letter>
+<uppercase-letter>[<lowercase-letter | digit>]*
 ```
 
 ### Grammar (BNF)
+
 ```bnf
-<snn> ::= <uppercase-letter> | <lowercase-letter>
+<snn> ::= <uppercase-letter> <tail>
+
+<tail> ::= ""                                ; Single letter (e.g., "X")
+        | <alphanumeric-char> <tail>         ; Extended name
+
+<alphanumeric-char> ::= <lowercase-letter> | <digit>
 
 <uppercase-letter> ::= "A" | "B" | "C" | ... | "Z"
 <lowercase-letter> ::= "a" | "b" | "c" | ... | "z"
+<digit> ::= "0" | "1" | "2" | "3" | ... | "9"
 ```
 
 ### Regular Expression
-```ruby
-/\A[A-Za-z]\z/
-```
-
-### Style Attribute Mapping
-
-| Style Attribute | SNN Encoding | Examples |
-|-----------------|--------------|----------|
-| **Style Family** | Letter choice | `C`/`c` = Chess family |
-| **Player Assignment** | Letter case | `C` = First player, `c` = Second player |
-
-## Game Examples
-
-The SNN specification is rule-agnostic and does not define specific letter assignments. However, here are common usage patterns:
-
-### Traditional Game Families
 
 ```ruby
-# Chess family styles
-chess_white = Sashite::Snn.parse("C")    # First player, Chess family
-chess_black = Sashite::Snn.parse("c")    # Second player, Chess family
-
-# Shōgi family styles
-shogi_sente = Sashite::Snn.parse("S")    # First player, Shōgi family
-shogi_gote = Sashite::Snn.parse("s")     # Second player, Shōgi family
-
-# Xiangqi family styles
-xiangqi_red = Sashite::Snn.parse("X")    # First player, Xiangqi family
-xiangqi_black = Sashite::Snn.parse("x")  # Second player, Xiangqi family
-```
-
-### Cross-Style Scenarios
-
-```ruby
-# Different families in one match
-def create_hybrid_match
-  [
-    Sashite::Snn.parse("C"),             # First player uses Chess family
-    Sashite::Snn.parse("s")              # Second player uses Shōgi family
-  ]
-end
-
-styles = create_hybrid_match
-styles[0].same_side?(styles[1])         # => false (different players)
-styles[0].same_letter?(styles[1])       # => false (different families)
+/\A[A-Z][a-z0-9]*\z/
 ```
 
-### Variant Families
+## Design Principles
 
-```ruby
-# Different letters can represent variants within traditions
-makruk = Sashite::Snn.parse("M")        # Makruk (Thai Chess) family
-janggi = Sashite::Snn.parse("J")        # Janggi (Korean Chess) family
-ogi = Sashite::Snn.parse("O")           # Ōgi (王棋) family
-
-# Each family can have both players
-makruk_black = makruk.flip              # Second player Makruk
-makruk_black.to_s                       # => "m"
-```
-
-## API Reference
+* **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.
 
-### Main Module Methods
+## Integration with SIN
 
-- `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(letter, side)` - Create style instance directly
+SNN names serve as the formal source for SIN character identifiers. For example:
 
-### Style Class
+| SNN       | SIN     |
+| --------- | ------- |
+| `Chess`   | `C`/`c` |
+| `Shogi`   | `S`/`s` |
+| `Xiangqi` | `X`/`x` |
+| `Makruk`  | `M`/`m` |
 
-#### Creation and Parsing
-- `Sashite::Snn::Style.new(letter, side)` - Create style instance
-- `Sashite::Snn::Style.parse(snn_string)` - Parse SNN string
+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.
 
-#### Attribute Access
-- `#letter` - Get style letter (symbol :A through :z)
-- `#side` - Get player side (:first or :second)
-- `#to_s` - Convert to SNN string representation
-
-#### Player Queries
-- `#first_player?` - Check if first player style
-- `#second_player?` - Check if second player style
-
-#### Transformations (immutable - return new instances)
-- `#flip` - Switch player assignment
-- `#with_letter(new_letter)` - Create style with different letter
-- `#with_side(new_side)` - Create style with different side
-
-#### Comparison Methods
-- `#same_letter?(other)` - Check if same style letter (case-insensitive)
-- `#same_side?(other)` - Check if same player 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
-
-### Letter Case and Side Mapping
+## Examples
 
 ```ruby
-# SNN encodes player assignment through case
-upper_case_letters = ("A".."Z").map { |letter| Sashite::Snn.parse(letter) }
-lower_case_letters = ("a".."z").map { |letter| Sashite::Snn.parse(letter) }
-
-# All uppercase letters are first player
-upper_case_letters.all?(&:first_player?)     # => true
-
-# All lowercase letters are second player
-lower_case_letters.all?(&:second_player?)    # => true
-
-# Letter families are related by case
-letter_a_first = Sashite::Snn.parse("A")
-letter_a_second = Sashite::Snn.parse("a")
-
-letter_a_first.same_letter?(letter_a_second)  # => true
-letter_a_first.same_side?(letter_a_second)    # => false
-```
-
-### Immutable Transformations
-
-```ruby
-# All transformations return new instances
-original = Sashite::Snn.style(:C, :first)
-flipped = original.flip
-changed_letter = original.with_letter(:S)
-
-# Original style is never modified
-original.to_s                           # => "C" (unchanged)
-flipped.to_s                            # => "c"
-changed_letter.to_s                     # => "S"
-
-# Transformations can be chained
-result = original.flip.with_letter(:M).flip
-result.to_s                             # => "M"
-```
-
-### Game Configuration Management
-
-```ruby
-class GameConfiguration
-  def initialize
-    @player_styles = {}
-  end
-
-  def set_player_style(player, letter)
-    side = player == :white ? :first : :second
-    @player_styles[player] = Sashite::Snn.style(letter, side)
-  end
-
-  def get_player_style(player)
-    @player_styles[player]
-  end
-
-  def cross_family_match?
-    return false if @player_styles.size < 2
-
-    styles = @player_styles.values
-    !styles.all? { |style| style.same_letter?(styles.first) }
-  end
-
-  def same_family_match?
-    !cross_family_match?
-  end
-end
-
-# Usage
-config = GameConfiguration.new
-config.set_player_style(:white, :C)    # Chess family, first player
-config.set_player_style(:black, :S)    # Shōgi family, second player
-
-config.cross_family_match?             # => true
-
-white_style = config.get_player_style(:white)
-white_style.to_s                       # => "C"
+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
 ```
 
-### 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_letter: styles.group_by { |s| s.letter.to_s.upcase },
-    unique_letters: styles.map { |s| s.letter.to_s.upcase }.uniq.size,
-    cross_family: styles.map { |s| s.letter.to_s.upcase }.uniq.size > 1
-  }
-end
-
-snns = %w[C c S s X x]
-analysis = analyze_styles(snns)
-analysis[:by_side][:first].size        # => 3
-analysis[:unique_letters]              # => 3
-analysis[:cross_family]                # => true
-```
-
-### Tournament Style Registry
-
-```ruby
-class TournamentStyleRegistry
-  def initialize
-    @registered_styles = Set.new
-  end
-
-  def register_letter(letter)
-    # Register both sides of a letter family
-    first_player_style = Sashite::Snn.style(letter.to_s.upcase.to_sym, :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_families
-    @registered_styles.map { |s| s.letter.to_s.upcase }.uniq.sort
-  end
-end
-
-# Usage
-registry = TournamentStyleRegistry.new
-registry.register_letter(:C)
-registry.register_letter(:S)
-
-chess_white = Sashite::Snn.parse("C")
-shogi_black = Sashite::Snn.parse("s")
-
-registry.valid_pairing?(chess_white, shogi_black)  # => true
-registry.supported_families                        # => ["C", "S"]
-```
-
-## Protocol Mapping
-
-Following the [Sashité Protocol](https://sashite.dev/protocol/):
-
-| Protocol Attribute | SNN Encoding | Examples | Notes |
-|-------------------|--------------|----------|-------|
-| **Style Family** | Letter choice | `C`, `S`, `X` | Rule-agnostic letter assignment |
-| **Player Assignment** | Case encoding | `C` = First player, `c` = Second player | Case determines side |
-
-## System Constraints
-
-- **26 possible identifiers** per player using ASCII letters (A-Z, a-z)
-- **Exactly 2 players** through case distinction
-- **Single character** per style-player combination
-- **Rule-agnostic** - no predefined letter meanings
-
-## Design Properties
-
-- **ASCII compatibility**: Maximum portability across systems
-- **Rule-agnostic**: Independent of specific game mechanics
-- **Minimal overhead**: Single character per style-player combination
-- **Canonical representation**: Each style-player combination has exactly one SNN identifier
-- **Immutable**: All style instances are frozen and transformations return new objects
-- **Functional**: Pure functions with no side effects
+## API Reference
 
-## Related Specifications
+### Main Module
 
-- [SNN Specification v1.0.0](https://sashite.dev/specs/snn/1.0.0/) - Complete technical specification
-- [SNN Examples](https://sashite.dev/specs/snn/1.0.0/examples/) - Practical implementation examples
-- [Sashité Protocol](https://sashite.dev/protocol/) - Conceptual foundation for abstract strategy board games
-- [PIN](https://sashite.dev/specs/pin/) - Piece Identifier Notation
-- [PNN](https://sashite.dev/specs/pnn/) - Piece Name Notation (style-aware piece representation)
-- [QPI](https://sashite.dev/specs/qpi/) - Qualified Piece Identifier
+* `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/)
-- [Sashité Protocol Foundation](https://sashite.dev/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,65 +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 single ASCII letters with case-based side encoding, enabling clear
-  # distinction between different style families 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-letter>
-  # - Uppercase letter: First player styles (A, B, C, ..., Z)
-  # - Lowercase letter: Second player styles (a, b, c, ..., z)
-  # - Single character only: Each SNN identifier is exactly one ASCII letter
+  # Format: <uppercase-letter>[<lowercase-letter | digit>]*
   #
   # Examples:
-  #   "C"  - First player, C style family
-  #   "c"  - Second player, C style family
-  #   "S"  - First player, S style family
-  #   "s"  - Second player, S style family
+  #   "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?("C") # => true
-    #   Sashite::Snn.valid?("c") # => true
-    #   Sashite::Snn.valid?("CHESS") # => false (multi-character)
-    #   Sashite::Snn.valid?("1") # => false (not a letter)
+    # @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 letter and side attributes
-    # @raise [ArgumentError] if the SNN string is invalid
-    # @example Parse different SNN formats
-    #   Sashite::Snn.parse("C") # => #<Snn::Style letter=:C side=:first>
-    #   Sashite::Snn.parse("c") # => #<Snn::Style letter=:c side=:second>
-    #   Sashite::Snn.parse("S") # => #<Snn::Style letter=:S 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 letter [Symbol] style letter (single ASCII letter as symbol)
-    # @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(:C, :first)  # => #<Snn::Style letter=:C side=:first>
-    #   Sashite::Snn.style(:s, :second) # => #<Snn::Style letter=:s side=:second>
-    def self.style(letter, side)
-      Style.new(letter, side)
+    # @example
+    #   Sashite::Snn.name("Xiangqi") # => #<Snn::Name value="Xiangqi">
+    def self.name(value)
+      Name.new(value)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sashite-snn
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Cyril Kato
@@ -10,13 +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 single ASCII letters with case-based side encoding (A-Z for first player,
-  a-z for second player), enabling clear distinction between different style families in
-  multi-style gaming environments. Perfect for cross-style matches, game engines, and hybrid
-  gaming systems requiring compact style identification.
+  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: []
@@ -26,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
@@ -53,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,250 +0,0 @@
-# frozen_string_literal: true
-
-module Sashite
-  module Snn
-    # Represents a style in SNN (Style Name Notation) format.
-    #
-    # A style consists of a single ASCII letter with case-based side encoding:
-    # - Uppercase letter: first player (A, B, C, ..., Z)
-    # - Lowercase letter: second player (a, b, c, ..., z)
-    #
-    # All instances are immutable - transformation methods return new instances.
-    # This follows the SNN Specification v1.0.0 with Letter and Side attributes.
-    class Style
-      # SNN validation pattern matching the specification
-      SNN_PATTERN = /\A[A-Za-z]\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_LETTER = "Letter must be a single ASCII letter symbol (A-Z, a-z), got: %s"
-      ERROR_INVALID_SIDE = "Side must be :first or :second, got: %s"
-
-      # @return [Symbol] the style letter (single ASCII letter as symbol)
-      attr_reader :letter
-
-      # @return [Symbol] the player side (:first or :second)
-      attr_reader :side
-
-      # Create a new style instance
-      #
-      # @param letter [Symbol] style letter (single ASCII letter as symbol)
-      # @param side [Symbol] player side (:first or :second)
-      # @raise [ArgumentError] if parameters are invalid
-      def initialize(letter, side)
-        self.class.validate_letter(letter)
-        self.class.validate_side(side)
-
-        @letter = letter
-        @side = side
-
-        freeze
-      end
-
-      # Parse an SNN string into a Style object
-      #
-      # @param snn_string [String] SNN notation string (single ASCII letter)
-      # @return [Style] parsed style object with letter and inferred side
-      # @raise [ArgumentError] if the SNN string is invalid
-      # @example Parse SNN strings with case-based side inference
-      #   Sashite::Snn::Style.parse("C") # => #<Snn::Style letter=:C side=:first>
-      #   Sashite::Snn::Style.parse("c") # => #<Snn::Style letter=:c side=:second>
-      #   Sashite::Snn::Style.parse("S") # => #<Snn::Style letter=:S side=:first>
-      def self.parse(snn_string)
-        string_value = String(snn_string)
-        validate_snn_string(string_value)
-
-        # Determine side from case
-        style_side = string_value == string_value.upcase ? FIRST_PLAYER : SECOND_PLAYER
-
-        # Use the letter directly as symbol
-        style_letter = string_value.to_sym
-
-        new(style_letter, 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?("C") # => true
-      #   Sashite::Snn::Style.valid?("c") # => true
-      #   Sashite::Snn::Style.valid?("CHESS") # => false (multi-character)
-      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 (single ASCII letter)
-      # @example Display styles
-      #   style.to_s  # => "C" (first player, C family)
-      #   style.to_s  # => "c" (second player, C family)
-      #   style.to_s  # => "S" (first player, S family)
-      def to_s
-        letter.to_s
-      end
-
-      # Create a new style with opposite ownership (side)
-      #
-      # @return [Style] new immutable style instance with flipped side
-      # @example Flip player sides
-      #   style.flip  # (:C, :first) => (:c, :second)
-      def flip
-        new_letter = first_player? ? letter.to_s.downcase.to_sym : letter.to_s.upcase.to_sym
-        self.class.new(new_letter, opposite_side)
-      end
-
-      # Create a new style with a different letter (keeping same side)
-      #
-      # @param new_letter [Symbol] new letter (single ASCII letter as symbol)
-      # @return [Style] new immutable style instance with different letter
-      # @example Change style letter
-      #   style.with_letter(:S)  # (:C, :first) => (:S, :first)
-      def with_letter(new_letter)
-        self.class.validate_letter(new_letter)
-        return self if letter == new_letter
-
-        # Ensure the new letter has the correct case for the current side
-        adjusted_letter = first_player? ? new_letter.to_s.upcase.to_sym : new_letter.to_s.downcase.to_sym
-        self.class.new(adjusted_letter, side)
-      end
-
-      # Create a new style with a different side (keeping same letter family)
-      #
-      # @param new_side [Symbol] :first or :second
-      # @return [Style] new immutable style instance with different side
-      # @example Change player side
-      #   style.with_side(:second)  # (:C, :first) => (:c, :second)
-      def with_side(new_side)
-        self.class.validate_side(new_side)
-        return self if side == new_side
-
-        # Adjust letter case for the new side
-        new_letter = new_side == FIRST_PLAYER ? letter.to_s.upcase.to_sym : letter.to_s.downcase.to_sym
-        self.class.new(new_letter, 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 letter family as another
-      #
-      # @param other [Style] style to compare with
-      # @return [Boolean] true if both styles use the same letter family (case-insensitive)
-      # @example Compare style letter families
-      #   c_style.same_letter?(C_style)  # (:c, :second) and (:C, :first) => true
-      def same_letter?(other)
-        return false unless other.is_a?(self.class)
-
-        letter.to_s.upcase == other.letter.to_s.upcase
-      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 letter and side
-      def ==(other)
-        return false unless other.is_a?(self.class)
-
-        letter == other.letter && 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, letter, and side
-      def hash
-        [self.class, letter, side].hash
-      end
-
-      # Validate that the letter is a valid single ASCII letter symbol
-      #
-      # @param letter [Symbol] the letter to validate
-      # @raise [ArgumentError] if invalid
-      def self.validate_letter(letter)
-        return if valid_letter?(letter)
-
-        raise ::ArgumentError, format(ERROR_INVALID_LETTER, letter.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 letter is valid (single ASCII letter symbol)
-      #
-      # @param letter [Object] the letter to check
-      # @return [Boolean] true if valid
-      def self.valid_letter?(letter)
-        return false unless letter.is_a?(::Symbol)
-
-        letter_string = letter.to_s
-        return false if letter_string.empty?
-
-        # Must be exactly one ASCII letter
-        letter_string.match?(SNN_PATTERN)
-      end
-
-      # Validate SNN string format
-      #
-      # @param string [String] string to validate
-      # @raise [ArgumentError] if string doesn't match SNN pattern
-      def self.validate_snn_string(string)
-        return if string.match?(SNN_PATTERN)
-
-        raise ::ArgumentError, format(ERROR_INVALID_SNN, string)
-      end
-
-      private_class_method :valid_letter?, :validate_snn_string
-
-      private
-
-      # Get the opposite side
-      #
-      # @return [Symbol] the opposite side
-      def opposite_side
-        first_player? ? SECOND_PLAYER : FIRST_PLAYER
-      end
-    end
-  end
-end