presentation.hpp

Go to the documentation of this file.

#pragma once
 
#include "terminal.hpp"
 
#include <uni20/core/math.hpp>
#include <uni20/core/scalar_io.hpp>
 
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdio>
#include <deque>
#include <fmt/core.h>
#include <initializer_list>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
namespace uni20::presentation
{
 
enum class color_mode
{
  never,
  automatic,
  always
};
 
enum class glyph_set
{
  unicode,
  emoji,
  ascii
};
 
enum class text_charset
{
  utf8,
  ascii_escape,
  ascii_replace
};
 
enum class width_mode
{
  bytes,
  display_cells
};
 
enum class ambiguous_width
{
  narrow,
  wide
};
 
enum class invalid_utf8
{
  escape,
  replace
};
 
enum class ornament_mode
{
  none,
  minimal,
  rich
};
 
enum class real_notation
{
  general,
  fixed,
  scientific
};
 
enum class table_alignment
{
  left,
  right,
  center,
  decimal
};
 
enum class table_rule_style
{
  single,
  double_line
};
 
struct numeric_format_options
{
    int float32_precision = 6;
    int float64_precision = 15;
    int long_double_precision = 18;
    int float128_precision = 36;
    real_notation notation = real_notation::general;
    bool normalize_negative_zero = true;
    std::string imaginary_unit = "i";
};
 
enum class semantic_glyph
{
  success,
  failure,
  fatal,
  warning,
  info,
  partial,
  deferred,
  skipped,
  arrow_right,
  arrow_left,
  arrow_up,
  arrow_down,
  arrow_left_right,
  ellipsis,
  box_horizontal,
  box_vertical,
  box_top_left,
  box_top_right,
  box_bottom_left,
  box_bottom_right,
  box_round_top_left,
  box_round_top_right,
  box_round_bottom_left,
  box_round_bottom_right,
  box_tee_left,
  box_tee_right,
  box_tee_up,
  box_tee_down,
  box_cross,
  box_double_horizontal,
  box_double_vertical,
  box_double_top_left,
  box_double_top_right,
  box_double_bottom_left,
  box_double_bottom_right,
  box_double_tee_left,
  box_double_tee_right,
  box_double_tee_up,
  box_double_tee_down,
  box_double_cross,
  box_double_vertical_tee_right_single,
  box_double_vertical_tee_left_single,
  box_double_vertical_cross_single_horizontal,
  box_double_down_single_horizontal,
  box_double_up_single_horizontal,
  box_single_vertical_tee_right_double,
  box_single_vertical_tee_left_double,
  box_single_vertical_cross_double_horizontal,
  box_single_down_double_horizontal,
  box_single_up_double_horizontal,
  box_diagonal_forward,
  box_diagonal_back,
  box_diagonal_cross,
  tree_branch,
  tree_last,
  tree_vertical,
  tree_space,
  bullet,
  matrix_top_left,
  matrix_top_right,
  matrix_middle_left,
  matrix_middle_right,
  matrix_bottom_left,
  matrix_bottom_right
};
 
struct output_policy
{
    color_mode color = color_mode::automatic;
    glyph_set glyphs = glyph_set::emoji;
    text_charset charset = text_charset::utf8;
    width_mode width = width_mode::display_cells;
    ambiguous_width ambiguous = ambiguous_width::narrow;
    invalid_utf8 invalid = invalid_utf8::escape;
    std::size_t tab_width = 8;
    std::optional<std::size_t> wrap_width = std::nullopt;
    ornament_mode ornaments = ornament_mode::rich;
    std::FILE* output_stream = stdout;
};
 
struct styled_text_span
{
    std::string text;
    terminal::TerminalStyle style;
};
 
struct semantic_glyph_span
{
    semantic_glyph glyph = semantic_glyph::info;
    terminal::TerminalStyle style;
};
 
using presentation_span = std::variant<styled_text_span, semantic_glyph_span>;
 
class styled_text {
  public:
    styled_text& append(std::string_view text, terminal::TerminalStyle style = {});
 
    styled_text& append(semantic_glyph glyph, terminal::TerminalStyle style = {});
 
    styled_text& append(styled_text const& other);
 
    [[nodiscard]] bool empty() const noexcept;
 
    [[nodiscard]] std::vector<presentation_span> const& spans() const noexcept;
 
  private:
    std::vector<presentation_span> spans_;
};
 
class text_style {
  public:
    text_style() = default;
 
    explicit text_style(terminal::TerminalStyle style) : style_(std::move(style)) {}
 
    explicit text_style(std::string_view spec) : style_(spec) {}
 
    explicit text_style(char const* spec) : text_style(spec != nullptr ? std::string_view(spec) : std::string_view{}) {}
 
    [[nodiscard]] terminal::TerminalStyle const& terminal_style() const noexcept { return style_; }
 
    [[nodiscard]] styled_text operator()(std::string_view text) const
    {
      styled_text result;
      result.append(text, style_);
      return result;
    }
 
    [[nodiscard]] styled_text operator()(char const* text) const
    {
      return (*this)(text != nullptr ? std::string_view(text) : std::string_view{});
    }
 
    [[nodiscard]] styled_text operator()(semantic_glyph glyph) const
    {
      styled_text result;
      result.append(glyph, style_);
      return result;
    }
 
    template <typename T>
      requires(!std::is_convertible_v<T &&, std::string_view> && !std::same_as<std::remove_cvref_t<T>, semantic_glyph>)
    [[nodiscard]] styled_text operator()(T&& value) const
    {
      styled_text result;
      result.append(fmt::format("{}", std::forward<T>(value)), style_);
      return result;
    }
 
    template <typename... Args>
      requires(sizeof...(Args) > 0)
    [[nodiscard]] styled_text operator()(fmt::format_string<Args...> format, Args&&... args) const
    {
      styled_text result;
      result.append(fmt::format(format, std::forward<Args>(args)...), style_);
      return result;
    }
 
    [[nodiscard]] styled_text operator()(semantic_glyph glyph, std::string_view text) const
    {
      styled_text result;
      result.append(glyph, style_).append(" ").append(text, style_);
      return result;
    }
 
    [[nodiscard]] styled_text operator()(semantic_glyph glyph, char const* text) const
    {
      return (*this)(glyph, text != nullptr ? std::string_view(text) : std::string_view{});
    }
 
    template <typename... Args>
      requires(sizeof...(Args) > 0)
    [[nodiscard]] styled_text operator()(semantic_glyph glyph, fmt::format_string<Args...> format, Args&&... args) const
    {
      styled_text result;
      result.append(glyph, style_).append(" ").append(fmt::format(format, std::forward<Args>(args)...), style_);
      return result;
    }
 
  private:
    terminal::TerminalStyle style_;
};
 
[[nodiscard]] inline text_style style(terminal::TerminalStyle style) { return text_style(std::move(style)); }
 
[[nodiscard]] inline text_style style(std::string_view spec) { return text_style(spec); }
 
[[nodiscard]] inline text_style style(char const* spec) { return text_style(spec); }
 
struct table_column
{
    std::string heading;
    table_alignment alignment = table_alignment::right;
};
 
struct table_border_options
{
    bool outer = false;
    bool column_separators = false;
    bool row_separators = false;
    bool header_separator = false;
    table_rule_style rule_style = table_rule_style::single;
    std::size_t horizontal_padding = 1;
};
 
struct table_cell
{
    styled_text content;
    std::size_t span = 1;
    std::optional<table_alignment> alignment = std::nullopt;
 
    table_cell() = default;
    table_cell(std::string_view text, std::size_t span_ = 1, std::optional<table_alignment> alignment_ = std::nullopt)
        : span(span_), alignment(alignment_)
    {
      content.append(text);
    }
    table_cell(char const* text, std::size_t span_ = 1, std::optional<table_alignment> alignment_ = std::nullopt)
        : table_cell(text != nullptr ? std::string_view(text) : std::string_view{}, span_, alignment_)
    {}
    table_cell(std::string text, std::size_t span_ = 1, std::optional<table_alignment> alignment_ = std::nullopt)
        : table_cell(std::string_view(text), span_, alignment_)
    {}
    table_cell(styled_text text, std::size_t span_ = 1, std::optional<table_alignment> alignment_ = std::nullopt)
        : content(std::move(text)), span(span_), alignment(alignment_)
    {}
};
 
[[nodiscard]] inline table_cell cell(styled_text content, std::size_t span = 1,
                                     std::optional<table_alignment> alignment = std::nullopt)
{
  return table_cell(std::move(content), span, alignment);
}
 
[[nodiscard]] inline table_cell cell(std::string_view text, std::size_t span = 1,
                                     std::optional<table_alignment> alignment = std::nullopt)
{
  return table_cell(text, span, alignment);
}
 
[[nodiscard]] inline table_cell cell(char const* text, std::size_t span = 1,
                                     std::optional<table_alignment> alignment = std::nullopt)
{
  return table_cell(text, span, alignment);
}
 
namespace detail
{
[[nodiscard]] inline table_cell make_table_cell(table_cell const& value) { return value; }
[[nodiscard]] inline table_cell make_table_cell(styled_text const& value) { return table_cell(value); }
[[nodiscard]] inline table_cell make_table_cell(std::string const& value) { return table_cell(value); }
[[nodiscard]] inline table_cell make_table_cell(std::string_view value) { return table_cell(value); }
[[nodiscard]] inline table_cell make_table_cell(char const* value) { return table_cell(value); }
 
template <typename T> [[nodiscard]] table_cell make_table_cell(T const& value)
{
  return table_cell(fmt::format("{}", value));
}
} // namespace detail
 
struct table_separator
{
    table_rule_style style = table_rule_style::single;
};
 
using table_entry = std::variant<std::vector<table_cell>, table_separator>;
 
class report_table {
  public:
    explicit report_table(std::string title = {});
 
    report_table& column(std::string heading, table_alignment alignment = table_alignment::right);
 
    report_table& row(std::vector<std::string> cells);
 
    report_table& row(std::vector<table_cell> cells);
 
    report_table& row(std::initializer_list<table_cell> cells);
 
    report_table& top_separator(table_rule_style style = table_rule_style::single);
 
    report_table& separator(table_rule_style style = table_rule_style::single);
 
    report_table& borders(table_border_options options);
 
    report_table& border_style(table_rule_style style);
 
    report_table& outer_border(bool enabled = true);
 
    report_table& column_separators(bool enabled = true);
 
    report_table& row_separators(bool enabled = true);
 
    report_table& header_separator(bool enabled = true);
 
    report_table& grid(bool enabled = true);
 
    report_table& grid(table_rule_style style);
 
    report_table& preserve_tokens(bool enabled = true);
 
    template <typename... Values> report_table& row(Values const&... values)
    {
      return this->row(std::vector<table_cell>{detail::make_table_cell(values)...});
    }
 
    [[nodiscard]] std::string const& title() const noexcept;
 
    [[nodiscard]] std::vector<table_column> const& columns() const noexcept;
 
    [[nodiscard]] std::vector<table_entry> const& entries() const noexcept;
 
    [[nodiscard]] std::vector<table_rule_style> const& top_separators() const noexcept;
 
    [[nodiscard]] table_border_options const& border_options() const noexcept;
 
    [[nodiscard]] bool preserves_tokens() const noexcept;
 
  private:
    std::string title_;
    std::vector<table_column> columns_;
    std::vector<table_entry> entries_;
    std::vector<table_rule_style> top_separators_;
    table_border_options border_options_;
    bool preserve_tokens_ = false;
};
 
class report_builder {
  public:
    explicit report_builder(std::string title = {});
 
    report_builder& status(semantic_glyph glyph, std::string label);
 
    report_builder& field(std::string key, std::string value);
 
    template <typename Value> report_builder& field(std::string key, Value const& value)
    {
      return this->field(std::move(key), fmt::format("{}", value));
    }
 
    report_table& table(std::string title);
 
    [[nodiscard]] std::string const& title() const noexcept;
 
    [[nodiscard]] std::vector<std::pair<semantic_glyph, std::string>> const& statuses() const noexcept;
 
    [[nodiscard]] std::vector<std::pair<std::string, std::string>> const& fields() const noexcept;
 
    [[nodiscard]] std::deque<report_table> const& tables() const noexcept;
 
  private:
    std::string title_;
    std::vector<std::pair<semantic_glyph, std::string>> statuses_;
    std::vector<std::pair<std::string, std::string>> fields_;
    std::deque<report_table> tables_;
};
 
[[nodiscard]] output_policy terminal_policy(std::FILE* stream = stdout);
 
[[nodiscard]] output_policy plain_policy();
 
[[nodiscard]] output_policy strict_ascii_policy(text_charset charset = text_charset::ascii_escape);
 
[[nodiscard]] bool should_emit_color(output_policy const& policy);
 
[[nodiscard]] std::string render_glyph(semantic_glyph glyph, output_policy const& policy);
 
[[nodiscard]] std::string render_text(std::string_view text, output_policy const& policy);
 
[[nodiscard]] std::string render(styled_text const& text, output_policy const& policy);
 
[[nodiscard]] std::string render_terminal(styled_text const& text, output_policy policy, std::FILE* stream = stdout);
 
[[nodiscard]] std::string render_plain(styled_text const& text, output_policy policy = plain_policy());
 
[[nodiscard]] std::string render_strict_ascii(styled_text const& text,
                                              text_charset charset = text_charset::ascii_escape,
                                              output_policy policy = strict_ascii_policy());
 
[[nodiscard]] styled_text render_report(report_builder const& report, output_policy const& policy);
 
[[nodiscard]] std::string render_terminal(report_builder const& report, output_policy policy,
                                          std::FILE* stream = stdout);
 
[[nodiscard]] std::string render_plain(report_builder const& report, output_policy policy = plain_policy());
 
[[nodiscard]] std::size_t display_width(std::string_view text, output_policy const& policy,
                                        std::size_t initial_column = 0);
 
[[nodiscard]] std::size_t display_width(styled_text const& text, output_policy const& policy,
                                        std::size_t initial_column = 0);
 
[[nodiscard]] std::string pad_left(std::string_view text, std::size_t target_width, output_policy const& policy);
 
[[nodiscard]] styled_text pad_left(styled_text const& text, std::size_t target_width, output_policy const& policy);
 
[[nodiscard]] std::string pad_right(std::string_view text, std::size_t target_width, output_policy const& policy);
 
[[nodiscard]] styled_text pad_right(styled_text const& text, std::size_t target_width, output_policy const& policy);
 
[[nodiscard]] std::string pad_center(std::string_view text, std::size_t target_width, output_policy const& policy);
 
[[nodiscard]] styled_text pad_center(styled_text const& text, std::size_t target_width, output_policy const& policy);
 
[[nodiscard]] std::string clip_to_width(std::string_view text, std::size_t max_width, output_policy const& policy,
                                        std::size_t initial_column = 0);
 
[[nodiscard]] std::string truncate_to_width(std::string_view text, std::size_t max_width, output_policy const& policy,
                                            std::string_view marker = "", std::size_t initial_column = 0);
 
[[nodiscard]] std::string truncate_left_to_width(std::string_view text, std::size_t max_width,
                                                 output_policy const& policy, std::string_view marker = "",
                                                 std::size_t initial_column = 0);
 
[[nodiscard]] std::string prefix_lines(std::string_view text, std::string_view prefix, output_policy const& policy,
                                       bool prefix_first = true);
 
[[nodiscard]] std::string indent_text(std::string_view text, std::size_t spaces, output_policy const& policy,
                                      bool indent_first = true);
 
[[nodiscard]] std::vector<std::string> wrap_text(std::string_view text, std::size_t max_width,
                                                 output_policy const& policy);
 
[[nodiscard]] std::vector<styled_text> wrap_text(styled_text const& text, std::size_t max_width,
                                                 output_policy const& policy);
 
template <uni20::Real T> [[nodiscard]] int real_precision(numeric_format_options const& options)
{
  if constexpr (std::is_same_v<std::remove_cv_t<T>, float>)
  {
    return options.float32_precision;
  }
  else if constexpr (std::is_same_v<std::remove_cv_t<T>, double>)
  {
    return options.float64_precision;
  }
#if UNI20_HAS_FLOAT128
  else if constexpr (std::is_same_v<std::remove_cv_t<T>, uni20::float128>)
  {
    return options.float128_precision;
  }
#endif
  else
  {
    return options.long_double_precision;
  }
}
 
[[nodiscard]] inline uni20::real_format_notation core_notation(real_notation notation)
{
  switch (notation)
  {
    case real_notation::fixed:
      return uni20::real_format_notation::fixed;
    case real_notation::scientific:
      return uni20::real_format_notation::scientific;
    case real_notation::general:
      return uni20::real_format_notation::general;
  }
  return uni20::real_format_notation::general;
}
 
template <uni20::Real T> [[nodiscard]] std::string format_real(T value, numeric_format_options const& options)
{
  return uni20::format_real(value,
                            uni20::scalar_format_options{.precision = real_precision<T>(options),
                                                         .notation = core_notation(options.notation),
                                                         .normalize_negative_zero = options.normalize_negative_zero,
                                                         .imaginary_unit = std::string_view(options.imaginary_unit)});
}
 
template <uni20::Complex T>
[[nodiscard]] std::string format_complex(T const& value, numeric_format_options const& options)
{
  using real_type = uni20::make_real_t<T>;
  return uni20::format_complex(
      value, uni20::scalar_format_options{.precision = real_precision<real_type>(options),
                                          .notation = core_notation(options.notation),
                                          .normalize_negative_zero = options.normalize_negative_zero,
                                          .imaginary_unit = std::string_view(options.imaginary_unit)});
}
 
template <typename T> [[nodiscard]] std::string format_scalar(T const& value, numeric_format_options const& options)
{
  using value_type = std::remove_cvref_t<T>;
  if constexpr (uni20::Real<value_type>)
  {
    return format_real(value, options);
  }
  else if constexpr (uni20::Complex<value_type>)
  {
    return format_complex(value, options);
  }
  else
  {
    return fmt::format("{}", value);
  }
}
 
namespace detail
{
[[nodiscard]] inline terminal::TerminalStyle nonfinite_scalar_style()
{
  return terminal::TerminalStyle(std::string_view("Red;Bold"));
}
} // namespace detail
 
template <typename T>
[[nodiscard]] std::string style_nonfinite_scalar(std::string text, T const& value, output_policy const& policy)
{
  using value_type = std::remove_cvref_t<T>;
  if constexpr (uni20::RealOrComplex<value_type>)
  {
    if (!uni20::isfinite(value) && should_emit_color(policy) && !text.empty())
    {
      return terminal::color_text(text, detail::nonfinite_scalar_style());
    }
  }
  return text;
}
 
template <typename T>
[[nodiscard]] std::string format_scalar_for_output(T const& value, numeric_format_options const& options,
                                                   output_policy const& policy)
{
  return style_nonfinite_scalar(format_scalar(value, options), value, policy);
}
 
} // namespace uni20::presentation