feen 3.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4120730f5c39a876c2dc1bba4536f997b822ddfee043e37cdb1dc68f1ffcbb31
-  data.tar.gz: 3a0365e075d0c0238625d841c78ccb52e21106bc47cc312ce6b1e4e47d08d6b9
+  metadata.gz: 1a033acfb60b8db7f259e6e787c71c6e9cae62ef3127faeddfec5c881e9a0171
+  data.tar.gz: f62cf07a12178a848df661c9a695bc7eb9c8adcac1ea399c252f7c4d9aee77af
 SHA512:
-  metadata.gz: 202e76081fbe4cbef65fdfa4833d370d7e2310ff6d3498fffa2baf10118afa12c1f15260a2e3f2f2ceecec6a99601b8a5bb89508e5e188583fad5015d944deb5
-  data.tar.gz: c9f8c235a87923c74d7f804535ad740d86eadfebd23c4cfa7756d4a9159a1a30c97874e619bad8e6f84a1def42f500048a6196a44a6f6422918237d4b89d4440
+  metadata.gz: d96c233e0adb0998281b40e8b282526275ace24c53d9200fffd66907617b0b905d34c592ad7f45659d3f8df9dfa64e738c825c2582b6e5d18da443008a2ae348
+  data.tar.gz: 443ec302a41d65bc96ca9605edc8d3b2f8fbfd323d042da95a3d783c86f7af301389d8d61f9e1114ec019084d94afe1af8602a70e9b4511ce6a8df177e8f6b82

data/README.md

@@ -38,39 +38,22 @@ require "feen"
 
 # Dump a classic Tsume Shogi problem
 FEEN.dump(
-  "active_side_id": 0,
-  "board": {
+  "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],
+  "shape": [9, 9],
+  "side_id": 0,
+  "square": {
      3 => "s",
-     4 => "k" ,
+     4 => "k",
      5 => "s",
     22 => "+P",
     43 => "+B"
-  },
-  "indexes": [9, 9],
-  "pieces_in_hand_grouped_by_sides": [
-    %w[S],
-    %w[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]
-  ]
+  }
 )
-# => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 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"
+# => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 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"
 
 # Parse a classic Tsume Shogi problem
-FEEN.parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 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")
-# => {
-#      "active_side_id": 0,
-#      "board": {
-#         3 => "s",
-#         4 => "k" ,
-#         5 => "s",
-#        22 => "+P",
-#        43 => "+B"
-#      },
-#      "indexes": [9, 9],
-#      "pieces_in_hand_grouped_by_sides": [
-#        %w[S],
-#        %w[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]
-#      ]
-#    }
+FEEN.parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 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")
+# => {:square=>{3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"}, :shape=>[9, 9], :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"], :side_id=>0}
 ```
 
 ## License

data/lib/feen.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "feen/dumper"
-require_relative "feen/parser"
+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.
@@ -10,37 +10,33 @@ require_relative "feen/parser"
 module FEEN
   # @example Dumps position params into a FEEN string.
   #
-  # @param active_side_id [Integer] The identifier of the player who must play.
-  # @param board [Hash] The indexes of each piece on the board.
-  # @param indexes [Array] The shape of the board.
-  # @param pieces_in_hand_grouped_by_sides [Array] The list of pieces in hand
-  #   grouped by players.
+  # @param in_hand [Array] The list of pieces in hand.
+  # @param shape [Array] The shape of the board.
+  # @param side_id [Integer] The identifier of the player who must play.
+  # @param square [Hash] The index of each piece on the board.
   #
   # @example Dump a classic Tsume Shogi problem
   #   dump(
-  #     "active_side_id": 0,
-  #     "board": {
-  #       "3": "s",
-  #       "4": "k" ,
-  #       "5": "s",
-  #       "22": "+P",
-  #       "43": "+B"
-  #     },
-  #     "indexes": [9, 9],
-  #     "pieces_in_hand_grouped_by_sides": [
-  #       %w[S],
-  #       %w[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]
-  #     ]
+  #     "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],
+  #     "shape": [9, 9],
+  #     "side_id": 0,
+  #     "square": {
+  #        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 0 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"
+  #   # => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 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"
   #
   # @return [String] The FEEN string representing the position.
-  def self.dump(active_side_id:, board: {}, indexes:, pieces_in_hand_grouped_by_sides:)
+  def self.dump(in_hand:, shape:, side_id:, square:)
     Dumper.call(
-      active_side_id: active_side_id,
-      board: board,
-      indexes: indexes,
-      pieces_in_hand_grouped_by_sides: pieces_in_hand_grouped_by_sides
+      in_hand: in_hand,
+      shape: shape,
+      side_id: side_id,
+      square: square
     )
   end
 
@@ -49,22 +45,18 @@ 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 0 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")
+  #   parse("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 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")
   #   # => {
-  #   #      "active_side_id": 0,
-  #   #      "board": {
-  #   #        "3": "s",
-  #   #        "4": "k" ,
-  #   #        "5": "s",
-  #   #        "22": "+P",
-  #   #        "43": "+B"
-  #   #      },
-  #   #      "indexes": [9, 9],
-  #   #      "pieces_in_hand_grouped_by_sides": [
-  #   #        %w[S],
-  #   #        %w[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]
-  #   #      ]
-  #   #    }
+  #   #      "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"],
+  #   #      "shape": [9, 9],
+  #   #      "side_id": 0,
+  #   #      "square": {
+  #   #         3 => "s",
+  #   #         4 => "k",
+  #   #         5 => "s",
+  #   #        22 => "+P",
+  #   #        43 => "+B"
+  #   #      }
   #
   # @return [Hash] The position params representing the position.
   def self.parse(feen)

data/lib/feen/dumper.rb

@@ -1,44 +1,40 @@
 # frozen_string_literal: true
 
-require_relative "dumper/board"
-require_relative "dumper/pieces_in_hand"
-require_relative "dumper/turn"
+require_relative File.join("dumper", "in_hand")
+require_relative File.join("dumper", "square")
+require_relative File.join("dumper", "turn")
 
 module FEEN
   # The dumper module.
   module Dumper
     # Dump position params into a FEEN string.
     #
-    # @param active_side_id [Integer] The identifier of the player who must play.
-    # @param board [Hash] The indexes of each piece on the board.
-    # @param indexes [Array] The shape of the board.
-    # @param pieces_in_hand_grouped_by_sides [Array] The list of pieces in hand
-    #   grouped by players.
+    # @param in_hand [Array] The list of pieces in hand.
+    # @param shape [Array] The shape of the board.
+    # @param side_id [Integer] The identifier of the player who must play.
+    # @param square [Hash] The index of each piece on the board.
     #
     # @example Dump a classic Tsume Shogi problem
     #   call(
-    #     "active_side_id": 0,
-    #     "board": {
-    #       "3": "s",
-    #       "4": "k" ,
-    #       "5": "s",
-    #       "22": "+P",
-    #       "43": "+B"
-    #     },
-    #     "indexes": [9, 9],
-    #     "pieces_in_hand_grouped_by_sides": [
-    #       %w[S],
-    #       %w[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]
-    #     ]
+    #     "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],
+    #     "shape": [9, 9],
+    #     "side_id": 0,
+    #     "square": {
+    #        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 0 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"
+    #   # => "3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 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"
     #
     # @return [String] The FEEN string representing the position.
-    def self.call(active_side_id:, board:, indexes:, pieces_in_hand_grouped_by_sides:)
+    def self.call(in_hand:, shape:, side_id:, square:)
       [
-        Board.new(indexes, board).to_s,
-        Turn.dump(active_side_id, pieces_in_hand_grouped_by_sides.length),
-        PiecesInHand.dump(pieces_in_hand_grouped_by_sides)
+        Square.new(shape, square).to_s,
+        Turn.dump(side_id),
+        InHand.dump(in_hand)
       ].join(" ")
     end
   end

data/lib/feen/dumper/in_hand.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FEEN
+  module Dumper
+    # The pieces in hand module.
+    module InHand
+      # 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,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 Dump an empty list of pieces in hand
+      #   dump([])
+      #   # => "-"
+      #
+      # @return [String] A string representing the pieces in hand.
+      def self.dump(piece_names)
+        return "-" if piece_names.empty?
+
+        piece_names.sort.join("/")
+      end
+    end
+  end
+end

data/lib/feen/dumper/{board.rb → square.rb}

@@ -2,7 +2,7 @@
 
 module FEEN
   module Dumper
-    # The board class.
+    # The square class.
     #
     # @example Dump an empty board of Xiangqi
     #   Board.new([10, 9]).to_s # => "9/9/9/9/9/9/9/9/9/9"
@@ -45,9 +45,9 @@ module FEEN
     #       89 => "俥"
     #     }
     #   ).to_s # => "車,馬,象,士,將,士,象,馬,車/9/1,砲,5,砲,1/卒,1,卒,1,卒,1,卒,1,卒/9/9/兵,1,兵,1,兵,1,兵,1,兵/1,炮,5,炮,1/9/俥,傌,相,仕,帥,仕,相,傌,俥"
-    class Board
+    class Square
       # @param indexes [Array] The shape of the board.
-      # @param board [Hash] The indexes of each piece on the board.
+      # @param board [Hash] The index of each piece on the board.
       def initialize(indexes, board)
         @indexes = indexes
         @squares = Array.new(length) { |i| board.fetch(i, nil) }

data/lib/feen/dumper/turn.rb

@@ -4,15 +4,14 @@ module FEEN
   module Dumper
     # The turn module.
     module Turn
-      # @param active_side_id [Integer] The identifier of the active player.
-      # @param sides_count [Integer] The number of players.
+      # @param side_id [Integer] The identifier of the active player.
       #
       # @example Dump the number that identify the player who have to play
-      #   dump(0, 2) # => "0"
+      #   dump(0) # => "0"
       #
       # @return [String] The number that identify the player who have to play.
-      def self.dump(active_side_id, sides_count)
-        String(Integer(active_side_id) % Integer(sides_count))
+      def self.dump(side_id)
+        String(side_id)
       end
     end
   end

data/lib/feen/parser.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "parser/board"
-require_relative "parser/pieces_in_hand"
-require_relative "parser/shape"
-require_relative "parser/turn"
+require_relative File.join("parser", "in_hand")
+require_relative File.join("parser", "shape")
+require_relative File.join("parser", "square")
+require_relative File.join("parser", "turn")
 
 module FEEN
   # The parser module.
@@ -13,41 +13,28 @@ 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 0 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")
+    #   call("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9 0 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")
     #   # => {
-    #   #      "active_side_id": 0,
-    #   #      "board": {
-    #   #        "3": "s",
-    #   #        "4": "k" ,
-    #   #        "5": "s",
-    #   #        "22": "+P",
-    #   #        "43": "+B"
-    #   #      },
-    #   #      "indexes": [9, 9],
-    #   #      "pieces_in_hand_grouped_by_sides": [
-    #   #        %w[S],
-    #   #        %w[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]
-    #   #      ]
-    #   #    }
+    #   #      "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"],
+    #   #      "shape": [9, 9],
+    #   #      "side_id": 0,
+    #   #      "square": {
+    #   #         3 => "s",
+    #   #         4 => "k",
+    #   #         5 => "s",
+    #   #        22 => "+P",
+    #   #        43 => "+B"
+    #   #      }
     #
     # @return [Hash] The position params representing the position.
     def self.call(feen)
-      params(*feen.split(" "))
-    end
+      square_str, side_id_str, in_hand_str = feen.split(" ")
 
-    # Parse the FEEN string's three fields and return the position params.
-    #
-    # @param board [String] The flatten board.
-    # @param active_side_id [String] The active side identifier.
-    # @param in_hand [String] The captured actors.
-    #
-    # @return [Hash] The position params representing the position.
-    private_class_method def self.params(board, active_side_id, in_hand)
       {
-        active_side_id: Turn.parse(active_side_id),
-        board: Board.new(board).to_h,
-        indexes: Shape.new(board).to_a,
-        pieces_in_hand_grouped_by_sides: PiecesInHand.parse(in_hand)
+        in_hand: InHand.parse(in_hand_str),
+        shape: Shape.new(square_str).to_a,
+        side_id: Turn.parse(side_id_str),
+        square: Square.new(square_str).to_h
       }
     end
   end

data/lib/feen/parser/in_hand.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FEEN
+  module Parser
+    # The pieces in hand module.
+    module InHand
+      # The list of pieces in hand grouped by players.
+      #
+      # @param piece_names_str [String] The serialized list of pieces in hand.
+      #
+      # @example Parse a list of serialized pieces in hand
+      #   parse("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", "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(piece_names_str)
+        return [] if piece_names_str == "-"
+
+        piece_names_str.split(",")
+      end
+    end
+  end
+end

data/lib/feen/parser/{board.rb → square.rb}

@@ -2,7 +2,7 @@
 
 module FEEN
   module Parser
-    # The board class.
+    # The square class.
     #
     # @example Parse a Shogi problem board and return an array
     #   Board.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_a
@@ -22,12 +22,12 @@ module FEEN
     #   Board.new("3,s,k,s,3/9/4,+P,4/9/7,+B,1/9/9/9/9").to_h
     #   # => {
     #   #       3 => "s",
-    #   #       4 => "k" ,
+    #   #       4 => "k",
     #   #       5 => "s",
     #   #      22 => "+P",
     #   #      43 => "+B"
     #   #    }
-    class Board
+    class Square
       # @param board [String] The flatten board.
       def initialize(board)
         @board = board
@@ -40,7 +40,7 @@ module FEEN
           .flat_map { |str| row(str) }
       end
 
-      # @return [Hash] The indexes of each piece on the board.
+      # @return [Hash] The index of each piece on the board.
       def to_h
         to_a
           .each_with_index

data/lib/feen/parser/turn.rb

@@ -4,15 +4,15 @@ module FEEN
   module Parser
     # The turn module.
     module Turn
-      # @param active_side_id [String] The identifier of bottom-side and
+      # @param side_id [String] The identifier of bottom-side and
       #   top-side.
       #
       # @example Parse the number that identify the player who have to play
       #   parse("0") # => 0
       #
       # @return [Integer] The number that identify the player who have to play.
-      def self.parse(active_side_id)
-        Integer(active_side_id)
+      def self.parse(side_id)
+        Integer(side_id)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feen
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.1
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-08 00:00:00.000000000 Z
+date: 2020-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: brutal
@@ -132,13 +132,13 @@ files:
 - README.md
 - lib/feen.rb
 - lib/feen/dumper.rb
-- lib/feen/dumper/board.rb
-- lib/feen/dumper/pieces_in_hand.rb
+- lib/feen/dumper/in_hand.rb
+- lib/feen/dumper/square.rb
 - lib/feen/dumper/turn.rb
 - lib/feen/parser.rb
-- lib/feen/parser/board.rb
-- lib/feen/parser/pieces_in_hand.rb
+- lib/feen/parser/in_hand.rb
 - lib/feen/parser/shape.rb
+- lib/feen/parser/square.rb
 - lib/feen/parser/turn.rb
 homepage: https://developer.sashite.com/specs/forsyth-edwards-expanded-notation
 licenses:
@@ -155,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/feen/dumper/pieces_in_hand.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module FEEN
-  module Dumper
-    # The pieces in hand class.
-    #
-    # @example Serialize a list of pieces in hand grouped by sides
-    #   PiecesInHand.dump(
-    #     %w[S],
-    #     %w[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]
-    #   )
-    #   # => "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"
-    class PiecesInHand
-      # Serialize pieces in hand lists into a string.
-      #
-      # @param pieces_in_hand_grouped_by_sides [Array] The list of pieces in hand
-      #   grouped by players.
-      #
-      # @return [String] A string representing the pieces in hand of both
-      #   players.
-      def self.dump(pieces_in_hand_grouped_by_sides)
-        pieces_in_hand_grouped_by_sides.map { |pieces| new(pieces).to_s }.join("/")
-      end
-
-      # @param pieces [Array] A list of pieces in hand.
-      def initialize(pieces)
-        @pieces = pieces.sort
-      end
-
-      # @return [String] A string representing the pieces in hand.
-      def to_s
-        @pieces.join(",")
-      end
-    end
-  end
-end

data/lib/feen/parser/pieces_in_hand.rb

@@ -1,27 +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_grouped_by_sides_str [String] The serialized list of
-      #   pieces in hand grouped by players.
-      #
-      # @example Parse a list of serialized pieces in hand
-      #   parse("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")
-      #   # => [
-      #   #      %w[S],
-      #   #      %w[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]
-      #   #    ]
-      #
-      # @return [Array] The list of pieces in hand grouped by players.
-      def self.parse(pieces_in_hand_grouped_by_sides_str)
-        pieces_in_hand_grouped_by_sides_str
-          .split("/", -1)
-          .map { |pieces_in_hand_str| pieces_in_hand_str.split(",") }
-      end
-    end
-  end
-end