feen 5.0.0.beta0 → 5.0.0.beta2

data/lib/feen.rb

@@ -1,65 +1,110 @@
 # frozen_string_literal: true
 
+require_relative File.join("feen", "converter")
 require_relative File.join("feen", "dumper")
 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://sashite.dev/documents/feen/1.0.0/
 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],
-  #     "piece_placement": {
-  #        3 => "s",
-  #        4 => "k",
-  #        5 => "s",
-  #       22 => "+P",
-  #       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"
-  #
-  # @return [String] The FEEN string representing the position.
-  def self.dump(board_shape:, side_to_move:, piece_placement:, pieces_in_hand: nil)
-    Dumper.call(
-      pieces_in_hand:,
-      board_shape:,
-      side_to_move:,
-      piece_placement:
-    )
+  # @param position [Hash] Hash containing the position data
+  # @option position [Array] :piece_placement Board position data
+  # @option position [Hash] :games_turn Games and turn data
+  # @option position [Array<Hash>] :pieces_in_hand Pieces in hand data
+  # @return [String] FEEN notation string
+  # @raise [ArgumentError] If the position data is invalid
+  # @example
+  #   position = {
+  #     piece_placement: [[{id: 'r'}, {id: 'n'}, {id: 'b'}, {id: 'q'}, {id: 'k'}, {id: 'b'}, {id: 'n'}, {id: 'r'}],
+  #                       [{id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}],
+  #                       [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],
+  #                       [{id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}],
+  #                       [{id: 'R'}, {id: 'N'}, {id: 'B'}, {id: 'Q'}, {id: 'K'}, {id: 'B'}, {id: 'N'}, {id: 'R'}]],
+  #     games_turn: {
+  #       active_player: 'CHESS',
+  #       inactive_player: 'chess',
+  #       uppercase_game: 'CHESS',
+  #       lowercase_game: 'chess'
+  #     },
+  #     pieces_in_hand: []
+  #   }
+  #   Feen.dump(position) # => "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -"
+  def self.dump(position)
+    Dumper.dump(position)
   end
 
   # Parses a FEEN string into position params.
   #
-  # @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")
+  # @param feen_string [String] FEEN notation string
+  # @return [Hash] Hash containing the parsed position data
+  # @raise [ArgumentError] If the FEEN string is invalid
+  # @example
+  #   feen_string = "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -"
+  #   Feen.parse(feen_string)
   #   # => {
-  #   #      "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",
-  #   #         5 => "s",
-  #   #        22 => "+P",
-  #   #        43 => "+B"
-  #   #      }
+  #   #      piece_placement: [[{id: 'r'}, {id: 'n'}, {id: 'b'}, {id: 'q'}, {id: 'k', suffix: '='}, {id: 'b'}, {id: 'n'}, {id: 'r'}],
+  #   #                        [{id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}, {id: 'p'}],
+  #   #                        [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],
+  #   #                        [{id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}, {id: 'P'}],
+  #   #                        [{id: 'R'}, {id: 'N'}, {id: 'B'}, {id: 'Q'}, {id: 'K', suffix: '='}, {id: 'B'}, {id: 'N'}, {id: 'R'}]],
+  #   #      games_turn: {
+  #   #        active_player: 'CHESS',
+  #   #        inactive_player: 'chess',
+  #   #        uppercase_game: 'CHESS',
+  #   #        lowercase_game: 'chess',
+  #   #        active_player_casing: :uppercase
+  #   #      },
+  #   #      pieces_in_hand: []
+  #   #    }
+  def self.parse(feen_string)
+    Parser.parse(feen_string)
+  end
+
+  # Validates if the given string is a valid FEEN string
+  #
+  # @param feen_string [String] FEEN string to validate
+  # @return [Boolean] True if the string is a valid FEEN string, false otherwise
+  # @example
+  #   Feen.valid?("rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -") # => true
+  #   Feen.valid?("invalid feen string") # => false
+  def self.valid?(feen_string)
+    parse(feen_string)
+    true
+  rescue ::ArgumentError
+    false
+  end
+
+  # Converts a FEN string to a FEEN string for chess positions
+  #
+  # @param fen_string [String] Standard FEN notation string for chess
+  # @return [String] Equivalent FEEN notation string
+  # @raise [ArgumentError] If the FEN string is invalid
+  # @example
+  #   Feen.from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
+  #   # => "rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -"
+  def self.from_fen(fen_string)
+    Converter.from_fen(fen_string)
+  end
+
+  # Converts a FEEN string to a FEN string for chess positions
   #
-  # @return [Hash] The position params representing the position.
-  def self.parse(feen)
-    Parser.call(feen)
+  # @param feen_string [String] FEEN notation string
+  # @return [String] Equivalent FEN notation string
+  # @raise [ArgumentError] If the FEEN string is invalid
+  # @example
+  #   Feen.to_fen("rnbqk=bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK=BNR CHESS/chess -")
+  #   # => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+  def self.to_fen(feen_string)
+    Converter.to_fen(feen_string)
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta0
+  version: 5.0.0.beta2
 platform: ruby
 authors:
 - Cyril Kato
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby interface for data serialization and deserialization in FEEN format.
 email: contact@cyril.email
@@ -19,19 +18,23 @@ files:
 - LICENSE.md
 - README.md
 - lib/feen.rb
+- lib/feen/converter.rb
+- lib/feen/converter/from_fen.rb
+- lib/feen/converter/to_fen.rb
 - lib/feen/dumper.rb
+- lib/feen/dumper/games_turn.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/games_turn.rb
 - lib/feen/parser/piece_placement.rb
 - lib/feen/parser/pieces_in_hand.rb
+- lib/feen/sanitizer.rb
 homepage: https://github.com/sashite/feen.rb
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -39,15 +42,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: FEEN support for the Ruby language.
 test_files: []

data/lib/feen/parser/board_shape.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Feen
-  module Parser
-    # 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]
-    class BoardShape
-      # @param board_str [String] The flatten board.
-      def initialize(board_str)
-        @board_str = board_str
-      end
-
-      # @return [Array] The size of each dimension of the board.
-      def to_a
-        indexes(@board_str, @board_str.scan(%r{/+}).sort.fetch(-1))
-      end
-
-      private
-
-      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
-            counter + number
-          end
-
-          return [last_index]
-        end
-
-        sub_strings = string.split(separator)
-        [sub_strings.length] + indexes(sub_strings.fetch(0), separator[1..])
-      end
-    end
-  end
-end