sashite-sin 1.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3411653c81ceb4f7711d40c8a924a2efc16e4573797dbd593d5e97cc95a5c643
-  data.tar.gz: 00776c4a29a213e1146cbbee42792c132706f64ac0b500c0389b3b0814fa9264
+  metadata.gz: 2b57d90bf310c7367cfb46d8fd7a927629c9daf51fea8fcb4c678abfe28bedba
+  data.tar.gz: 535401969041a91f3d54f05e022ac7f0f78ea705075dccfd5f306b402f7fa8a7
 SHA512:
-  metadata.gz: d818c870d4a9dc08f74da00acf89662c0e4794ba55bc658d4aca25a1895edc8ded12df5a83f4378375392c1576b12bbb29e47668732089b096fde659153a87da
-  data.tar.gz: 2ebe9efb770a4ca03319d74bc53965dc40d7e5778663a6b4d4a1ab6f7f07a7ef338a313e50f664a49068f0593a88ff5b893f62a3b91c7a88b1fe5a73729bd9ef
+  metadata.gz: 73e7edb26036041f09a93b5ae1f21c125ea34b8981dcc4d255674e2319d47bc733022e35d33d203792f5b750e9054695779c4e470d6500e87c7de35c2290653b
+  data.tar.gz: 0b828c1a6e076de5c29e6eaf32149719cfd4a1fcc3a6f30fd276bd3afdbf923aee5aabb90812684a3f5c6d3106889422b76deaeadf60c7e9cff2a2dcdc7fdf80

data/README.md

@@ -33,15 +33,15 @@ gem install sashite-sin
 ```ruby
 require "sashite/sin"
 
-# Parse SIN strings into style objects
-style = Sashite::Sin.parse("C")           # => #<Sin::Style letter=:C side=:first>
-style.to_s                                # => "C"
-style.letter                              # => :C
-style.side                                # => :first
+# Parse SIN strings into identifier objects
+identifier = Sashite::Sin.parse("C")           # => #<Sin::Identifier letter=:C side=:first>
+identifier.to_s                                # => "C"
+identifier.letter                              # => :C
+identifier.side                                # => :first
 
-# Create styles directly
-style = Sashite::Sin.style(:C, :first)           # => #<Sin::Style letter=:C side=:first>
-style = Sashite::Sin::Style.new(:c, :second)     # => #<Sin::Style letter=:c side=:second>
+# Create identifiers directly
+identifier = Sashite::Sin.identifier(:C, :first)           # => #<Sin::Identifier letter=:C side=:first>
+identifier = Sashite::Sin::Identifier.new(:c, :second)     # => #<Sin::Identifier letter=:c side=:second>
 
 # Validate SIN strings
 Sashite::Sin.valid?("C")                 # => true
@@ -50,38 +50,38 @@ Sashite::Sin.valid?("1")                 # => false (not a letter)
 Sashite::Sin.valid?("CC")                # => false (not single character)
 ```
 
-### Style Transformations
+### Identifier Transformations
 
 ```ruby
 # All transformations return new immutable instances
-style = Sashite::Sin.parse("C")
+identifier = Sashite::Sin.parse("C")
 
 # Flip player assignment
-flipped = style.flip                      # => #<Sin::Style letter=:c side=:second>
-flipped.to_s                              # => "c"
+flipped = identifier.flip # => #<Sin::Identifier letter=:c side=:second>
+flipped.to_s # => "c"
 
 # Change letter
-changed = style.with_letter(:S)           # => #<Sin::Style letter=:S side=:first>
-changed.to_s                              # => "S"
+changed = identifier.with_letter(:S) # => #<Sin::Identifier letter=:S side=:first>
+changed.to_s # => "S"
 
 # Change side
-other_side = style.with_side(:second)     # => #<Sin::Style letter=:c side=:second>
-other_side.to_s                           # => "c"
+other_side = identifier.with_side(:second) # => #<Sin::Identifier letter=:c side=:second>
+other_side.to_s # => "c"
 
 # Chain transformations
-result = style.flip.with_letter(:M)       # => #<Sin::Style letter=:m side=:second>
-result.to_s                               # => "m"
+result = identifier.flip.with_letter(:M) # => #<Sin::Identifier letter=:m side=:second>
+result.to_s # => "m"
 ```
 
 ### Player and Style Queries
 
 ```ruby
-style = Sashite::Sin.parse("C")
+identifier = Sashite::Sin.parse("C")
 opposite = Sashite::Sin.parse("s")
 
 # Player identification
-style.first_player?                       # => true
-style.second_player?                      # => false
+identifier.first_player?                       # => true
+identifier.second_player?                      # => false
 opposite.first_player?                    # => false
 opposite.second_player?                   # => true
 
@@ -95,23 +95,23 @@ chess1.same_side?(shogi)                  # => true (both first player)
 chess1.same_letter?(shogi)                # => false (different letters)
 ```
 
-### Style Collections
+### Identifier Collections
 
 ```ruby
-# Working with multiple styles
-styles = %w[C c S s M m].map { |sin| Sashite::Sin.parse(sin) }
+# Working with multiple identifiers
+identifiers = %w[C c S s M m].map { |sin| Sashite::Sin.parse(sin) }
 
 # Filter by player
-first_player_styles = styles.select(&:first_player?)
-first_player_styles.map(&:to_s) # => ["C", "S", "M"]
+first_player_identifiers = identifiers.select(&:first_player?)
+first_player_identifiers.map(&:to_s) # => ["C", "S", "M"]
 
 # Group by letter family
-by_letter = styles.group_by { |s| s.letter.to_s.upcase }
+by_letter = identifiers.group_by { |i| i.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"]
+chess_identifiers = identifiers.select { |i| i.letter.to_s.upcase == "C" }
+chess_identifiers.map(&:to_s) # => ["C", "c"]
 ```
 
 ## Format Specification
@@ -148,15 +148,15 @@ The SIN specification is rule-agnostic and does not define specific letter assig
 ### Traditional Game Families
 
 ```ruby
-# Chess family styles
+# Chess family identifiers
 chess_white = Sashite::Sin.parse("C")    # First player, Chess family
 chess_black = Sashite::Sin.parse("c")    # Second player, Chess family
 
-# Shōgi family styles
+# Shōgi family identifiers
 shogi_sente = Sashite::Sin.parse("S")    # First player, Shōgi family
 shogi_gote = Sashite::Sin.parse("s")     # Second player, Shōgi family
 
-# Xiangqi family styles
+# Xiangqi family identifiers
 xiangqi_red = Sashite::Sin.parse("X")    # First player, Xiangqi family
 xiangqi_black = Sashite::Sin.parse("x")  # Second player, Xiangqi family
 ```
@@ -172,9 +172,9 @@ def create_hybrid_match
   ]
 end
 
-styles = create_hybrid_match
-styles[0].same_side?(styles[1])         # => false (different players)
-styles[0].same_letter?(styles[1])       # => false (different families)
+identifiers = create_hybrid_match
+identifiers[0].same_side?(identifiers[1])         # => false (different players)
+identifiers[0].same_letter?(identifiers[1])       # => false (different families)
 ```
 
 ### Variant Families
@@ -195,14 +195,14 @@ makruk_black.to_s                       # => "m"
 ### Main Module Methods
 
 - `Sashite::Sin.valid?(sin_string)` - Check if string is valid SIN notation
-- `Sashite::Sin.parse(sin_string)` - Parse SIN string into Style object
-- `Sashite::Sin.style(letter, side)` - Create style instance directly
+- `Sashite::Sin.parse(sin_string)` - Parse SIN string into Identifier object
+- `Sashite::Sin.identifier(letter, side)` - Create identifier instance directly
 
-### Style Class
+### Identifier Class
 
 #### Creation and Parsing
-- `Sashite::Sin::Style.new(letter, side)` - Create style instance
-- `Sashite::Sin::Style.parse(sin_string)` - Parse SIN string
+- `Sashite::Sin::Identifier.new(letter, side)` - Create identifier instance
+- `Sashite::Sin::Identifier.parse(sin_string)` - Parse SIN string
 
 #### Attribute Access
 - `#letter` - Get style letter (symbol :A through :z)
@@ -210,25 +210,25 @@ makruk_black.to_s                       # => "m"
 - `#to_s` - Convert to SIN string representation
 
 #### Player Queries
-- `#first_player?` - Check if first player style
-- `#second_player?` - Check if second player style
+- `#first_player?` - Check if first player identifier
+- `#second_player?` - Check if second player identifier
 
 #### 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
+- `#with_letter(new_letter)` - Create identifier with different letter
+- `#with_side(new_side)` - Create identifier 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
+### Identifier Class Constants
 
-- `Sashite::Sin::Style::FIRST_PLAYER` - Symbol for first player (:first)
-- `Sashite::Sin::Style::SECOND_PLAYER` - Symbol for second player (:second)
-- `Sashite::Sin::Style::VALID_SIDES` - Array of valid sides
-- `Sashite::Sin::Style::SIN_PATTERN` - Regular expression for SIN validation
+- `Sashite::Sin::Identifier::FIRST_PLAYER` - Symbol for first player (:first)
+- `Sashite::Sin::Identifier::SECOND_PLAYER` - Symbol for second player (:second)
+- `Sashite::Sin::Identifier::VALID_SIDES` - Array of valid sides
+- `Sashite::Sin::Identifier::SIN_PATTERN` - Regular expression for SIN validation
 
 ## Advanced Usage
 
@@ -257,11 +257,11 @@ letter_a_first.same_side?(letter_a_second)    # => false
 
 ```ruby
 # All transformations return new instances
-original = Sashite::Sin.style(:C, :first)
+original = Sashite::Sin.identifier(:C, :first)
 flipped = original.flip
 changed_letter = original.with_letter(:S)
 
-# Original style is never modified
+# Original identifier is never modified
 original.to_s                           # => "C" (unchanged)
 flipped.to_s                            # => "c"
 changed_letter.to_s                     # => "S"
@@ -293,7 +293,7 @@ Following the [Sashité Protocol](https://sashite.dev/protocol/):
 - **Rule-agnostic**: Independent of specific game mechanics
 - **Minimal overhead**: Single character per style-player combination
 - **Canonical representation**: Each style-player combination has exactly one SIN identifier
-- **Immutable**: All style instances are frozen and transformations return new objects
+- **Immutable**: All identifier instances are frozen and transformations return new objects
 - **Functional**: Pure functions with no side effects
 
 ## Related Specifications

data/lib/sashite/sin/{style.rb → identifier.rb}

@@ -2,15 +2,15 @@
 
 module Sashite
   module Sin
-    # Represents a style in SIN (Style Identifier Notation) format.
+    # Represents an identifier in SIN (Style Identifier Notation) format.
     #
-    # A style consists of a single ASCII letter with case-based side encoding:
+    # An identifier 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 SIN Specification v1.0.0 with Letter and Side attributes.
-    class Style
+    class Identifier
       # SIN validation pattern matching the specification
       SIN_PATTERN = /\A[A-Za-z]\z/
 
@@ -32,7 +32,7 @@ module Sashite
       # @return [Symbol] the player side (:first or :second)
       attr_reader :side
 
-      # Create a new style instance
+      # Create a new identifier instance
       #
       # @param letter [Symbol] style letter (single ASCII letter as symbol)
       # @param side [Symbol] player side (:first or :second)
@@ -47,26 +47,26 @@ module Sashite
         freeze
       end
 
-      # Parse an SIN string into a Style object
+      # Parse an SIN string into an Identifier object
       #
       # @param sin_string [String] SIN notation string (single ASCII letter)
-      # @return [Style] parsed style object with letter and inferred side
+      # @return [Identifier] parsed identifier object with letter and inferred side
       # @raise [ArgumentError] if the SIN string is invalid
       # @example Parse SIN strings with case-based side inference
-      #   Sashite::Sin::Style.parse("C") # => #<Sin::Style letter=:C side=:first>
-      #   Sashite::Sin::Style.parse("c") # => #<Sin::Style letter=:c side=:second>
-      #   Sashite::Sin::Style.parse("S") # => #<Sin::Style letter=:S side=:first>
+      #   Sashite::Sin::Identifier.parse("C") # => #<Sin::Identifier letter=:C side=:first>
+      #   Sashite::Sin::Identifier.parse("c") # => #<Sin::Identifier letter=:c side=:second>
+      #   Sashite::Sin::Identifier.parse("S") # => #<Sin::Identifier letter=:S side=:first>
       def self.parse(sin_string)
         string_value = String(sin_string)
         validate_sin_string(string_value)
 
         # Determine side from case
-        style_side = string_value == string_value.upcase ? FIRST_PLAYER : SECOND_PLAYER
+        identifier_side = string_value == string_value.upcase ? FIRST_PLAYER : SECOND_PLAYER
 
         # Use the letter directly as symbol
-        style_letter = string_value.to_sym
+        identifier_letter = string_value.to_sym
 
-        new(style_letter, style_side)
+        new(identifier_letter, identifier_side)
       end
 
       # Check if a string is a valid SIN notation
@@ -75,42 +75,42 @@ module Sashite
       # @return [Boolean] true if valid SIN, false otherwise
       #
       # @example Validate SIN strings
-      #   Sashite::Sin::Style.valid?("C") # => true
-      #   Sashite::Sin::Style.valid?("c") # => true
-      #   Sashite::Sin::Style.valid?("CHESS") # => false (multi-character)
+      #   Sashite::Sin::Identifier.valid?("C") # => true
+      #   Sashite::Sin::Identifier.valid?("c") # => true
+      #   Sashite::Sin::Identifier.valid?("CHESS") # => false (multi-character)
       def self.valid?(sin_string)
         return false unless sin_string.is_a?(::String)
 
         sin_string.match?(SIN_PATTERN)
       end
 
-      # Convert the style to its SIN string representation
+      # Convert the identifier to its SIN string representation
       #
       # @return [String] SIN 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)
+      # @example Display identifiers
+      #   identifier.to_s  # => "C" (first player, C family)
+      #   identifier.to_s  # => "c" (second player, C family)
+      #   identifier.to_s  # => "S" (first player, S family)
       def to_s
         letter.to_s
       end
 
-      # Create a new style with opposite ownership (side)
+      # Create a new identifier with opposite ownership (side)
       #
-      # @return [Style] new immutable style instance with flipped side
+      # @return [Identifier] new immutable identifier instance with flipped side
       # @example Flip player sides
-      #   style.flip  # (:C, :first) => (:c, :second)
+      #   identifier.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)
+      # Create a new identifier 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)
+      # @return [Identifier] new immutable identifier instance with different letter
+      # @example Change identifier letter
+      #   identifier.with_letter(:S)  # (:C, :first) => (:S, :first)
       def with_letter(new_letter)
         self.class.validate_letter(new_letter)
         return self if letter == new_letter
@@ -120,12 +120,12 @@ module Sashite
         self.class.new(adjusted_letter, side)
       end
 
-      # Create a new style with a different side (keeping same letter family)
+      # Create a new identifier with a different side (keeping same letter family)
       #
       # @param new_side [Symbol] :first or :second
-      # @return [Style] new immutable style instance with different side
+      # @return [Identifier] new immutable identifier instance with different side
       # @example Change player side
-      #   style.with_side(:second)  # (:C, :first) => (:c, :second)
+      #   identifier.with_side(:second)  # (:C, :first) => (:c, :second)
       def with_side(new_side)
         self.class.validate_side(new_side)
         return self if side == new_side
@@ -135,36 +135,36 @@ module Sashite
         self.class.new(new_letter, new_side)
       end
 
-      # Check if the style belongs to the first player
+      # Check if the identifier 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
+      # Check if the identifier 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
+      # Check if this identifier 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
+      # @param other [Identifier] identifier to compare with
+      # @return [Boolean] true if both identifiers use the same letter family (case-insensitive)
+      # @example Compare identifier letter families
+      #   c_identifier.same_letter?(C_identifier)  # (: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
+      # Check if this identifier 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
+      # @param other [Identifier] identifier to compare with
+      # @return [Boolean] true if both identifiers belong to the same side
       def same_side?(other)
         return false unless other.is_a?(self.class)
 
@@ -174,7 +174,7 @@ module Sashite
       # Custom equality comparison
       #
       # @param other [Object] object to compare with
-      # @return [Boolean] true if both objects are styles with identical letter and side
+      # @return [Boolean] true if both objects are identifiers with identical letter and side
       def ==(other)
         return false unless other.is_a?(self.class)
 

data/lib/sashite/sin.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "sin/style"
+require_relative "sin/identifier"
 
 module Sashite
   # SIN (Style Identifier Notation) implementation for Ruby
@@ -20,7 +20,7 @@ module Sashite
   #   "S"  - First player, S style family
   #   "s"  - Second player, S style family
   #
-  # See: https://sashite.dev/specs/sin/1.0.0/
+  # @see https://sashite.dev/specs/sin/1.0.0/
   module Sin
     # Check if a string is a valid SIN notation
     #
@@ -33,33 +33,33 @@ module Sashite
     #   Sashite::Sin.valid?("CHESS") # => false (multi-character)
     #   Sashite::Sin.valid?("1") # => false (not a letter)
     def self.valid?(sin_string)
-      Style.valid?(sin_string)
+      Identifier.valid?(sin_string)
     end
 
-    # Parse an SIN string into a Style object
+    # Parse an SIN string into an Identifier object
     #
     # @param sin_string [String] SIN notation string
-    # @return [Sin::Style] parsed style object with letter and side attributes
+    # @return [Sin::Identifier] parsed identifier object with letter and side attributes
     # @raise [ArgumentError] if the SIN string is invalid
     # @example Parse different SIN formats
-    #   Sashite::Sin.parse("C") # => #<Sin::Style letter=:C side=:first>
-    #   Sashite::Sin.parse("c") # => #<Sin::Style letter=:c side=:second>
-    #   Sashite::Sin.parse("S") # => #<Sin::Style letter=:S side=:first>
+    #   Sashite::Sin.parse("C") # => #<Sin::Identifier letter=:C side=:first>
+    #   Sashite::Sin.parse("c") # => #<Sin::Identifier letter=:c side=:second>
+    #   Sashite::Sin.parse("S") # => #<Sin::Identifier letter=:S side=:first>
     def self.parse(sin_string)
-      Style.parse(sin_string)
+      Identifier.parse(sin_string)
     end
 
-    # Create a new style instance
+    # Create a new identifier instance
     #
     # @param letter [Symbol] style letter (single ASCII letter as symbol)
     # @param side [Symbol] player side (:first or :second)
-    # @return [Sin::Style] new immutable style instance
+    # @return [Sin::Identifier] new immutable identifier instance
     # @raise [ArgumentError] if parameters are invalid
-    # @example Create styles directly
-    #   Sashite::Sin.style(:C, :first)  # => #<Sin::Style letter=:C side=:first>
-    #   Sashite::Sin.style(:s, :second) # => #<Sin::Style letter=:s side=:second>
-    def self.style(letter, side)
-      Style.new(letter, side)
+    # @example Create identifiers directly
+    #   Sashite::Sin.identifier(:C, :first)  # => #<Sin::Identifier letter=:C side=:first>
+    #   Sashite::Sin.identifier(:s, :second) # => #<Sin::Identifier letter=:s side=:second>
+    def self.identifier(letter, side)
+      Identifier.new(letter, side)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sashite-sin
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Cyril Kato
@@ -12,11 +12,11 @@ dependencies: []
 description: |
   SIN (Style Identifier Notation) provides a rule-agnostic format for identifying styles
   in abstract strategy board games. This gem implements the SIN Specification v1.0.0 with
-  a modern Ruby interface featuring immutable style objects and functional programming
+  a modern Ruby interface featuring immutable identifier objects and functional programming
   principles. SIN 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.
+  gaming systems requiring compact style identification with enhanced collision resolution.
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -26,7 +26,7 @@ files:
 - README.md
 - lib/sashite-sin.rb
 - lib/sashite/sin.rb
-- lib/sashite/sin/style.rb
+- lib/sashite/sin/identifier.rb
 homepage: https://github.com/sashite/sin.rb
 licenses:
 - MIT
@@ -53,6 +53,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: SIN (Style Identifier Notation) implementation for Ruby with immutable style
+summary: SIN (Style Identifier Notation) implementation for Ruby with immutable identifier
   objects
 test_files: []