sashite-sin 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0243c39193799ab26a617517ae8deb0a63f4c6400a00ebdd265710ccae62dccb
-  data.tar.gz: 6a7c470c3f03680ab983ebb65c66d0a28dacaf1b6f422d5a900d214999f6ba2b
+  metadata.gz: '080b65573c2e27e8efe5c2ed79009daf31124b35c88ddc7bbe4023e6fe553acf'
+  data.tar.gz: fc25ce0ac44111a41d764aa8badac8ca2727a163e00accd5d8bf52ca301198d0
 SHA512:
-  metadata.gz: fcd80485fabc9888e20925161a29b9c6cd1dc286d8cd802e1363e8887991226243c414c7ff6c50714b464d6eb8058519c5d04fd82458856a5c4d0a618e1185b9
-  data.tar.gz: b1005945dd8bdcd9c818c07a104ac8582e3b2e966dc73626034cf53f7b1c7d306a59b419621c0eb3dc1705200e55ffa54904b4f54d2842348d13f797e9e3b329
+  metadata.gz: 93caf9df6d423fa40562f43971b8ea1c1a0c1bba1d4de9d11ee59184d2906638e2d4aa25639ed40010090dfa2929a658e9ba52f714bb46d1616639b6f2983685
+  data.tar.gz: 3d8c978b778d1210e71c288a41daf9f80a750a5a1f975c22a1536f8499f280a7302f0a51c6641d72522b3cc18b88bca5bb94ab7fdac5f8c7de1920b5444fc700

data/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2025 Cyril Kato
+   Copyright 2025-2026 Cyril Kato
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/README.md

@@ -2,7 +2,7 @@
 
 [![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)
-[![CI](https://github.com/sashite/sin.rb/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/sashite/sin.rb/actions)
+[![CI](https://github.com/sashite/sin.rb/actions/workflows/ruby.yml/badge.svg?branch=main)](https://github.com/sashite/sin.rb/actions)
 [![License](https://img.shields.io/github/license/sashite/sin.rb?label=License&logo=github)](https://github.com/sashite/sin.rb/raw/main/LICENSE)
 
 > **SIN** (Style Identifier Notation) implementation for Ruby.
@@ -35,13 +35,13 @@ require "sashite/sin"
 
 # Standard parsing (raises on error)
 sin = Sashite::Sin.parse("C")
-sin.style  # => :C
-sin.side   # => :first
+sin.abbr  # => :C
+sin.side  # => :first
 
 # Lowercase indicates second player
 sin = Sashite::Sin.parse("c")
-sin.style  # => :C
-sin.side   # => :second
+sin.abbr  # => :C
+sin.side  # => :second
 
 # Invalid input raises ArgumentError
 Sashite::Sin.parse("")    # => raises ArgumentError
@@ -72,34 +72,6 @@ Sashite::Sin.valid?("CC")  # => false
 Sashite::Sin.valid?("1")   # => false
 ```
 
-### Accessing Identifier Data
-
-```ruby
-sin = Sashite::Sin.parse("C")
-
-# Get attributes
-sin.style  # => :C
-sin.side   # => :first
-
-# Get string component
-sin.letter  # => "C"
-```
-
-### Transformations
-
-All transformations return new immutable `Identifier` objects.
-
-```ruby
-sin = Sashite::Sin.parse("C")
-
-# Side transformation
-sin.flip.to_s  # => "c"
-
-# Attribute changes
-sin.with_style(:S).to_s  # => "S"
-sin.with_side(:second).to_s  # => "c"
-```
-
 ### Queries
 
 ```ruby
@@ -111,8 +83,8 @@ sin.second_player?  # => false
 
 # Comparison queries
 other = Sashite::Sin.parse("c")
-sin.same_style?(other)  # => true
-sin.same_side?(other)   # => false
+sin.same_abbr?(other)  # => true
+sin.same_side?(other)  # => false
 ```
 
 ## API Reference
@@ -120,20 +92,20 @@ sin.same_side?(other)   # => false
 ### Types
 
 ```ruby
-# Identifier represents a parsed SIN identifier with style and side.
+# Identifier represents a parsed SIN identifier with abbreviation and side.
 class Sashite::Sin::Identifier
-  # Creates an Identifier from style and side.
+  # Creates an Identifier from abbreviation and side.
   # Raises ArgumentError if attributes are invalid.
   #
-  # @param style [Symbol] Style abbreviation (:A through :Z)
+  # @param abbr [Symbol] Style abbreviation (:A through :Z)
   # @param side [Symbol] Player side (:first or :second)
   # @return [Identifier]
-  def initialize(style, side)
+  def initialize(abbr, side)
 
-  # Returns the style as an uppercase symbol.
+  # Returns the style abbreviation as an uppercase symbol.
   #
   # @return [Symbol]
-  def style
+  def abbr
 
   # Returns the player side.
   #
@@ -150,8 +122,8 @@ end
 ### Constants
 
 ```ruby
-Sashite::Sin::Identifier::VALID_STYLES  # => [:A, :B, ..., :Z]
-Sashite::Sin::Identifier::VALID_SIDES   # => [:first, :second]
+Sashite::Sin::Identifier::VALID_ABBRS  # => [:A, :B, ..., :Z]
+Sashite::Sin::Identifier::VALID_SIDES  # => [:first, :second]
 ```
 
 ### Parsing
@@ -176,19 +148,6 @@ def Sashite::Sin.parse(string)
 def Sashite::Sin.valid?(string)
 ```
 
-### Transformations
-
-All transformations return new `Sashite::Sin::Identifier` objects:
-
-```ruby
-# Side transformation
-def flip  # => Identifier
-
-# Attribute changes
-def with_style(style)  # => Identifier
-def with_side(side)    # => Identifier
-```
-
 ### Queries
 
 ```ruby
@@ -197,8 +156,8 @@ def first_player?   # => Boolean
 def second_player?  # => Boolean
 
 # Comparison queries
-def same_style?(other)  # => Boolean
-def same_side?(other)   # => Boolean
+def same_abbr?(other)  # => Boolean
+def same_side?(other)  # => Boolean
 ```
 
 ### Errors
@@ -213,10 +172,10 @@ All parsing and validation errors raise `ArgumentError` with descriptive message
 
 ## Design Principles
 
-- **Bounded values**: Explicit validation of styles and sides
+- **Bounded values**: Explicit validation of abbreviations and sides
 - **Object-oriented**: `Identifier` class enables methods and encapsulation
 - **Ruby idioms**: `valid?` predicate, `to_s` conversion, `ArgumentError` for invalid input
-- **Immutable identifiers**: All transformations return new objects
+- **Immutable identifiers**: Instances are frozen after creation
 - **No dependencies**: Pure Ruby standard library only
 
 ## Related Specifications

data/lib/sashite/sin/constants.rb

@@ -4,20 +4,20 @@ module Sashite
   module Sin
     # Constants for the SIN (Style Identifier Notation) specification.
     #
-    # Defines valid values for styles and sides, as well as formatting constants.
+    # Defines valid values for abbreviations and sides, as well as formatting constants.
     #
-    # @example Accessing valid styles
-    #   Constants::VALID_STYLES  # => [:A, :B, ..., :Z]
+    # @example Accessing valid abbreviations
+    #   Constants::VALID_ABBRS  # => [:A, :B, ..., :Z]
     #
     # @example Accessing valid sides
     #   Constants::VALID_SIDES  # => [:first, :second]
     #
     # @see https://sashite.dev/specs/sin/1.0.0/
     module Constants
-      # Valid style symbols (A-Z as uppercase symbols).
+      # Valid abbreviation symbols (A-Z as uppercase symbols).
       #
-      # @return [Array<Symbol>] Array of 26 valid style symbols
-      VALID_STYLES = %i[A B C D E F G H I J K L M N O P Q R S T U V W X Y Z].freeze
+      # @return [Array<Symbol>] Array of 26 valid abbreviation symbols
+      VALID_ABBRS = %i[A B C D E F G H I J K L M N O P Q R S T U V W X Y Z].freeze
 
       # Valid side symbols.
       #

data/lib/sashite/sin/errors/argument/messages.rb

@@ -29,10 +29,10 @@ module Sashite
           # @return [String] Error message
           MUST_BE_LETTER = "must be a letter"
 
-          # Error message for invalid style value.
+          # Error message for invalid abbreviation value.
           #
           # @return [String] Error message
-          INVALID_STYLE = "invalid style"
+          INVALID_ABBR = "invalid abbr"
 
           # Error message for invalid side value.
           #

data/lib/sashite/sin/identifier.rb

@@ -8,7 +8,7 @@ module Sashite
     # Represents a parsed SIN (Style Identifier Notation) identifier.
     #
     # An Identifier encodes two attributes:
-    # - Style: the piece style (A-Z as uppercase symbol)
+    # - Abbr: the style abbreviation (A-Z as uppercase symbol)
     # - Side: the player side (:first or :second)
     #
     # Instances are immutable (frozen after creation).
@@ -23,21 +23,21 @@ module Sashite
     #
     # @see https://sashite.dev/specs/sin/1.0.0/
     class Identifier
-      # Valid style symbols (A-Z).
-      VALID_STYLES = Constants::VALID_STYLES
+      # Valid abbreviation symbols (A-Z).
+      VALID_ABBRS = Constants::VALID_ABBRS
 
       # Valid side symbols.
       VALID_SIDES = Constants::VALID_SIDES
 
-      # @return [Symbol] Piece style (:A to :Z, always uppercase)
-      attr_reader :style
+      # @return [Symbol] Style abbreviation (:A to :Z, always uppercase)
+      attr_reader :abbr
 
       # @return [Symbol] Player side (:first or :second)
       attr_reader :side
 
       # Creates a new Identifier instance.
       #
-      # @param style [Symbol] Piece style (:A to :Z)
+      # @param abbr [Symbol] Style abbreviation (:A to :Z)
       # @param side [Symbol] Player side (:first or :second)
       # @return [Identifier] A new frozen Identifier instance
       # @raise [Errors::Argument] If any attribute is invalid
@@ -45,11 +45,11 @@ module Sashite
       # @example
       #   Identifier.new(:C, :first)
       #   Identifier.new(:S, :second)
-      def initialize(style, side)
-        validate_style!(style)
+      def initialize(abbr, side)
+        validate_abbr!(abbr)
         validate_side!(side)
 
-        @style = style
+        @abbr = abbr
         @side = side
 
         freeze
@@ -67,18 +67,7 @@ module Sashite
       #   Identifier.new(:C, :first).to_s   # => "C"
       #   Identifier.new(:C, :second).to_s  # => "c"
       def to_s
-        letter
-      end
-
-      # Returns the letter component of the SIN.
-      #
-      # @return [String] Uppercase for first player, lowercase for second
-      #
-      # @example
-      #   Identifier.new(:C, :first).letter   # => "C"
-      #   Identifier.new(:C, :second).letter  # => "c"
-      def letter
-        base = String(style)
+        base = String(abbr)
 
         case side
         when :first  then base.upcase
@@ -86,56 +75,6 @@ module Sashite
         end
       end
 
-      # ========================================================================
-      # Side Transformations
-      # ========================================================================
-
-      # Returns a new Identifier with the opposite side.
-      #
-      # @return [Identifier] A new Identifier with flipped side
-      #
-      # @example
-      #   sin = Identifier.new(:C, :first)
-      #   sin.flip.to_s  # => "c"
-      def flip
-        new_side = first_player? ? :second : :first
-        self.class.new(style, new_side)
-      end
-
-      # ========================================================================
-      # Attribute Transformations
-      # ========================================================================
-
-      # Returns a new Identifier with a different style.
-      #
-      # @param new_style [Symbol] The new piece style (:A to :Z)
-      # @return [Identifier] A new Identifier with the specified style
-      # @raise [Errors::Argument] If the style is invalid
-      #
-      # @example
-      #   sin = Identifier.new(:C, :first)
-      #   sin.with_style(:S).to_s  # => "S"
-      def with_style(new_style)
-        return self if style.equal?(new_style)
-
-        self.class.new(new_style, side)
-      end
-
-      # Returns a new Identifier with a different side.
-      #
-      # @param new_side [Symbol] The new side (:first or :second)
-      # @return [Identifier] A new Identifier with the specified side
-      # @raise [Errors::Argument] If the side is invalid
-      #
-      # @example
-      #   sin = Identifier.new(:C, :first)
-      #   sin.with_side(:second).to_s  # => "c"
-      def with_side(new_side)
-        return self if side.equal?(new_side)
-
-        self.class.new(style, new_side)
-      end
-
       # ========================================================================
       # Side Queries
       # ========================================================================
@@ -164,17 +103,17 @@ module Sashite
       # Comparison Queries
       # ========================================================================
 
-      # Checks if two Identifiers have the same style.
+      # Checks if two Identifiers have the same abbreviation.
       #
       # @param other [Identifier] The other Identifier to compare
-      # @return [Boolean] true if same style
+      # @return [Boolean] true if same abbreviation
       #
       # @example
       #   sin1 = Identifier.new(:C, :first)
       #   sin2 = Identifier.new(:C, :second)
-      #   sin1.same_style?(sin2)  # => true
-      def same_style?(other)
-        style.equal?(other.style)
+      #   sin1.same_abbr?(sin2)  # => true
+      def same_abbr?(other)
+        abbr.equal?(other.abbr)
       end
 
       # Checks if two Identifiers have the same side.
@@ -206,7 +145,7 @@ module Sashite
       def ==(other)
         return false unless self.class === other
 
-        style.equal?(other.style) && side.equal?(other.side)
+        abbr.equal?(other.abbr) && side.equal?(other.side)
       end
 
       alias eql? ==
@@ -215,7 +154,7 @@ module Sashite
       #
       # @return [Integer] Hash code
       def hash
-        [style, side].hash
+        [abbr, side].hash
       end
 
       # Returns an inspect string for the Identifier.
@@ -234,10 +173,10 @@ module Sashite
       # Private Validation
       # ========================================================================
 
-      def validate_style!(style)
-        return if ::Symbol === style && Constants::VALID_STYLES.include?(style)
+      def validate_abbr!(abbr)
+        return if ::Symbol === abbr && Constants::VALID_ABBRS.include?(abbr)
 
-        raise Errors::Argument, Errors::Argument::Messages::INVALID_STYLE
+        raise Errors::Argument, Errors::Argument::Messages::INVALID_ABBR
       end
 
       def validate_side!(side)

data/lib/sashite/sin/parser.rb

@@ -11,8 +11,8 @@ module Sashite
     # malformed input, Unicode lookalikes, and injection attacks.
     #
     # @example Parsing a valid SIN string
-    #   Parser.parse("C")  # => { style: :C, side: :first }
-    #   Parser.parse("c")  # => { style: :C, side: :second }
+    #   Parser.parse("C")  # => { abbr: :C, side: :first }
+    #   Parser.parse("c")  # => { abbr: :C, side: :second }
     #
     # @example Validation
     #   Parser.valid?("C")   # => true
@@ -23,12 +23,12 @@ module Sashite
       # Parses a SIN string into its components.
       #
       # @param input [String] The SIN string to parse
-      # @return [Hash] Hash with :style and :side keys
+      # @return [Hash] Hash with :abbr and :side keys
       # @raise [Errors::Argument] If the input is invalid
       #
       # @example
-      #   Parser.parse("C")  # => { style: :C, side: :first }
-      #   Parser.parse("s")  # => { style: :S, side: :second }
+      #   Parser.parse("C")  # => { abbr: :C, side: :first }
+      #   Parser.parse("s")  # => { abbr: :S, side: :second }
       def self.parse(input)
         validate_input_type!(input)
         validate_not_empty!(input)
@@ -103,15 +103,15 @@ module Sashite
         raise Errors::Argument, Errors::Argument::Messages::MUST_BE_LETTER
       end
 
-      # Extracts style and side from a validated byte.
+      # Extracts abbr and side from a validated byte.
       #
       # @param byte [Integer] A validated ASCII letter byte
-      # @return [Hash] Hash with :style and :side keys
+      # @return [Hash] Hash with :abbr and :side keys
       private_class_method def self.extract_components(byte)
         if uppercase_letter?(byte)
-          { style: byte.chr.to_sym, side: :first }
+          { abbr: byte.chr.to_sym, side: :first }
         else
-          { style: byte.chr.upcase.to_sym, side: :second }
+          { abbr: byte.chr.upcase.to_sym, side: :second }
         end
       end
 

data/lib/sashite/sin.rb

@@ -17,9 +17,9 @@ module Sashite
   #
   # @example Parsing SIN strings
   #   sin = Sashite::Sin.parse("C")
-  #   sin.style  # => :C
-  #   sin.side   # => :first
-  #   sin.to_s   # => "C"
+  #   sin.abbr  # => :C
+  #   sin.side  # => :first
+  #   sin.to_s  # => "C"
   #
   # @example Creating identifiers directly
   #   sin = Sashite::Sin::Identifier.new(:C, :first)
@@ -39,17 +39,17 @@ module Sashite
     #
     # @example Parsing uppercase (first player)
     #   sin = Sashite::Sin.parse("C")
-    #   sin.style  # => :C
-    #   sin.side   # => :first
+    #   sin.abbr  # => :C
+    #   sin.side  # => :first
     #
     # @example Parsing lowercase (second player)
     #   sin = Sashite::Sin.parse("c")
-    #   sin.style  # => :C
-    #   sin.side   # => :second
+    #   sin.abbr  # => :C
+    #   sin.side  # => :second
     def self.parse(input)
       components = Parser.parse(input)
 
-      Identifier.new(components.fetch(:style), components.fetch(:side))
+      Identifier.new(components.fetch(:abbr), components.fetch(:side))
     end
 
     # Reports whether the input is a valid SIN string.

data/lib/sashite-sin.rb

@@ -1,14 +1,3 @@
 # 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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sashite-sin
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Cyril Kato