qpdf_ruby 0.1.0

data/ext/qpdf_ruby/mcr_node.cpp

@@ -0,0 +1,20 @@
+#include "struct_node.hpp"
+
+McrNode::McrNode(int mcid, int pageObj, int pageGen, int pageNumber)
+    : mcid(mcid), pageObj(pageObj), pageGen(pageGen), pageNumber(pageNumber) {}
+
+std::string McrNode::to_string(int level, PDFStructWalker& walker) {
+  std::ostringstream oss;
+
+  IndentHelper::indent(oss, level);
+  oss << "[MCR: MCID=" << mcid << " PageObj=" << pageObj << " Gen=" << pageGen;
+  if (pageNumber > 0) {
+    oss << " PageNumber=" << pageNumber;
+  }
+  oss << "]" << std::endl;
+
+  return oss.str();
+}
+
+int McrNode::getMcid() const { return mcid; }
+void McrNode::setPageNumber(int pageNum) { pageNumber = pageNum; }

data/ext/qpdf_ruby/pdf_image_mapper.cpp

@@ -0,0 +1,294 @@
+#include "pdf_image_mapper.hpp"
+#include <qpdf/BufferInputSource.hh>
+#include <qpdf/QPDFTokenizer.hh>
+
+#include <algorithm>
+#include <optional>
+
+using Matrix = std::array<double, 6>;
+
+static std::pair<double, double> apply_matrix(const Matrix& m, double x, double y) {
+  double x_new = m[0] * x + m[2] * y + m[4];
+  double y_new = m[1] * x + m[3] * y + m[5];
+  return {x_new, y_new};
+}
+
+static std::array<double, 4> compute_bbox(double width, double height, const Matrix& matrix) {
+  std::array<std::pair<double, double>, 4> corners = {apply_matrix(matrix, 0, 0), apply_matrix(matrix, width, 0),
+                                                      apply_matrix(matrix, width, height),
+                                                      apply_matrix(matrix, 0, height)};
+
+  double min_x = corners[0].first;
+  double max_x = corners[0].first;
+  double min_y = corners[0].second;
+  double max_y = corners[0].second;
+
+  for (int i = 1; i < 4; ++i) {
+    min_x = std::min(min_x, corners[i].first);
+    max_x = std::max(max_x, corners[i].first);
+    min_y = std::min(min_y, corners[i].second);
+    max_y = std::max(max_y, corners[i].second);
+  }
+
+  return {min_x, min_y, max_x, max_y};
+}
+
+static char const* tokenTypeName(QPDFTokenizer::token_type_e ttype) {
+  // Do this is a case statement instead of a lookup so the compiler
+  // will warn if we miss any.
+  switch (ttype) {
+    case QPDFTokenizer::tt_bad:
+      return "bad";
+    case QPDFTokenizer::tt_array_close:
+      return "array_close";
+    case QPDFTokenizer::tt_array_open:
+      return "array_open";
+    case QPDFTokenizer::tt_brace_close:
+      return "brace_close";
+    case QPDFTokenizer::tt_brace_open:
+      return "brace_open";
+    case QPDFTokenizer::tt_dict_close:
+      return "dict_close";
+    case QPDFTokenizer::tt_dict_open:
+      return "dict_open";
+    case QPDFTokenizer::tt_integer:
+      return "integer";
+    case QPDFTokenizer::tt_name:
+      return "name";
+    case QPDFTokenizer::tt_real:
+      return "real";
+    case QPDFTokenizer::tt_string:
+      return "string";
+    case QPDFTokenizer::tt_null:
+      return "null";
+    case QPDFTokenizer::tt_bool:
+      return "bool";
+    case QPDFTokenizer::tt_word:
+      return "word";
+    case QPDFTokenizer::tt_eof:
+      return "eof";
+    case QPDFTokenizer::tt_space:
+      return "space";
+    case QPDFTokenizer::tt_comment:
+      return "comment";
+    case QPDFTokenizer::tt_inline_image:
+      return "inline-image";
+  }
+  return nullptr;
+}
+
+static std::optional<ImageInfo> get_image_info(QPDFObjectHandle resources, const std::string& name) {
+  if (resources.isNull() || !resources.isDictionary()) {
+    return std::nullopt;
+  }
+
+  QPDFObjectHandle xobjects = resources.getKey("/XObject");
+  if (xobjects.isNull() || !xobjects.isDictionary()) {
+    return std::nullopt;
+  }
+
+  if (!xobjects.hasKey(name)) {
+    return std::nullopt;
+  }
+
+  QPDFObjectHandle xobject = xobjects.getKey(name);
+  if (!xobject.isStream()) {
+    return std::nullopt;
+  }
+
+  QPDFObjectHandle dict = xobject.getDict();
+  bool is_image =
+      (dict.hasKey("/Subtype") && dict.getKey("/Subtype").isName() && dict.getKey("/Subtype").getName() == "/Image");
+
+  if (is_image) {
+    ImageInfo image_info;
+
+    if (dict.hasKey("/Height") && dict.getKey("/Height").isInteger()) {
+      image_info.height = dict.getKey("/Height").getIntValue();
+    }
+
+    if (dict.hasKey("/Width") && dict.getKey("/Width").isInteger()) {
+      image_info.width = dict.getKey("/Width").getIntValue();
+    }
+
+    return image_info;
+  }
+
+  return std::nullopt;
+  ;
+}
+
+PDFImageMapper::PDFImageMapper(int target_mcid) : target_mcid(target_mcid), in_target_mcid(false) {}
+
+void PDFImageMapper::push_cm(double value) {
+  if (cm_fixed_size_queue.size() == 6) {
+    cm_fixed_size_queue.pop_front();  // Remove oldest element
+  }
+  cm_fixed_size_queue.push_back(value);
+}
+
+void PDFImageMapper::find(QPDF& pdf) {
+  QPDFPageDocumentHelper doc_helper(pdf);
+  std::vector<QPDFPageObjectHelper> pages = doc_helper.getAllPages();
+  for (auto& page : pages) {
+    QPDFPageObjectHelper poh(page);
+
+    auto crop_box = poh.getCropBox();
+
+    this->find(poh);
+  }
+}
+
+struct OperatorInfo {
+  const char* name;
+  const char* description;
+  int operand_count;
+};
+
+static constexpr OperatorInfo OPERATOR_CM = {"cm", "Concatenate matrix (set CTM)", 6};
+static constexpr OperatorInfo OPERATOR_Q = {"q", "Save graphics state", 0};
+static constexpr OperatorInfo OPERATOR_Q_UPPER = {"Q", "Restore graphics state", 0};
+static constexpr OperatorInfo OPERATOR_DO = {"Do", "Invoke named XObject (draw image/form)", 1};
+static constexpr OperatorInfo OPERATOR_BDC = {"BDC", "Begin Marked Content sequence with property list", 2};
+static constexpr OperatorInfo OPERATOR_EMC = {"EMC", "End Marked Content sequence", 0};
+
+class CMDoExtractor : public QPDFObjectHandle::ParserCallbacks {
+ public:
+  explicit CMDoExtractor(QPDFPageObjectHelper& page_ref) : page(page_ref) {
+    // You can add any other initialization logic here if needed
+  }
+
+  std::vector<double> current_matrix = {1, 0, 0, 1, 0, 0};
+  std::stack<std::vector<double>> matrix_stack;
+  std::vector<QPDFObjectHandle> operand_stack;
+
+  std::stack<int> mcid_stack;
+  int current_mcid;
+
+  void handleEOF() override {
+    // No action needed for this example
+  }
+
+  std::optional<ImageInfo> image_info(std::string imgName) {
+    QPDFObjectHandle resources = page.getObjectHandle().getKey("/Resources");
+
+    return get_image_info(resources, imgName);
+  }
+
+  void handleObject(QPDFObjectHandle obj, size_t offset, size_t length) override {
+    if (obj.isOperator()) {
+      std::string op = obj.getOperatorValue();
+
+      if (op == OPERATOR_CM.name && operand_stack.size() >= OPERATOR_CM.operand_count) {
+        auto numeric_at = [&](std::size_t distance_from_top) -> double {
+          auto& obj = operand_stack[operand_stack.size() - distance_from_top];
+          auto t = obj.getTypeName();  // "integer", "real", …
+          if (std::strcmp(t, "integer") != 0 && std::strcmp(t, "real") != 0) {
+            std::stringstream ss;
+            ss << "numeric operand expected (got " << t << ")";
+            throw std::runtime_error(ss.str());
+          }
+          return obj.getNumericValue();
+        };
+
+        // pull operands (top of stack is distance 1)
+        double f = numeric_at(1);
+        double e = numeric_at(2);
+        double d = numeric_at(3);
+        double c = numeric_at(4);
+        double b = numeric_at(5);
+        double a = numeric_at(6);
+        current_matrix = {a, b, c, d, e, f};
+
+        operand_stack.resize(operand_stack.size() - 6);
+      } else if (op == OPERATOR_Q.name) {
+        matrix_stack.push(current_matrix);
+      } else if (op == OPERATOR_Q_UPPER.name) {
+        if (!matrix_stack.empty()) {
+          current_matrix = matrix_stack.top();
+          matrix_stack.pop();
+        }
+      } else if (op == OPERATOR_BDC.name && operand_stack.size() >= OPERATOR_BDC.operand_count) {
+        mcid_stack.push(current_mcid);  // Save current MCID
+
+        QPDFObjectHandle properties_obj = operand_stack.back();  // Properties operand
+        // QPDFObjectHandle tag_obj = operand_stack[operand_stack.size() - 2]; // Tag operand
+
+        int mcid_val = -1;  // Default if MCID not found or not an integer
+        if (properties_obj.isDictionary()) {
+          if (properties_obj.hasKey("/MCID") && properties_obj.getKey("/MCID").isInteger()) {
+            mcid_val = properties_obj.getKey("/MCID").getIntValue();
+          }
+        } else if (properties_obj.isName()) {
+          // Properties is a name, look it up in Resources /Properties dictionary
+          QPDFObjectHandle resources = page.getObjectHandle().getKey("/Resources");
+          if (resources.isDictionary() && resources.hasKey("/Properties")) {
+            QPDFObjectHandle properties_dict = resources.getKey("/Properties");
+            if (properties_dict.isDictionary() && properties_dict.hasKey(properties_obj.getName())) {
+              QPDFObjectHandle actual_props = properties_dict.getKey(properties_obj.getName());
+              if (actual_props.isDictionary() && actual_props.hasKey("/MCID") &&
+                  actual_props.getKey("/MCID").isInteger()) {
+                mcid_val = actual_props.getKey("/MCID").getIntValue();
+              }
+            }
+          }
+        }
+        current_mcid = mcid_val;
+        operand_stack.resize(operand_stack.size() - OPERATOR_BDC.operand_count);
+      } else if (op == OPERATOR_EMC.name) {  // EMC takes 0 operands
+        if (!mcid_stack.empty()) {
+          current_mcid = mcid_stack.top();
+          mcid_stack.pop();
+        } else {
+          current_mcid = -1;  // Reset to default if stack underflow (should be balanced)
+        }
+        // EMC takes 0 operands, so no change to operand_stack based on operand_count
+      } else if (op == OPERATOR_DO.name && !operand_stack.empty()) {
+        std::string imgName = operand_stack.back().getName();
+        auto image_info = this->image_info(imgName);
+
+        std::copy(current_matrix.begin(), current_matrix.end(), image_info->cm_matrix.begin());
+
+        image_info->mcid = current_mcid;
+
+        image_info->bbox = compute_bbox(image_info->width, image_info->height, image_info->cm_matrix);
+
+        QPDFObjectHandle mb = page.getObjectHandle().getKey("/MediaBox");
+
+        double px0 = mb.getArrayItem(0).getNumericValue();
+        double py0 = mb.getArrayItem(1).getNumericValue();
+        double px1 = mb.getArrayItem(2).getNumericValue();
+        double py1 = mb.getArrayItem(3).getNumericValue();
+
+        auto& bb = image_info->bbox;   // shorthand reference
+        bb[0] = std::max(bb[0], px0);  // left  edge
+        bb[1] = std::max(bb[1], py0);  // bottom edge
+        bb[2] = std::min(bb[2], px1);  // right edge
+        bb[3] = std::min(bb[3], py1);  // top   edge
+
+        image_to_mcid[imgName] = *image_info;
+
+        operand_stack.pop_back();
+      } else {
+        // For other operators, just clear the operand stack
+        operand_stack.clear();
+      }
+    } else {
+      operand_stack.push_back(obj);
+    }
+  }
+
+  const std::map<std::string, ImageInfo>& getImageMap() const { return image_to_mcid; }
+
+ private:
+  QPDFPageObjectHelper& page;
+  std::map<std::string, ImageInfo> image_to_mcid;
+};
+
+void PDFImageMapper::find(QPDFPageObjectHelper& page) {
+  CMDoExtractor cb(page);
+  page.parseContents(&cb);
+
+  const auto& extracted_map = cb.getImageMap();
+  image_to_mcid.insert(extracted_map.begin(), extracted_map.end());
+}

data/ext/qpdf_ruby/pdf_image_mapper.hpp

@@ -0,0 +1,66 @@
+// x_object_finder.hpp
+#pragma once
+
+#include <qpdf/QPDF.hh>
+#include <qpdf/QPDFPageDocumentHelper.hh>
+#include <qpdf/QPDFPageObjectHelper.hh>
+#include <qpdf/QPDFObjectHandle.hh>
+#include <qpdf/QIntC.hh>
+#include <qpdf/QPDFExc.hh>
+#include <qpdf/QTC.hh>
+#include <qpdf/QUtil.hh>
+#include <qpdf/BufferInputSource.hh>
+#include <qpdf/QPDFTokenizer.hh>
+#include <qpdf/Buffer.hh>
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <map>
+#include <stack>
+#include <regex>
+#include <sstream>
+#include <deque>
+
+struct ImageInfo {
+  int mcid;
+  double width;
+  double height;
+  std::array<double, 6> cm_matrix;            // stores the transformation matrix values
+  std::array<double, 4> bbox = {0, 0, 0, 0};  // user-space bounding box [llx, lly, urx, ury]
+
+  ImageInfo() : mcid(-1), width(0), height(0), cm_matrix{0, 0, 0, 0, 0, 0} {}
+
+  ImageInfo(int m, double w, double h, const std::array<double, 6>& cm) : mcid(m), width(w), height(h), cm_matrix(cm) {}
+
+  std::string to_string() const {
+    std::ostringstream oss;
+    oss << "ImageInfo(mcid=" << mcid << ", width=" << width << ", height=" << height << ", cm_matrix=[";
+    for (size_t i = 0; i < cm_matrix.size(); ++i) {
+      oss << cm_matrix[i];
+      if (i != cm_matrix.size() - 1) oss << ", ";
+    }
+    oss << "])";
+    return oss.str();
+  }
+};
+
+class PDFImageMapper {
+ public:
+  explicit PDFImageMapper(int target_mcid);
+
+  void find(QPDF& pdf);
+  // Parses the page's content stream to find the XObject name for the MCID
+  void find(QPDFPageObjectHelper& page);
+
+  void push_cm(double value);
+
+  // Expose internal map for external use
+  const std::map<std::string, ImageInfo>& getImageMap() const { return image_to_mcid; }
+
+ private:
+  int target_mcid;
+  bool in_target_mcid;
+  std::map<std::string, ImageInfo> image_to_mcid;
+  std::deque<double> cm_fixed_size_queue;
+};

data/ext/qpdf_ruby/pdf_struct_walker.cpp

@@ -0,0 +1,46 @@
+#include "pdf_struct_walker.hpp"
+#include "struct_node.hpp"
+
+PDFStructWalker::PDFStructWalker(std::ostream& out, const std::unordered_map<int, std::array<double, 4>>& mcid2bbox)
+    : out(out), mcid2bbox(const_cast<std::unordered_map<int, std::array<double, 4>>&>(mcid2bbox)) {}
+
+std::string PDFStructWalker::get_structure_as_string(QPDFObjectHandle const& node) {
+  std::unique_ptr<StructNode> structNode = StructNode::fromQPDF(node);
+
+  return structNode->to_string(0, *this);
+}
+
+void PDFStructWalker::ensureLayoutBBox(QPDFObjectHandle const& node) {
+  std::unique_ptr<StructNode> structNode = StructNode::fromQPDF(node);
+
+  structNode->ensureLayoutBBox(*this);
+}
+
+void PDFStructWalker::buildPageObjectMap(QPDF& pdf) {
+  pageObjToNumMap.clear();
+  std::vector<QPDFObjectHandle> pages = pdf.getAllPages();
+  for (int i = 0; i < pages.size(); ++i) {
+    // Map the page's object ID to its 1-based page number
+    pageObjToNumMap[pages.at(i).getObjGen()] = i + 1;
+  }
+}
+
+const std::map<QPDFObjGen, int>& PDFStructWalker::getPageObjectMap() const { return pageObjToNumMap; }
+
+std::array<double, 4> PDFStructWalker::getPageCropBoxFor(QPDFObjectHandle const& page_oh) const {
+  auto inherited = [](QPDFObjectHandle node, char const* key) -> QPDFObjectHandle {
+    while (!node.isNull()) {
+      if (auto val = node.getKey(key); !val.isNull()) return val;
+      node = node.getKey("/Parent");
+    }
+    return QPDFObjectHandle();  // null ⇒ not found
+  };
+
+  QPDFObjectHandle crop = inherited(page_oh, "/CropBox");
+  if (crop.isNull()) crop = inherited(page_oh, "/MediaBox");  // spec default
+
+  std::array<double, 4> r;
+  for (size_t i = 0; i < 4; ++i) r[i] = crop.getArrayItem(i).getNumericValue();
+
+  return r;
+}

data/ext/qpdf_ruby/pdf_struct_walker.hpp

@@ -0,0 +1,34 @@
+// PDFStructWalker.h
+
+#pragma once
+
+#include <qpdf/QPDF.hh>
+#include <qpdf/QPDFWriter.hh>
+#include <qpdf/QPDFPageObjectHelper.hh>
+#include <qpdf/QPDFObjectHandle.hh>
+
+#include <iostream>
+#include <stdexcept>  // For std::exception (if you add try-catch)
+#include <vector>     // For std::vector
+#include <string>     // For std::string
+#include <regex>
+#include <map>
+
+class PDFStructWalker {
+ private:
+  std::ostream& out;
+  std::map<QPDFObjGen, int> pageObjToNumMap;
+  std::unordered_map<int, std::array<double, 4>>& mcid2bbox;
+
+ public:
+  PDFStructWalker(std::ostream& out = std::cout, const std::unordered_map<int, std::array<double, 4>>& mcid2bbox = {});
+
+  void buildPageObjectMap(QPDF& pdf);
+  std::string get_structure_as_string(QPDFObjectHandle const& node);
+  void ensureLayoutBBox(QPDFObjectHandle const& node);
+
+  const std::map<QPDFObjGen, int>& getPageObjectMap() const;
+  std::array<double, 4> getPageCropBoxFor(QPDFObjectHandle const& elem) const;
+
+  const std::unordered_map<int, std::array<double, 4>>& getMcidBboxMap() const { return mcid2bbox; }
+};

data/ext/qpdf_ruby/qpdf_ruby.cpp

@@ -0,0 +1,204 @@
+#include "qpdf_ruby.hpp"
+#include "pdf_struct_walker.hpp"
+#include "struct_node.hpp"
+#include "pdf_image_mapper.hpp"
+#include "document_handle.hpp"
+
+#include <qpdf/QPDF.hh>
+#include <qpdf/QPDFWriter.hh>
+#include <qpdf/QPDFPageObjectHelper.hh>
+#include <qpdf/QPDFObjectHandle.hh>
+
+#include <iostream>
+#include <stdexcept>  // For std::exception (if you add try-catch)
+#include <vector>     // For std::vector
+#include <string>     // For std::string
+#include <regex>
+
+VALUE rb_mQpdfRuby;
+VALUE rb_cDocument;
+
+using namespace qpdf_ruby;
+
+VALUE rb_qpdf_get_structure_string(VALUE self) {
+  DocumentHandle* h;
+  Data_Get_Struct(self, DocumentHandle, h);
+
+  try {
+    QPDF& pdf = h->qpdf();
+
+    QPDFObjectHandle catalog = pdf.getRoot();
+    QPDFObjectHandle struct_root = catalog.getKey("/StructTreeRoot");
+    if (!struct_root.isDictionary()) {
+      rb_raise(rb_eRuntimeError, "No StructTreeRoot found");
+    }
+    QPDFObjectHandle topKids = struct_root.getKey("/K");
+
+    PDFStructWalker walker(std::cout);  // For now, std::cout, unless you pass another stream
+    walker.buildPageObjectMap(pdf);
+
+    std::string result;
+    if (topKids.isArray()) {
+      for (int i = 0; i < topKids.getArrayNItems(); ++i) {
+        result += walker.get_structure_as_string(topKids.getArrayItem(i));
+      }
+    } else {
+      result = walker.get_structure_as_string(topKids);
+    }
+
+    return rb_str_new(result.c_str(), result.length());
+  } catch (const std::exception& e) {
+    rb_raise(rb_eRuntimeError, "Error: %s", e.what());
+  }
+  return Qnil;
+}
+
+VALUE rb_qpdf_mark_paths_as_artifacts(VALUE self) {
+  DocumentHandle* h;
+  Data_Get_Struct(self, DocumentHandle, h);
+  try {
+    QPDF& pdf = h->qpdf();
+
+    std::vector<QPDFObjectHandle> pages = pdf.getAllPages();
+    std::regex path_regex(R"((?:[-+]?\d*\.?\d+(?:e[-+]?\d+)?\s+){4}re\s+(?:S|s|f\*?|F|B\*?|b\*?|n))",
+                          std::regex::ECMAScript | std::regex::optimize);
+
+    for (auto& page_obj : pages) {
+      QPDFPageObjectHelper poh(page_obj);
+      std::vector<QPDFObjectHandle> contents = poh.getPageContents();
+      std::vector<QPDFObjectHandle> new_contents_array;
+
+      for (auto& content_stream : contents) {
+        if (content_stream.isStream()) {
+          // Use std::shared_ptr instead of PointerHolder
+          std::shared_ptr<Buffer> stream_buffer = content_stream.getStreamData();
+          std::string stream_data_str(reinterpret_cast<char*>(stream_buffer->getBuffer()), stream_buffer->getSize());
+
+          std::string new_stream_data_str = std::regex_replace(stream_data_str, path_regex, "/Artifact BMC\n$&\nEMC");
+
+          // Create a new Buffer with std::shared_ptr
+          std::shared_ptr<Buffer> new_buffer = std::make_shared<Buffer>(new_stream_data_str.length());
+          memcpy(new_buffer->getBuffer(), new_stream_data_str.data(), new_stream_data_str.length());
+
+          QPDFObjectHandle new_stream = QPDFObjectHandle::newStream(&pdf, new_buffer);
+          new_contents_array.push_back(new_stream);
+        } else {
+          new_contents_array.push_back(content_stream);
+        }
+      }
+
+      if (new_contents_array.size() == 1) {
+        page_obj.replaceKey("/Contents", new_contents_array[0]);
+      } else {
+        page_obj.replaceKey("/Contents", QPDFObjectHandle::newArray(new_contents_array));
+      }
+    }
+  } catch (const QPDFExc& e) {  // Catching specific QPDF exceptions is good
+    rb_raise(rb_eRuntimeError, "QPDF Error: %s (filename: %s)", e.what(), e.getFilename().c_str());
+  } catch (const std::exception& e) {  // Fallback for other standard exceptions
+    rb_raise(rb_eRuntimeError, "Error: %s", e.what());
+  }
+
+  return Qnil;
+}
+
+VALUE rb_qpdf_ensure_bboxs(VALUE self) {
+  DocumentHandle* h;
+  Data_Get_Struct(self, DocumentHandle, h);
+
+  try {
+    QPDF& pdf = h->qpdf();
+
+    QPDFObjectHandle catalog = pdf.getRoot();
+    QPDFObjectHandle struct_root = catalog.getKey("/StructTreeRoot");
+    if (!struct_root.isDictionary()) {
+      rb_raise(rb_eRuntimeError, "No StructTreeRoot found");
+    }
+    QPDFObjectHandle topKids = struct_root.getKey("/K");
+
+    PDFImageMapper finder(0);
+
+    finder.find(pdf);
+
+    std::unordered_map<int, std::array<double, 4>> mcid2bbox;
+    for (const auto& kv : finder.getImageMap()) {
+      if (kv.second.mcid >= 0) mcid2bbox[kv.second.mcid] = kv.second.bbox;
+    }
+
+    PDFStructWalker walker(std::cout, mcid2bbox);  // For now, std::cout, unless you pass another stream
+
+    if (topKids.isArray()) {
+      for (int i = 0; i < topKids.getArrayNItems(); ++i) {
+        walker.ensureLayoutBBox(topKids.getArrayItem(i));
+      }
+    } else {
+      walker.ensureLayoutBBox(topKids);
+    }
+  } catch (const std::exception& e) {
+    rb_raise(rb_eRuntimeError, "Error: %s", e.what());
+  }
+  return Qnil;
+}
+
+static void doc_free(void* ptr) { qpdf_ruby::qpdf_ruby_close(static_cast<qpdf_ruby::DocumentHandle*>(ptr)); }
+
+static VALUE doc_alloc(VALUE klass) { return Data_Wrap_Struct(klass, /* mark */ 0, doc_free, nullptr); }
+
+static VALUE doc_initialize(VALUE self, VALUE filename) {
+  Check_Type(filename, T_STRING);
+  DocumentHandle* h = qpdf_ruby::qpdf_ruby_open(StringValueCStr(filename));
+  if (!h) rb_sys_fail("qpdf_ruby_open");
+  DATA_PTR(self) = h;
+
+  return self;
+}
+
+static VALUE doc_write(VALUE self, VALUE out_filename) {
+  DocumentHandle* h;
+  Data_Get_Struct(self, DocumentHandle, h);
+  if (qpdf_ruby::qpdf_ruby_write(h, StringValueCStr(out_filename)) == -1) rb_sys_fail("qpdf_ruby_write");
+
+  return Qnil;
+}
+
+VALUE qpdf_ruby_write_memory(DocumentHandle* h) {
+  if (!h) rb_sys_fail("Bad handle");
+  std::string bytes = h->write_to_memory();
+  return rb_str_new(bytes.data(), bytes.size());
+}
+
+static VALUE doc_from_memory(VALUE klass, VALUE str, VALUE password) {
+  Check_Type(str, T_STRING);
+  Check_Type(password, T_STRING);
+
+  DocumentHandle* h = qpdf_ruby_open_memory("ruby-memory", reinterpret_cast<unsigned char const*>(RSTRING_PTR(str)),
+                                            RSTRING_LEN(str), StringValueCStr(password));
+
+  if (!h) rb_sys_fail("qpdf_ruby_open_memory");
+
+  VALUE obj = Data_Wrap_Struct(klass, 0, doc_free, h);
+  return obj;
+}
+
+static VALUE doc_to_memory(VALUE self) {
+  DocumentHandle* h;
+  Data_Get_Struct(self, DocumentHandle, h);
+  return qpdf_ruby_write_memory(h);  // returns a Ruby ::String
+}
+
+RUBY_FUNC_EXPORTED "C" void Init_qpdf_ruby(void) {
+  rb_mQpdfRuby = rb_define_module("QpdfRuby");
+  rb_cDocument = rb_define_class_under(rb_mQpdfRuby, "Document", rb_cObject);
+
+  rb_define_alloc_func(rb_cDocument, doc_alloc);
+
+  rb_define_method(rb_cDocument, "initialize", RUBY_METHOD_FUNC(doc_initialize), 1);
+  rb_define_singleton_method(rb_cDocument, "from_memory", RUBY_METHOD_FUNC(doc_from_memory), 2);
+
+  rb_define_method(rb_cDocument, "write", RUBY_METHOD_FUNC(doc_write), 1);
+  rb_define_method(rb_cDocument, "to_memory", RUBY_METHOD_FUNC(doc_to_memory), 0);
+
+  rb_define_method(rb_cDocument, "mark_paths_as_artifacts", RUBY_METHOD_FUNC(rb_qpdf_mark_paths_as_artifacts), 0);
+  rb_define_method(rb_cDocument, "ensure_bbox", RUBY_METHOD_FUNC(rb_qpdf_ensure_bboxs), 0);
+  rb_define_method(rb_cDocument, "show_structure", RUBY_METHOD_FUNC(rb_qpdf_get_structure_string), 0);
+}

data/ext/qpdf_ruby/qpdf_ruby.hpp

@@ -0,0 +1,10 @@
+#ifndef QPDF_RUBY_H
+#define QPDF_RUBY_H 1
+
+#include "ruby.h"
+
+VALUE rb_qpdf_mark_paths_as_artifacts(VALUE self);
+VALUE rb_qpdf_ensure_bboxs(VALUE self);
+VALUE rb_qpdf_get_structure_string(VALUE self);
+
+#endif /* QPDF_RUBY_H */

data/ext/qpdf_ruby/stream_node.cpp

@@ -0,0 +1,10 @@
+#include "struct_node.hpp"
+
+std::string StreamNode::to_string(int level, PDFStructWalker& walker) {
+  std::ostringstream oss;
+  IndentHelper::indent(oss, level);
+  oss << "[Stream: length=" << size;
+
+  oss << "]" << std::endl;
+  return oss.str();
+}