sashite-snn 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c75eb6af8fa8c0ff0a9791e0ecc0fe49b7e6c0827733e96f2e37e552ddca50b0
-  data.tar.gz: 2ac49000ca7ff3f2ae01e0a7d240f2fb99d5cab34a915b9799a5088c7461b4f3
+  metadata.gz: 6fb3b57b1f252e95f7e7d3e8484d6729b90ca6f13dfd19705c9ac61d6095cf25
+  data.tar.gz: 296ec73c256baf0ea7999b74b7933b0e95f92b2b7488e3d5efb69b43b7132951
 SHA512:
-  metadata.gz: 9ec03703cf421329344a597f91d4157e4b44f1d5347cb4f8eea1a5c9e79e6800ad0880f6d9a8ad003df18d48ab5afb084d6526ffcbf6df14323b21ee751fc54e
-  data.tar.gz: e95c9a8e58fbe6254e546456a5de92a79de1eeb33688292ec1c58f58ba30b6a94357a61d1396a1a639e0051c772b888af355e421a3726b2faf3ae7179450afd6
+  metadata.gz: 1e7b8270ca459703a6bd41f47424af55452f8c287567abc8bdf0e85acc69914f20a1830361ce10e3f0e157c137e3f31f60149481274b24e6dedb597d109927d6
+  data.tar.gz: 9a684bb46685f7a77fbade6caaf2d642f31a6b31b142e1fb5a47512e8a4133fa50adf0f24c8b551d87c67232c23db6c5436e95d819a38ac72e069f37da63aff5

data/README.md

@@ -9,9 +9,9 @@
 
 ## 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) 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.
 
-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/), providing a rule-agnostic notation system for style identification in board games.
 
 ## Installation
 
@@ -28,143 +28,166 @@ 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
+style = Sashite::Snn.parse("C")           # => #<Snn::Style letter=:C side=:first>
+style.to_s                                # => "C"
+style.letter                              # => :C
+style.side                                # => :first
 
 # 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>
+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>
 
 # 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"
+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)
+```
+
+### Style Transformations
+
+```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"
+
+# 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"
+```
+
+### Player and Style Queries
+
+```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)
+```
+
+### Style Collections
+
+```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"]
+
+# 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"]
 ```
 
 ## Format Specification
 
 ### Structure
 ```
-<style-identifier>
+<style-letter>
 ```
 
-### Components
+### Grammar (BNF)
+```bnf
+<snn> ::= <uppercase-letter> | <lowercase-letter>
 
-- **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)
+<uppercase-letter> ::= "A" | "B" | "C" | ... | "Z"
+<lowercase-letter> ::= "a" | "b" | "c" | ... | "z"
+```
 
 ### Regular Expression
 ```ruby
-/\A([A-Z][A-Z0-9]*|[a-z][a-z0-9]*)\z/
+/\A[A-Za-z]\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
+### Style Attribute Mapping
 
-## Game Examples
+| Style Attribute | SNN Encoding | Examples |
+|-----------------|--------------|----------|
+| **Style Family** | Letter choice | `C`/`c` = Chess family |
+| **Player Assignment** | Letter case | `C` = First player, `c` = Second player |
 
-### 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"
-```
-
-### Chess Variants
-```ruby
-# Fischer Random Chess
-chess960_white = Sashite::Snn.style(:Chess960, :first)
-chess960_black = chess960_white.flip
-chess960_black.to_s                               # => "chess960"
+## Game Examples
 
-# King of the Hill Chess
-koth = Sashite::Snn.style(:Koth, :first)
-koth.to_s                                         # => "KOTH"
+The SNN specification is rule-agnostic and does not define specific letter assignments. However, here are common usage patterns:
 
-# Three-Check Chess
-threecheck = Sashite::Snn.style(:Threecheck, :first)
-```
+### Traditional Game Families
 
-### Shōgi Variants
 ```ruby
-# Traditional Shōgi
-standard_shogi = Sashite::Snn.style(:Shogi, :first)
+# Chess family styles
+chess_white = Sashite::Snn.parse("C")    # First player, Chess family
+chess_black = Sashite::Snn.parse("c")    # Second player, Chess family
 
-# Mini Shōgi
-mini_shogi = Sashite::Snn.style(:Minishogi, :first)
+# 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
 
-# Chu Shōgi
-chu_shogi = Sashite::Snn.style(:Chushogi, :first)
+# Xiangqi family styles
+xiangqi_red = Sashite::Snn.parse("X")    # First player, Xiangqi family
+xiangqi_black = Sashite::Snn.parse("x")  # Second player, Xiangqi family
 ```
 
-### Multi-Style Gaming
+### Cross-Style Scenarios
+
 ```ruby
-# Cross-tradition match
+# Different families in one 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
+  [
+    Sashite::Snn.parse("C"),             # First player uses Chess family
+    Sashite::Snn.parse("s")              # Second player uses Shōgi family
   ]
-
-  # 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
+styles = create_hybrid_match
+styles[0].same_side?(styles[1])         # => false (different players)
+styles[0].same_letter?(styles[1])       # => false (different families)
+```
+
+### Variant Families
 
-chess_white = Sashite::Snn.parse("CHESS")
-shogi_black = Sashite::Snn.parse("shogi")
-puts compatible_styles?(chess_white, shogi_black)  # => true
+```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
@@ -173,139 +196,123 @@ puts compatible_styles?(chess_white, shogi_black)  # => true
 
 - `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
+- `Sashite::Snn.style(letter, 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)
+- `Sashite::Snn::Style.new(letter, side)` - Create style instance
+- `Sashite::Snn::Style.parse(snn_string)` - Parse SNN string
 
 #### Attribute Access
-- `#name` - Get style name (symbol with proper capitalization)
+- `#letter` - Get style letter (symbol :A through :z)
 - `#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:
-
-```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)
-
-style1.to_s    # => "CHESS" (uppercase display)
-style2.to_s    # => "chess" (lowercase display)
-```
-
-#### Side Queries
+#### Player 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
+- `#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_name?(other)` - Check if same style name
-- `#same_side?(other)` - Check if same side
+- `#same_letter?(other)` - Check if same style letter (case-insensitive)
+- `#same_side?(other)` - Check if same player side
 - `#==(other)` - Full equality comparison
 
-### Constants
-- `Sashite::Snn::SNN_REGEX` - Regular expression for SNN validation
+### 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
+### Letter Case and Side Mapping
 
 ```ruby
-# Parsing different cases results in same name
-white_chess = Sashite::Snn.parse("CHESS")
-black_chess = Sashite::Snn.parse("chess")
+# 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) }
 
-# Names are normalized with proper capitalization
-white_chess.name  # => :Chess
-black_chess.name  # => :Chess (same name!)
+# All uppercase letters are first player
+upper_case_letters.all?(&:first_player?)     # => true
 
-# Sides are different
-white_chess.side  # => :first
-black_chess.side  # => :second
+# All lowercase letters are second player
+lower_case_letters.all?(&:second_player?)    # => true
 
-# Display follows side convention
-white_chess.to_s  # => "CHESS"
-black_chess.to_s  # => "chess"
+# Letter families are related by case
+letter_a_first = Sashite::Snn.parse("A")
+letter_a_second = Sashite::Snn.parse("a")
 
-# Same name, different sides
-white_chess.same_name?(black_chess)  # => true
-white_chess.same_side?(black_chess)  # => false
+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(:Chess, :first)
+original = Sashite::Snn.style(:C, :first)
 flipped = original.flip
-renamed = original.with_name(:Shogi)
+changed_letter = original.with_letter(:S)
 
 # Original style is never modified
-puts original.to_s  # => "CHESS"
-puts flipped.to_s   # => "chess"
-puts renamed.to_s   # => "SHOGI"
+original.to_s                           # => "C" (unchanged)
+flipped.to_s                            # => "c"
+changed_letter.to_s                     # => "S"
 
 # Transformations can be chained
-result = original.flip.with_name(:Xiangqi)
-puts result.to_s    # => "xiangqi"
+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, style_name)
+  def set_player_style(player, letter)
     side = player == :white ? :first : :second
-    @player_styles[player] = Sashite::Snn.style(style_name, side)
+    @player_styles[player] = Sashite::Snn.style(letter, side)
   end
 
   def get_player_style(player)
     @player_styles[player]
   end
 
-  def style_mismatch?
+  def cross_family_match?
     return false if @player_styles.size < 2
 
     styles = @player_styles.values
-    !styles.all? { |style| style.same_name?(styles.first) }
+    !styles.all? { |style| style.same_letter?(styles.first) }
   end
 
-  def cross_tradition_match?
-    return false if @player_styles.size < 2
-
-    style_names = @player_styles.values.map(&:name).uniq
-    style_names.size > 1
+  def same_family_match?
+    !cross_family_match?
   end
 end
 
 # Usage
 config = GameConfiguration.new
-config.set_player_style(:white, :Chess)
-config.set_player_style(:black, :Shogi)
+config.set_player_style(:white, :C)    # Chess family, first player
+config.set_player_style(:black, :S)    # Shōgi family, second player
 
-puts config.cross_tradition_match?  # => true
-puts config.style_mismatch?         # => true
+config.cross_family_match?             # => true
 
 white_style = config.get_player_style(:white)
-puts white_style.to_s               # => "CHESS"
+white_style.to_s                       # => "C"
 ```
 
 ### Style Analysis
+
 ```ruby
 def analyze_styles(snns)
   styles = snns.map { |snn| Sashite::Snn.parse(snn) }
@@ -313,29 +320,30 @@ def analyze_styles(snns)
   {
     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
+    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[CHESS chess SHOGI shogi XIANGQI xiangqi]
+snns = %w[C c S s X x]
 analysis = analyze_styles(snns)
-puts analysis[:by_side][:first].size   # => 3
-puts analysis[:unique_names]           # => 3
-puts analysis[:cross_tradition]        # => true
+analysis[:by_side][:first].size        # => 3
+analysis[:unique_letters]              # => 3
+analysis[:cross_family]                # => true
 ```
 
-### Tournament Style Management
+### Tournament Style Registry
+
 ```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)
+  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)
@@ -354,94 +362,62 @@ class TournamentStyleRegistry
     @registered_styles.select { |style| style.side == side }
   end
 
-  def supported_traditions
-    @registered_styles.map(&:name).uniq
+  def supported_families
+    @registered_styles.map { |s| s.letter.to_s.upcase }.uniq.sort
   end
 end
 
 # Usage
 registry = TournamentStyleRegistry.new
-registry.register_style(:Chess)
-registry.register_style(:Shogi)
+registry.register_letter(:C)
+registry.register_letter(:S)
 
-chess_white = Sashite::Snn.parse("CHESS")
-shogi_black = Sashite::Snn.parse("shogi")
+chess_white = Sashite::Snn.parse("C")
+shogi_black = Sashite::Snn.parse("s")
 
-puts registry.valid_pairing?(chess_white, shogi_black)  # => true
-puts registry.supported_traditions                      # => [:Chess, :Shogi]
+registry.valid_pairing?(chess_white, shogi_black)  # => true
+registry.supported_families                        # => ["C", "S"]
 ```
 
 ## Protocol Mapping
 
-Following the [Game Protocol](https://sashite.dev/game-protocol/):
+Following the [Sashité Protocol](https://sashite.dev/protocol/):
 
 | Protocol Attribute | SNN Encoding | Examples | Notes |
 |-------------------|--------------|----------|-------|
-| **Style** | Alphanumeric identifier | `CHESS`, `SHOGI`, `XIANGQI` | Name is always stored as uppercase symbol |
-| **Side** | Case encoding | `CHESS` = First player, `chess` = Second player | Case is determined by side during rendering |
-
-**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.
-
-**Canonical principle**: Identical styles must have identical SNN representations.
-
-## Properties
-
-* **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
-
-## Implementation Notes
-
-### Name Normalization Convention
-
-SNN follows a strict name normalization convention:
+| **Style Family** | Letter choice | `C`, `S`, `X` | Rule-agnostic letter assignment |
+| **Player Assignment** | Case encoding | `C` = First player, `c` = Second player | Case determines side |
 
-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
-
-```ruby
-# Input: "chess" (lowercase)
-# ↓ Parsing
-# name: :Chess (normalized with proper capitalization)
-# side: :second (inferred from lowercase input)
-# ↓ Display
-# SNN: "chess" (final representation)
-```
+## System Constraints
 
-This ensures that `parse(snn).to_s == snn` for all valid SNN strings while maintaining internal consistency.
+- **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
 
-## System Constraints
+## Design Properties
 
-- **Alphanumeric identifiers** starting with a letter
-- **Exactly 2 players** (uppercase/lowercase distinction)
-- **Case consistency** within each identifier (no mixed case)
+- **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
 
 ## Related Specifications
 
-- [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)
+- [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)
-- [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
+- [QPI](https://sashite.dev/specs/qpi/) - Qualified Piece Identifier
 
 ## Documentation
 
 - [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/)
+- [Sashité Protocol Foundation](https://sashite.dev/protocol/)
 - [API Documentation](https://rubydoc.info/github/sashite/snn.rb/main)
 
 ## Development

data/lib/sashite/snn/style.rb

@@ -4,18 +4,15 @@ 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)
+    # 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 Game Protocol's style model with Name and Side attributes.
+    # This follows the SNN Specification v1.0.0 with Letter 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/
+      SNN_PATTERN = /\A[A-Za-z]\z/
 
       # Player side constants
       FIRST_PLAYER = :first
@@ -26,25 +23,25 @@ module Sashite
 
       # 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_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 name (with proper capitalization)
-      attr_reader :name
+      # @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 name [Symbol] style name (with proper capitalization)
+      # @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(name, side)
-        self.class.validate_name(name)
+      def initialize(letter, side)
+        self.class.validate_letter(letter)
         self.class.validate_side(side)
 
-        @name = name
+        @letter = letter
         @side = side
 
         freeze
@@ -52,72 +49,90 @@ module Sashite
 
       # Parse an SNN string into a Style object
       #
-      # @param snn_string [String] SNN notation string
-      # @return [Style] new style instance
+      # @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
-      #   Snn::Style.parse("CHESS")     # => #<Snn::Style name=:Chess side=:first>
-      #   Snn::Style.parse("chess")     # => #<Snn::Style name=:Chess side=:second>
-      #   Snn::Style.parse("SHOGI")     # => #<Snn::Style name=:Shogi side=:first>
+      # @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)
-        matches = match_pattern(string_value)
-
-        identifier = matches[:identifier]
+        validate_snn_string(string_value)
 
         # Determine side from case
-        style_side = identifier == identifier.upcase ? FIRST_PLAYER : SECOND_PLAYER
+        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
 
-        # Normalize name to proper capitalization
-        style_name = normalize_name(identifier)
+      # 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)
 
-        new(style_name, style_side)
+        snn_string.match?(SNN_PATTERN)
       end
 
       # Convert the style to its SNN string representation
       #
-      # @return [String] SNN notation string
-      # @example
-      #   style.to_s  # => "CHESS"
-      #   style.to_s  # => "chess"
-      #   style.to_s  # => "SHOGI"
+      # @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
-        first_player? ? name.to_s.upcase : name.to_s.downcase
+        letter.to_s
       end
 
       # Create a new style with opposite ownership (side)
       #
-      # @return [Style] new style instance with flipped side
-      # @example
-      #   style.flip  # (:Chess, :first) => (:Chess, :second)
+      # @return [Style] new immutable style instance with flipped side
+      # @example Flip player sides
+      #   style.flip  # (:C, :first) => (:c, :second)
       def flip
-        self.class.new(name, opposite_side)
+        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 name (keeping same side)
+      # Create a new style with a different letter (keeping same side)
       #
-      # @param new_name [Symbol] new name (with proper capitalization)
-      # @return [Style] new style instance with different name
-      # @example
-      #   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
+      # @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
 
-        self.class.new(new_name, side)
+        # 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 name)
+      # Create a new style with a different side (keeping same letter family)
       #
       # @param new_side [Symbol] :first or :second
-      # @return [Style] new style instance with different side
-      # @example
-      #   style.with_side(:second)  # (:Chess, :first) => (:Chess, :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
 
-        self.class.new(name, 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
@@ -134,22 +149,22 @@ module Sashite
         side == SECOND_PLAYER
       end
 
-      # Check if this style has the same name as another
+      # Check if this style has the same letter family as another
       #
       # @param other [Style] style to compare with
-      # @return [Boolean] true if same name
-      # @example
-      #   chess1.same_name?(chess2)  # (:Chess, :first) and (:Chess, :second) => true
-      def same_name?(other)
+      # @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)
 
-        name == other.name
+        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 same side
+      # @return [Boolean] true if both styles belong to the same side
       def same_side?(other)
         return false unless other.is_a?(self.class)
 
@@ -159,11 +174,11 @@ module Sashite
       # Custom equality comparison
       #
       # @param other [Object] object to compare with
-      # @return [Boolean] true if styles are equal
+      # @return [Boolean] true if both objects are styles with identical letter and side
       def ==(other)
         return false unless other.is_a?(self.class)
 
-        name == other.name && side == other.side
+        letter == other.letter && side == other.side
       end
 
       # Alias for == to ensure Set functionality works correctly
@@ -171,19 +186,19 @@ module Sashite
 
       # Custom hash implementation for use in collections
       #
-      # @return [Integer] hash value
+      # @return [Integer] hash value based on class, letter, and side
       def hash
-        [self.class, name, side].hash
+        [self.class, letter, side].hash
       end
 
-      # Validate that the name is a valid symbol with proper capitalization
+      # Validate that the letter is a valid single ASCII letter symbol
       #
-      # @param name [Symbol] the name to validate
+      # @param letter [Symbol] the letter to validate
       # @raise [ArgumentError] if invalid
-      def self.validate_name(name)
-        return if valid_name?(name)
+      def self.validate_letter(letter)
+        return if valid_letter?(letter)
 
-        raise ::ArgumentError, format(ERROR_INVALID_NAME, name.inspect)
+        raise ::ArgumentError, format(ERROR_INVALID_LETTER, letter.inspect)
       end
 
       # Validate that the side is a valid symbol
@@ -196,44 +211,31 @@ module Sashite
         raise ::ArgumentError, format(ERROR_INVALID_SIDE, side.inspect)
       end
 
-      # Check if a name is valid (symbol with proper capitalization)
+      # Check if a letter is valid (single ASCII letter symbol)
       #
-      # @param name [Object] the name to check
+      # @param letter [Object] the letter to check
       # @return [Boolean] true if valid
-      def self.valid_name?(name)
-        return false unless name.is_a?(::Symbol)
+      def self.valid_letter?(letter)
+        return false unless letter.is_a?(::Symbol)
 
-        name_string = name.to_s
-        return false if name_string.empty?
+        letter_string = letter.to_s
+        return false if letter_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
+        # Must be exactly one ASCII letter
+        letter_string.match?(SNN_PATTERN)
       end
 
-      # Match SNN pattern against string
+      # Validate SNN string format
       #
-      # @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
+      # @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_name?, :normalize_name, :match_pattern
+      private_class_method :valid_letter?, :validate_snn_string
 
       private
 

data/lib/sashite/snn.rb

@@ -6,66 +6,60 @@ 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.
+  # SNN uses single ASCII letters with case-based side encoding, enabling clear
+  # distinction between different style families in multi-style gaming environments.
   #
-  # 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: <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
   #
   # Examples:
-  #   "CHESS"  - First player chess style
-  #   "chess"  - Second player chess style
-  #   "SHOGI"  - First player shōgi style
-  #   "shogi"  - Second player shōgi style
+  #   "C"  - First player, C style family
+  #   "c"  - Second player, C style family
+  #   "S"  - First player, S style family
+  #   "s"  - Second player, S style family
   #
   # See: https://sashite.dev/specs/snn/1.0.0/
   module Snn
-    # Regular expression for SNN validation
-    # Matches: uppercase alphanumeric identifier OR lowercase alphanumeric identifier
-    SNN_REGEX = /\A([A-Z][A-Z0-9]*|[a-z][a-z0-9]*)\z/
-
     # Check if a string is a valid SNN notation
     #
-    # @param snn [String] The string to validate
+    # @param snn_string [String] the string to validate
     # @return [Boolean] true if valid SNN, false otherwise
     #
-    # @example
-    #   Sashite::Snn.valid?("CHESS")    # => true
-    #   Sashite::Snn.valid?("chess")    # => true
-    #   Sashite::Snn.valid?("Chess")    # => false
-    #   Sashite::Snn.valid?("123")      # => false
-    def self.valid?(snn)
-      return false unless snn.is_a?(::String)
-
-      snn.match?(SNN_REGEX)
+    # @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)
+    def self.valid?(snn_string)
+      Style.valid?(snn_string)
     end
 
     # Parse an SNN string into a Style object
     #
     # @param snn_string [String] SNN notation string
-    # @return [Snn::Style] new style instance
+    # @return [Snn::Style] parsed style object with letter and side attributes
     # @raise [ArgumentError] if the SNN string is invalid
-    # @example
-    #   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>
+    # @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>
     def self.parse(snn_string)
       Style.parse(snn_string)
     end
 
     # Create a new style instance
     #
-    # @param name [Symbol] style name (with proper capitalization)
+    # @param letter [Symbol] style letter (single ASCII letter as symbol)
     # @param side [Symbol] player side (:first or :second)
-    # @return [Snn::Style] new style instance
+    # @return [Snn::Style] new immutable style instance
     # @raise [ArgumentError] if parameters are invalid
-    # @example
-    #   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 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)
     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.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Cyril Kato
@@ -13,9 +13,10 @@ 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.
+  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.
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -34,7 +35,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: