feen 5.0.0.beta4 → 5.0.0.beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de87bfc9b071e9f1ff14b6f7378ba0a6f9f78cdb9a9bfe32ca00f2494a1be2cd
-  data.tar.gz: fd4d19e8a3b7fb845f081b127a859ff0791c8c11c05e1efb4846152044f67c18
+  metadata.gz: 28b60c3d60fd3241172fee9e143c53e6dca04082a2efe7f0fa7559b85dc6eac0
+  data.tar.gz: a15999144de7bcd5637b6efca4ed1c4a8ae7d3757d6d583123dfaf44468d6d35
 SHA512:
-  metadata.gz: e9fe95297b8577a3bf171a865deca0dc9c2eed91a7d039c04f97077d53d3fa912ca553f28f448f0dd987087926d3ca5225624d7f2d8d08a9275a16a11efe26e0
-  data.tar.gz: b82b7e00f5ece6f5e5859750226be3c74db23e694c8e53def8c8c656fe2fb3ecba7f0f4166cf3d9a4f6c7b4ab7af3cf6544da87a2684e438a389d96e04b3dc75
+  metadata.gz: 861669bea6101dba5eefcf6062b9e4e0b37152618e7ffa9c1ba963eb37b2f49cad804f4c1bbee31bd030bf4ddd9602563df7e54cc244384d37e1f45ec748c5ff
+  data.tar.gz: 6f00dcfc09fd378fde0fbe3cd36b078718eab1fa27e208d474637ef89853a7543be4027116d623d0e037c340f0deeae90ce337404db09c953faecba852f56ece

data/README.md

@@ -12,6 +12,7 @@
 FEEN (Forsyth–Edwards Enhanced Notation) is a compact, canonical, and rule-agnostic textual format for representing static board positions in two-player piece-placement games.
 
 This gem implements the [FEEN Specification v1.0.0](https://sashite.dev/documents/feen/1.0.0/), providing a Ruby interface for:
+
 - Representing positions from various games without knowledge of specific rules
 - Supporting boards of arbitrary dimensions
 - Encoding pieces in hand (as used in Shogi)
@@ -22,7 +23,7 @@ This gem implements the [FEEN Specification v1.0.0](https://sashite.dev/document
 
 ```ruby
 # In your Gemfile
-gem "feen", ">= 5.0.0.beta4"
+gem "feen", ">= 5.0.0.beta5"
 ```
 
 Or install manually:
@@ -48,20 +49,20 @@ Convert a FEEN string into a structured Ruby object:
 ```ruby
 require "feen"
 
-feen_string = "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess"
+feen_string = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
 position = Feen.parse(feen_string)
 
 # Result is a hash:
 # {
 #   piece_placement: [
-#     ["r", "n", "b", "q", "k=", "b", "n", "r"],
+#     ["r'", "n", "b", "q", "k", "b", "n", "r'"],
 #     ["p", "p", "p", "p", "p", "p", "p", "p"],
 #     ["", "", "", "", "", "", "", ""],
 #     ["", "", "", "", "", "", "", ""],
 #     ["", "", "", "", "", "", "", ""],
 #     ["", "", "", "", "", "", "", ""],
 #     ["P", "P", "P", "P", "P", "P", "P", "P"],
-#     ["R", "N", "B", "Q", "K=", "B", "N", "R"]
+#     ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
 #   ],
 #   pieces_in_hand: [],
 #   games_turn: ["CHESS", "chess"]
@@ -76,7 +77,7 @@ Parse a FEEN string without raising exceptions:
 require "feen"
 
 # Valid FEEN string
-result = Feen.safe_parse("rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess")
+result = Feen.safe_parse("r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess")
 # => {piece_placement: [...], pieces_in_hand: [...], games_turn: [...]}
 
 # Invalid FEEN string
@@ -93,14 +94,14 @@ require "feen"
 
 # Representation of a chess board in initial position
 piece_placement = [
-  ["r", "n", "b", "q", "k=", "b", "n", "r"],
+  ["r'", "n", "b", "q", "k", "b", "n", "r'"],
   ["p", "p", "p", "p", "p", "p", "p", "p"],
   ["", "", "", "", "", "", "", ""],
   ["", "", "", "", "", "", "", ""],
   ["", "", "", "", "", "", "", ""],
   ["", "", "", "", "", "", "", ""],
   ["P", "P", "P", "P", "P", "P", "P", "P"],
-  ["R", "N", "B", "Q", "K=", "B", "N", "R"]
+  ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
 ]
 
 result = Feen.dump(
@@ -108,7 +109,7 @@ result = Feen.dump(
   games_turn:      %w[CHESS chess],
   pieces_in_hand:  []
 )
-# => "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess"
+# => "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
 ```
 
 ### Validation
@@ -132,6 +133,7 @@ Feen.valid?("lnsgk3l/5g3/p1ppB2pp/9/8B/2P6/P2PPPPPP/3K3R1/5rSNL N5P2gn2sl SHOGI/
 ```
 
 The `valid?` method performs two levels of validation:
+
 1. **Syntax check**: Verifies the string can be parsed as FEEN
 2. **Canonicity check**: Ensures the string is in its canonical form through round-trip conversion
 
@@ -142,11 +144,12 @@ As FEEN is rule-agnostic, it can represent positions from various board games. H
 ### International Chess
 
 ```ruby
-feen_string = "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess"
+feen_string = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
 ```
 
 In this initial chess position:
-- The `=` suffixes on kings indicate castling rights on both sides (though FEEN doesn't define this semantics)
+
+- The `'` suffixes on rooks indicate an intermediate state (which might represent castling rights in chess, though FEEN doesn't define this semantics)
 - The third field `CHESS/chess` indicates it's the player with uppercase pieces' turn to move
 
 ### Shogi (Japanese Chess)
@@ -156,6 +159,7 @@ feen_string = "lnsgk3l/5g3/p1ppB2pp/9/8B/2P6/P2PPPPPP/3K3R1/5rSNL N5P2gln2s SHOG
 ```
 
 In this shogi position:
+
 - The format supports promotions with the `+` prefix (e.g., `+P` for a promoted pawn)
 - The notation allows for pieces in hand, indicated in the second field
 - `SHOGI/shogi` indicates it's Sente's (Black's, uppercase) turn to move
@@ -176,6 +180,7 @@ feen_string = "rheagaehr/9/1c5c1/s1s1s1s1s/9/9/S1S1S1S1S/1C5C1/9/RHEAGAEHR - XIA
 ```
 
 In this Xiangqi position:
+
 - The representation uses single letters for the different pieces
 - The format naturally adapts to the presence of a "river" (empty space in the middle)
 
@@ -212,19 +217,15 @@ result = Feen.dump(
 
 FEEN supports prefixes and suffixes for pieces to denote various states or capabilities:
 
-- **Prefix `+`**: May indicate promotion or special state
+- **Prefix `+`**: Enhanced state
   - Example in shogi: `+P` may represent a promoted pawn
 
-- **Suffix `=`**: May indicate dual-option status
-  - Example in chess: `K=` may represent a king eligible for both kingside and queenside castling
-
-- **Suffix `<`**: May indicate left-side constraint
-  - Example in chess: `K<` may represent a king eligible for queenside castling only
-  - Example in chess: `P<` may represent a pawn that may be captured _en passant_ from the left
+- **Prefix `-`**: Diminished state
+  - Could represent a piece with limited movement or other restrictions
 
-- **Suffix `>`**: May indicate right-side constraint
-  - Example in chess: `K>` may represent a king eligible for kingside castling only
-  - Example in chess: `P>` may represent a pawn that may be captured en passant from the right
+- **Suffix `'`**: Intermediate state
+  - Example in chess: `R'` may represent a rook that has intermediate status (such as castling eligibility)
+  - Example in chess: `P'` may represent a pawn that may be captured _en passant_
 
 These modifiers have no defined semantics in the FEEN specification itself but provide a flexible framework for representing piece-specific conditions while maintaining FEEN's rule-agnostic nature.
 
@@ -239,4 +240,4 @@ The [gem](https://rubygems.org/gems/feen) is available as open source under the
 
 ## About Sashité
 
-This project is maintained by [Sashité](https://sashite.com/) - a project dedicated to promoting chess variants and sharing the beauty of Chinese, Japanese, and Western chess cultures.
+This project is maintained by [Sashité](https://sashite.com/) — promoting chess variants and sharing the beauty of Chinese, Japanese, and Western chess cultures.

data/lib/feen/dumper/piece_placement.rb

@@ -7,7 +7,7 @@ module Feen
       #
       # @param piece_placement [Array] Hierarchical array representing the board where:
       #   - Empty squares are represented by empty strings ("")
-      #   - Pieces are represented by strings (e.g., "r", "K=", "+P")
+      #   - Pieces are represented by strings (e.g., "r", "R'", "+P")
       #   - Dimensions are represented by nested arrays
       # @return [String] FEEN piece placement string
       # @raise [ArgumentError] If the piece placement structure is invalid

data/lib/feen/dumper.rb

@@ -23,19 +23,19 @@ module Feen
     # @example Creating a FEEN string for chess initial position
     #   Feen::Dumper.dump(
     #     piece_placement: [
-    #       ["r", "n", "b", "q", "k=", "b", "n", "r"],
+    #       ["r'", "n", "b", "q", "k", "b", "n", "r'"],
     #       ["p", "p", "p", "p", "p", "p", "p", "p"],
     #       ["", "", "", "", "", "", "", ""],
     #       ["", "", "", "", "", "", "", ""],
     #       ["", "", "", "", "", "", "", ""],
     #       ["", "", "", "", "", "", "", ""],
     #       ["P", "P", "P", "P", "P", "P", "P", "P"],
-    #       ["R", "N", "B", "Q", "K=", "B", "N", "R"]
+    #       ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
     #     ],
     #     pieces_in_hand: [],
     #     games_turn: ["CHESS", "chess"]
     #   )
-    #   # => "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess"
+    #   # => "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
     #
     # @param piece_placement [Array] Board position data structure representing the spatial
     #                                distribution of pieces across the board, where each cell

data/lib/feen/parser/piece_placement.rb

@@ -30,10 +30,8 @@ module Feen
       VALID_PREFIXES = [PREFIX_PROMOTION, PREFIX_DIMINISHED].freeze
 
       # Valid piece suffixes
-      SUFFIX_EQUALS = "="
-      SUFFIX_LEFT = "<"
-      SUFFIX_RIGHT = ">"
-      VALID_SUFFIXES = [SUFFIX_EQUALS, SUFFIX_LEFT, SUFFIX_RIGHT].freeze
+      SUFFIX_INTERMEDIATE = "'"
+      VALID_SUFFIXES = [SUFFIX_INTERMEDIATE].freeze
 
       # Build validation pattern step by step to match BNF
       # <letter> ::= <letter-lowercase> | <letter-uppercase>
@@ -42,8 +40,8 @@ module Feen
       # <prefix> ::= "+" | "-"
       PREFIX = "[+-]"
 
-      # <suffix> ::= "=" | "<" | ">"
-      SUFFIX = "[=<>]"
+      # <suffix> ::= "'"
+      SUFFIX = "[']"
 
       # <piece> ::= <letter> | <prefix> <letter> | <letter> <suffix> | <prefix> <letter> <suffix>
       PIECE = "(?:#{PREFIX}?#{LETTER}#{SUFFIX}?)"

data/lib/feen/parser.rb

@@ -26,18 +26,18 @@ module Feen
     # @raise [ArgumentError] If the FEEN string is invalid
     #
     # @example Parsing a standard chess initial position
-    #   feen = "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess"
+    #   feen = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
     #   result = Feen::Parser.parse(feen)
     #   # => {
     #   #      piece_placement: [
-    #   #        ["r", "n", "b", "q", "k=", "b", "n", "r"],
+    #   #        ["r'", "n", "b", "q", "k", "b", "n", "r'"],
     #   #        ["p", "p", "p", "p", "p", "p", "p", "p"],
     #   #        ["", "", "", "", "", "", "", ""],
     #   #        ["", "", "", "", "", "", "", ""],
     #   #        ["", "", "", "", "", "", "", ""],
     #   #        ["", "", "", "", "", "", "", ""],
     #   #        ["P", "P", "P", "P", "P", "P", "P", "P"],
-    #   #        ["R", "N", "B", "Q", "K=", "B", "N", "R"]
+    #   #        ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
     #   #      ],
     #   #      pieces_in_hand: [],
     #   #      games_turn: ["CHESS", "chess"]
@@ -76,7 +76,7 @@ module Feen
     # @return [Hash, nil] Hash containing the parsed position data or nil if parsing fails
     #
     # @example Parsing a valid FEEN string
-    #   feen = "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess"
+    #   feen = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
     #   result = Feen::Parser.safe_parse(feen)
     #   # => {piece_placement: [...], pieces_in_hand: [...], games_turn: [...]}
     #

data/lib/feen.rb

@@ -23,21 +23,21 @@ module Feen
   # @raise [ArgumentError] If any parameter is invalid
   # @example
   #   piece_placement = [
-  #     ["r", "n", "b", "q", "k=", "b", "n", "r"],
+  #     ["r'", "n", "b", "q", "k", "b", "n", "r'"],
   #     ["p", "p", "p", "p", "p", "p", "p", "p"],
   #     ["", "", "", "", "", "", "", ""],
   #     ["", "", "", "", "", "", "", ""],
   #     ["", "", "", "", "", "", "", ""],
   #     ["", "", "", "", "", "", "", ""],
   #     ["P", "P", "P", "P", "P", "P", "P", "P"],
-  #     ["R", "N", "B", "Q", "K=", "B", "N", "R"]
+  #     ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
   #   ]
   #   Feen.dump(
   #     piece_placement: piece_placement,
   #     pieces_in_hand: [],
   #     games_turn: ["CHESS", "chess"]
   #   )
-  #   # => "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess"
+  #   # => "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
   def self.dump(piece_placement:, pieces_in_hand:, games_turn:)
     Dumper.dump(piece_placement:, pieces_in_hand:, games_turn:)
   end
@@ -51,18 +51,18 @@ module Feen
   #   - :games_turn [Array<String>] - A two-element array with [active_variant, inactive_variant]
   # @raise [ArgumentError] If the FEEN string is invalid
   # @example
-  #   feen_string = "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess"
+  #   feen_string = "r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess"
   #   Feen.parse(feen_string)
   #   # => {
   #   #      piece_placement: [
-  #   #        ["r", "n", "b", "q", "k=", "b", "n", "r"],
+  #   #        ["r'", "n", "b", "q", "k", "b", "n", "r'"],
   #   #        ["p", "p", "p", "p", "p", "p", "p", "p"],
   #   #        ["", "", "", "", "", "", "", ""],
   #   #        ["", "", "", "", "", "", "", ""],
   #   #        ["", "", "", "", "", "", "", ""],
   #   #        ["", "", "", "", "", "", "", ""],
   #   #        ["P", "P", "P", "P", "P", "P", "P", "P"],
-  #   #        ["R", "N", "B", "Q", "K=", "B", "N", "R"]
+  #   #        ["R'", "N", "B", "Q", "K", "B", "N", "R'"]
   #   #      ],
   #   #      pieces_in_hand: [],
   #   #      games_turn: ["CHESS", "chess"]
@@ -80,7 +80,7 @@ module Feen
   # @return [Hash, nil] Hash containing the parsed position data or nil if parsing fails
   # @example
   #   # Valid FEEN string
-  #   Feen.safe_parse("rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR - CHESS/chess")
+  #   Feen.safe_parse("r'nbqkbnr'/pppppppp/8/8/8/8/PPPPPPPP/R'NBQKBNR' - CHESS/chess")
   #   # => {piece_placement: [...], pieces_in_hand: [...], games_turn: [...]}
   #
   #   # Invalid FEEN string

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta4
+  version: 5.0.0.beta5
 platform: ruby
 authors:
 - Cyril Kato
@@ -46,9 +46,7 @@ metadata:
   homepage_uri: https://github.com/sashite/feen.rb
   source_code_uri: https://github.com/sashite/feen.rb
   specification_uri: https://sashite.dev/documents/feen/1.0.0/
-  funding_uri: https://github.com/sponsors/cyril
   rubygems_mfa_required: 'true'
-  article_uri: https://blog.cyril.email/posts/2025-05-01/introducing-feen-notation.html
 rdoc_options: []
 require_paths:
 - lib