sashite-feen 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8182f6c48f6a615f38d75d3060f216c06c6606b118544cb4f4f0e40b9615e89
-  data.tar.gz: 1150aacab981e71aa32aaae585ec1998cd678bb5997432135b0089394eef2482
+  metadata.gz: 6b244edf5ff22990c8ad8e4e866e866191b64836f984916f1342084b17d70cb7
+  data.tar.gz: a61e40e9f447f988f91382209985421608895d160f5d43b5892fd21c53f93e67
 SHA512:
-  metadata.gz: b8ed4a473fce336ce73cb89c684e9ea7820842b78e12766bc32440f25da7f61998c13077ce3743972ef234a85771c63f58778835dd11bfba1fd97ef63dfb7154
-  data.tar.gz: 679296955c3b032e0ebe7b9f6ca4776b42b617f67a876e5de6bee015d186e40287d9cc964a3bb2d3faec0dbaf0dd98d810e3bf522cde197d340f168ba9be3a84
+  metadata.gz: 5cf29b74cb4e1dc5ff0ede275fcf56af3476ef01eaf045c118aa086ae688df6122a685d97ca4dbbfb4bbe0956f1a19e0ee73d157c0148ca6baffd67d278f06ef
+  data.tar.gz: fb2b2e4ad688be264f031b61434d8f8cf513733b3894547f2053d46762c62144a5ba727a39bffc48f4de17cd42b362bfc19fd45bda249b654f6a90462355e6b1

data/README.md

@@ -5,11 +5,11 @@
 ![Ruby](https://github.com/sashite/feen.rb/actions/workflows/main.yml/badge.svg?branch=main)
 [![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** (Forsyth–Edwards Enhanced Notation) implementation for the Ruby language.
+> **FEEN** (Field Expression Encoding Notation) implementation for the Ruby language.
 
 ## What is FEEN?
 
-FEEN (Forsyth–Edwards Enhanced Notation) is a universal, rule-agnostic notation for representing board game positions. It extends traditional FEN to support:
+FEEN (Field Expression Encoding Notation) is a universal, rule-agnostic notation for representing board game positions. It extends traditional FEN to support:
 
 - **Multiple game systems** (Chess, Shōgi, Xiangqi, and more)
 - **Cross-style games** where players use different piece sets
@@ -39,7 +39,7 @@ gem install sashite-feen
 require "sashite/feen"
 
 # Parse a FEEN string into an immutable position object
-position = Sashite::Feen.parse("+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c")
+position = Sashite::Feen.parse("+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c")
 
 # Access position components
 position.placement  # Board configuration
@@ -63,7 +63,7 @@ A FEEN string consists of three space-separated fields:
 
 **Example:**
 ```txt
-+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c
++rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c
 ```
 
 1. **Piece placement**: Board configuration using EPIN notation with `/` separators (can be empty for board-less positions)
@@ -145,16 +145,16 @@ The `to_a` method returns an array representation that adapts to the board's dim
 
 ```ruby
 # 1D board - Returns flat array
-feen = "K2P3k / C/c"
+feen = "K^2P3k^ / C/c"
 position = Sashite::Feen.parse(feen)
 position.placement.to_a
 # => [K, nil, nil, P, nil, nil, nil, k]
 
 # 2D board - Returns array of arrays
-feen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / C/c"
+feen = "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c"
 position = Sashite::Feen.parse(feen)
 position.placement.to_a
-# => [[r,n,b,q,k,b,n,r], [p,p,p,p,p,p,p,p], [nil×8], ...]
+# => [[+r,n,b,q,+k^,b,n,+r], [+p,+p,+p,+p,+p,+p,+p,+p], [nil×8], ...]
 
 # 3D board - Returns array of ranks (to be structured by application)
 feen = "5/5//5/5 / R/r"
@@ -229,17 +229,17 @@ styles.active.to_s.upcase != styles.inactive.to_s.upcase
 ```ruby
 # Starting position
 chess_start = Sashite::Feen.parse(
-  "+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c"
+  "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c"
 )
 
 # After 1.e4
 after_e4 = Sashite::Feen.parse(
-  "+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/4P3/8/+P+P+P+P1+P+P+P/+RNBQ+KBN+R / c/C"
+  "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/4P3/8/+P+P+P+P1+P+P+P/+RNBQ+K^BN+R / c/C"
 )
 
 # Ruy Lopez opening
 ruy_lopez = Sashite::Feen.parse(
-  "r1bqkbnr/+p+p+p+p1+p+p+p/2n5/1B2p3/4P3/5N2/+P+P+P+P1+P+P+P/RNBQK2R / c/C"
+  "+r1bq+k^bn+r/+p+p+p+p1+p+p+p/2n5/1B2p3/4P3/5N2/+P+P+P+P1+P+P+P/+RNBQ+K^2+R / c/C"
 )
 ```
 
@@ -248,12 +248,12 @@ ruy_lopez = Sashite::Feen.parse(
 ```ruby
 # Starting position
 shogi_start = Sashite::Feen.parse(
-  "lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL / S/s"
+  "lnsgk^gsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGK^GSNL / S/s"
 )
 
 # Position with pieces in hand
 shogi_midgame = Sashite::Feen.parse(
-  "lnsgkgsnl/1r5b1/pppp1pppp/9/4p4/9/PPPP1PPPP/1B5R1/LNSGKGSNL P/p s/S"
+  "lnsgk^gsnl/1r5b1/pppp1pppp/9/4p4/9/PPPP1PPPP/1B5R1/LNSGK^GSNL P/p s/S"
 )
 
 # Access captured pieces
@@ -270,12 +270,12 @@ position.hands.first_player.count { |p| p.to_s == "P" } # => 1
 ```ruby
 # Chess vs Makruk
 chess_vs_makruk = Sashite::Feen.parse(
-  "rnsmksnr/8/pppppppp/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/m"
+  "rnsmk^snr/8/pppppppp/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/m"
 )
 
 # Chess vs Shōgi
 chess_vs_shogi = Sashite::Feen.parse(
-  "lnsgkgsnl/1r5b1/pppppppp/9/9/9/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/s"
+  "lnsgk^gsnl/1r5b1/pppppppp/9/9/9/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/s"
 )
 
 # Check styles
@@ -289,7 +289,7 @@ position.styles.inactive.to_s  # => "m" (Makruk, second player)
 ```ruby
 # 3D Chess (Raumschach)
 raumschach = Sashite::Feen.parse(
-  "rnknr/+p+p+p+p+p/5/5/5//buqbu/+p+p+p+p+p/5/5/5//5/5/5/5/5//5/5/5/+P+P+P+P+P/BUQBU//5/5/5/+P+P+P+P+P/RNKNR / R/r"
+  "+rn+k^n+r/+p+p+p+p+p/5/5/5//buqbu/+p+p+p+p+p/5/5/5//5/5/5/5/5//5/5/5/+P+P+P+P+P/BUQBU//5/5/5/+P+P+P+P+P/+RN+K^N+R / R/r"
 )
 
 # Check dimensionality
@@ -317,7 +317,7 @@ large_board = Sashite::Feen.parse("100/100/100 / G/g")
 large_board.placement.total_squares # => 300
 
 # Single square
-single = Sashite::Feen.parse("K / C/c")
+single = Sashite::Feen.parse("K^ / C/c")
 single.placement.rank_count # => 1
 ```
 
@@ -327,7 +327,7 @@ FEEN supports any valid combination of ranks and separators:
 
 ```ruby
 # Extreme irregularity with variable separators
-feen = "99999/3///K/k//r / G/g"
+feen = "99999/3///K^/k^//r / G/g"
 position = Sashite::Feen.parse(feen)
 
 # Access the structure
@@ -352,11 +352,11 @@ FEEN supports empty ranks (ranks with no pieces):
 
 ```ruby
 # Trailing separator creates empty rank
-feen = "K/// / C/c"
+feen = "K^/// / C/c"
 position = Sashite::Feen.parse(feen)
 
 position.placement.ranks.size  # => 2
-position.placement.ranks[0]    # => [K]
+position.placement.ranks[0]    # => [K^]
 position.placement.ranks[1]    # => [] (empty rank)
 position.placement.separators  # => ["///"]
 
@@ -389,7 +389,7 @@ position2 = Sashite::Feen.parse("8/8/8/8/8/8/8/8 / C/c")
 position1 == position2 # => true
 
 # Round-trip parsing
-original = "+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c"
+original = "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c"
 position = Sashite::Feen.parse(original)
 Sashite::Feen.dump(position) == original # => true
 
@@ -402,13 +402,13 @@ position.hands.first_player.size # Number of captured pieces
 
 ```ruby
 # Enhanced pieces (promoted, with special rights)
-enhanced = Sashite::Feen.parse("+K+Q+R+B/8/8/8/8/8/8/8 / C/c")
+enhanced = Sashite::Feen.parse("+K^+Q+R+B/8/8/8/8/8/8/8 / C/c")
 
 # Diminished pieces (weakened, vulnerable)
-diminished = Sashite::Feen.parse("-K-Q-R-B/8/8/8/8/8/8/8 / C/c")
+diminished = Sashite::Feen.parse("-K^-Q-R-B/8/8/8/8/8/8/8 / C/c")
 
 # Foreign pieces (using opponent's style)
-foreign = Sashite::Feen.parse("K'Q'R'B'/k'q'r'b'/8/8/8/8/8/8 / C/s")
+foreign = Sashite::Feen.parse("K^'Q'R'B'/k^'q'r'b'/8/8/8/8/8/8 / C/s")
 ```
 
 ## Error Handling

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

@@ -29,7 +29,7 @@ module Sashite
         #
         # @example Chess starting position
         #   dump(placement)
-        #   # => "+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R"
+        #   # => "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R"
         #
         # @example Empty 8x8 board
         #   dump(placement)
@@ -37,7 +37,7 @@ module Sashite
         #
         # @example 1D board
         #   dump(placement)
-        #   # => "K2P3k"
+        #   # => "K^2P3k^"
         #
         # @example Irregular 3D board
         #   dump(placement)

data/lib/sashite/feen/dumper.rb

@@ -6,7 +6,7 @@ require_relative "dumper/style_turn"
 
 module Sashite
   module Feen
-    # Dumper for FEEN (Forsyth–Edwards Enhanced Notation) positions.
+    # Dumper for FEEN (Field Expression Encoding Notation) positions.
     #
     # Converts a Position object into its canonical FEEN string representation
     # by delegating serialization to specialized dumpers for each component.
@@ -29,7 +29,7 @@ module Sashite
       #
       # @example Dump a position to FEEN
       #   feen_string = Dumper.dump(position)
-      #   # => "+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c"
+      #   # => "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c"
       def self.dump(position)
         fields = [
           Dumper::PiecePlacement.dump(position.placement),
@@ -49,8 +49,8 @@ module Sashite
       # @return [String] Complete FEEN string
       #
       # @example Join three fields
-      #   join_fields(["rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR", "/", "C/c"])
-      #   # => "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR / C/c"
+      #   join_fields(["+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R", "/", "C/c"])
+      #   # => "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c"
       private_class_method def self.join_fields(fields)
         fields.join(FIELD_SEPARATOR)
       end

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

@@ -24,9 +24,6 @@ module Sashite
         # Rank separator character.
         RANK_SEPARATOR = "/"
 
-        # Pattern to match EPIN pieces (optional state, letter, optional derivation).
-        EPIN_PATTERN = /\A[-+]?[A-Za-z]'?\z/
-
         # Parse a FEEN piece placement string into a Placement object.
         #
         # Supports any valid FEEN structure:
@@ -265,10 +262,11 @@ module Sashite
 
         # Extract EPIN notation from character array.
         #
-        # EPIN format: [state][letter][derivation]
+        # EPIN format: [state][letter][terminal][derivation]
         # - state: optional "+" or "-" prefix
         # - letter: required A-Z or a-z
-        # - derivation: optional "'" suffix
+        # - terminal: optional "^" suffix
+        # - derivation: optional "'" suffix (comes after "^" if both are present)
         #
         # @param chars [Array<String>] Array of characters
         # @param start_index [Integer] Starting index
@@ -284,6 +282,12 @@ module Sashite
         # @example Foreign piece
         #   extract_epin(['K', "'", 'Q'], 0)  # => ["K'", 2]
         #
+        # @example Terminal piece
+        #   extract_epin(['K', '^', 'Q'], 0)  # => ["K^", 2]
+        #
+        # @example Foreign terminal piece
+        #   extract_epin(['K', '^', "'", 'Q'], 0)  # => ["K^'", 3]
+        #
         # @example Complex piece
         #   extract_epin(['-', 'p', "'", 'K'], 0)  # => ["-p'", 3]
         private_class_method def self.extract_epin(chars, start_index)
@@ -305,6 +309,12 @@ module Sashite
           piece_chars << chars[i]
           i += 1
 
+          # Optional terminal suffix (^)
+          if i < chars.size && chars[i] == "^"
+            piece_chars << chars[i]
+            i += 1
+          end
+
           # Optional derivation suffix (')
           if i < chars.size && chars[i] == "'"
             piece_chars << chars[i]
@@ -312,7 +322,7 @@ module Sashite
           end
 
           piece_str = piece_chars.join
-          consumed = i - start_index
+          consumed  = i - start_index
 
           [piece_str, consumed]
         end
@@ -342,7 +352,7 @@ module Sashite
         #   parse_piece("X#")    # => raises Error::Piece
         private_class_method def self.parse_piece(epin_str)
           # Pre-validate format
-          unless EPIN_PATTERN.match?(epin_str)
+          unless ::Sashite::Epin.valid?(epin_str)
             raise ::Sashite::Feen::Error::Piece,
                   "Invalid EPIN notation: #{epin_str}"
           end

data/lib/sashite/feen/parser.rb

@@ -9,7 +9,7 @@ require_relative "position"
 
 module Sashite
   module Feen
-    # Parser for FEEN (Forsyth–Edwards Enhanced Notation) strings.
+    # Parser for FEEN (Field Expression Encoding Notation) strings.
     #
     # Parses a complete FEEN string by splitting it into three space-separated
     # fields and delegating parsing to specialized parsers for each component.

data/lib/sashite/feen/placement.rb

@@ -32,7 +32,7 @@ module Sashite
     #   placement = Placement.new(ranks, separators)
     #
     # @example Highly irregular structure
-    #   # "99999/3///K/k//r"
+    #   # "99999/3///K^/k^//r"
     #   ranks = [[nil]*99999, [nil]*3, [king], [king_b], [rook]]
     #   separators = ["/", "///", "/", "//"]
     #   placement = Placement.new(ranks, separators)
@@ -169,7 +169,7 @@ module Sashite
       #
       # @example
       #   placement.to_s
-      #   # => "+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R"
+      #   # => "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R"
       def to_s
         Dumper::PiecePlacement.dump(self)
       end

data/lib/sashite/feen/position.rb

@@ -29,7 +29,7 @@ module Sashite
       #   position = Position.new(placement, hands, styles)
       #
       # @example Parse from FEEN string
-      #   position = Sashite::Feen.parse("+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c")
+      #   position = Sashite::Feen.parse("+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c")
       def initialize(placement, hands, styles)
         @placement = placement
         @hands = hands
@@ -48,7 +48,7 @@ module Sashite
       #
       # @example
       #   position.to_s
-      #   # => "+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c"
+      #   # => "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c"
       def to_s
         Dumper.dump(self)
       end

data/lib/sashite/feen.rb

@@ -4,7 +4,7 @@ require_relative "feen/dumper"
 require_relative "feen/parser"
 
 module Sashite
-  # FEEN (Forsyth–Edwards Enhanced Notation) module provides parsing and dumping
+  # FEEN (Field Expression Encoding Notation) module provides parsing and dumping
   # functionality for board game positions.
   #
   # FEEN is a universal, rule-agnostic notation for representing board game positions.
@@ -29,10 +29,10 @@ module Sashite
     #
     # @example Dump a position to FEEN
     #   feen_string = Sashite::Feen.dump(position)
-    #   # => "+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c"
+    #   # => "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c"
     #
     # @example Round-trip parsing and dumping
-    #   original = "+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c"
+    #   original = "+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c"
     #   position = Sashite::Feen.parse(original)
     #   Sashite::Feen.dump(position) == original  # => true
     def self.dump(position)
@@ -53,13 +53,13 @@ module Sashite
     # @raise [Error::Validation] For other semantic violations
     #
     # @example Parse a chess starting position
-    #   position = Sashite::Feen.parse("+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R / C/c")
+    #   position = Sashite::Feen.parse("+rnbq+k^bn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+K^BN+R / C/c")
     #   position.placement  # => Placement object (board configuration)
     #   position.hands      # => Hands object (pieces in hand)
     #   position.styles     # => Styles object (style-turn information)
     #
     # @example Parse a shogi position with captured pieces
-    #   position = Sashite::Feen.parse("lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL P/p S/s")
+    #   position = Sashite::Feen.parse("lnsgk^gsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGK^GSNL P/p S/s")
     def self.parse(string)
       Parser.parse(string)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sashite-feen
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Cyril Kato
@@ -15,30 +15,30 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: sashite-sin
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: 2.1.0
 description: |
-  FEEN (Forsyth—Edwards Enhanced Notation) provides a universal, rule-agnostic format for
+  FEEN (Field Expression Encoding Notation) provides a universal, rule-agnostic format for
   representing board game positions. This gem implements the FEEN Specification v1.0.0 with
   a modern Ruby interface featuring immutable position objects and functional programming
   principles. FEEN extends traditional FEN notation to support multiple game systems (chess,
@@ -93,8 +93,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.7.2
 specification_version: 4
-summary: FEEN (Forsyth—Edwards Enhanced Notation) implementation for Ruby with universal
+summary: FEEN (Field Expression Encoding Notation) implementation for Ruby with universal
   position representation
 test_files: []