html_writer.h

#ifndef SOURCEMETA_CORE_HTML_WRITER_H_
#define SOURCEMETA_CORE_HTML_WRITER_H_
 
#ifndef SOURCEMETA_CORE_HTML_EXPORT
#include <sourcemeta/core/html_export.h>
#endif
 
#include <sourcemeta/core/html_buffer.h>
#include <sourcemeta/core/html_escape.h>
#include <sourcemeta/core/preprocessor.h>
 
#include <array>       // std::array
#include <cassert>     // assert
#include <cstddef>     // std::size_t
#include <cstdint>     // std::uint8_t
#include <string>      // std::string
#include <string_view> // std::string_view
#include <vector>      // std::vector
 
namespace sourcemeta::core {

class SOURCEMETA_CORE_HTML_EXPORT HTMLWriter {
public:
  SOURCEMETA_FORCEINLINE auto reserve(std::size_t bytes) -> void {
    this->buffer_.reserve(bytes);
  }

  SOURCEMETA_FORCEINLINE auto close() -> HTMLWriter & {
    this->tag_open_ = false;
    assert(!this->tag_stack_.empty());
    if (this->tag_stack_.empty()) [[unlikely]] {
      return *this;
    }
    const auto &closing{this->tag_stack_.back()};
    // Copying every byte of the fixed storage is cheaper than copying a
    // variable number of them, and the bytes past the tag are then dropped
    this->buffer_.reserve_additional(closing.bytes.size());
    this->buffer_.append_unchecked(
        std::string_view{closing.bytes.data(), closing.bytes.size()});
    this->buffer_.remove_suffix(closing.bytes.size() - closing.size);
    this->tag_stack_.pop_back();
    return *this;
  }

  SOURCEMETA_FORCEINLINE auto attribute(std::string_view name,
                                        std::string_view value)
      -> HTMLWriter & {
    assert(this->tag_open_);
    this->reopen_tag();
    // The space before the name, the equals sign and the quotation mark after
    // it, along with the end of the tag, which takes four bytes for a void
    // element
    this->buffer_.reserve_additional(name.size() + 7);
    this->buffer_.append_unchecked(" ");
    this->buffer_.append_unchecked(name);
    this->buffer_.append_unchecked("=\"");
    html_escape_append(this->buffer_, value);
    this->buffer_.reserve_additional(4);
    if (this->tag_open_is_void_) {
      this->buffer_.append_unchecked("\" />");
    } else {
      this->buffer_.append_unchecked("\">");
    }
    return *this;
  }

  SOURCEMETA_FORCEINLINE auto attribute(std::string_view name) -> HTMLWriter & {
    assert(this->tag_open_);
    this->reopen_tag();
    this->buffer_.reserve_additional(name.size() + 1);
    this->buffer_.append_unchecked(" ");
    this->buffer_.append_unchecked(name);
    this->end_open_tag();
    return *this;
  }

  SOURCEMETA_FORCEINLINE auto ensure_line_feed() -> HTMLWriter & {
    this->tag_open_ = false;
    if (this->buffer_.size() > 0 && this->buffer_.back() != '\n') {
      this->buffer_.append('\n');
    }
 
    return *this;
  }

  [[nodiscard]] SOURCEMETA_FORCEINLINE auto take() -> std::string {
    this->tag_open_ = false;
    this->tag_stack_.clear();
    return this->buffer_.take();
  }

  SOURCEMETA_FORCEINLINE auto clear() -> void {
    this->tag_open_ = false;
    this->tag_stack_.clear();
    this->buffer_.clear();
  }

  SOURCEMETA_FORCEINLINE auto text(std::string_view content) -> HTMLWriter & {
    this->tag_open_ = false;
    html_escape_append(this->buffer_, content);
    return *this;
  }

  SOURCEMETA_FORCEINLINE auto raw(std::string_view content) -> HTMLWriter & {
    this->tag_open_ = false;
    this->buffer_.append(content);
    return *this;
  }

  [[nodiscard]] SOURCEMETA_FORCEINLINE auto str() -> const std::string & {
    return this->buffer_.str();
  }

  auto write(std::ostream &stream) -> void;
 
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
 
#ifndef DOXYGEN
// Macro to generate container element methods.
// Container elements write <tag> on open and </tag> on close().
// Overloads:
//   .tag()              open with no attributes
//   .tag(text)          open, write escaped text, close (shorthand)
// NOLINTBEGIN(bugprone-macro-parentheses)
#define HTML_WRITER_CONTAINER(name)                                            \
  SOURCEMETA_FORCEINLINE auto name() -> HTMLWriter & {                         \
    this->open_tag("<" #name ">", ClosingTag{"</" #name ">"});                 \
    return *this;                                                              \
  }                                                                            \
  SOURCEMETA_FORCEINLINE auto name(std::string_view text_content)              \
      -> HTMLWriter & {                                                        \
    this->open_tag("<" #name ">", ClosingTag{"</" #name ">"});                 \
    this->text(text_content);                                                  \
    this->close();                                                             \
    return *this;                                                              \
  }
// NOLINTEND(bugprone-macro-parentheses)
 
// Same as above but with a different C++ method name than the HTML tag
// NOLINTBEGIN(bugprone-macro-parentheses)
#define HTML_WRITER_CONTAINER_NAMED(name, tag)                                 \
  SOURCEMETA_FORCEINLINE auto name() -> HTMLWriter & {                         \
    this->open_tag("<" #tag ">", ClosingTag{"</" #tag ">"});                   \
    return *this;                                                              \
  }                                                                            \
  SOURCEMETA_FORCEINLINE auto name(std::string_view text_content)              \
      -> HTMLWriter & {                                                        \
    this->open_tag("<" #tag ">", ClosingTag{"</" #tag ">"});                   \
    this->text(text_content);                                                  \
    this->close();                                                             \
    return *this;                                                              \
  }
// NOLINTEND(bugprone-macro-parentheses)
 
// Macro to generate void element methods.
// Void elements are self-closing: <tag /> or <tag attr="val" />
// NOLINTBEGIN(bugprone-macro-parentheses)
#define HTML_WRITER_VOID(name)                                                 \
  SOURCEMETA_FORCEINLINE auto name() -> HTMLWriter & {                         \
    this->void_tag("<" #name " />");                                           \
    return *this;                                                              \
  }
// NOLINTEND(bugprone-macro-parentheses)
#endif
 
  // =========================================================================
  // Document Structure Elements
  // =========================================================================

  HTML_WRITER_CONTAINER(html)
  HTML_WRITER_VOID(base)
  HTML_WRITER_CONTAINER(head)
  HTML_WRITER_VOID(link)
  HTML_WRITER_VOID(meta)
  HTML_WRITER_CONTAINER(style)
  HTML_WRITER_CONTAINER(title)
  HTML_WRITER_CONTAINER(body)
 
  // =========================================================================
  // Content Sectioning Elements
  // =========================================================================
 
  
  HTML_WRITER_CONTAINER(address)
  HTML_WRITER_CONTAINER(article)
  HTML_WRITER_CONTAINER(aside)
  HTML_WRITER_CONTAINER(footer)
  HTML_WRITER_CONTAINER(header)
  HTML_WRITER_CONTAINER(h1)
  HTML_WRITER_CONTAINER(h2)
  HTML_WRITER_CONTAINER(h3)
  HTML_WRITER_CONTAINER(h4)
  HTML_WRITER_CONTAINER(h5)
  HTML_WRITER_CONTAINER(h6)
  HTML_WRITER_CONTAINER(hgroup)
  HTML_WRITER_CONTAINER(main)
  HTML_WRITER_CONTAINER(nav)
  HTML_WRITER_CONTAINER(section)
  HTML_WRITER_CONTAINER(search)
 
  // =========================================================================
  // Text Content Elements
  // =========================================================================
 
  
  HTML_WRITER_CONTAINER(blockquote)
  HTML_WRITER_CONTAINER(dd)
  HTML_WRITER_CONTAINER(div)
  HTML_WRITER_CONTAINER(dl)
  HTML_WRITER_CONTAINER(dt)
  HTML_WRITER_CONTAINER(figcaption)
  HTML_WRITER_CONTAINER(figure)
  HTML_WRITER_VOID(hr)
  HTML_WRITER_CONTAINER(li)
  HTML_WRITER_CONTAINER(menu)
  HTML_WRITER_CONTAINER(ol)
  HTML_WRITER_CONTAINER(p)
  HTML_WRITER_CONTAINER(pre)
  HTML_WRITER_CONTAINER(ul)
 
  // =========================================================================
  // Inline Text Semantics Elements
  // =========================================================================
 
  
  HTML_WRITER_CONTAINER(a)
  HTML_WRITER_CONTAINER(abbr)
  HTML_WRITER_CONTAINER(b)
  HTML_WRITER_CONTAINER(bdi)
  HTML_WRITER_CONTAINER(bdo)
  HTML_WRITER_VOID(br)
  HTML_WRITER_CONTAINER(cite)
  HTML_WRITER_CONTAINER(code)
  HTML_WRITER_CONTAINER(data)
  HTML_WRITER_CONTAINER(dfn)
  HTML_WRITER_CONTAINER(em)
  HTML_WRITER_CONTAINER(i)
  HTML_WRITER_CONTAINER(kbd)
  HTML_WRITER_CONTAINER(mark)
  HTML_WRITER_CONTAINER(q)
  HTML_WRITER_CONTAINER(rp)
  HTML_WRITER_CONTAINER(rt)
  HTML_WRITER_CONTAINER(ruby)
  HTML_WRITER_CONTAINER(s)
  HTML_WRITER_CONTAINER(samp)
  HTML_WRITER_CONTAINER(small)
  HTML_WRITER_CONTAINER(span)
  HTML_WRITER_CONTAINER(strong)
  HTML_WRITER_CONTAINER(sub)
  HTML_WRITER_CONTAINER(sup)
  HTML_WRITER_CONTAINER(time)
  HTML_WRITER_CONTAINER(u)
  HTML_WRITER_CONTAINER(var)
  HTML_WRITER_VOID(wbr)
 
  // =========================================================================
  // Image and Multimedia Elements
  // =========================================================================
 
  
  HTML_WRITER_VOID(area)
  HTML_WRITER_CONTAINER(audio)
  HTML_WRITER_VOID(img)
  HTML_WRITER_CONTAINER(map)
  HTML_WRITER_VOID(track)
  HTML_WRITER_CONTAINER(video)
 
  // =========================================================================
  // Embedded Content Elements
  // =========================================================================
 
  
  HTML_WRITER_VOID(embed)
  HTML_WRITER_CONTAINER(iframe)
  HTML_WRITER_CONTAINER(object)
  HTML_WRITER_CONTAINER(picture)
  HTML_WRITER_CONTAINER(portal)
  HTML_WRITER_VOID(source)
 
  // =========================================================================
  // Scripting Elements
  // =========================================================================
 
  
  HTML_WRITER_CONTAINER(canvas)
  HTML_WRITER_CONTAINER(noscript)
  HTML_WRITER_CONTAINER(script)
 
  // =========================================================================
  // Demarcating Edits Elements
  // =========================================================================
 
  
  HTML_WRITER_CONTAINER(del)
  HTML_WRITER_CONTAINER(ins)
 
  // =========================================================================
  // Table Content Elements
  // =========================================================================
 
  
  HTML_WRITER_CONTAINER(caption)
  HTML_WRITER_VOID(col)
  HTML_WRITER_CONTAINER(colgroup)
  HTML_WRITER_CONTAINER(table)
  HTML_WRITER_CONTAINER(tbody)
  HTML_WRITER_CONTAINER(td)
  HTML_WRITER_CONTAINER(tfoot)
  HTML_WRITER_CONTAINER(th)
  HTML_WRITER_CONTAINER(thead)
  HTML_WRITER_CONTAINER(tr)
 
  // =========================================================================
  // Forms Elements
  // =========================================================================
 
  
  HTML_WRITER_CONTAINER(button)
  HTML_WRITER_CONTAINER(datalist)
  HTML_WRITER_CONTAINER(fieldset)
  HTML_WRITER_CONTAINER(form)
  HTML_WRITER_VOID(input)
  HTML_WRITER_CONTAINER(label)
  HTML_WRITER_CONTAINER(legend)
  HTML_WRITER_CONTAINER(meter)
  HTML_WRITER_CONTAINER(optgroup)
  HTML_WRITER_CONTAINER(option)
  HTML_WRITER_CONTAINER(output)
  HTML_WRITER_CONTAINER(progress)
  HTML_WRITER_CONTAINER(select)
  HTML_WRITER_CONTAINER(textarea)
 
  // =========================================================================
  // Interactive Elements
  // =========================================================================
 
  
  HTML_WRITER_CONTAINER(details)
  HTML_WRITER_CONTAINER(dialog)
  HTML_WRITER_CONTAINER(summary)
 
  // =========================================================================
  // Web Components Elements
  // =========================================================================
 
  
  HTML_WRITER_CONTAINER(slot)
  // The trailing underscore keeps this element name from colliding with the
  // template keyword
  // NOLINTNEXTLINE(readability-identifier-naming)
  HTML_WRITER_CONTAINER_NAMED(template_, template)
 
#ifndef DOXYGEN
#undef HTML_WRITER_CONTAINER
#undef HTML_WRITER_CONTAINER_NAMED
#undef HTML_WRITER_VOID
#endif
 
private:
  // A closing tag kept in a fixed number of bytes, as copying a constant
  // number of bytes is cheaper than copying a variable one
  struct ClosingTag {
    constexpr explicit ClosingTag(const std::string_view tag) noexcept
        : size{static_cast<std::uint8_t>(tag.size())} {
      for (std::size_t index = 0; index < tag.size(); index += 1) {
        this->bytes[index] = tag[index];
      }
    }
 
    std::array<char, 16> bytes{};
    std::uint8_t size;
  };
 
  SOURCEMETA_FORCEINLINE auto open_tag(std::string_view opening,
                                       const ClosingTag &closing) -> void {
    this->buffer_.append(opening);
    this->tag_stack_.push_back(closing);
    this->tag_open_ = true;
    this->tag_open_is_void_ = false;
  }
 
  SOURCEMETA_FORCEINLINE auto void_tag(std::string_view opening) -> void {
    this->buffer_.append(opening);
    this->tag_open_ = true;
    this->tag_open_is_void_ = true;
  }
 
  // Remove the characters that end the tag opened last, so that attributes
  // can go before them
  SOURCEMETA_FORCEINLINE auto reopen_tag() -> void {
    this->buffer_.remove_suffix(this->tag_open_is_void_ ? 3 : 1);
  }
 
  SOURCEMETA_FORCEINLINE auto end_open_tag() -> void {
    if (this->tag_open_is_void_) {
      this->buffer_.append(" />");
    } else {
      this->buffer_.append('>');
    }
  }
 
  HTMLBuffer buffer_;
  std::vector<ClosingTag> tag_stack_;
  bool tag_open_{false};
  bool tag_open_is_void_{false};
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
};
 
} // namespace sourcemeta::core
 
#endif