sashite-sin 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3411653c81ceb4f7711d40c8a924a2efc16e4573797dbd593d5e97cc95a5c643
+  data.tar.gz: 00776c4a29a213e1146cbbee42792c132706f64ac0b500c0389b3b0814fa9264
+SHA512:
+  metadata.gz: d818c870d4a9dc08f74da00acf89662c0e4794ba55bc658d4aca25a1895edc8ded12df5a83f4378375392c1576b12bbb29e47668732089b096fde659153a87da
+  data.tar.gz: 2ebe9efb770a4ca03319d74bc53965dc40d7e5778663a6b4d4a1ab6f7f07a7ef338a313e50f664a49068f0593a88ff5b893f62a3b91c7a88b1fe5a73729bd9ef

data/LICENSE.md

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

data/README.md

@@ -0,0 +1,348 @@
+# Sin.rb
+
+[![Version](https://img.shields.io/github/v/tag/sashite/sin.rb?label=Version&logo=github)](https://github.com/sashite/sin.rb/tags)
+[![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/sashite/sin.rb/main)
+![Ruby](https://github.com/sashite/sin.rb/actions/workflows/main.yml/badge.svg?branch=main)
+[![License](https://img.shields.io/github/license/sashite/sin.rb?label=License&logo=github)](https://github.com/sashite/sin.rb/raw/main/LICENSE.md)
+
+> **SIN** (Style Identifier Notation) implementation for the Ruby language.
+
+## What is SIN?
+
+SIN (Style Identifier Notation) provides a compact, ASCII-based format for identifying **styles** in abstract strategy board games. SIN uses single-character identifiers with case encoding to represent both style identity and player assignment simultaneously.
+
+This gem implements the [SIN Specification v1.0.0](https://sashite.dev/specs/sin/1.0.0/), providing a rule-agnostic notation system for style identification in board games.
+
+## Installation
+
+```ruby
+# In your Gemfile
+gem "sashite-sin"
+```
+
+Or install manually:
+
+```sh
+gem install sashite-sin
+```
+
+## Usage
+
+### Basic Operations
+
+```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
+
+# 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>
+
+# Validate SIN strings
+Sashite::Sin.valid?("C")                 # => true
+Sashite::Sin.valid?("c")                 # => true
+Sashite::Sin.valid?("1")                 # => false (not a letter)
+Sashite::Sin.valid?("CC")                # => false (not single character)
+```
+
+### Style Transformations
+
+```ruby
+# All transformations return new immutable instances
+style = Sashite::Sin.parse("C")
+
+# Flip player assignment
+flipped = style.flip                      # => #<Sin::Style 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"
+
+# Change side
+other_side = style.with_side(:second)     # => #<Sin::Style 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"
+```
+
+### Player and Style Queries
+
+```ruby
+style = Sashite::Sin.parse("C")
+opposite = Sashite::Sin.parse("s")
+
+# Player identification
+style.first_player?                       # => true
+style.second_player?                      # => false
+opposite.first_player?                    # => false
+opposite.second_player?                   # => true
+
+# Letter comparison
+chess1 = Sashite::Sin.parse("C")
+chess2 = Sashite::Sin.parse("c")
+shogi = Sashite::Sin.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 { |sin| Sashite::Sin.parse(sin) }
+
+# 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-letter>
+```
+
+### Grammar (BNF)
+```bnf
+<sin> ::= <uppercase-letter> | <lowercase-letter>
+
+<uppercase-letter> ::= "A" | "B" | "C" | ... | "Z"
+<lowercase-letter> ::= "a" | "b" | "c" | ... | "z"
+```
+
+### Regular Expression
+```ruby
+/\A[A-Za-z]\z/
+```
+
+### Style Attribute Mapping
+
+| Style Attribute | SIN Encoding | Examples |
+|-----------------|--------------|----------|
+| **Style Family** | Letter choice | `C`/`c` = Chess family |
+| **Player Assignment** | Letter case | `C` = First player, `c` = Second player |
+
+## Game Examples
+
+The SIN 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::Sin.parse("C")    # First player, Chess family
+chess_black = Sashite::Sin.parse("c")    # Second player, Chess family
+
+# Shōgi family styles
+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_red = Sashite::Sin.parse("X")    # First player, Xiangqi family
+xiangqi_black = Sashite::Sin.parse("x")  # Second player, Xiangqi family
+```
+
+### Cross-Style Scenarios
+
+```ruby
+# Different families in one match
+def create_hybrid_match
+  [
+    Sashite::Sin.parse("C"),             # First player uses Chess family
+    Sashite::Sin.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)
+```
+
+### Variant Families
+
+```ruby
+# Different letters can represent variants within traditions
+makruk = Sashite::Sin.parse("M")        # Makruk (Thai Chess) family
+janggi = Sashite::Sin.parse("J")        # Janggi (Korean Chess) family
+ogi = Sashite::Sin.parse("O")           # Ōgi (王棋) family
+
+# Each family can have both players
+makruk_black = makruk.flip              # Second player Makruk
+makruk_black.to_s                       # => "m"
+```
+
+## API Reference
+
+### 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
+
+### Style Class
+
+#### Creation and Parsing
+- `Sashite::Sin::Style.new(letter, side)` - Create style instance
+- `Sashite::Sin::Style.parse(sin_string)` - Parse SIN string
+
+#### Attribute Access
+- `#letter` - Get style letter (symbol :A through :z)
+- `#side` - Get player side (:first or :second)
+- `#to_s` - Convert to SIN 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::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
+
+## Advanced Usage
+
+### Letter Case and Side Mapping
+
+```ruby
+# SIN encodes player assignment through case
+upper_case_letters = ("A".."Z").map { |letter| Sashite::Sin.parse(letter) }
+lower_case_letters = ("a".."z").map { |letter| Sashite::Sin.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::Sin.parse("A")
+letter_a_second = Sashite::Sin.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::Sin.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"
+```
+
+## Protocol Mapping
+
+Following the [Sashité Protocol](https://sashite.dev/protocol/):
+
+| Protocol Attribute | SIN 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 SIN identifier
+- **Immutable**: All style instances are frozen and transformations return new objects
+- **Functional**: Pure functions with no side effects
+
+## Related Specifications
+
+- [SIN Specification v1.0.0](https://sashite.dev/specs/sin/1.0.0/) - Complete technical specification
+- [SIN Examples](https://sashite.dev/specs/sin/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
+
+## Documentation
+
+- [Official SIN Specification v1.0.0](https://sashite.dev/specs/sin/1.0.0/)
+- [SIN Examples Documentation](https://sashite.dev/specs/sin/1.0.0/examples/)
+- [Sashité Protocol Foundation](https://sashite.dev/protocol/)
+- [API Documentation](https://rubydoc.info/github/sashite/sin.rb/main)
+
+## Development
+
+```sh
+# Clone the repository
+git clone https://github.com/sashite/sin.rb.git
+cd sin.rb
+
+# Install dependencies
+bundle install
+
+# Run tests
+ruby test.rb
+
+# Generate documentation
+yard doc
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/new-feature`)
+3. Add tests for your changes
+4. Ensure all tests pass (`ruby test.rb`)
+5. Commit your changes (`git commit -am 'Add new feature'`)
+6. Push to the branch (`git push origin feature/new-feature`)
+7. Create a Pull Request
+
+## License
+
+Available as open source under the [MIT License](https://opensource.org/licenses/MIT).
+
+## About
+
+Maintained by [Sashité](https://sashite.com/) — promoting chess variants and sharing the beauty of board game cultures.

data/lib/sashite/sin/style.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Sashite
+  module Sin
+    # Represents a style in SIN (Style Identifier 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 SIN Specification v1.0.0 with Letter and Side attributes.
+    class Style
+      # SIN validation pattern matching the specification
+      SIN_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_SIN = "Invalid SIN 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 SIN string into a Style object
+      #
+      # @param sin_string [String] SIN notation string (single ASCII letter)
+      # @return [Style] parsed style 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>
+      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
+
+        # 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 SIN notation
+      #
+      # @param sin_string [String] the string to validate
+      # @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)
+      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
+      #
+      # @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)
+      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?(SIN_PATTERN)
+      end
+
+      # Validate SIN string format
+      #
+      # @param string [String] string to validate
+      # @raise [ArgumentError] if string doesn't match SIN pattern
+      def self.validate_sin_string(string)
+        return if string.match?(SIN_PATTERN)
+
+        raise ::ArgumentError, format(ERROR_INVALID_SIN, string)
+      end
+
+      private_class_method :valid_letter?, :validate_sin_string
+
+      private
+
+      # Get the opposite side
+      #
+      # @return [Symbol] the opposite side
+      def opposite_side
+        first_player? ? SECOND_PLAYER : FIRST_PLAYER
+      end
+    end
+  end
+end

data/lib/sashite/sin.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "sin/style"
+
+module Sashite
+  # SIN (Style Identifier Notation) implementation for Ruby
+  #
+  # Provides a rule-agnostic format for identifying styles in abstract strategy board games.
+  # SIN uses single ASCII letters with case-based side encoding, enabling clear
+  # distinction between different style families in multi-style gaming environments.
+  #
+  # 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 SIN identifier is exactly one ASCII letter
+  #
+  # 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
+  #
+  # See: https://sashite.dev/specs/sin/1.0.0/
+  module Sin
+    # Check if a string is a valid SIN notation
+    #
+    # @param sin_string [String] the string to validate
+    # @return [Boolean] true if valid SIN, false otherwise
+    #
+    # @example Validate various SIN formats
+    #   Sashite::Sin.valid?("C") # => true
+    #   Sashite::Sin.valid?("c") # => true
+    #   Sashite::Sin.valid?("CHESS") # => false (multi-character)
+    #   Sashite::Sin.valid?("1") # => false (not a letter)
+    def self.valid?(sin_string)
+      Style.valid?(sin_string)
+    end
+
+    # Parse an SIN string into a Style object
+    #
+    # @param sin_string [String] SIN notation string
+    # @return [Sin::Style] parsed style 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>
+    def self.parse(sin_string)
+      Style.parse(sin_string)
+    end
+
+    # Create a new style 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
+    # @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)
+    end
+  end
+end

data/lib/sashite-sin.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "sashite/sin"
+
+# Sashité namespace for board game notation libraries
+#
+# Sashité provides a collection of libraries for representing and manipulating
+# board game concepts according to the Sashité Protocol specifications.
+#
+# @see https://sashite.dev/protocol/ Sashité Protocol
+# @see https://sashite.dev/specs/ Sashité Specifications
+# @author Sashité
+module Sashite
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: sashite-sin
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cyril Kato
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+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
+  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.
+email: contact@cyril.email
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/sashite-sin.rb
+- lib/sashite/sin.rb
+- lib/sashite/sin/style.rb
+homepage: https://github.com/sashite/sin.rb
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/sashite/sin.rb/issues
+  documentation_uri: https://rubydoc.info/github/sashite/sin.rb/main
+  homepage_uri: https://github.com/sashite/sin.rb
+  source_code_uri: https://github.com/sashite/sin.rb
+  specification_uri: https://sashite.dev/specs/sin/1.0.0/
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: SIN (Style Identifier Notation) implementation for Ruby with immutable style
+  objects
+test_files: []