From c44b263973ff327d523a0206d81df1c7064a30b2 Mon Sep 17 00:00:00 2001
From: Tsche <che@pydong.org>
Date: Thu, 11 Sep 2025 01:36:07 +0000
Subject: [PATCH 1/2] format extensions (colorization, member access etc)

---
 example/CMakeLists.txt                  |  16 +-
 example/format.cpp                      |  11 +
 include/rsl/_format_impl/accessor.hpp   |  44 ++++
 include/rsl/_format_impl/fmt_parser.hpp | 311 ++++++++++++++++++++++++
 include/rsl/_format_impl/parser.hpp     |  72 ++++++
 include/rsl/_format_impl/style.hpp      |  35 +++
 include/rsl/_format_impl/util.hpp       |  40 +++
 include/rsl/format                      |  32 +++
 include/rsl/print                       |  41 ++++
 include/rsl/style/terminal.hpp          |  33 +++
 include/rsl/variant                     |   4 +-
 src/print.cpp                           |   0
 test/CMakeLists.txt                     |   1 +
 test/format/CMakeLists.txt              |   3 +
 test/format/field_parser.cpp            | 120 +++++++++
 15 files changed, 754 insertions(+), 9 deletions(-)
 create mode 100644 example/format.cpp
 create mode 100644 include/rsl/_format_impl/accessor.hpp
 create mode 100644 include/rsl/_format_impl/fmt_parser.hpp
 create mode 100644 include/rsl/_format_impl/parser.hpp
 create mode 100644 include/rsl/_format_impl/style.hpp
 create mode 100644 include/rsl/_format_impl/util.hpp
 create mode 100644 include/rsl/format
 create mode 100644 include/rsl/print
 create mode 100644 include/rsl/style/terminal.hpp
 create mode 100644 src/print.cpp
 create mode 100644 test/format/CMakeLists.txt
 create mode 100644 test/format/field_parser.cpp

diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 29a335e..e3b8145 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -1,12 +1,14 @@
 function(DEFINE_EXAMPLE TARGET)
   add_executable(example_${TARGET} "${TARGET}.cpp")
-  target_link_libraries(example_${TARGET} PRIVATE rsl_util)
+  target_link_libraries(example_${TARGET} PRIVATE rsl-util)
 endfunction()
 
-DEFINE_EXAMPLE(assert)
+# DEFINE_EXAMPLE(assert)
 
-add_executable(example_review 
-  review.cpp 
-  review_tu2.cpp
-)
-target_link_libraries(example_review PRIVATE rsl_util)
\ No newline at end of file
+DEFINE_EXAMPLE(format)
+
+# add_executable(example_review 
+#   review.cpp 
+#   review_tu2.cpp
+# )
+# target_link_libraries(example_review PRIVATE rsl_util)
\ No newline at end of file
diff --git a/example/format.cpp b/example/format.cpp
new file mode 100644
index 0000000..b26e239
--- /dev/null
+++ b/example/format.cpp
@@ -0,0 +1,11 @@
+#include <rsl/print>
+struct Foo {int a; char b;};
+int main() {
+  rsl::println("a {[red]1} asdf {[blue]0} b", 42, 'c');
+  rsl::println("a {[cyan]} asdf {[green]} b", 42, 'c');
+  rsl::println("a {[yellow]!}{} sfdg {}{[reset]!} b", 42, 'c');
+
+  rsl::println("b={b}, a={a}", Foo(42, 'c'));
+  rsl::println("b={0.b}, a={0.a}", Foo(42, 'c'));
+  rsl::println("b={0.1}, a={0.0}", Foo(42, 'c'));
+}
\ No newline at end of file
diff --git a/include/rsl/_format_impl/accessor.hpp b/include/rsl/_format_impl/accessor.hpp
new file mode 100644
index 0000000..8756448
--- /dev/null
+++ b/include/rsl/_format_impl/accessor.hpp
@@ -0,0 +1,44 @@
+#pragma once
+#include <utility>
+#include <tuple>
+#include <meta>
+
+namespace rsl::_format_impl {
+  template <std::meta::info Member>
+struct MemberAccessor {
+  template <typename T>
+  friend constexpr decltype(auto) operator>>(T&& obj, MemberAccessor) {
+    return std::forward_like<T>(std::forward<T>(obj).[:Member:]);
+  }
+};
+
+template <std::size_t Idx>
+struct SubscriptAccessor {
+  template <typename T>
+  friend constexpr decltype(auto) operator>>(T&& obj, SubscriptAccessor) {
+    return std::forward_like<T>(std::forward<T>(obj)[Idx]);
+  }
+};
+
+template <std::size_t Idx>
+struct TupleAccessor {
+  template <typename T>
+  friend constexpr decltype(auto) operator>>(T&& obj, TupleAccessor) {
+    using std::get;
+    return get<Idx>(std::forward<T>(obj));
+  }
+};
+
+template <std::size_t Idx, typename... Fields>
+struct Accessor {
+  static constexpr std::size_t index = Idx;
+
+  template <typename T>
+  static constexpr decltype(auto) get(T&& obj) {
+    return (std::forward<T>(obj) >> ... >> Fields{});
+  }
+};
+
+template <typename...>
+struct AccessorList {};
+}
\ No newline at end of file
diff --git a/include/rsl/_format_impl/fmt_parser.hpp b/include/rsl/_format_impl/fmt_parser.hpp
new file mode 100644
index 0000000..1c17ccf
--- /dev/null
+++ b/include/rsl/_format_impl/fmt_parser.hpp
@@ -0,0 +1,311 @@
+#pragma once
+#include <algorithm>
+#include <vector>
+#include <meta>
+#include <string_view>
+#include <string>
+#include <format>
+
+#include <rsl/string_view>
+#include <rsl/span>
+
+#include <rsl/util/to_string.hpp>
+
+#include "accessor.hpp"
+#include "parser.hpp"
+#include "style.hpp"
+#include "util.hpp"
+
+namespace rsl::_format_impl {
+
+struct FormatResult {
+  using join_t = std::string (FormatResult::*)(StyleMap const*) const;
+  join_t join;
+
+  template <auto... Args>
+  std::string join_impl(StyleMap const* style_map) const {
+    static constexpr Style::Tag style_tags[] = {Args...};
+
+    std::string result;
+    result.reserve(raw.size() - sizeof...(Args));
+
+    std::size_t index = 0;
+    for (auto&& substr : std::views::split(raw, style_separator)) {
+      result += std::string_view(substr);
+      if (style_map != nullptr && sizeof...(Args) > index) {
+        result += (*style_map)[style_tags[index++]];
+      }
+    }
+    return result;
+  }
+
+  FormatResult(std::string result, join_t joiner) : raw(result), join(joiner) {}
+
+  std::string raw;
+  [[nodiscard]] std::string with_style(StyleMap const& style) const {
+    return (this->*join)(&style);
+  }
+  [[nodiscard]] std::string unstyled() const { return (this->*join)(nullptr); }
+  [[nodiscard]] constexpr explicit(false) operator std::string() const { return unstyled(); }
+};
+
+template <rsl::string_view fmt, typename Accessors, std::meta::info Joiner, typename... Args>
+FormatResult format_impl(Args&&... args) {
+  auto str = [&]<typename... Xs>(AccessorList<Xs...>) {
+    return std::format(fmt.data(), Xs::get(args...[Xs::index])...);
+  }(Accessors{});
+  return FormatResult(str, extract<FormatResult::join_t>(Joiner));
+}
+
+struct FormatString {
+  std::string string;
+  std::vector<Style> style_tags;
+  std::vector<std::meta::info> accessors;
+
+  template <typename... Args>
+  using format_type = FormatResult (*)(Args&&...);
+
+  template <typename... Args>
+  consteval format_type<Args...> get_format() {
+    std::vector<std::meta::info> args = {
+        std::meta::reflect_constant(rsl::string_view(std::define_static_string(string)))};
+    args.push_back(substitute(^^AccessorList, accessors));
+
+    std::vector<std::meta::info> join_args = {};
+    for (auto const& style : style_tags) {
+      join_args.emplace_back(style);
+    }
+    args.push_back(reflect_constant(substitute(^^FormatResult::join_impl, join_args)));
+
+    (args.push_back(^^Args), ...);
+    return extract<format_type<Args...>>(substitute(^^format_impl, args));
+  }
+};
+
+enum struct ReplacementType : std::uint8_t {
+  invalid   = 0,
+  remove    = 1,
+  automatic = 2,
+  indexed   = 3,
+  field     = 4
+};
+
+struct Replacement final : Parser {
+  ReplacementType kind = ReplacementType::invalid;
+  std::string field;
+  std::string specs;
+  std::vector<std::string> style_tags;
+
+  std::size_t index = -1ZU;
+
+  using Parser::Parser;
+
+  constexpr void add_style(FormatString& out, bool enable) const {
+    if (!style_tags.empty()) {
+      out.string += style_separator;
+      out.style_tags.emplace_back(style_tags, enable);
+    }
+  }
+
+  constexpr void render(FormatString& out) const {
+    if (kind == ReplacementType::invalid) {
+      // todo emit error?
+      return;
+    }
+
+    add_style(out, true);
+    if (kind == ReplacementType::remove) {
+      return;
+    }
+
+    out.string += '{';
+    out.string += util::utos(index);
+    if (!specs.empty()) {
+      out.string += ":";
+      out.string += specs;
+    }
+    out.string += '}';
+    add_style(out, false);
+  }
+
+  constexpr void do_parse() {
+    if (!is_valid()) {
+      kind = ReplacementType::automatic;
+      return;
+    }
+
+    // color tags
+    if (consume('[')) {
+      auto start = cursor;
+      while (is_valid() && current() != ']') {
+        if (current() == ',') {
+          style_tags.emplace_back(data.substr(start, cursor - start));
+          start = cursor + 1;
+        }
+        ++cursor;
+      }
+
+      if (cursor != start) {
+        style_tags.emplace_back(data.substr(start, cursor - start));
+      }
+
+      if (!consume(']')) {
+        // std::println("missing closing ]");
+        kind = ReplacementType::invalid;
+        return;
+      }
+    }
+
+    auto rest = data.substr(cursor);
+    if (auto colon_pos = rest.find(':'); colon_pos != rest.npos) {
+      field = rest.substr(0, colon_pos);
+      specs = rest.substr(colon_pos + 1);
+    } else {
+      if (current() == ':') {
+        specs = rest.substr(1);
+      } else {
+        field = rest;
+      }
+    }
+
+    if (field.empty()) {
+      kind = ReplacementType::automatic;
+    } else if (field == "!") {
+      kind = ReplacementType::remove;
+      if (!specs.empty()) {
+        kind = ReplacementType::invalid;
+        // error
+      }
+    } else {
+      kind = std::ranges::all_of(field, is_digit)  //
+                 ? ReplacementType::indexed
+                 : ReplacementType::field;
+    }
+  }
+
+  consteval std::meta::info get_accessor(std::size_t index, std::meta::info type) {
+    std::vector accessors{std::meta::reflect_constant(index)};
+    for (auto subfield : std::views::split(field, '.')) {
+      type = remove_cvref(type);
+      std::meta::info accessor{};
+      if (std::ranges::all_of(subfield, is_digit)) {
+        index = util::stou(std::string_view{subfield});
+        if (is_subscriptable(type)) {
+          // member access by subscript operator
+          type     = substitute(^^subscript_result, {type});
+          accessor = substitute(^^SubscriptAccessor, {std::meta::reflect_constant(index)});
+        } else if (is_tuple_like(type)) {
+          // member access by get<Idx>(...)
+          type     = substitute(^^std::tuple_element_t, {std::meta::reflect_constant(index), type});
+          accessor = substitute(^^TupleAccessor, {std::meta::reflect_constant(index)});
+        } else {
+          // member access by index
+          auto member = nonstatic_data_members_of(type, std::meta::access_context::current())[index];
+          type        = type_of(member);
+          accessor    = substitute(^^MemberAccessor, {reflect_constant(member)});
+        }
+      } else {
+        // member access by name
+        index       = get_member_index(type, std::string_view{subfield});
+        auto member = nonstatic_data_members_of(type, std::meta::access_context::current())[index];
+        type        = type_of(member);
+        accessor    = substitute(^^MemberAccessor, {reflect_constant(member)});
+      }
+      accessors.push_back(accessor);
+    }
+
+    return substitute(^^Accessor, accessors);
+  }
+};
+
+struct FormatParser : Parser {
+  using Parser::Parser;
+
+  FormatString result;
+
+  constexpr void push_text(int start, int end) { result.string += data.substr(start, end - start); }
+
+  consteval std::meta::info get_arg_accessor(std::size_t index) {
+    return substitute(^^Accessor, {std::meta::reflect_constant(index)});
+  }
+
+  consteval void do_parse(std::vector<std::meta::info> const& arg_types) {
+    auto direct = std::vector<int>(arg_types.size(), -1);
+    int start   = cursor;
+
+    bool has_positional = false;
+    bool has_automatic  = false;
+
+    while (is_valid()) {
+      if (current() != '{') {
+        ++cursor;
+        continue;
+      }
+
+      // escaped curly braces
+      if (peek() == '{') {
+        // skip to first unbalanced } - this will match the outer {
+        ++cursor;
+        skip_to('}');
+        ++cursor;
+        continue;
+      }
+      push_text(start, cursor);
+      ++cursor;
+
+      start = cursor;
+      skip_to('}');
+      auto replacement = Replacement(data.substr(start, cursor - start));
+      replacement.do_parse();
+      std::size_t index = 0;
+
+      // TODO move into Replacement?
+      switch (replacement.kind) {
+        case ReplacementType::invalid:
+          // todo error
+          break;
+        case ReplacementType::remove: break;
+
+        case ReplacementType::automatic: {
+          has_automatic = true;
+          result.accessors.push_back(get_arg_accessor(result.accessors.size()));
+          replacement.index = result.accessors.size() - 1;
+        } break;
+        case ReplacementType::indexed: {
+          has_positional = true;
+          index          = util::stou(replacement.field);
+          if (direct[index] == -1) {
+            result.accessors.push_back(get_arg_accessor(index));
+            direct[index] = int(result.accessors.size() - 1);
+          }
+          replacement.index = direct[index];
+        } break;
+        case ReplacementType::field: {
+          has_positional = true;
+          auto dot_pos   = replacement.field.find('.');
+          if (dot_pos == replacement.field.npos || !is_digit(replacement.field[0])) {
+            if (arg_types.size() != 1) {
+              // todo error
+              throw "implicit 0. not allowed with more than one arg";
+            }
+          } else {
+            index             = util::stou(replacement.field.substr(0, dot_pos));
+            replacement.field = replacement.field.substr(dot_pos + 1);
+          }
+          result.accessors.push_back(replacement.get_accessor(index, arg_types[index]));
+          replacement.index = result.accessors.size() - 1;
+        } break;
+      }
+
+      replacement.render(result);
+
+      ++cursor;
+      start = cursor;
+    }
+
+    if (start != cursor) {
+      push_text(start, cursor);
+    }
+  }
+};
+}  // namespace rsl::_format_impl
\ No newline at end of file
diff --git a/include/rsl/_format_impl/parser.hpp b/include/rsl/_format_impl/parser.hpp
new file mode 100644
index 0000000..67b111f
--- /dev/null
+++ b/include/rsl/_format_impl/parser.hpp
@@ -0,0 +1,72 @@
+#pragma once
+#include <string_view>
+#include <algorithm>
+#include <concepts>
+
+//TODO move to _impl, reuse for kwargs?
+namespace rsl::_format_impl {
+
+constexpr bool is_whitespace(char c) {
+  return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+}
+
+constexpr bool is_digit(char c) {
+  return c >= '0' && c <= '9';
+}
+
+constexpr bool is_integer(std::string_view str) {
+  if (str.empty()) {
+    return false;
+  }
+
+  if (str[0] == '-') {
+    str.remove_prefix(1);
+  }
+  return std::ranges::all_of(str, is_digit);
+}
+
+struct Parser {
+  std::string_view data;
+  int cursor = 0;
+
+  constexpr Parser(std::string_view data) : data(data) {}
+
+  constexpr bool is_valid() const { return cursor >= 0 && cursor < data.size(); }
+  constexpr char current() const { return is_valid() ? data[cursor] : '\0'; }
+  constexpr char peek() const {
+    return (is_valid() && cursor + 1 < data.size()) ? data[cursor + 1] : '\0';
+  }
+
+  constexpr bool consume(char expected) {
+    if (current() == expected) {
+      ++cursor;
+      return true;
+    }
+    return false;
+  }
+
+  constexpr void skip_whitespace() {
+    while (is_valid()) {
+      if (char c = current(); is_whitespace(c) || c == '\\') {
+        ++cursor;
+      } else {
+        break;
+      }
+    }
+  }
+
+  constexpr void skip_to(std::same_as<char> auto... needles) {
+    int brace_count = 0;
+    while (is_valid()) {
+      if (char c = current(); brace_count == 0 && ((c == needles) || ...)) {
+        break;
+      } else if (c == '{') {
+        ++brace_count;
+      } else if (c == '}') {
+        --brace_count;
+      }
+      ++cursor;
+    }
+  }
+};
+}  // namespace rsl::_format_impl
\ No newline at end of file
diff --git a/include/rsl/_format_impl/style.hpp b/include/rsl/_format_impl/style.hpp
new file mode 100644
index 0000000..33780cc
--- /dev/null
+++ b/include/rsl/_format_impl/style.hpp
@@ -0,0 +1,35 @@
+#pragma once
+#include <meta>
+#include <vector>
+#include <string_view>
+
+#include <rsl/span>
+#include <rsl/string_view>
+
+namespace rsl::_format_impl {
+inline constexpr char style_separator = '\037';
+
+struct Style {
+  std::vector<std::string> tags;
+  bool enable = true;
+
+  struct Tag {
+    rsl::span<rsl::string_view const> tags;
+    bool enable;
+  };
+
+  consteval explicit operator std::meta::info() const {
+    auto args = std::vector<rsl::string_view>();
+    for (auto const& tag : tags) {
+      args.emplace_back(std::define_static_string(tag));
+    }
+    return std::meta::reflect_constant(Tag{std::define_static_array(args), enable});
+  }
+};
+
+struct StyleMap {
+  virtual ~StyleMap() = default;
+  virtual std::string_view operator[](Style::Tag tag) const { return ""; }
+};
+
+}  // namespace rsl::_format_impl
\ No newline at end of file
diff --git a/include/rsl/_format_impl/util.hpp b/include/rsl/_format_impl/util.hpp
new file mode 100644
index 0000000..9ed065d
--- /dev/null
+++ b/include/rsl/_format_impl/util.hpp
@@ -0,0 +1,40 @@
+#pragma once
+#include <cstddef>
+#include <string_view>
+#include <ranges>
+#include <meta>
+
+
+//  TODO extract?
+namespace rsl::_format_impl {
+consteval std::size_t get_member_index(std::meta::info type, std::string_view name) {
+  std::vector<std::string_view> names = nonstatic_data_members_of(type, std::meta::access_context::current()) |
+                                        std::views::transform(std::meta::identifier_of) |
+                                        std::ranges::to<std::vector>();
+  if (auto it = std::ranges::find(names, name); it != names.end()) {
+    return std::distance(names.begin(), it);
+  }
+  return -1UZ;
+}
+
+template <typename T>
+concept subscriptable = requires(T obj) { obj[0]; };
+
+template <typename T>
+using subscript_result = decltype(std::declval<T>()[0]);
+
+consteval bool is_subscriptable(std::meta::info r) {
+  return extract<bool>(substitute(^^subscriptable, {r}));
+}
+
+template <typename T>
+concept tuple_like = requires(T obj) {
+  typename std::tuple_element_t<0, std::remove_cvref_t<T>>;
+  { get<0>(obj) } -> std::convertible_to<std::tuple_element_t<0, std::remove_cvref_t<T>>>;
+};
+
+consteval bool is_tuple_like(std::meta::info r) {
+  return extract<bool>(substitute(^^tuple_like, {r}));
+}
+
+}  // namespace rsl::_format_impl
\ No newline at end of file
diff --git a/include/rsl/format b/include/rsl/format
new file mode 100644
index 0000000..1317261
--- /dev/null
+++ b/include/rsl/format
@@ -0,0 +1,32 @@
+#pragma once
+#include "_format_impl/fmt_parser.hpp"
+#include "_format_impl/style.hpp"
+
+namespace rsl {
+namespace _format_impl {
+  template <typename... Args>
+struct Fmt {
+  FormatString::format_type<Args...> do_format;
+
+  template <typename T>
+    requires std::convertible_to<T const&, std::string_view>
+  consteval Fmt(T const& fmt) {
+    auto parser = FormatParser(fmt);
+    parser.do_parse({^^Args...});
+    do_format = parser.result.get_format<Args...>();
+  }
+};
+}
+
+using style_map = _format_impl::StyleMap;
+
+using format_result = _format_impl::FormatResult;
+
+template <typename... Args>
+using format_string = _format_impl::Fmt<std::type_identity_t<Args>...>;
+
+template <typename... Args>
+format_result format(format_string<Args...> fmt, Args&&... args) {
+  return fmt.do_format(std::forward<Args>(args)...);
+}
+}
\ No newline at end of file
diff --git a/include/rsl/print b/include/rsl/print
new file mode 100644
index 0000000..f038a49
--- /dev/null
+++ b/include/rsl/print
@@ -0,0 +1,41 @@
+#pragma once
+#include <cstdio>
+
+#include <rsl/format>
+#include <rsl/style/terminal.hpp>
+
+#ifdef __unix__
+#include <unistd.h>
+#elif defined(_WIN32) || defined(WIN32) 
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#ifndef STDIN_FILENO
+  #define STDIN_FILENO _fileno(stdin)
+  #define STDOUT_FILENO _fileno(stdout)
+  #define STDERR_FILENO _fileno(stderr)
+ #endif
+#else
+#error "Unsupported platform"
+#endif
+
+namespace rsl {
+bool isatty(int fd) {
+#if IS_WINDOWS
+  return bool(_isatty(fd));
+#else
+  return bool(::isatty(fd));
+#endif
+}
+
+template <typename... Args>
+void println(rsl::format_string<Args...> fmt, Args&&... args) {
+  auto result = rsl::format(fmt, std::forward<Args>(args)...);
+  if (rsl::isatty(STDOUT_FILENO)) {
+    auto colorized = result.with_style(style::Terminal());
+    std::puts(colorized.c_str());
+  } else {
+    std::puts(result.unstyled().c_str());
+  }
+}
+}
\ No newline at end of file
diff --git a/include/rsl/style/terminal.hpp b/include/rsl/style/terminal.hpp
new file mode 100644
index 0000000..19dc747
--- /dev/null
+++ b/include/rsl/style/terminal.hpp
@@ -0,0 +1,33 @@
+#pragma once
+#include <rsl/format>
+#include <unordered_map>
+
+namespace rsl::style {
+struct Terminal : rsl::style_map {
+  static inline std::unordered_map<std::string_view, std::string_view> map = {
+      {  "reset",  "\x1b[0m"},
+      {  "black", "\x1b[30m"},
+      {    "red", "\x1b[31m"},
+      {  "green", "\x1b[32m"},
+      { "yellow", "\x1b[33m"},
+      {   "blue", "\x1b[34m"},
+      {"magenta", "\x1b[35m"},
+      {   "cyan", "\x1b[36m"},
+      {  "white", "\x1b[37m"},
+      {"default", "\x1b[3m8"}
+  };
+
+  std::string_view operator[](rsl::_format_impl::Style::Tag style) const override {
+    if (not style.enable) {
+      return "\x1b[0m";
+    }
+
+    for (auto tag : style.tags) {
+      if (auto it = map.find(tag); it != map.end()) {
+        return it->second;
+      }
+    }
+    return "";
+  }
+};
+}  // namespace rsl::style
\ No newline at end of file
diff --git a/include/rsl/variant b/include/rsl/variant
index fd661c3..b5db253 100644
--- a/include/rsl/variant
+++ b/include/rsl/variant
@@ -913,8 +913,8 @@ public:
   using tags = E;
 
   storage_type* operator->() { return &this->storage; }
-  storage_type* operator->() const { return &this->storage; }
-  storage_type const* operator*() { return &this->storage; }
+  storage_type const* operator->() const { return &this->storage; }
+  storage_type* operator*() { return &this->storage; }
   storage_type const* operator*() const { return &this->storage; }
 
   explicit(false) operator E() const { return _tagged_variant_impl::transitions<E>[this->index()]; }
diff --git a/src/print.cpp b/src/print.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9a95961..0eacdcf 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -8,3 +8,4 @@ add_subdirectory(expect)
 add_subdirectory(serializer)
 add_subdirectory(string_view)
 add_subdirectory(span)
+add_subdirectory(format)
diff --git a/test/format/CMakeLists.txt b/test/format/CMakeLists.txt
new file mode 100644
index 0000000..0b3a22e
--- /dev/null
+++ b/test/format/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(rsl-util-test PRIVATE 
+  field_parser.cpp
+)
diff --git a/test/format/field_parser.cpp b/test/format/field_parser.cpp
new file mode 100644
index 0000000..f06fd92
--- /dev/null
+++ b/test/format/field_parser.cpp
@@ -0,0 +1,120 @@
+#include <string_view>
+#include <vector>
+#include <string>
+#include <rsl/_format_impl/fmt_parser.hpp>
+
+#include <gtest/gtest.h>
+
+using namespace rsl::_format_impl;
+
+namespace {
+Replacement parse(std::string_view str) {
+  auto parser = Replacement(str);
+  parser.do_parse();
+  return parser;
+}
+}  // namespace
+
+
+TEST(FormatField, Simple) {
+  auto empty = parse("");
+  ASSERT_EQ(empty.kind, ReplacementType::automatic);
+  ASSERT_TRUE(empty.field.empty());
+  ASSERT_TRUE(empty.specs.empty());
+  ASSERT_TRUE(empty.style_tags.empty());
+
+  auto indexed = parse("1");
+  ASSERT_EQ(indexed.kind, ReplacementType::indexed);
+  ASSERT_EQ(indexed.field, "1");
+  ASSERT_TRUE(indexed.specs.empty());
+  ASSERT_TRUE(indexed.style_tags.empty());
+
+  auto field = parse("foo");
+  ASSERT_EQ(field.kind, ReplacementType::field);
+  ASSERT_EQ(field.field, "foo");
+  ASSERT_TRUE(field.specs.empty());
+  ASSERT_TRUE(field.style_tags.empty());
+
+  auto bang = parse("!");
+  ASSERT_EQ(bang.kind, ReplacementType::remove);
+  ASSERT_EQ(bang.field, "!");
+  ASSERT_TRUE(bang.specs.empty());
+  ASSERT_TRUE(bang.style_tags.empty());
+}
+
+TEST(FormatField, WithSpecs) {
+  auto empty = parse(":[<3");
+  ASSERT_EQ(empty.kind, ReplacementType::automatic);
+  ASSERT_TRUE(empty.field.empty());
+  ASSERT_EQ(empty.specs, "[<3");
+  ASSERT_TRUE(empty.style_tags.empty());
+
+  auto indexed = parse("1:[<3");
+  ASSERT_EQ(indexed.kind, ReplacementType::indexed);
+  ASSERT_EQ(indexed.field, "1");
+  ASSERT_EQ(indexed.specs, "[<3");
+  ASSERT_TRUE(indexed.style_tags.empty());
+
+  auto field = parse("foo:[<3");
+  ASSERT_EQ(field.kind, ReplacementType::field);
+  ASSERT_EQ(field.field, "foo");
+  ASSERT_EQ(field.specs, "[<3");
+  ASSERT_TRUE(field.style_tags.empty());
+
+  auto bang = parse("!:[<3");
+  ASSERT_EQ(bang.kind, ReplacementType::invalid);
+}
+
+TEST(FormatField, WithColor) {
+  auto expected = std::vector<std::string>{"red"};
+  auto empty = parse("[red]");
+  ASSERT_EQ(empty.kind, ReplacementType::automatic);
+  ASSERT_TRUE(empty.field.empty());
+  ASSERT_EQ(empty.style_tags, expected);
+
+  auto indexed = parse("[red]1");
+  ASSERT_EQ(indexed.kind, ReplacementType::indexed);
+  ASSERT_EQ(indexed.field, "1");
+  ASSERT_EQ(indexed.style_tags, expected);
+
+  auto field = parse("[red]foo");
+  ASSERT_EQ(field.kind, ReplacementType::field);
+  ASSERT_EQ(field.field, "foo");
+  ASSERT_EQ(field.style_tags, expected);
+
+  auto bang = parse("[red]!");
+  ASSERT_EQ(bang.kind, ReplacementType::remove);
+  ASSERT_EQ(bang.field, "!");
+  ASSERT_EQ(bang.style_tags, expected);
+}
+
+TEST(FormatField, WithColorAndSpec) {
+  auto expected = std::vector<std::string>{"red"};
+  auto empty = parse("[red]:[<3");
+  ASSERT_EQ(empty.kind, ReplacementType::automatic);
+  ASSERT_TRUE(empty.field.empty());
+  ASSERT_EQ(empty.specs, "[<3");
+  ASSERT_EQ(empty.style_tags, expected);
+
+  auto indexed = parse("[red]1:[<3");
+  ASSERT_EQ(indexed.kind, ReplacementType::indexed);
+  ASSERT_EQ(indexed.field, "1");
+  ASSERT_EQ(indexed.specs, "[<3");
+  ASSERT_EQ(indexed.style_tags, expected);
+
+  auto field = parse("[red]foo:[<3");
+  ASSERT_EQ(field.kind, ReplacementType::field);
+  ASSERT_EQ(field.field, "foo");
+  ASSERT_EQ(field.specs, "[<3");
+  ASSERT_EQ(field.style_tags, expected);
+
+  auto bang = parse("[red]!:[<3");
+  ASSERT_EQ(bang.kind, ReplacementType::invalid);
+}
+
+TEST(FormatField, MultiColor) {
+  auto expected = std::vector<std::string>{"fg=red", "bg=blue"};
+  
+  auto no_space = parse("[fg=red,bg=blue]");
+  ASSERT_EQ(no_space.style_tags, expected);
+}
\ No newline at end of file

From f3fad130e1369841ad947e6595393fb0b02169e3 Mon Sep 17 00:00:00 2001
From: Tsche <che@pydong.org>
Date: Thu, 11 Sep 2025 01:52:25 +0000
Subject: [PATCH 2/2] remove unused file, update gitignore

---
 .gitignore    | 4 +++-
 src/print.cpp | 0
 2 files changed, 3 insertions(+), 1 deletion(-)
 delete mode 100644 src/print.cpp

diff --git a/.gitignore b/.gitignore
index ac397e1..e36f8c7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -50,4 +50,6 @@
 .cache
 .pytest_cache
 
-.devcontainer
\ No newline at end of file
+.devcontainer
+
+lib/
\ No newline at end of file
diff --git a/src/print.cpp b/src/print.cpp
deleted file mode 100644
index e69de29..0000000