sashite-feen 0.2.0 → 0.3.0

data/lib/sashite/feen/dumper/piece_placement.rb

@@ -6,19 +6,23 @@ module Sashite
       # Dumper for the piece placement field (first field of FEEN).
       #
       # Converts a Placement object into its FEEN string representation,
-      # encoding board configuration using EPIN notation with empty square
-      # compression and multi-dimensional separator support.
+      # encoding board configuration using EPIN notation with:
+      # - Empty square compression (consecutive nils → numbers)
+      # - Exact separator preservation (from Placement.separators)
+      # - Support for any irregular board structure
+      #
+      # The dumper produces canonical FEEN strings that enable perfect
+      # round-trip conversion (dump → parse → dump).
       #
       # @see https://sashite.dev/specs/feen/1.0.0/
       module PiecePlacement
-        # Rank separator for 2D boards.
-        RANK_SEPARATOR = "/"
-
         # Dump a Placement object into its FEEN piece placement string.
         #
-        # Converts the board configuration into FEEN notation by processing
-        # each rank, compressing consecutive empty squares into digits, and
-        # joining ranks with appropriate separators for multi-dimensional boards.
+        # Process:
+        # 1. For 1D boards: dump single rank directly
+        # 2. For multi-D boards: interleave ranks with their separators
+        # 3. Compress consecutive empty squares into numbers
+        # 4. Convert pieces to EPIN strings
         #
         # @param placement [Placement] The board placement object
         # @return [String] FEEN piece placement field string
@@ -30,78 +34,131 @@ module Sashite
         # @example Empty 8x8 board
         #   dump(placement)
         #   # => "8/8/8/8/8/8/8/8"
+        #
+        # @example 1D board
+        #   dump(placement)
+        #   # => "K2P3k"
+        #
+        # @example Irregular 3D board
+        #   dump(placement)
+        #   # => "5/5//5/5/5"
+        #
+        # @example Very large board
+        #   dump(placement)
+        #   # => "100/100/100"
         def self.dump(placement)
-          ranks = placement.ranks.map { |rank| dump_rank(rank) }
-          join_ranks(ranks, placement.dimension, placement.sections)
+          # Special case: 1D board (no separators)
+          return dump_rank(placement.ranks[0]) if placement.one_dimensional?
+
+          # Multi-dimensional: interleave ranks and separators
+          dump_multi_dimensional(placement)
+        end
+
+        # Dump multi-dimensional placement.
+        #
+        # Alternates between ranks and separators:
+        # rank[0] + sep[0] + rank[1] + sep[1] + ... + rank[n]
+        #
+        # @param placement [Placement] Placement object
+        # @return [String] FEEN string with separators
+        #
+        # @example 2D board
+        #   dump_multi_dimensional(placement)
+        #   # => "r1/r2/r3"
+        #
+        # @example 3D board with mixed separators
+        #   dump_multi_dimensional(placement)
+        #   # => "r1/r2//r3"
+        private_class_method def self.dump_multi_dimensional(placement)
+          result = []
+
+          placement.ranks.each_with_index do |rank, idx|
+            # Dump the rank
+            result << dump_rank(rank)
+
+            # Add separator if not last rank
+            result << placement.separators[idx] if idx < placement.separators.size
+          end
+
+          result.join
         end
 
         # Dump a single rank into its FEEN representation.
         #
         # Converts a rank (array of pieces and nils) into FEEN notation by:
-        # 1. Converting pieces to EPIN strings
-        # 2. Compressing consecutive nils into digit counts
+        # 1. Converting pieces to EPIN strings (via piece.to_s)
+        # 2. Compressing consecutive nils into number strings
+        #
+        # Algorithm:
+        # - Iterate through rank squares
+        # - Count consecutive nils (empty_count)
+        # - When hitting a piece: flush count (if > 0), add piece
+        # - At end: flush final count (if > 0)
         #
         # @param rank [Array] Array of piece objects and nils
         # @return [String] FEEN rank string
         #
-        # @example Rank with pieces and empty squares
-        #   dump_rank([piece1, nil, nil, piece2])
+        # @example Rank with pieces only
+        #   dump_rank([K, Q, R, B])
+        #   # => "KQRB"
+        #
+        # @example Rank with empty squares
+        #   dump_rank([K, nil, nil, Q])
         #   # => "K2Q"
+        #
+        # @example Rank all empty
+        #   dump_rank([nil, nil, nil, nil, nil, nil, nil, nil])
+        #   # => "8"
+        #
+        # @example Very large empty count
+        #   dump_rank(Array.new(100, nil))
+        #   # => "100"
+        #
+        # @example Complex rank
+        #   dump_rank([+K, nil, nil, -p', nil, R])
+        #   # => "+K2-p'1R"
         private_class_method def self.dump_rank(rank)
           result = []
           empty_count = 0
 
           rank.each do |square|
             if square.nil?
+              # Empty square: increment counter
               empty_count += 1
             else
-              result << empty_count.to_s if empty_count > 0
+              # Piece: flush empty count, add piece
+              flush_empty_count!(result, empty_count)
               result << square.to_s
               empty_count = 0
             end
           end
 
-          result << empty_count.to_s if empty_count > 0
+          # Flush final empty count
+          flush_empty_count!(result, empty_count)
+
           result.join
         end
 
-        # Join ranks with appropriate separators for multi-dimensional boards.
+        # Flush accumulated empty count to result array.
         #
-        # Uses section information if available, otherwise treats all ranks equally.
+        # If empty_count > 0, appends the number as a string.
+        # This enables compression of consecutive empty squares.
         #
-        # @param ranks [Array<String>] Array of rank strings
-        # @param dimension [Integer] Board dimensionality (default 2)
-        # @param sections [Array<Integer>, nil] Section sizes for grouping
-        # @return [String] Complete piece placement string
+        # @param result [Array<String>] Result array being built
+        # @param empty_count [Integer] Number of consecutive empty squares
+        # @return [void]
         #
-        # @example 2D board
-        #   join_ranks(["8", "8"], 2, nil)
-        #   # => "8/8"
-        #
-        # @example 3D board with sections
-        #   join_ranks(["5", "5", "5", "5"], 3, [2, 2])
-        #   # => "5/5//5/5"
-        private_class_method def self.join_ranks(ranks, dimension = 2, sections = nil)
-          if dimension == 2 || sections.nil?
-            # Simple 2D case or no section info
-            separator = RANK_SEPARATOR * (dimension - 1)
-            ranks.join(separator)
-          else
-            # Multi-dimensional with section info
-            rank_separator = RANK_SEPARATOR
-            section_separator = RANK_SEPARATOR * (dimension - 1)
-
-            # Group ranks by sections
-            result = []
-            offset = 0
-            sections.each do |section_size|
-              section_ranks = ranks[offset, section_size]
-              result << section_ranks.join(rank_separator)
-              offset += section_size
-            end
-
-            result.join(section_separator)
-          end
+        # @example Flush count
+        #   result = ["K"]
+        #   flush_empty_count!(result, 5)
+        #   result  # => ["K", "5"]
+        #
+        # @example No flush (zero count)
+        #   result = ["K"]
+        #   flush_empty_count!(result, 0)
+        #   result  # => ["K"]
+        private_class_method def self.flush_empty_count!(result, empty_count)
+          result << empty_count.to_s if empty_count > 0
         end
       end
     end

data/lib/sashite/feen/dumper/pieces_in_hand.rb

@@ -126,6 +126,7 @@ module Sashite
         private_class_method def self.prefix_order(piece_str)
           return 0 if piece_str.start_with?("-")
           return 1 if piece_str.start_with?("+")
+
           2
         end
 

data/lib/sashite/feen/hands.rb

@@ -30,8 +30,8 @@ module Sashite
       # @example Both players have captured pieces
       #   hands = Hands.new([rook, bishop], [pawn1, pawn2, knight])
       def initialize(first_player, second_player)
-        @first_player = first_player.freeze
-        @second_player = second_player.freeze
+        @first_player = first_player.sort_by(&:to_s).freeze
+        @second_player = second_player.sort_by(&:to_s).freeze
 
         freeze
       end