qpdf_ruby 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c89e78922fbb1a3922b13c425086212a70454a28b6f17f9f75b8fe9ab772256
-  data.tar.gz: 3144ff7e6bae54b2b71fe80bd1b22652b5466120d03cf2fa7f7dcccab15c9d7a
+  metadata.gz: 1031f5b376f46ea2e57b4a06692f10fe62f081bf010eff784e7e179c3dca83d1
+  data.tar.gz: aa3e9a16d357779d6b51c7d66c8736641a140a180844cd3f6c5bcbb22988ce32
 SHA512:
-  metadata.gz: 2e6736a64f275a612a85727c94ebe7e5ccde471b5024f974611b6a43ce747ee317f0544769996816f943aff50071e9fcc5eb5e92b08316af921b29cc6dea9c1d
-  data.tar.gz: 8941eff1af71bed2d082e4eb66256d9b284800aa9cfd95100fadc3eeb4888663f647d5f939816b82fbdd6e735b479aff0724ee6fc72ba8931456c6a64c67d822
+  metadata.gz: baaebb9aa86b819c652f7e2b9f8b593df9419c75d4cf9279e1301b6d0302b43c4aa1c629f2f8e65582ca07dd659889c9397d9286179b627442f29605e6356673
+  data.tar.gz: 6f31a3e8543f7bc23561ef74ad445e9a32e136fcbb0d57721d6058cc158441d4069af1d1ef50480494617d2e367a445316beb3100bfb25e1089dfb8d9eff23cc

data/CHANGELOG.md

@@ -6,10 +6,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-[unreleased]: https://github.com/dieter-medium/qpdf_ruby/compare/v0.2.0..HEAD
+[unreleased]: https://github.com/dieter-medium/qpdf_ruby/compare/v0.3.0..HEAD
 
 <!-- generated by git-cliff end -->
 
+## [0.3.0] - 2026-10-08
+
+Records who made a file: `set_document_info` writes the creator and producer to the information
+dictionary and to XMP, and keeps the two in agreement.
+
+### 🚀 Added
+
+- `set_document_info(creator:, producer:)`: the information dictionary's `/Creator` and
+  `/Producer`, and XMP `xmp:CreatorTool` and `pdf:Producer`, replacing any other value there so the
+  two always agree; `xmp_error` says why a packet that is not well-formed was left alone.
+- `document_info`: the information dictionary's string entries, for inspection.
+
+### 🐛 Fixed
+
+- A `title:` with a NUL, a control character or bytes that are not UTF-8 raises `ArgumentError`
+  instead of writing invalid XMP (`add_pdfua_identification`, `apply_pdfua_fixes`).
+- An XMP property counts only on the document's own `rdf:Description`: a `dc:title` or
+  `pdfuaid:part` nested inside another property no longer suppresses the identification.
+
 ## [0.2.0] - 2026-10-02
 
 Makes the tagged PDFs Chromium prints (`Page.printToPDF` with `generateTaggedPDF`) PDF/UA-1
@@ -68,6 +87,7 @@ as PDF/UA-1 and PAC 2024 passes without errors.
 
 ### 🔄 Released
 
-- [unreleased](https://github.com/dieter-medium/qpdf_ruby/compare/v0.2.0..HEAD)
+- [unreleased](https://github.com/dieter-medium/qpdf_ruby/compare/v0.3.0..HEAD)
+- [0.3.0](https://github.com/dieter-medium/qpdf_ruby/compare/v0.2.0..v0.3.0)
 - [0.2.0](https://github.com/dieter-medium/qpdf_ruby/compare/v0.1.1..v0.2.0)
 - [0.1.1](https://github.com/dieter-medium/qpdf_ruby/compare/v0.1.0..v0.1.1) 

data/README.md

@@ -46,7 +46,8 @@ Also:
 | Count untagged content (dry run, per kind) | `doc.untagged_content` |
 | Add a layout `/BBox` to every `/Figure`¹, and `/Placement /Block` to one outside a line of text (PAC 2024 warns of a "possibly inappropriate use" of a Figure without it) | `doc.ensure_bbox` |
 | Dump the structure tree as XML | `doc.show_structure` |
-| Inspect links, XMP, RoleMap | `doc.links`, `doc.metadata`, `doc.role_map` |
+| Set who made the file: Info `/Creator` and `/Producer`, XMP `xmp:CreatorTool` and `pdf:Producer`, kept in agreement (another XMP value is replaced; `xmp_error` says why a packet that is not well-formed was left alone) | `doc.set_document_info(creator:, producer:)` |
+| Inspect links, XMP, RoleMap, the information dictionary | `doc.links`, `doc.metadata`, `doc.role_map`, `doc.document_info` |
 | Count ParentTree entries that do not name their content's structure element (0 = consistent) | `doc.parent_tree_mismatches` |
 | Encrypt | `doc.encrypt(user_pw:, owner_pw:, …)` |
 | Read/write files or memory | `Document.new(path, password = nil)`, `Document.from_memory(bytes, password = nil)`, `#write(path)`, `#to_memory` |

data/ext/qpdf_ruby/pdfua.cpp

@@ -8,11 +8,13 @@
 #include <qpdf/QPDFPageObjectHelper.hh>
 #include <qpdf/QPDFTokenizer.hh>
 
+#include <algorithm>
 #include <climits>
 #include <cstdlib>
 #include <functional>
 #include <memory>
 #include <set>
+#include <stdexcept>
 #include <vector>
 
 namespace qpdf_ruby::pdfua {
@@ -813,6 +815,17 @@ namespace {
 
 constexpr char kRdfNs[] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
 
+// A new XMP packet holding `description` as the catalog's metadata stream.
+void add_packet(QPDF& pdf, std::string const& description) {
+  std::string xmp = "<?xpacket begin=\"\xEF\xBB\xBF\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n"
+                    "<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"><rdf:RDF xmlns:rdf=\"" +
+                    std::string(kRdfNs) + "\">\n" + description + "</rdf:RDF></x:xmpmeta>\n<?xpacket end=\"w\"?>";
+  QPDFObjectHandle stream = QPDFObjectHandle::newStream(&pdf, xmp);
+  stream.getDict().replaceKey("/Type", QPDFObjectHandle::newName("/Metadata"));
+  stream.getDict().replaceKey("/Subtype", QPDFObjectHandle::newName("/XML"));
+  pdf.getRoot().replaceKey("/Metadata", stream);
+}
+
 // The identification step, with the reason when the file could not be identified.
 bool identify(QPDF& pdf, std::optional<std::string> const& title, std::optional<std::string>& unidentified) {
   QPDFObjectHandle root = pdf.getRoot();
@@ -875,14 +888,7 @@ bool identify(QPDF& pdf, std::optional<std::string> const& title, std::optional<
     return true;
   }
 
-  std::string xmp = "<?xpacket begin=\"\xEF\xBB\xBF\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n"
-                    "<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"><rdf:RDF xmlns:rdf=\"" +
-                    std::string(kRdfNs) + "\">\n" + description(true, !doc_title.empty()) +
-                    "</rdf:RDF></x:xmpmeta>\n<?xpacket end=\"w\"?>";
-  QPDFObjectHandle stream = QPDFObjectHandle::newStream(&pdf, xmp);
-  stream.getDict().replaceKey("/Type", QPDFObjectHandle::newName("/Metadata"));
-  stream.getDict().replaceKey("/Subtype", QPDFObjectHandle::newName("/XML"));
-  root.replaceKey("/Metadata", stream);
+  add_packet(pdf, description(true, !doc_title.empty()));
   return true;
 }
 
@@ -893,6 +899,96 @@ bool add_pdfua_identification(QPDF& pdf, std::optional<std::string> const& title
   return identify(pdf, title, unidentified);
 }
 
+namespace {
+
+constexpr char kXmpNs[] = "http://ns.adobe.com/xap/1.0/";
+constexpr char kPdfNs[] = "http://ns.adobe.com/pdf/1.3/";
+
+// Sets the information dictionary's `key` unless it already holds `value`; true if it changed.
+bool set_info(QPDF& pdf, std::string const& key, std::string const& value) {
+  QPDFObjectHandle info = pdf.getTrailer().getKey("/Info");
+  if (!info.isDictionary()) {
+    info = pdf.makeIndirectObject(QPDFObjectHandle::newDictionary());
+    pdf.getTrailer().replaceKey("/Info", info);
+  }
+  QPDFObjectHandle current = info.getKey(key);
+  if (current.isString() && current.getUTF8Value() == value) return false;
+  info.replaceKey(key, QPDFObjectHandle::newUnicodeString(value));
+  return true;
+}
+
+}  // namespace
+
+DocumentInfoResult set_document_info(QPDF& pdf, std::optional<std::string> const& creator,
+                                     std::optional<std::string> const& producer) {
+  DocumentInfoResult result;
+  struct Wanted {
+    char const* ns;
+    char const* local;
+    char const* prefix;
+    std::string value;
+  };
+  std::vector<Wanted> wanted;
+  if (creator && !creator->empty()) {
+    result.changed = set_info(pdf, "/Creator", *creator) || result.changed;
+    wanted.push_back({kXmpNs, "CreatorTool", "xmp", *creator});
+  }
+  if (producer && !producer->empty()) {
+    result.changed = set_info(pdf, "/Producer", *producer) || result.changed;
+    wanted.push_back({kPdfNs, "Producer", "pdf", *producer});
+  }
+  if (wanted.empty()) return result;
+
+  auto description = [&](std::vector<Wanted> const& properties) {
+    std::string out = std::string("<rdf:Description xmlns:rdf=\"") + kRdfNs + "\" rdf:about=\"\"";
+    for (auto const& p : properties) out += std::string(" xmlns:") + p.prefix + "=\"" + p.ns + "\"";
+    out += ">";
+    for (auto const& p : properties) {
+      out += std::string("<") + p.prefix + ":" + p.local + ">" + xml_escape(p.value) + "</" + p.prefix + ":" + p.local + ">";
+    }
+    return out + "</rdf:Description>\n";
+  };
+
+  QPDFObjectHandle metadata = pdf.getRoot().getKey("/Metadata");
+  if (!metadata.isStream()) {
+    add_packet(pdf, description(wanted));
+    result.changed = true;
+    return result;
+  }
+
+  auto data = metadata.getStreamData(qpdf_dl_generalized);
+  std::string xmp(reinterpret_cast<char const*>(data->getBuffer()), data->getSize());
+  xmp::Scan packet = xmp::scan(xmp);
+  if (!packet.well_formed || packet.rdf_close == std::string::npos) {
+    result.xmp_error = "existing XMP metadata is not well-formed XML with an rdf:RDF element";
+    return result;
+  }
+
+  // A property that already says exactly this, once, stays; any other occurrence of it goes, so
+  // the packet and the information dictionary never disagree.
+  std::vector<Wanted> missing;
+  std::vector<std::pair<size_t, size_t>> removals;
+  for (auto const& w : wanted) {
+    std::vector<xmp::Property const*> found;
+    for (auto const& p : packet.located) {
+      if (p.ns == w.ns && p.local == w.local) found.push_back(&p);
+    }
+    if (found.size() == 1 && found[0]->has_value && found[0]->value == w.value) continue;
+    for (auto const* p : found) removals.emplace_back(p->begin, p->end);
+    missing.push_back(w);
+  }
+  if (missing.empty()) return result;
+
+  std::sort(removals.begin(), removals.end(), [](auto const& a, auto const& b) { return a.first > b.first; });
+  for (auto const& [begin, end] : removals) xmp.erase(begin, end - begin);
+  size_t close = xmp::scan(xmp).rdf_close;
+  if (close == std::string::npos) throw std::logic_error("XMP packet lost its rdf:RDF element");
+  xmp.insert(close, description(missing));
+  metadata.replaceStreamData(xmp, QPDFObjectHandle::newNull(), QPDFObjectHandle::newNull());
+  result.changed = true;
+  return result;
+}
+
 Report apply(QPDF& pdf, std::map<std::string, std::string> const& link_texts, std::optional<std::string> const& title) {
   Report report;
   report.decorations = artifact_tagged_decorations(pdf);

data/ext/qpdf_ruby/pdfua.hpp

@@ -6,6 +6,7 @@
 #include <map>
 #include <optional>
 #include <string>
+#include <vector>
 
 // Fixes for the PDF/UA-1 gaps of Chromium's tagged PDF (print-to-PDF with generateTaggedPDF): it
 // writes no /Artifact sections, no LBody, no link descriptions, no XMP identification, and uses
@@ -84,6 +85,21 @@ long count_figures_without_alt(QPDF& pdf);
 // unidentified_reason. Returns true if anything changed.
 bool add_pdfua_identification(QPDF& pdf, std::optional<std::string> const& title);
 
+// Who made the file: the information dictionary's /Creator and /Producer, and their XMP twins
+// xmp:CreatorTool and pdf:Producer, kept in agreement. A value that is not given, or empty, is left
+// alone. The information dictionary is always set. In XMP a property that already holds exactly
+// that value once stays; every other occurrence of it is removed and the value written in a new
+// rdf:Description - a packet that is not well-formed XML with an rdf:RDF element is left alone and
+// xmp_error says so. Without a packet a new one is written. The values must be valid XML text
+// (xmp::valid_text) - the Ruby binding checks that.
+struct DocumentInfoResult {
+  bool changed = false;
+  std::optional<std::string> xmp_error;  // why the XMP packet was not updated, if it was not
+};
+
+DocumentInfoResult set_document_info(QPDF& pdf, std::optional<std::string> const& creator,
+                                     std::optional<std::string> const& producer);
+
 struct Report {
   long decorations = 0;
   UntaggedCounts artifacts;

data/ext/qpdf_ruby/qpdf_ruby.cpp

@@ -5,6 +5,7 @@
 #include "pdfua.hpp"
 #include "ruby_guard.hpp"
 #include "struct_node.hpp"
+#include "xmp_scan.hpp"
 
 #include <qpdf/QPDF.hh>
 #include <qpdf/QPDFObjectHandle.hh>
@@ -50,6 +51,16 @@ static VALUE checked_string(VALUE value) {
 
 static VALUE checked_optional_string(VALUE value) { return NIL_P(value) ? Qnil : checked_string(value); }
 
+// A string that goes into XMP: nil, or UTF-8 made of XML 1.0 characters - a NUL or a control
+// character would make the packet invalid XML.
+static VALUE checked_xmp_string(VALUE value, char const* keyword) {
+  value = checked_optional_string(value);
+  if (!NIL_P(value) && !xmp::valid_text(RSTRING_PTR(value), static_cast<size_t>(RSTRING_LEN(value)))) {
+    rb_raise(rb_eArgError, "%s must be UTF-8 text without control characters (XML 1.0)", keyword);
+  }
+  return value;
+}
+
 static int collect_link_text(VALUE key, VALUE value, VALUE pairs) {
   rb_ary_push(pairs, rb_assoc_new(rb_obj_as_string(key), rb_obj_as_string(value)));
   return ST_CONTINUE;
@@ -302,6 +313,27 @@ static VALUE doc_metadata(VALUE self) {
       [](std::optional<std::string> const& xmp) { return xmp ? ruby_string(*xmp) : Qnil; });
 }
 
+// The information dictionary's string entries as {"Creator" => "...", ...}; empty without one.
+static VALUE doc_document_info(VALUE self) {
+  DocumentHandle* h = handle_of(self);
+  return guarded_to_ruby(
+      [&] {
+        std::map<std::string, std::string> out;
+        QPDFObjectHandle info = h->qpdf().getTrailer().getKey("/Info");
+        if (info.isDictionary()) {
+          for (auto [key, value] : info.ditems()) {
+            if (value.isString()) out[key.substr(1)] = value.getUTF8Value();
+          }
+        }
+        return out;
+      },
+      [](std::map<std::string, std::string> const& entries) {
+        VALUE hash = rb_hash_new();
+        for (auto const& [key, value] : entries) rb_hash_aset(hash, ruby_string(key), ruby_string(value));
+        return hash;
+      });
+}
+
 // The structure tree's RoleMap as {"Aside" => "Sect", ...}.
 static VALUE doc_role_map(VALUE self) {
   DocumentHandle* h = handle_of(self);
@@ -334,13 +366,36 @@ static VALUE doc_add_pdfua_identification(int argc, VALUE* argv, VALUE self) {
   ID keys[1] = {rb_intern("title")};
   VALUE values[1];
   rb_get_kwargs(kwargs, keys, 0, 1, values);
-  VALUE title = checked_optional_string(given(values[0]));
+  VALUE title = checked_xmp_string(given(values[0]), "title");
   DocumentHandle* h = handle_of(self);
   bool changed = guarded([&] { return pdfua::add_pdfua_identification(h->qpdf(), cpp_optional_string(title)); });
   RB_GC_GUARD(title);
   return changed ? Qtrue : Qfalse;
 }
 
+static VALUE doc_set_document_info(int argc, VALUE* argv, VALUE self) {
+  VALUE kwargs = Qnil;
+  rb_scan_args(argc, argv, ":", &kwargs);
+  ID keys[2] = {rb_intern("creator"), rb_intern("producer")};
+  VALUE values[2];
+  rb_get_kwargs(kwargs, keys, 0, 2, values);
+  VALUE creator = checked_xmp_string(given(values[0]), "creator");
+  VALUE producer = checked_xmp_string(given(values[1]), "producer");
+  DocumentHandle* h = handle_of(self);
+
+  VALUE out = guarded_to_ruby(
+      [&] { return pdfua::set_document_info(h->qpdf(), cpp_optional_string(creator), cpp_optional_string(producer)); },
+      [](pdfua::DocumentInfoResult const& result) {
+        VALUE hash = rb_hash_new();
+        rb_hash_aset(hash, ID2SYM(rb_intern("changed")), result.changed ? Qtrue : Qfalse);
+        rb_hash_aset(hash, ID2SYM(rb_intern("xmp_error")), result.xmp_error ? ruby_string(*result.xmp_error) : Qnil);
+        return hash;
+      });
+  RB_GC_GUARD(creator);
+  RB_GC_GUARD(producer);
+  return out;
+}
+
 static VALUE report_hash(pdfua::Report const& report);
 
 static VALUE doc_apply_pdfua_fixes(int argc, VALUE* argv, VALUE self) {
@@ -350,7 +405,7 @@ static VALUE doc_apply_pdfua_fixes(int argc, VALUE* argv, VALUE self) {
   VALUE values[2];
   rb_get_kwargs(kwargs, keys, 0, 2, values);
   VALUE pairs = checked_link_texts(given(values[0]));
-  VALUE title = checked_optional_string(given(values[1]));
+  VALUE title = checked_xmp_string(given(values[1]), "title");
   DocumentHandle* h = handle_of(self);
 
   VALUE out = guarded_to_ruby(
@@ -436,9 +491,11 @@ RUBY_FUNC_EXPORTED void Init_qpdf_ruby(void) {
   rb_define_method(rb_cDocument, "figures_without_alt", RUBY_METHOD_FUNC(doc_figures_without_alt), 0);
   rb_define_method(rb_cDocument, "add_pdfua_identification", RUBY_METHOD_FUNC(doc_add_pdfua_identification), -1);
   rb_define_method(rb_cDocument, "apply_pdfua_fixes", RUBY_METHOD_FUNC(doc_apply_pdfua_fixes), -1);
+  rb_define_method(rb_cDocument, "set_document_info", RUBY_METHOD_FUNC(doc_set_document_info), -1);
 
   rb_define_method(rb_cDocument, "links", RUBY_METHOD_FUNC(doc_links), 0);
   rb_define_method(rb_cDocument, "metadata", RUBY_METHOD_FUNC(doc_metadata), 0);
+  rb_define_method(rb_cDocument, "document_info", RUBY_METHOD_FUNC(doc_document_info), 0);
   rb_define_method(rb_cDocument, "role_map", RUBY_METHOD_FUNC(doc_role_map), 0);
 
   rb_define_method(rb_cDocument, "encrypt", RUBY_METHOD_FUNC(doc_encrypt), -1);

data/ext/qpdf_ruby/xmp_scan.cpp

@@ -73,10 +73,18 @@ bool decode(std::string const& raw, std::string& out) {
 
 using Bindings = std::map<std::string, std::string>;  // prefix ("" = default) -> namespace URI
 
+// Where an element sits: the first rdf:RDF, an rdf:Description directly under it, a property of
+// that Description, or anything else.
+enum class Kind { Other, RdfRoot, Description, Property };
+
 struct Element {
   std::string qname;
   Bindings bindings;
-  bool rdf_root;
+  Kind kind;
+  size_t start = 0;          // the "<" of the start tag
+  size_t content_start = 0;  // just after its ">"
+  bool simple = true;        // no child element or CDATA inside
+  std::string ns, local;
 };
 
 // The namespace of a qualified name under `bindings`; false for an unbound prefix.
@@ -143,7 +151,7 @@ class Scanner {
       if (lt == std::string::npos) return true;
       pos_ = lt;
       bool ok = starts("<!--")      ? skip_past("-->")
-                : starts("<![CDATA[") ? !stack_.empty() && skip_past("]]>")
+                : starts("<![CDATA[") ? !stack_.empty() && (stack_.back().simple = false, skip_past("]]>"))
                 : starts("<?")        ? skip_past("?>")
                 : starts("<!DOCTYPE") ? doctype()
                 : starts("</")        ? end_tag(out)
@@ -175,18 +183,31 @@ class Scanner {
     spaces();
     if (pos_ >= xml_.size() || xml_[pos_] != '>' || stack_.empty() || stack_.back().qname != qname) return false;
     ++pos_;
-    if (stack_.back().rdf_root) out.rdf_close = lt;
+    Element const& closed = stack_.back();
+    if (closed.kind == Kind::RdfRoot) out.rdf_close = lt;
+    if (closed.kind == Kind::Property) {
+      Property property{closed.ns, closed.local, closed.start, pos_, "", false};
+      if (closed.simple) property.has_value = decode(xml_.substr(closed.content_start, lt - closed.content_start), property.value);
+      if (!property.has_value) property.value.clear();
+      out.located.push_back(std::move(property));
+    }
     stack_.pop_back();
     return true;
   }
 
   bool start_tag(Scan& out) {
+    size_t lt = pos_;
+    if (!stack_.empty()) stack_.back().simple = false;
     ++pos_;
     std::string qname = name();
     if (qname.empty()) return false;
     if (stack_.empty() && seen_root_) return false;  // a second root element
 
-    std::vector<std::pair<std::string, std::string>> attributes;
+    struct Attribute {
+      std::string qname, value;
+      size_t begin, end;
+    };
+    std::vector<Attribute> attributes;
     Bindings bindings = stack_.empty() ? Bindings{} : stack_.back().bindings;
     bool self_closing = false;
     while (true) {
@@ -203,6 +224,7 @@ class Scanner {
         break;
       }
       if (pos_ == before) return false;  // attributes must be separated by white space
+      size_t attribute_begin = before;
       std::string attribute = name();
       spaces();
       if (attribute.empty() || pos_ >= xml_.size() || xml_[pos_] != '=') return false;
@@ -222,24 +244,38 @@ class Scanner {
         if (attribute.size() == 6 || value.empty()) return false;
         bindings[attribute.substr(6)] = value;
       } else {
-        attributes.emplace_back(attribute, value);
+        attributes.push_back({attribute, value, attribute_begin, pos_});
       }
     }
 
     std::string ns, local;
     if (!resolve(qname, bindings, false, ns, local)) return false;
-    out.properties.insert({ns, local});
-    for (auto const& [attribute, value] : attributes) {
+    Kind parent = stack_.empty() ? Kind::Other : stack_.back().kind;
+    Kind kind = Kind::Other;
+    if (ns == kRdfNs && local == "RDF" && !seen_rdf_) {
+      kind = Kind::RdfRoot;
+      seen_rdf_ = true;
+    } else if (parent == Kind::RdfRoot && ns == kRdfNs && local == "Description") {
+      kind = Kind::Description;
+    } else if (parent == Kind::Description) {
+      kind = Kind::Property;
+      out.properties.insert({ns, local});
+    }
+    for (auto const& attribute : attributes) {
       std::string attribute_ns, attribute_local;
-      if (!resolve(attribute, bindings, true, attribute_ns, attribute_local)) return false;
-      if (!attribute_ns.empty()) out.properties.insert({attribute_ns, attribute_local});
+      if (!resolve(attribute.qname, bindings, true, attribute_ns, attribute_local)) return false;
+      bool property = kind == Kind::Description && !attribute_ns.empty() && attribute_ns != kRdfNs && attribute_ns != kXmlNs;
+      if (!property) continue;
+      out.properties.insert({attribute_ns, attribute_local});
+      out.located.push_back({attribute_ns, attribute_local, attribute.begin, attribute.end, attribute.value, true});
     }
 
-    bool rdf_root = ns == kRdfNs && local == "RDF" && !seen_rdf_;
-    if (rdf_root) seen_rdf_ = true;
     if (stack_.empty()) seen_root_ = true;
-    if (self_closing) return true;
-    stack_.push_back({qname, std::move(bindings), rdf_root});
+    if (self_closing) {
+      if (kind == Kind::Property) out.located.push_back({ns, local, lt, pos_, "", true});
+      return true;
+    }
+    stack_.push_back({qname, std::move(bindings), kind, lt, pos_, true, ns, local});
     return true;
   }
 
@@ -254,4 +290,40 @@ class Scanner {
 
 Scan scan(std::string const& xml) { return Scanner(xml).run(); }
 
+bool valid_text(char const* text, size_t size) noexcept {
+  auto const* bytes = reinterpret_cast<unsigned char const*>(text);
+  for (size_t i = 0; i < size;) {
+    unsigned char lead = bytes[i];
+    unsigned long cp;
+    size_t length;
+    if (lead < 0x80) {
+      cp = lead;
+      length = 1;
+    } else if ((lead & 0xE0) == 0xC0) {
+      cp = lead & 0x1F;
+      length = 2;
+    } else if ((lead & 0xF0) == 0xE0) {
+      cp = lead & 0x0F;
+      length = 3;
+    } else if ((lead & 0xF8) == 0xF0) {
+      cp = lead & 0x07;
+      length = 4;
+    } else {
+      return false;
+    }
+    if (i + length > size) return false;
+    for (size_t k = 1; k < length; ++k) {
+      if ((bytes[i + k] & 0xC0) != 0x80) return false;
+      cp = (cp << 6) | (bytes[i + k] & 0x3F);
+    }
+    static constexpr unsigned long kMinimum[] = {0, 0, 0x80, 0x800, 0x10000};
+    if (cp < kMinimum[length]) return false;  // an overlong form
+    bool allowed = cp == 0x9 || cp == 0xA || cp == 0xD || (cp >= 0x20 && cp <= 0xD7FF) ||
+                   (cp >= 0xE000 && cp <= 0xFFFD) || (cp >= 0x10000 && cp <= 0x10FFFF);
+    if (!allowed) return false;
+    i += length;
+  }
+  return true;
+}
+
 }  // namespace qpdf_ruby::xmp

data/ext/qpdf_ruby/xmp_scan.hpp

@@ -3,19 +3,36 @@
 #include <set>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace qpdf_ruby::xmp {
 
-// What the identification step needs to know about an XMP packet, read with namespace scoping:
+// A property of the document - a child element or a namespaced attribute of an rdf:Description
+// directly under the packet's first rdf:RDF - with where it sits in the packet.
+struct Property {
+  std::string ns;
+  std::string local;
+  // [begin, end) of the whole element, or of the attribute with the white space before it.
+  size_t begin = 0;
+  size_t end = 0;
+  // The text value, references resolved; empty for an element with child elements, CDATA or a
+  // reference the scanner does not know (has_value false).
+  std::string value;
+  bool has_value = false;
+};
+
+// What the metadata steps need to know about an XMP packet, read with namespace scoping:
 // comments, CDATA sections, processing instructions and a DOCTYPE are skipped, so a property that
-// is only mentioned in one of them does not count.
+// is only mentioned in one of them does not count, and neither does an element of the same name
+// anywhere but on the document's own rdf:Description.
 struct Scan {
   // Every tag closed in order, one root element, every prefix bound, attributes quoted and
   // separated. Not a validating parser: names and text outside the root are not checked.
   bool well_formed = false;
-  // (namespace URI, local name) of every element and every namespaced attribute - XMP allows a
-  // simple property in either form.
+  // (namespace URI, local name) of every property of the document - XMP allows a simple property
+  // as an element or as an attribute.
   std::set<std::pair<std::string, std::string>> properties;
+  std::vector<Property> located;
   // Offset of the "<" of the end tag of the outermost rdf:RDF element; npos without one.
   size_t rdf_close = std::string::npos;
 
@@ -24,4 +41,9 @@ struct Scan {
 
 Scan scan(std::string const& xml);
 
+// True if `size` bytes at `text` are UTF-8 made only of XML 1.0 characters (no NUL, no control
+// character but tab, line feed and carriage return, no surrogate, no U+FFFE/U+FFFF) - what may go
+// into an XMP packet. Allocates nothing and never throws.
+bool valid_text(char const* text, size_t size) noexcept;
+
 }  // namespace qpdf_ruby::xmp

data/lib/qpdf_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QpdfRuby
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/sig/qpdf_ruby.rbs

@@ -33,6 +33,8 @@ module QpdfRuby
       unidentified_reason: String?
     }
 
+    type document_info_result = { changed: bool, xmp_error: String? }
+
     type link = { page: Integer, uri: String?, contents: String? }
 
     def self.from_memory: (String data, ?String? password) -> Document
@@ -58,9 +60,11 @@ module QpdfRuby
     def retag_grouping_figures: () -> Integer
     def figures_without_alt: () -> Integer
     def add_pdfua_identification: (?title: String?) -> bool
+    def set_document_info: (?creator: String?, ?producer: String?) -> document_info_result
 
     def links: () -> Array[link]
     def metadata: () -> String?
+    def document_info: () -> Hash[String, String]
     def role_map: () -> Hash[String, String]
 
     def encrypt: (

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qpdf_ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Dieter S.