feen 5.0.0.beta0 → 5.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53d90951a531e63bc118104956d29e7c71c90075ab4d42d57506ec5197a783cb
-  data.tar.gz: 2cbf73113cc4a429420c3c4e0f30c448380a397bf39f264e617fa85119193f7f
+  metadata.gz: 2fa56bccbb1911f15569f2f5643646986cbf83661efba3165c69978e7c85fd56
+  data.tar.gz: 13d706d1bfe1c09f6d015d0a8f28af621754677711074ec60ec96e395f1a1061
 SHA512:
-  metadata.gz: 3919811f24c5ad1f82dfd257eeefe3515efbcb6fd433a1feb20597e4c6a0fbe6a24c33bef56ea7f612e87fac3124b6334b261c1e987a02f7ecf43a6da745f950
-  data.tar.gz: 7b16a8ecd4d80444d1ee14477be61906f3c9503f0a05083dc191822d8a663a6a4fee379c6b0d40fd9bec509c98f0ae863282e1512a6035b7f0624279cb774da0
+  metadata.gz: 5479cbd02c902aa8c45cc12ecfab31c7b7283eb1f8ec60b110c889505a7ebbcf76fa7b0d2e6ad44c60da954312fa85ae03cd4981d929207b0612754f1d62a033
+  data.tar.gz: b6268ce619808bf2c2f889261b55007edbfc030bc37b8edea7f73f505de55e8c0fc1cd4a268e8e2bdc71fe21c9fa33f904c8b26a23b92b471e406e109494bd97

data/README.md

@@ -6,30 +6,18 @@
 [![RuboCop](https://github.com/sashite/feen.rb/workflows/RuboCop/badge.svg?branch=main)](https://github.com/sashite/feen.rb/actions?query=workflow%3Arubocop+branch%3Amain)
 [![License](https://img.shields.io/github/license/sashite/feen.rb?label=License&logo=github)](https://github.com/sashite/feen.rb/raw/main/LICENSE.md)
 
-> __FEEN__ (FEN Easy Extensible Notation) support for the Ruby language.
+> __FEEN__ (Forsyth–Edwards Expanded Notation) support for the Ruby language.
 
 ## Overview
 
-This is an implementation of [FEEN](https://developer.sashite.com/specs/fen-easy-extensible-notation), a generic format that can be used for serializing and deserializing positions.
-
-A __FEEN__ string consists of a single line of ASCII text containing three data fields, separated by a space. These are:
-
-1. Piece placement
-2. Side to move
-3. Pieces in hand
-
-The main chess variants may be supported, including [Chess](https://en.wikipedia.org/wiki/Chess), [Janggi](https://en.wikipedia.org/wiki/Janggi), [Makruk](https://en.wikipedia.org/wiki/Makruk), [Shogi](https://en.wikipedia.org/wiki/Shogi), [Xiangqi](https://en.wikipedia.org/wiki/Xiangqi).
-
-More exotic variants may be also supported, like: [Dai dai shogi](https://en.wikipedia.org/wiki/Dai_dai_shogi), [Four-player chess](https://en.wikipedia.org/wiki/Four-player_chess), or [Three-dimensional chess](https://en.wikipedia.org/wiki/Three-dimensional_chess) 🖖
-
-![3D chess on Star Trek (from the episode "Court Martial")](https://github.com/sashite/feen.rb/raw/main/star-trek-chess.jpg)
+This is an implementation of [FEEN](https://github.com/sashite/specs/blob/main/forsyth-edwards-expanded-notation.md), a flexible and minimalist format for describing chess variant positions.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "feen", ">= 5.0.0.beta0"
+gem "feen", ">= 5.0.0.beta1"
 ```
 
 And then execute:
@@ -50,22 +38,20 @@ gem install feen --pre
 
 A position can be serialized by filling in these fields:
 
-- **Piece placement**: Describes the placement of pieces on the board with a hash that references each piece on the board. The keys could be numbers, or strings of characters representing coordinates.
-- **Side to move**: A char that indicates who moves next. In chess, "`w`" would mean that White must move, and "`b`" that Black must move. In Shogi, "`s`" could mean that Sente must move, and "`g`" that Gote must move. In Xiangqi, "`r`" could mean that Red must move, and "`b`" that Black must move.
-- **Pieces in hand**: An array of all captured pieces that remain _in hand_, like in Shogi.
-- **Board shape**: An array of integers. For instance, it would be `[10, 9]` in Xiangqi. And it would be `[8, 8]` in Chess.
+- **Board shape**: An array of integers. For instance, it would be `[10, 9]` for a Xiangqi board. Or it would be `[8, 8]` for a Chess board.
+- **Piece placement**: Describes the placement of pieces on the board with a hash that references each piece on the board.
+- **Side to move**: A char that indicates who moves next. In chess, "`w`" would mean that White can play a move.
 
-#### Examples
+#### Example
 
-##### A classic Tsume Shogi problem
+From a classic Tsume Shogi problem:
 
 ```ruby
 require "feen"
 
 Feen.dump(
-  side_to_move:    "s",
-  pieces_in_hand:  %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
   board_shape:     [9, 9],
+  side_to_move:    "s",
   piece_placement: {
     3  => "s",
     4  => "k",
@@ -74,23 +60,20 @@ Feen.dump(
     43 => "+B"
   }
 )
-# => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 s S,b,g*4,n*4,p*17,r*2,s"
+# => "3sks3/9/4+P4/9/7+B1/9/9/9/9 s"
 ```
 
 ### Deserialization
 
 Serialized positions can be converted back to fields.
 
-#### Examples
-
-##### A classic Tsume Shogi problem
+#### Example
 
 ```ruby
 require "feen"
 
-Feen.parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 s S,b,g*4,n*4,p*17,r*2,s")
+Feen.parse("3sks3/9/4+P4/9/7+B1/9/9/9/9 s")
 # {:board_shape=>[9, 9],
-#  :pieces_in_hand=>["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
 #  :piece_placement=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"},
 #  :side_to_move=>"s"}
 ```

data/lib/feen/dumper/piece_placement.rb

@@ -44,7 +44,7 @@ module Feen
     #       88 => "傌",
     #       89 => "俥"
     #     }
-    #   ).to_s # => "車,馬,象,士,將,士,象,馬,車/9/1,砲,5,砲,1/卒,1,卒,1,卒,1,卒,1,卒/9/9/兵,1,兵,1,兵,1,兵,1,兵/1,炮,5,炮,1/9/俥,傌,相,仕,帥,仕,相,傌,俥"
+    #   ).to_s # => "車馬象士將士象馬車/9/1砲5砲1/卒1卒1卒1卒1卒/9/9/兵1兵1兵1兵1兵/1炮5炮1/9/俥傌相仕帥仕相傌俥"
     class PiecePlacement
       # @param indexes [Array] The shape of the board.
       # @param piece_placement [Hash] The index of each piece on the board.
@@ -79,6 +79,7 @@ module Feen
           .map { |square| square.nil? ? 1 : square }
           .join(",")
           .gsub(/1,[1,]*1/) { |str| str.split(",").length }
+          .delete(",")
       end
     end
   end

data/lib/feen/dumper.rb

@@ -1,23 +1,20 @@
 # frozen_string_literal: true
 
 require_relative File.join("dumper", "piece_placement")
-require_relative File.join("dumper", "pieces_in_hand")
 
 module Feen
   # The dumper module.
   module Dumper
     # Dump position params into a FEEN string.
     #
-    # @param side_to_move [String] Identify the active side.
-    # @param pieces_in_hand [Array, nil] The list of pieces in hand.
     # @param board_shape [Array] The shape of the board.
+    # @param side_to_move [String] Identify the active side.
     # @param piece_placement [Hash] The index of each piece on the board.
     #
     # @example Dump a classic Tsume Shogi problem
     #   call(
-    #     "side_to_move": "s",
-    #     "pieces_in_hand": %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
     #     "board_shape": [9, 9],
+    #     "side_to_move": "s",
     #     "piece_placement": {
     #        3 => "s",
     #        4 => "k",
@@ -26,17 +23,14 @@ module Feen
     #       43 => "+B"
     #     }
     #   )
-    #   # => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 s S,b,g*4,n*4,p*17,r*2,s"
+    #   # => "3sks3/9/4+P4/9/7+B1/9/9/9/9 s"
     #
     # @return [String] The FEEN string representing the position.
-    def self.call(board_shape:, side_to_move:, piece_placement:, pieces_in_hand: nil)
-      array = [
+    def self.call(board_shape:, side_to_move:, piece_placement:)
+      [
         PiecePlacement.new(board_shape, piece_placement).to_s,
         side_to_move
-      ]
-
-      array << PiecesInHand.dump(pieces_in_hand) if Array(pieces_in_hand).any?
-      array.join(" ")
+      ].join(" ")
     end
   end
 end

data/lib/feen/parser/board_shape.rb

@@ -5,11 +5,12 @@ module Feen
     # The BoardShape class.
     #
     # @example Parse the shape of a shogiban
-    #   BoardShape.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_a # => [9, 9]
+    #   BoardShape.new("3sks3/9/4+P4/9/7+B1/9/9/9/9").to_a # => [9, 9]
     class BoardShape
       # @param board_str [String] The flatten board.
-      def initialize(board_str)
+      def initialize(board_str, regex: /\+?[a-z]/i)
         @board_str = board_str
+        @regex = regex
       end
 
       # @return [Array] The size of each dimension of the board.
@@ -21,8 +22,9 @@ module Feen
 
       def indexes(string, separator)
         if separator.empty?
-          last_index = string.split(",").inject(0) do |counter, sub_string|
-            number = sub_string.match?(/[0-9]+/) ? Integer(sub_string) : 1
+          last_index = string.scan(/(\d+|#{@regex})/).inject(0) do |counter, match|
+            sub_string = match[0]
+            number = sub_string.match?(/\d+/) ? Integer(sub_string) : 1
             counter + number
           end
 

data/lib/feen/parser.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require_relative File.join("parser", "board_shape")
-require_relative File.join("parser", "pieces_in_hand")
-require_relative File.join("parser", "piece_placement")
 
 module Feen
   # The parser module.
@@ -12,11 +10,10 @@ module Feen
     # @param feen [String] The FEEN string representing a position.
     #
     # @example Parse a classic Tsume Shogi problem
-    #   call("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 s S,b,g*4,n*4,p*17,r*2,s")
+    #   call("3sks3/9/4+P4/9/7+B1/9/9/9/9 s")
     #   # => {
-    #   #      "side_to_move": "s",
-    #   #      "pieces_in_hand": ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
     #   #      "board_shape": [9, 9],
+    #   #      "side_to_move": "s",
     #   #      "piece_placement": {
     #   #         3 => "s",
     #   #         4 => "k",
@@ -26,15 +23,29 @@ module Feen
     #   #      }
     #
     # @return [Hash] The position params representing the position.
-    def self.call(feen)
-      piece_placement, side_to_move, pieces_in_hand = feen.split
+    def self.call(feen, regex: /\+?[a-z]/i)
+      piece_placement_str, side_to_move_str = feen.split
 
       {
-        board_shape:     BoardShape.new(piece_placement).to_a,
-        pieces_in_hand:  PiecesInHand.parse(pieces_in_hand),
-        piece_placement: PiecePlacement.new(piece_placement).to_h,
-        side_to_move:
+        board_shape:     BoardShape.new(piece_placement_str, regex:).to_a,
+        piece_placement: piece_placement(piece_placement_str, regex:),
+        side_to_move:    side_to_move_str
       }
     end
+
+    def self.piece_placement(string, regex:)
+      hash = {}
+      index = 0
+      string.scan(/(\d+|#{regex})/) do |match|
+        if /\d+/.match?(match[0])
+          index += match[0].to_i
+        else
+          hash[index] = match[0]
+          index += 1
+        end
+      end
+      hash
+    end
+    private_class_method :piece_placement
   end
 end

data/lib/feen.rb

@@ -6,20 +6,18 @@ require_relative File.join("feen", "parser")
 # This module provides a Ruby interface for data serialization and
 # deserialization in FEEN format.
 #
-# @see https://developer.sashite.com/specs/fen-easy-extensible-notation
+# @see https://github.com/sashite/specs/blob/main/forsyth-edwards-expanded-notation.md
 module Feen
   # Dumps position params into a FEEN string.
   #
-  # @param pieces_in_hand [Array, nil] The list of pieces in hand.
   # @param board_shape [Array] The shape of the board.
   # @param side_to_move [String] The identifier of the player who must play.
   # @param piece_placement [Hash] The index of each piece on the board.
   #
   # @example Dump a classic Tsume Shogi problem
   #   dump(
-  #     "side_to_move": "s",
-  #     "pieces_in_hand": %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p],
   #     "board_shape": [9, 9],
+  #     "side_to_move": "s",
   #     "piece_placement": {
   #        3 => "s",
   #        4 => "k",
@@ -28,12 +26,11 @@ module Feen
   #       43 => "+B"
   #     }
   #   )
-  #   # => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 s S,b,g*4,n*4,p*17,r*2,s"
+  #   # => "3sks3/9/4+P4/9/7+B1/9/9/9/9 s"
   #
   # @return [String] The FEEN string representing the position.
-  def self.dump(board_shape:, side_to_move:, piece_placement:, pieces_in_hand: nil)
+  def self.dump(board_shape:, side_to_move:, piece_placement:)
     Dumper.call(
-      pieces_in_hand:,
       board_shape:,
       side_to_move:,
       piece_placement:
@@ -45,9 +42,8 @@ module Feen
   # @param feen [String] The FEEN string representing a position.
   #
   # @example Parse a classic Tsume Shogi problem
-  #   parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 s S,b,g*4,n*4,p*17,r*2,s")
+  #   parse("3sks3/9/4+P4/9/7+B1/9/9/9/9 s")
   #   # => {
-  #   #      "pieces_in_hand": ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
   #   #      "board_shape": [9, 9],
   #   #      "side_to_move": "s",
   #   #      "piece_placement": {
@@ -59,7 +55,7 @@ module Feen
   #   #      }
   #
   # @return [Hash] The position params representing the position.
-  def self.parse(feen)
-    Parser.call(feen)
+  def self.parse(feen, regex: /\+?[a-z]/i)
+    Parser.call(feen, regex:)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta0
+  version: 5.0.0.beta1
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-25 00:00:00.000000000 Z
+date: 2023-04-27 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby interface for data serialization and deserialization in FEEN format.
 email: contact@cyril.email
@@ -21,11 +21,8 @@ files:
 - lib/feen.rb
 - lib/feen/dumper.rb
 - lib/feen/dumper/piece_placement.rb
-- lib/feen/dumper/pieces_in_hand.rb
 - lib/feen/parser.rb
 - lib/feen/parser/board_shape.rb
-- lib/feen/parser/piece_placement.rb
-- lib/feen/parser/pieces_in_hand.rb
 homepage: https://github.com/sashite/feen.rb
 licenses:
 - MIT

data/lib/feen/dumper/pieces_in_hand.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Dumper
-    # A module that serializes pieces in hand lists into a string.
-    module PiecesInHand
-      # Serialize pieces in hand lists into a string.
-      #
-      # @param piece_names [Array] A list of pieces in hand.
-      #
-      # @example Dump a list of pieces in hand
-      #   dump(["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"])
-      #   # => "S,b,g*4,n*4,p*17,r*2,s"
-      #
-      # @example Dump an empty list of pieces in hand
-      #   dump([])
-      #   # => nil
-      #
-      # @return [String, nil] A serialized list of pieces in hand.
-      def self.dump(piece_names)
-        return if piece_names.empty?
-
-        hash = piece_names.group_by(&:itself).transform_values(&:count)
-        hash.map { |k, v| v > 1 ? "#{k}*#{v}" : k }.sort.join(",")
-      end
-    end
-  end
-end

data/lib/feen/parser/piece_placement.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    # The PiecePlacement class.
-    #
-    # @example Parse a Shogi problem board and return an array
-    #   PiecePlacement.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_a
-    #   # => [
-    #   #      nil, nil, nil, "s", "k", "s", nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, "+P", nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, "+B", nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil,
-    #   #      nil, nil, nil, nil, nil, nil, nil, nil, nil
-    #   #    ]
-    #
-    # @example Parse a Shogi problem board and return a hash
-    #   PiecePlacement.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_h
-    #   # => {
-    #   #       3 => "s",
-    #   #       4 => "k",
-    #   #       5 => "s",
-    #   #      22 => "+P",
-    #   #      43 => "+B"
-    #   #    }
-    class PiecePlacement
-      # @param piece_placement_str [String] The placement of pieces on the board.
-      def initialize(piece_placement_str)
-        @piece_placement_str = piece_placement_str
-      end
-
-      # @return [Array] The list of pieces on the board.
-      def to_a
-        @piece_placement_str
-          .split(%r{[/,]+})
-          .flat_map { |str| row(str) }
-      end
-
-      # @return [Hash] The index of each piece on the board.
-      def to_h
-        to_a
-          .each_with_index
-          .inject({}) do |h, (v, i)|
-            next h if v.nil?
-
-            h.merge(i => v)
-          end
-      end
-
-      private
-
-      def row(string)
-        string.match?(/[0-9]+/) ? ::Array.new(Integer(string)) : string
-      end
-    end
-  end
-end

data/lib/feen/parser/pieces_in_hand.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    # The pieces in hand module.
-    module PiecesInHand
-      # The list of pieces in hand grouped by players.
-      #
-      # @param pieces_in_hand [String, nil] The serialized list of pieces in hand.
-      #
-      # @example Parse a list of serialized pieces in hand
-      #   parse("S,b,g*4,n*4,p*17,r*2,s")
-      #   # => ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"]
-      #
-      # @example Parse an empty list of serialized pieces in hand
-      #   parse("-")
-      #   # => []
-      #
-      # @return [Array] The list of pieces in hand grouped by players.
-      def self.parse(pieces_in_hand)
-        return if pieces_in_hand.nil?
-
-        pieces_in_hand.split(",").flat_map do |piece|
-          if piece.include?("*")
-            letter, count = piece.split("*")
-            [letter] * count.to_i
-          else
-            piece
-          end
-        end.sort
-      end
-    end
-  end
-end