ldown 0.0.1

data/ext/ldown/ldown.c

@@ -0,0 +1,820 @@
+/*
+ * Copyright (C) 2026  gemmaro
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/* Admonitions: TODO, Question */
+
+/* TODO: Support abstract syntax tree manipulation. */
+
+/* Question: lowdown_file(3) and lowdown_file_diff(3); are they any
+   safe ways to do these with Ruby's C API? */
+
+/* Question: Should we provide buffer class?  I don't think so, since
+   the only its parameter is a grow (increment) size, which is
+   typically 256 or something, greater than zero at least. */
+
+#include "ldown.h"
+
+#include <stdlib.h>
+#include <sys/queue.h> /* required by lowdown */
+
+#include <lowdown.h>
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+#include <stddef.h>
+
+/* rbl_ prefix means RuBy Lowdown. */
+
+#define RBL_BUF_GROW 256
+
+VALUE rb_mLdown, rbl_cDocument, rbl_cNode,
+    /* per format: */
+    rbl_cHTML, rbl_cGemini, rbl_cLaTeX, rbl_cOpenDocument, rbl_cRoff,
+    rbl_cTerm,
+    /* misc --> */ rbl_eError;
+
+static inline void
+set_feat (unsigned int *feat, unsigned int fval, size_t index,
+          const VALUE *kwargs_vals)
+{
+  if (!RB_UNDEF_P (kwargs_vals[index]) && RB_TEST (kwargs_vals[index]))
+    *feat |= fval;
+}
+
+static inline struct lowdown_opts
+get_opts (VALUE kwargs)
+{
+  /* Naming: Separate "no-".  If it's hard to read, dissect.
+     Basically respect originals. */
+  const ID kwargs_ids[] = {
+    /* feat: */
+    rb_intern ("attrs"),
+    rb_intern ("autolink"),
+    rb_intern ("callouts"),
+    rb_intern ("commonmark"),
+    rb_intern ("deflist"),
+    rb_intern ("fenced"),
+    rb_intern ("footnotes"),
+    rb_intern ("hilite"),
+    rb_intern ("mantitle"),
+    rb_intern ("math"),
+    rb_intern ("metadata"),
+    rb_intern ("no_code_indented" /* nocodeind */),
+    rb_intern ("no_intra_emph" /* nointem */),
+    rb_intern ("strike"),
+    rb_intern ("super"),
+    rb_intern ("super_short"),
+    rb_intern ("tables"),
+    rb_intern ("tasklist"),
+    /* oflags/general: */
+    rb_intern ("no_link"),
+    rb_intern ("no_rellink"),
+    rb_intern ("shortlink"),
+    rb_intern ("skip_html"),
+    rb_intern ("smarty"),
+    rb_intern ("standalone"),
+    /* oflags/HTML: */
+    rb_intern ("html_callout_mdn"),
+    rb_intern ("html_callout_gfm"),
+    rb_intern ("html_custom_attrs"),
+    rb_intern ("html_escape"),
+    rb_intern ("html_hard_wrap"),
+    rb_intern ("html_head_ids"),
+    rb_intern ("html_num_entity" /* ent */),
+    rb_intern ("html_owasp"),
+    rb_intern ("html_titleblock"),
+    /* oflags/gemini: */
+    rb_intern ("gemini_link_end"),
+    rb_intern ("gemini_link_in"),
+    rb_intern ("gemini_link_no_ref"),
+    rb_intern ("gemini_link_roman"),
+    rb_intern ("gemini_metadata"),
+    /* oflags/latex: */
+    rb_intern ("latex_numbered"),
+    /* oflags/roff: */
+    rb_intern ("roff_groff"),
+    rb_intern ("roff_numbered"),
+    rb_intern ("roff_manpage"),
+    rb_intern ("roff_endnotes"),
+    /* oflags/term: */
+    rb_intern ("term_all_meta"),
+    rb_intern ("term_no_ansi"),
+    rb_intern ("term_no_colour"),
+
+    rb_intern ("maxdepth"),
+  };
+  VALUE kwargs_vals[sizeof (kwargs_ids) / sizeof (kwargs_ids[0])] = { 0 };
+  rb_get_kwargs (kwargs, kwargs_ids, 0,
+                 sizeof (kwargs_ids) / sizeof (kwargs_ids[0]), kwargs_vals);
+
+  unsigned int feat = 0;
+  set_feat (&feat, LOWDOWN_ATTRS, 0, kwargs_vals);
+  set_feat (&feat, LOWDOWN_AUTOLINK, 1, kwargs_vals);
+  set_feat (&feat, LOWDOWN_CALLOUTS, 2, kwargs_vals);
+  set_feat (&feat, LOWDOWN_COMMONMARK, 3, kwargs_vals);
+  set_feat (&feat, LOWDOWN_DEFLIST, 4, kwargs_vals);
+  set_feat (&feat, LOWDOWN_FENCED, 5, kwargs_vals);
+  set_feat (&feat, LOWDOWN_FOOTNOTES, 6, kwargs_vals);
+  set_feat (&feat, LOWDOWN_HILITE /* or highlit; what is this? */, 7,
+            kwargs_vals);
+  set_feat (&feat, LOWDOWN_MANTITLE, 8, kwargs_vals);
+  set_feat (&feat, LOWDOWN_MATH, 9, kwargs_vals);
+  set_feat (&feat, LOWDOWN_METADATA, 10, kwargs_vals);
+  set_feat (&feat, LOWDOWN_NOCODEIND, 11, kwargs_vals);
+  set_feat (&feat, LOWDOWN_NOINTEM, 12, kwargs_vals);
+  set_feat (&feat, LOWDOWN_STRIKE, 13, kwargs_vals);
+  set_feat (&feat, LOWDOWN_SUPER, 14, kwargs_vals);
+  set_feat (&feat, LOWDOWN_SUPER_SHORT, 15, kwargs_vals);
+  set_feat (&feat, LOWDOWN_TABLES, 16, kwargs_vals);
+  set_feat (&feat, LOWDOWN_TASKLIST, 17, kwargs_vals);
+
+  unsigned int oflags = 0;
+  if (!RB_UNDEF_P (kwargs_vals[18]) && RB_TEST (kwargs_vals[18]))
+    oflags |= LOWDOWN_NOLINK;
+  if (!RB_UNDEF_P (kwargs_vals[19]) && RB_TEST (kwargs_vals[19]))
+    oflags |= LOWDOWN_NORELLINK;
+  if (!RB_UNDEF_P (kwargs_vals[20]) && RB_TEST (kwargs_vals[20]))
+    oflags |= LOWDOWN_SHORTLINK;
+  if (!RB_UNDEF_P (kwargs_vals[21]) && RB_TEST (kwargs_vals[21]))
+    oflags |= LOWDOWN_SKIP_HTML;
+  if (!RB_UNDEF_P (kwargs_vals[22]) && RB_TEST (kwargs_vals[22]))
+    oflags |= LOWDOWN_SMARTY;
+  if (!RB_UNDEF_P (kwargs_vals[23]) && RB_TEST (kwargs_vals[23]))
+    oflags |= LOWDOWN_STANDALONE;
+  /* oflags/HTML: */
+  if (!RB_UNDEF_P (kwargs_vals[24]) && RB_TEST (kwargs_vals[24]))
+    oflags |= LOWDOWN_HTML_CALLOUT_MDN;
+  if (!RB_UNDEF_P (kwargs_vals[25]) && RB_TEST (kwargs_vals[25]))
+    oflags |= LOWDOWN_HTML_CALLOUT_GFM;
+  if (!RB_UNDEF_P (kwargs_vals[26]) && RB_TEST (kwargs_vals[26]))
+    oflags |= LOWDOWN_HTML_CUSTOM_ATTRS;
+  if (!RB_UNDEF_P (kwargs_vals[27]) && RB_TEST (kwargs_vals[27]))
+    oflags |= LOWDOWN_HTML_ESCAPE;
+  if (!RB_UNDEF_P (kwargs_vals[28]) && RB_TEST (kwargs_vals[28]))
+    oflags |= LOWDOWN_HTML_HARD_WRAP;
+  if (!RB_UNDEF_P (kwargs_vals[29]) && RB_TEST (kwargs_vals[29]))
+    oflags |= LOWDOWN_HTML_HEAD_IDS;
+  if (!RB_UNDEF_P (kwargs_vals[30]) && RB_TEST (kwargs_vals[30]))
+    oflags |= LOWDOWN_HTML_NUM_ENT;
+  if (!RB_UNDEF_P (kwargs_vals[31]) && RB_TEST (kwargs_vals[31]))
+    oflags |= LOWDOWN_HTML_OWASP;
+  if (!RB_UNDEF_P (kwargs_vals[32]) && RB_TEST (kwargs_vals[32]))
+    oflags |= LOWDOWN_HTML_TITLEBLOCK;
+  if (!RB_UNDEF_P (kwargs_vals[33]) && RB_TEST (kwargs_vals[33]))
+    oflags |= LOWDOWN_GEMINI_LINK_END;
+  if (!RB_UNDEF_P (kwargs_vals[34]) && RB_TEST (kwargs_vals[34]))
+    oflags |= LOWDOWN_GEMINI_LINK_IN;
+  if (!RB_UNDEF_P (kwargs_vals[35]) && RB_TEST (kwargs_vals[35]))
+    oflags |= LOWDOWN_GEMINI_LINK_NOREF;
+  if (!RB_UNDEF_P (kwargs_vals[36]) && RB_TEST (kwargs_vals[36]))
+    oflags |= LOWDOWN_GEMINI_LINK_ROMAN;
+  if (!RB_UNDEF_P (kwargs_vals[37]) && RB_TEST (kwargs_vals[37]))
+    oflags |= LOWDOWN_GEMINI_METADATA;
+
+  if (!RB_UNDEF_P (kwargs_vals[38]) && RB_TEST (kwargs_vals[38]))
+    oflags |= LOWDOWN_LATEX_NUMBERED;
+  if (!RB_UNDEF_P (kwargs_vals[39]) && RB_TEST (kwargs_vals[39]))
+    oflags |= LOWDOWN_ROFF_GROFF;
+  if (!RB_UNDEF_P (kwargs_vals[40]) && RB_TEST (kwargs_vals[40]))
+    oflags |= LOWDOWN_ROFF_NUMBERED;
+  if (!RB_UNDEF_P (kwargs_vals[41]) && RB_TEST (kwargs_vals[41]))
+    oflags |= LOWDOWN_ROFF_MANPAGE;
+  if (!RB_UNDEF_P (kwargs_vals[42]) && RB_TEST (kwargs_vals[42]))
+    oflags |= LOWDOWN_ROFF_ENDNOTES;
+  if (!RB_UNDEF_P (kwargs_vals[43]) && RB_TEST (kwargs_vals[43]))
+    oflags |= LOWDOWN_TERM_ALL_META;
+  if (!RB_UNDEF_P (kwargs_vals[44]) && RB_TEST (kwargs_vals[44]))
+    oflags |= LOWDOWN_TERM_NOANSI;
+  if (!RB_UNDEF_P (kwargs_vals[45]) && RB_TEST (kwargs_vals[45]))
+    oflags |= LOWDOWN_TERM_NOCOLOUR;
+
+  size_t maxdepth = 0;
+  if (!RB_UNDEF_P (kwargs_vals[46]) && RB_TEST (kwargs_vals[46]))
+    maxdepth = RB_NUM2SIZE (kwargs_vals[46]);
+
+  /* TODO: support more options, including nroff, odt, term, etc. */
+  return (struct lowdown_opts){
+    .feat = feat,
+    .oflags = oflags,
+    .maxdepth = maxdepth,
+  };
+}
+
+static inline VALUE
+rbl_parse_into (int argc, VALUE *argv, enum lowdown_type type)
+{
+  VALUE input, kwargs;
+  rb_scan_args (argc, argv, "1:", &input, &kwargs);
+
+  const char *buf = rb_string_value_ptr (&input);
+  size_t bufsz = RSTRING_LEN (input);
+
+  struct lowdown_opts opts = get_opts (kwargs);
+  opts.type = type;
+
+  char *ret;
+  size_t retsz;
+  struct lowdown_metaq metaq = { 0 };
+
+  int result = lowdown_buf (&opts, buf, bufsz, &ret, &retsz, &metaq);
+  if (result == 0)
+    rb_raise (rbl_eError, "failed to parse");
+
+  VALUE ary = rb_ary_new ();
+  VALUE output = rb_str_new (ret, retsz);
+  free (ret);
+  rb_ary_push (ary, output);
+
+  VALUE hash = rb_hash_new ();
+  struct lowdown_meta *meta;
+  TAILQ_FOREACH (meta, &metaq, entries)
+  {
+    VALUE key = rb_str_new_cstr (meta->key),
+          val = rb_str_new_cstr (meta->value);
+    rb_hash_aset (hash, key, val);
+  }
+  lowdown_metaq_free (&metaq);
+  rb_ary_push (ary, hash);
+
+  return ary;
+}
+
+static VALUE
+rbl_mLdown_m_into_html (int argc, VALUE *argv, VALUE klass)
+{
+  (void)klass;
+  return rbl_parse_into (argc, argv, LOWDOWN_HTML);
+}
+
+static VALUE
+rbl_mLdown_m_into_latex (int argc, VALUE *argv, VALUE klass)
+{
+  (void)klass;
+  return rbl_parse_into (argc, argv, LOWDOWN_LATEX);
+}
+
+static VALUE
+rbl_mLdown_m_into_man (int argc, VALUE *argv, VALUE klass)
+{
+  (void)klass;
+  return rbl_parse_into (argc, argv, LOWDOWN_MAN);
+}
+
+static VALUE
+rbl_mLdown_m_into_mdoc (int argc, VALUE *argv, VALUE klass)
+{
+  (void)klass;
+  return rbl_parse_into (argc, argv, LOWDOWN_MDOC);
+}
+
+static VALUE
+rbl_mLdown_m_into_fodt (int argc, VALUE *argv, VALUE klass)
+{
+  (void)klass;
+  return rbl_parse_into (argc, argv, LOWDOWN_FODT);
+}
+
+static VALUE
+rbl_mLdown_m_into_term (int argc, VALUE *argv, VALUE klass)
+{
+  (void)klass;
+  return rbl_parse_into (argc, argv, LOWDOWN_TERM);
+}
+
+static VALUE
+rbl_mLdown_m_into_gemini (int argc, VALUE *argv, VALUE klass)
+{
+  (void)klass;
+  return rbl_parse_into (argc, argv, LOWDOWN_GEMINI);
+}
+
+static VALUE
+rbl_mLdown_m_into_ms (int argc, VALUE *argv, VALUE klass)
+{
+  (void)klass;
+  return rbl_parse_into (argc, argv, LOWDOWN_MS);
+}
+
+static VALUE
+rbl_mLdown_m_into_tree (int argc, VALUE *argv, VALUE klass)
+{
+  (void)klass;
+  return rbl_parse_into (argc, argv, LOWDOWN_TREE);
+}
+
+/* document */
+
+static void
+rbl_cDocument_free (void *ptr)
+{
+  struct lowdown_doc *doc = ptr;
+  lowdown_doc_free (doc);
+}
+
+static const rb_data_type_t rbl_cDocument_type
+    = { .wrap_struct_name = "lowdown document",
+        .function = { .dfree = rbl_cDocument_free },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+static VALUE
+rbl_cDocument_alloc (VALUE klass)
+{
+  return rb_data_typed_object_wrap (rbl_cDocument, NULL, &rbl_cDocument_type);
+}
+
+static VALUE
+rbl_cDocument_m_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+
+  struct lowdown_opts opts = get_opts (kwargs);
+
+  struct lowdown_doc *doc = lowdown_doc_new (&opts);
+  if (doc == NULL)
+    rb_raise (rbl_eError, "failed to initialize document");
+
+  RTYPEDDATA_DATA (self) = doc;
+  return self;
+}
+
+static VALUE
+rbl_cDocument_m_parse (VALUE self, VALUE input)
+{
+  struct lowdown_doc *doc = RTYPEDDATA_DATA (self);
+  if (!doc)
+    rb_raise (rbl_eError, "improperly initialized document");
+
+  const char *input_bytes = rb_string_value_cstr (&input);
+  size_t size = RSTRING_LEN (input);
+  /* Question: Supporting node identifier and metadata specification
+     useful?  They are currently NULL. */
+  struct lowdown_node *node
+      = lowdown_doc_parse (doc, NULL, input_bytes, size, NULL);
+  if (node == NULL)
+    rb_raise (rbl_eError, "failed to parse");
+
+  VALUE node_obj = rb_obj_alloc (rbl_cNode);
+  RTYPEDDATA_DATA (node_obj) = node;
+  return node_obj;
+}
+
+/* HTML */
+
+static void
+rbl_cHTML_free (void *ptr)
+{
+  void *doc = ptr;
+  lowdown_html_free (doc);
+}
+
+static const rb_data_type_t rbl_cHTML_type
+    = { .wrap_struct_name = "lowdown HTML",
+        .function = { .dfree = rbl_cHTML_free },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+static VALUE
+rbl_cHTML_alloc (VALUE klass)
+{
+  return rb_data_typed_object_wrap (rbl_cHTML, NULL, &rbl_cHTML_type);
+}
+
+static VALUE
+rbl_cHTML_m_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+
+  struct lowdown_opts opts = get_opts (kwargs);
+
+  void *rndr = lowdown_html_new (&opts);
+  if (rndr == NULL)
+    rb_raise (rbl_eError, "failed to initialize HTML");
+
+  RTYPEDDATA_DATA (self) = rndr;
+  return self;
+}
+
+static VALUE
+rbl_cHTML_m_render (VALUE self, VALUE node)
+{
+  struct lowdown_buf *out = lowdown_buf_new (RBL_BUF_GROW);
+  if (out == NULL)
+    rb_raise (rbl_eError, "failed to create buffer");
+
+  void *rndr = RTYPEDDATA_DATA (self);
+  struct lowdown_node *node_ptr = RTYPEDDATA_DATA (node);
+  if (!lowdown_html_rndr (out, rndr, node_ptr))
+    rb_raise (rbl_eError, "failed to render into HTML");
+
+  VALUE rendered = rb_utf8_str_new (out->data, out->size);
+  lowdown_buf_free (out);
+  return rendered;
+}
+
+/* Gemini */
+
+static void
+rbl_cGemini_free (void *ptr)
+{
+  void *doc = ptr;
+  lowdown_gemini_free (doc);
+}
+
+static const rb_data_type_t rbl_cGemini_type
+    = { .wrap_struct_name = "lowdown Gemini",
+        .function = { .dfree = rbl_cGemini_free },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+static VALUE
+rbl_cGemini_alloc (VALUE klass)
+{
+  return rb_data_typed_object_wrap (rbl_cGemini, NULL, &rbl_cGemini_type);
+}
+
+static VALUE
+rbl_cGemini_m_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+
+  struct lowdown_opts opts = get_opts (kwargs);
+
+  void *rndr = lowdown_gemini_new (&opts);
+  if (rndr == NULL)
+    rb_raise (rbl_eError, "failed to initialize Gemini");
+
+  RTYPEDDATA_DATA (self) = rndr;
+  return self;
+}
+
+static VALUE
+rbl_cGemini_m_render (VALUE self, VALUE node)
+{
+  struct lowdown_buf *out = lowdown_buf_new (RBL_BUF_GROW);
+  if (out == NULL)
+    rb_raise (rbl_eError, "failed to create buffer");
+
+  void *rndr = RTYPEDDATA_DATA (self);
+  struct lowdown_node *node_ptr = RTYPEDDATA_DATA (node);
+  if (!lowdown_gemini_rndr (out, rndr, node_ptr))
+    rb_raise (rbl_eError, "failed to render into Gemini");
+
+  VALUE rendered = rb_utf8_str_new (out->data, out->size);
+  lowdown_buf_free (out);
+  return rendered;
+}
+
+/* LaTeX */
+
+static void
+rbl_cLaTeX_free (void *ptr)
+{
+  void *doc = ptr;
+  lowdown_latex_free (doc);
+}
+
+static const rb_data_type_t rbl_cLaTeX_type
+    = { .wrap_struct_name = "lowdown LaTeX",
+        .function = { .dfree = rbl_cLaTeX_free },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+static VALUE
+rbl_cLaTeX_alloc (VALUE klass)
+{
+  return rb_data_typed_object_wrap (rbl_cLaTeX, NULL, &rbl_cLaTeX_type);
+}
+
+static VALUE
+rbl_cLaTeX_m_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+
+  struct lowdown_opts opts = get_opts (kwargs);
+
+  void *rndr = lowdown_latex_new (&opts);
+  if (rndr == NULL)
+    rb_raise (rbl_eError, "failed to initialize LaTeX");
+
+  RTYPEDDATA_DATA (self) = rndr;
+  return self;
+}
+
+static VALUE
+rbl_cLaTeX_m_render (VALUE self, VALUE node)
+{
+  struct lowdown_buf *out = lowdown_buf_new (RBL_BUF_GROW);
+  if (out == NULL)
+    rb_raise (rbl_eError, "failed to create buffer");
+
+  void *rndr = RTYPEDDATA_DATA (self);
+  struct lowdown_node *node_ptr = RTYPEDDATA_DATA (node);
+  if (!lowdown_latex_rndr (out, rndr, node_ptr))
+    rb_raise (rbl_eError, "failed to render into LaTeX");
+
+  VALUE rendered = rb_utf8_str_new (out->data, out->size);
+  lowdown_buf_free (out);
+  return rendered;
+}
+
+/* OpenDocument */
+
+static void
+rbl_cOpenDocument_free (void *ptr)
+{
+  void *doc = ptr;
+  lowdown_odt_free (doc);
+}
+
+static const rb_data_type_t rbl_cOpenDocument_type
+    = { .wrap_struct_name = "lowdown OpenDocument",
+        .function = { .dfree = rbl_cOpenDocument_free },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+static VALUE
+rbl_cOpenDocument_alloc (VALUE klass)
+{
+  return rb_data_typed_object_wrap (rbl_cOpenDocument, NULL,
+                                    &rbl_cOpenDocument_type);
+}
+
+static VALUE
+rbl_cOpenDocument_m_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+
+  struct lowdown_opts opts = get_opts (kwargs);
+
+  void *rndr = lowdown_odt_new (&opts);
+  if (rndr == NULL)
+    rb_raise (rbl_eError, "failed to initialize OpenDocument");
+
+  RTYPEDDATA_DATA (self) = rndr;
+  return self;
+}
+
+static VALUE
+rbl_cOpenDocument_m_render (VALUE self, VALUE node)
+{
+  struct lowdown_buf *out = lowdown_buf_new (RBL_BUF_GROW);
+  if (out == NULL)
+    rb_raise (rbl_eError, "failed to create buffer");
+
+  void *rndr = RTYPEDDATA_DATA (self);
+  struct lowdown_node *node_ptr = RTYPEDDATA_DATA (node);
+  if (!lowdown_odt_rndr (out, rndr, node_ptr))
+    rb_raise (rbl_eError, "failed to render into OpenDocument");
+
+  VALUE rendered = rb_utf8_str_new (out->data, out->size);
+  lowdown_buf_free (out);
+  return rendered;
+}
+
+/* Roff */
+
+static void
+rbl_cRoff_free (void *ptr)
+{
+  void *doc = ptr;
+  lowdown_roff_free (doc);
+}
+
+static const rb_data_type_t rbl_cRoff_type
+    = { .wrap_struct_name = "lowdown Roff",
+        .function = { .dfree = rbl_cRoff_free },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+static VALUE
+rbl_cRoff_alloc (VALUE klass)
+{
+  return rb_data_typed_object_wrap (rbl_cRoff, NULL, &rbl_cRoff_type);
+}
+
+static VALUE
+rbl_cRoff_m_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+
+  struct lowdown_opts opts = get_opts (kwargs);
+
+  void *rndr = lowdown_roff_new (&opts);
+  if (rndr == NULL)
+    rb_raise (rbl_eError, "failed to initialize Roff");
+
+  RTYPEDDATA_DATA (self) = rndr;
+  return self;
+}
+
+static VALUE
+rbl_cRoff_m_render (VALUE self, VALUE node)
+{
+  struct lowdown_buf *out = lowdown_buf_new (RBL_BUF_GROW);
+  if (out == NULL)
+    rb_raise (rbl_eError, "failed to create buffer");
+
+  void *rndr = RTYPEDDATA_DATA (self);
+  struct lowdown_node *node_ptr = RTYPEDDATA_DATA (node);
+  if (!lowdown_roff_rndr (out, rndr, node_ptr))
+    rb_raise (rbl_eError, "failed to render into Roff");
+
+  VALUE rendered = rb_utf8_str_new (out->data, out->size);
+  lowdown_buf_free (out);
+  return rendered;
+}
+
+/* Term */
+
+static void
+rbl_cTerm_free (void *ptr)
+{
+  void *doc = ptr;
+  lowdown_term_free (doc);
+}
+
+static const rb_data_type_t rbl_cTerm_type
+    = { .wrap_struct_name = "lowdown Term",
+        .function = { .dfree = rbl_cTerm_free },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+static VALUE
+rbl_cTerm_alloc (VALUE klass)
+{
+  return rb_data_typed_object_wrap (rbl_cTerm, NULL, &rbl_cTerm_type);
+}
+
+static VALUE
+rbl_cTerm_m_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+
+  struct lowdown_opts opts = get_opts (kwargs);
+
+  void *rndr = lowdown_term_new (&opts);
+  if (rndr == NULL)
+    rb_raise (rbl_eError, "failed to initialize Term");
+
+  RTYPEDDATA_DATA (self) = rndr;
+  return self;
+}
+
+static VALUE
+rbl_cTerm_m_render (VALUE self, VALUE node)
+{
+  struct lowdown_buf *out = lowdown_buf_new (RBL_BUF_GROW);
+  if (out == NULL)
+    rb_raise (rbl_eError, "failed to create buffer");
+
+  void *rndr = RTYPEDDATA_DATA (self);
+  struct lowdown_node *node_ptr = RTYPEDDATA_DATA (node);
+  if (!lowdown_term_rndr (out, rndr, node_ptr))
+    rb_raise (rbl_eError, "failed to render into Term");
+
+  VALUE rendered = rb_utf8_str_new (out->data, out->size);
+  lowdown_buf_free (out);
+  return rendered;
+}
+
+/* node */
+
+static void
+rbl_cNode_free (void *ptr)
+{
+  void *node = ptr;
+  lowdown_node_free (node);
+}
+
+static const rb_data_type_t rbl_cNode_type
+    = { .wrap_struct_name = "lowdown node",
+        .function = { .dfree = rbl_cNode_free },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+static VALUE
+rbl_cNode_alloc (VALUE klass)
+{
+  return rb_data_typed_object_wrap (rbl_cNode, NULL, &rbl_cNode_type);
+}
+
+static VALUE
+rbl_cNode_m_tree (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+
+  struct lowdown_opts opts = get_opts (kwargs);
+
+  struct lowdown_buf *out = lowdown_buf_new (RBL_BUF_GROW);
+  if (out == NULL)
+    rb_raise (rbl_eError, "failed to create buffer");
+
+  struct lowdown_node *node_ptr = RTYPEDDATA_DATA (self);
+  if (lowdown_tree_rndr (out, node_ptr, &opts) == 0)
+    rb_raise (rbl_eError, "failed to render into Term");
+
+  VALUE rendered = rb_utf8_str_new (out->data, out->size);
+  lowdown_buf_free (out);
+  return rendered;
+}
+
+static VALUE
+rbl_cNode_m_diff_from (VALUE self, VALUE old)
+{
+  struct lowdown_node *new = rb_check_typeddata (self, &rbl_cNode_type);
+  struct lowdown_node *o = rb_check_typeddata (old, &rbl_cNode_type);
+  size_t max_id;
+  struct lowdown_node *node = lowdown_diff (
+      o, new, &max_id /* Question: utilize max node identifier? */);
+  if (!node)
+    rb_raise (rbl_eError, "memory exhaustion");
+
+  return rb_data_typed_object_wrap (rbl_cNode, node, &rbl_cNode_type);
+}
+
+/* initialize */
+
+RUBY_FUNC_EXPORTED void
+Init_ldown (void)
+{
+  rb_mLdown = rb_define_module ("Ldown");
+
+  rb_define_module_function (rb_mLdown, "into_html", rbl_mLdown_m_into_html,
+                             -1);
+  rb_define_module_function (rb_mLdown, "into_latex", rbl_mLdown_m_into_latex,
+                             -1);
+  rb_define_module_function (rb_mLdown, "into_man", rbl_mLdown_m_into_man, -1);
+  rb_define_module_function (rb_mLdown, "into_mdoc", rbl_mLdown_m_into_mdoc,
+                             -1);
+  rb_define_module_function (rb_mLdown, "into_fodt", rbl_mLdown_m_into_fodt,
+                             -1);
+  rb_define_module_function (rb_mLdown, "into_term", rbl_mLdown_m_into_term,
+                             -1);
+  rb_define_module_function (rb_mLdown, "into_gemini",
+                             rbl_mLdown_m_into_gemini, -1);
+  rb_define_module_function (rb_mLdown, "into_ms", rbl_mLdown_m_into_ms, -1);
+  rb_define_module_function (rb_mLdown, "into_tree", rbl_mLdown_m_into_tree,
+                             -1);
+
+  rbl_cDocument = rb_define_class_under (rb_mLdown, "Document", rb_cObject);
+  rb_define_alloc_func (rbl_cDocument, rbl_cDocument_alloc);
+  rb_define_method (rbl_cDocument, "initialize", rbl_cDocument_m_initialize,
+                    -1);
+  rb_define_method (rbl_cDocument, "parse", rbl_cDocument_m_parse, 1);
+
+  rbl_cHTML = rb_define_class_under (rb_mLdown, "HTML", rb_cObject);
+  rb_define_alloc_func (rbl_cHTML, rbl_cHTML_alloc);
+  rb_define_method (rbl_cHTML, "initialize", rbl_cHTML_m_initialize, -1);
+  rb_define_method (rbl_cHTML, "render", rbl_cHTML_m_render, 1);
+
+  rbl_cGemini = rb_define_class_under (rb_mLdown, "Gemini", rb_cObject);
+  rb_define_alloc_func (rbl_cGemini, rbl_cGemini_alloc);
+  rb_define_method (rbl_cGemini, "initialize", rbl_cGemini_m_initialize, -1);
+  rb_define_method (rbl_cGemini, "render", rbl_cGemini_m_render, 1);
+
+  rbl_cLaTeX = rb_define_class_under (rb_mLdown, "LaTeX", rb_cObject);
+  rb_define_alloc_func (rbl_cLaTeX, rbl_cLaTeX_alloc);
+  rb_define_method (rbl_cLaTeX, "initialize", rbl_cLaTeX_m_initialize, -1);
+  rb_define_method (rbl_cLaTeX, "render", rbl_cLaTeX_m_render, 1);
+
+  rbl_cOpenDocument
+      = rb_define_class_under (rb_mLdown, "OpenDocument", rb_cObject);
+  rb_define_alloc_func (rbl_cOpenDocument, rbl_cOpenDocument_alloc);
+  rb_define_method (rbl_cOpenDocument, "initialize",
+                    rbl_cOpenDocument_m_initialize, -1);
+  rb_define_method (rbl_cOpenDocument, "render", rbl_cOpenDocument_m_render,
+                    1);
+
+  rbl_cRoff = rb_define_class_under (rb_mLdown, "Roff", rb_cObject);
+  rb_define_alloc_func (rbl_cRoff, rbl_cRoff_alloc);
+  rb_define_method (rbl_cRoff, "initialize", rbl_cRoff_m_initialize, -1);
+  rb_define_method (rbl_cRoff, "render", rbl_cRoff_m_render, 1);
+
+  rbl_cTerm = rb_define_class_under (rb_mLdown, "Term", rb_cObject);
+  rb_define_alloc_func (rbl_cTerm, rbl_cTerm_alloc);
+  rb_define_method (rbl_cTerm, "initialize", rbl_cTerm_m_initialize, -1);
+  rb_define_method (rbl_cTerm, "render", rbl_cTerm_m_render, 1);
+
+  rbl_cNode = rb_define_class_under (rb_mLdown, "Node", rb_cObject);
+  rb_define_alloc_func (rbl_cNode, rbl_cNode_alloc);
+  rb_define_method (rbl_cNode, "tree", rbl_cNode_m_tree, -1);
+  rb_define_method (rbl_cNode, "diff_from", rbl_cNode_m_diff_from, 1);
+
+  rbl_eError = rb_define_class_under (rb_mLdown, "Error", rb_eStandardError);
+}