qpdf_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c5f6da89731f271f230b6784f82f01bb4f1dfe4060d4caae6d956fa73d8fc13e
+  data.tar.gz: c3d2e9dc8baf1975acbca704b8b76dab210c0f959ce78b8655d1c3c295585d10
+SHA512:
+  metadata.gz: c850b48c57e89e431b3d7340b1cd4819f28887402cdc03af7e108533249a4e8742351732c22217b0fed011e4799b9b00268219ec2b1ea17d6576ef50125ffbbb
+  data.tar.gz: 60f89a46753d7caa4d70a3832c2dc68bd01470528c5c6c6939df10920608f3e451ed7c11d42874fd6944df1a06bdd4847020e1289fb1b07c100fc502cc48e5ce

data/.clang-format

@@ -0,0 +1,4 @@
+BasedOnStyle: Google
+SortIncludes: false
+IndentWidth: 2
+ColumnLimit: 120

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,88 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.3
+  Exclude:
+    - 'ext/qpdf_ruby/extconf.rb'
+    - 'tmp/**/*'
+    - 'vendor/**/*'
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false
+
+RSpec/SubjectStub:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: false
+
+Layout/FirstArgumentIndentation:
+  Enabled: false
+
+Layout/ClosingParenthesisIndentation:
+  Enabled: false
+
+Layout/FirstHashElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/FirstArrayElementIndentation:
+  Enabled: false
+
+Layout/MultilineOperationIndentation:
+  Enabled: false
+
+Layout/BeginEndAlignment:
+  Enabled: false
+
+Layout/ArrayAlignment:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Layout/LineEndStringConcatenationIndentation:
+  Enabled: false
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 10
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Max: 10
+
+
+Gemspec/DevelopmentDependencies:
+  EnforcedStyle: gemspec
+
+RSpec/InstanceVariable:
+  Enabled: false
+
+RSpec/BeforeAfterAll:
+  Enabled: false
+
+RSpec/SpecFilePathFormat:
+  Enabled: true
+  Exclude:
+    - 'spec/acceptance/**/*_spec.rb'
+
+RSpec/DescribeClass:
+  Enabled: true
+  Exclude:
+    - 'spec/acceptance/**/*_spec.rb'
+
+plugins:
+  - rubocop-rake
+  - rubocop-rspec

data/.ruby-gemset

@@ -0,0 +1 @@
+qpdf_ruby

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.3.4

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-06-11
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dieter S.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# QpdfRuby
+
+> **Patch & polish PDFs so that PAC 2024 finally turns green.**
+
+QpdfRuby is a very small Ruby wrapper around the battle‑tested
+[QPDF \>= 12](https://qpdf.sourceforge.net/) C++ library.  Right now the
+library focuses on only **three specialised tasks** that are needed when
+PDFs are printed from Chromium‑based browsers and subsequently audited
+with the PAC 2024 accessibility checker:
+
+1. **Export the structure tree as XML** – handy for debugging.
+2. **Mark vector path objects as `/Artifact`** so that decorative lines,
+   boxes, &c. are ignored by assistive technologies.
+3. **Add missing `/BBox` entries to every `/Figure` element** (derived
+   from the page’s graphic operators) so that screen readers know the
+   physical extent of each image.
+
+Together these tweaks eliminate the most common complaints PAC 2024 has
+about browser‑generated PDFs.
+
+---
+
+## Features in Detail
+
+| Feature                                        | Ruby API                                 |
+| ---------------------------------------------- | ---------------------------------------- |
+| Dump structure tree as XML                     | `doc.show_structure`                     |
+| Mark path objects ( `re … S/s/f/F/B/b` )       | `doc.mark_paths_as_artifacts`            |
+| Ensure `/Figure` elements have a layout BBox¹  | `doc.ensure_bbox`                        |
+
+_¹Internally the gem parses each page’s content stream, maps image
+`/MCID`s to their transformation matrix, computes the bounding box
+(courtesy of a little linear algebra) and finally writes the result into
+the structure tree._
+
+---
+
+## Installation
+
+### Requirements
+
+* **Ruby** \>= 3.1
+* **QPDF** \>= 12.0.0 (headers & libs)
+
+### macOS
+```bash
+brew install qpdf
+bundle config set --local build.qpdf_ruby "--with-qpdf-dir=$(brew --prefix qpdf)"
+```  
+
+### Debian/Ubuntu
+```bash
+# on Debian 11/Ubuntu 20.04 you may need newer packages from testing
+sudo apt-get update && sudo apt-get install -y libqpdf-dev qpdf
+```
+If `apt` cannot provide QPDF ≥ 12 you can compile it yourself or pull the
+package from *testing/unstable* – see the [Dockerfile](./docker/Dockerfile) for a working
+`apt preferences` snippet.
+
+### Add the gem
+```bash
+bundle add qpdf_ruby
+# …or without bundler:
+# gem install qpdf_ruby -- --with-qpdf-include=/usr/local/include/qpdf --with-qpdf-lib=/usr/local/lib
+```
+
+---
+
+## Quick Start
+```ruby
+require "qpdf_ruby"
+
+pdf = QpdfRuby::Document.new("input.pdf")
+
+# 1. tag decorative paths
+pdf.mark_paths_as_artifacts
+
+# 2. add BBox to every <Figure>
+pdf.ensure_bbox
+
+# 3. introspect structure tree (optional)
+File.write("structure.xml", pdf.show_structure)
+
+# 4. save 🎉
+pdf.write("fixed.pdf")
+```
+
+Run PAC 2024 on `fixed.pdf` – it should report far fewer (or zero!)
+errors compared to the original browser output.
+
+---
+
+## Development
+```bash
+git clone https://github.com/dieter-medium/qpdf_ruby.git
+cd qpdf_ruby
+bin/setup        # install gem + test deps
+autotest         # guard & RSpec
+```
+* Bump **version.rb** → `bundle exec rake release` to push a new gem.
+
+### Testing with local QPDF builds
+If you tinker with QPDF itself, point Bundler to your custom prefix:
+```bash
+bundle config set --local build.qpdf_ruby "--with-qpdf-include=$HOME/opt/qpdf/include --with-qpdf-lib=$HOME/opt/qpdf/lib"
+```
+
+---
+
+## Roadmap
+
+  TBD
+
+---
+
+## Contributing
+Bug reports & pull requests are welcome at
+<https://github.com/dieter-medium/qpdf_ruby>.
+
+### Code Style
+* C++ 17, clang‑format enforced
+* Ruby 3.2, rubocop default rules
+
+---
+
+## License
+
+[MIT](https://opensource.org/licenses/MIT) – see `LICENSE.txt` for full
+text.

data/Rakefile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+require "rake/extensiontask"
+
+desc "Build the gem including native extensions"
+task build: :compile
+
+GEMSPEC = Gem::Specification.load("qpdf_ruby.gemspec")
+
+Rake::ExtensionTask.new("qpdf_ruby", GEMSPEC) do |ext|
+  ext.lib_dir = "lib/qpdf_ruby"
+end
+
+Dir.glob("tasks/*.rake").each { |r| load r }
+
+task default: %i[clobber compile spec rubocop]

data/docker/Dockerfile

@@ -0,0 +1,46 @@
+FROM ruby:3.3
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN set -eux; \
+    echo "deb http://deb.debian.org/debian testing main"   >  /etc/apt/sources.list.d/extra.list; \
+    echo "deb http://deb.debian.org/debian unstable main" >> /etc/apt/sources.list.d/extra.list; \
+    \
+    printf "Package: *\nPin: release a=testing\nPin-Priority: 100\n\n"   >  /etc/apt/preferences.d/99-pin-testing; \
+    printf "Package: *\nPin: release a=unstable\nPin-Priority: 100\n"  >> /etc/apt/preferences.d/99-pin-testing; \
+    \
+    apt-get update; \
+    apt-get -y --no-install-recommends install qpdf libqpdf-dev -t testing; \
+    apt-mark hold qpdf libqpdf-dev; \
+    \
+    apt-get clean; rm -rf /var/lib/apt/lists/*;
+
+# Smoke‑test (shown in build log)
+RUN qpdf --version  # should print "qpdf version 12.x"
+
+
+COPY ./pkg/qpdf_ruby-*.gem ./
+COPY ./spec/fixtures/example_accessibility.pdf /tmp/dummy.pdf
+
+RUN gem install  ./qpdf_ruby-*.gem -- --with-qpdf-include=/usr/local/include/qpdf --with-qpdf-lib=/usr/local/lib
+
+RUN ruby -r qpdf_ruby -e 'puts "QpdfRuby version: #{QpdfRuby::VERSION}";doc = QpdfRuby::Document.new "/tmp/dummy.pdf"; puts doc.show_structure'
+
+# Create a non-root user
+RUN set -eux; \
+    groupadd -r appuser && useradd -r -g appuser -m -d /home/appuser appuser
+
+
+RUN set -eux; \
+    mkdir -p /workspace
+
+# Set working directory
+WORKDIR /workspace
+
+RUN chown -R appuser:appuser /workspace
+
+# Switch to non-root user
+USER appuser
+
+CMD ["/usr/bin/bash"]
+

data/exe/qpdf_ruby

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "qpdf_ruby"

data/ext/qpdf_ruby/array_node.cpp

@@ -0,0 +1,17 @@
+#include "struct_node.hpp"
+
+void ArrayNode::addChild(std::unique_ptr<StructNode> child) { children.push_back(std::move(child)); }
+
+std::string ArrayNode::to_string(int level, PDFStructWalker& walker) {
+  std::ostringstream oss;
+  for (const auto& child : children) {
+    oss << child->to_string(level, walker);
+  }
+  return oss.str();
+}
+
+void ArrayNode::ensureLayoutBBox(PDFStructWalker& walker) {
+  for (const auto& child : children) {
+    child->ensureLayoutBBox(walker);
+  }
+}

data/ext/qpdf_ruby/document_handle.cpp

@@ -0,0 +1,102 @@
+#include "document_handle.hpp"
+
+#include <qpdf/QPDFWriter.hh>
+#include <stdexcept>
+#include <system_error>
+#include <cerrno>
+
+using namespace qpdf_ruby;
+
+std::unique_ptr<DocumentHandle> DocumentHandle::open(const std::string& filename) {
+  auto qpdf = std::make_shared<QPDF>();
+  try {
+    // Use empty password → owner & user pwd same.
+    qpdf->processFile(filename.c_str());
+  } catch (const std::exception& ex) {
+    throw std::runtime_error(std::string("qpdf_ruby: failed to open “") + filename + "”: " + ex.what());
+  }
+  return std::unique_ptr<DocumentHandle>(new DocumentHandle(qpdf));
+}
+
+std::unique_ptr<DocumentHandle> DocumentHandle::open_memory(std::string const& desc, std::vector<unsigned char> buf,
+                                                            std::string const& pwd) {
+  auto qpdf = std::make_shared<QPDF>();
+  try {
+    qpdf->processMemoryFile(desc.c_str(), reinterpret_cast<char const*>(buf.data()), buf.size(),
+                            pwd.empty() ? nullptr : pwd.c_str());
+  } catch (std::exception const& ex) {
+    throw std::runtime_error("qpdf_ruby: open_memory failed: " + std::string(ex.what()));
+  }
+
+  auto h = std::unique_ptr<DocumentHandle>(new DocumentHandle(qpdf));
+  h->m_owned_buf = std::move(buf);  // keep bytes alive
+  return h;
+}
+
+DocumentHandle::DocumentHandle(std::shared_ptr<QPDF> qpdf) : m_qpdf(std::move(qpdf)) {}
+
+void DocumentHandle::write(const std::string& out_filename) {
+  try {
+    // honour original file’s extension-level features (linearized? encrypted? …)
+    QPDFWriter w(*m_qpdf, out_filename.c_str());
+    w.setStaticID(true);  // deterministic IDs – helps tests
+    w.write();
+  } catch (const std::exception& ex) {
+    throw std::runtime_error(std::string("qpdf_ruby: failed to write “") + out_filename + "”: " + ex.what());
+  }
+}
+
+std::string DocumentHandle::write_to_memory() {
+  try {
+    QPDFWriter w(*m_qpdf, nullptr);
+    w.setStaticID(true);
+    w.setOutputMemory();
+    w.write();
+
+    auto b = w.getBuffer();
+    return std::string(reinterpret_cast<char const*>(b->getBuffer()), b->getSize());
+  } catch (std::exception const& ex) {
+    throw std::runtime_error("qpdf_ruby: write_to_memory failed: " + std::string(ex.what()));
+  }
+}
+
+// ------------------------- C bridge impl --------------------------------
+
+extern "C" {
+DocumentHandle* qpdf_ruby_open(const char* filename) {
+  try {
+    return DocumentHandle::open(filename).release();
+  } catch (const std::exception&) {
+    errno = EIO;
+    return nullptr;
+  }
+}
+
+DocumentHandle* qpdf_ruby_open_memory(char const* desc, unsigned char const* buf, size_t len, char const* pwd) {
+  try {
+    std::vector<unsigned char> copy(buf, buf + len);  // simple ownership
+    return DocumentHandle::open_memory(desc, std::move(copy), pwd ? pwd : "").release();
+  } catch (...) {
+    errno = EIO;
+    return nullptr;
+  }
+}
+
+int qpdf_ruby_write(DocumentHandle* handle, const char* out_filename) {
+  if (!handle) {
+    errno = EBADF;
+    return -1;
+  }
+  try {
+    handle->write(out_filename);
+    return 0;
+  } catch (const std::exception&) {
+    errno = EIO;
+    return -1;
+  }
+}
+
+void qpdf_ruby_close(DocumentHandle* handle) {
+  delete handle;  // ok on nullptr
+}
+}  // extern "C"

data/ext/qpdf_ruby/document_handle.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <qpdf/QPDF.hh>
+
+namespace qpdf_ruby {
+
+/**
+ * A thin RAII wrapper around std::shared_ptr<QPDF>.
+ *
+ * - Only one QPDF parse per PDF file.
+ * - Shared among Ruby proxy objects (StructureProxy, PathsProxy, …).
+ * - Non-copyable but movable.
+ */
+class DocumentHandle final {
+ public:
+  // ---- factory ----------------------------------------------------------
+  static std::unique_ptr<DocumentHandle> open(const std::string& filename);
+  static std::unique_ptr<DocumentHandle> open_memory(std::string const& description, std::vector<unsigned char> data,
+                                                     std::string const& password = "");
+
+  // ---- public API -------------------------------------------------------
+  /** Write the (possibly-modified) PDF to disk. */
+  void write(const std::string& out_filename);
+
+  std::string write_to_memory();
+
+  /** Direct access for C++ helpers that need the raw QPDF. */
+  QPDF& qpdf() { return *m_qpdf; }
+  const QPDF& qpdf() const { return *m_qpdf; }
+
+  // ---- rule of five -----------------------------------------------------
+  ~DocumentHandle() = default;
+  DocumentHandle(const DocumentHandle&) = delete;
+  DocumentHandle& operator=(const DocumentHandle&) = delete;
+  DocumentHandle(DocumentHandle&&) noexcept = default;
+  DocumentHandle& operator=(DocumentHandle&&) noexcept = default;
+
+ private:
+  explicit DocumentHandle(std::shared_ptr<QPDF> qpdf);
+
+  std::shared_ptr<QPDF> m_qpdf;
+  std::vector<unsigned char> m_owned_buf;
+};
+
+extern "C" {
+/** Returns a freshly allocated handle or nullptr on error (see errno). */
+DocumentHandle* qpdf_ruby_open(const char* filename);
+
+DocumentHandle* qpdf_ruby_open_memory(char const* desc, unsigned char const* buf, size_t len, char const* pwd);
+
+/** Writes PDF; returns 0 on success, -1 on error (see errno). */
+int qpdf_ruby_write(DocumentHandle* handle, const char* out_filename);
+
+/** Deletes the handle (idempotent). */
+void qpdf_ruby_close(DocumentHandle* handle);
+}
+
+}  // namespace qpdf_ruby

data/ext/qpdf_ruby/extconf.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+# Makes all symbols private by default to avoid unintended conflict
+# with other gems. To explicitly export symbols you can use RUBY_FUNC_EXPORTED
+# selectively, or entirely remove this flag.
+append_cflags("-fvisibility=hidden")
+
+if with_config("qpdf-dir")
+  qpdf_include_dir, qpdf_lib_dir = dir_config("qpdf")
+  $INCFLAGS << " -I#{qpdf_include_dir}"
+  $LDFLAGS << " -L#{qpdf_lib_dir} -lqpdf"
+else
+  $LDFLAGS << " -lqpdf"
+end
+
+if RbConfig::CONFIG["host_os"] =~ /darwin/
+  $LDFLAGS << " -Wl,-search_paths_first -Wl,-headerpad_max_install_names -Wl,-multiply_defined,suppress"
+  $LDFLAGS << " -Wl,-undefined,dynamic_lookup"
+end
+
+$CXXFLAGS << " -std=c++17"
+
+create_makefile("qpdf_ruby/qpdf_ruby")

data/ext/qpdf_ruby/figure_node.cpp

@@ -0,0 +1,109 @@
+#include "struct_node.hpp"
+
+static void add_bbox(PDFStructWalker& walker, QPDFObjectHandle node) {
+  int mcid = -std::numeric_limits<int>::infinity();
+
+  if (node.getKey("/K").isInteger()) {
+    mcid = node.getKey("/K").getIntValue();
+  }
+
+  // Get the bbox from the walker or use defaults
+
+  QPDFObjectHandle pageObj;
+  QPDFObjectHandle currentNode = node;
+  bool found = false;
+
+  // Try to find /Pg by walking up the parent chain
+  while (currentNode.isDictionary()) {
+    if (currentNode.hasKey("/Pg")) {
+      pageObj = currentNode.getKey("/Pg");
+      found = true;
+      break;
+    }
+
+    if (currentNode.hasKey("/P")) {
+      currentNode = currentNode.getKey("/P");
+    } else {
+      break;  // No more parents to check
+    }
+  }
+
+  if (!found && node.hasKey("/K") && node.getKey("/K").isArray()) {
+    QPDFObjectHandle kids = node.getKey("/K");
+    for (int i = 0; i < kids.getArrayNItems(); ++i) {
+      QPDFObjectHandle kid = kids.getArrayItem(i);
+      if (kid.isDictionary() && kid.hasKey("/Pg")) {
+        pageObj = kid.getKey("/Pg");
+        found = true;
+        break;
+      }
+    }
+  }
+
+  if (!found || !pageObj.isIndirect()) {
+    std::cerr << "No /Pg key found for MCID " << mcid << ", cannot add BBox." << std::endl;
+    return;
+  }
+
+  auto media_box = walker.getPageCropBoxFor(pageObj);
+
+  double llx = media_box[0], lly = media_box[1], urx = media_box[2], ury = media_box[3];
+  auto const& bbox_map = walker.getMcidBboxMap();
+
+  // Use a try/catch to prevent failures when accessing the map
+  try {
+    if (bbox_map.count(mcid) > 0) {
+      auto const& b = bbox_map.at(mcid);
+      llx = b[0];
+      lly = b[1];
+      urx = b[2];
+      ury = b[3];
+    }
+  } catch (const std::exception& e) {
+    std::cerr << "Error accessing mcid " << mcid << " in bbox map: " << e.what() << std::endl;
+    // Continue with default values
+  }
+
+  QPDFObjectHandle attrs;
+  attrs = QPDFObjectHandle::newDictionary();
+  attrs.replaceKey("/O", QPDFObjectHandle::newName("/Layout"));
+
+  node.replaceKey("/A", attrs);
+
+  if (!attrs.hasKey("/BBox")) {
+    QPDFObjectHandle arr = QPDFObjectHandle::newArray();
+    arr.appendItem(QPDFObjectHandle::newReal(llx));
+    arr.appendItem(QPDFObjectHandle::newReal(lly));
+    arr.appendItem(QPDFObjectHandle::newReal(urx));
+    arr.appendItem(QPDFObjectHandle::newReal(ury));
+
+    attrs.replaceKey("/BBox", arr);
+  }
+}
+
+void FigureNode::ensureLayoutBBox(PDFStructWalker& walker) {
+  StructElemNode::ensureLayoutBBox(walker);
+
+  // Bail if a BBox is already present *anywhere* in /A
+  if (node.hasKey("/A")) {
+    QPDFObjectHandle A = node.getKey("/A");
+    auto has_bbox = [](QPDFObjectHandle const& dict) {
+      QPDFObjectHandle non_const_dict = dict;
+      return non_const_dict.isDictionary() && non_const_dict.hasKey("/O") &&
+             non_const_dict.getKey("/O").getName() == "/Layout" && non_const_dict.hasKey("/BBox");
+    };
+
+    if ((A.isDictionary() && has_bbox(A)) || (A.isArray() && [&]() -> bool {
+          for (int i = 0; i < A.getArrayNItems(); ++i) {
+            if (has_bbox(A.getArrayItem(i))) {
+              return true;
+            }
+          }
+          return false;
+        }())) {
+      return;  // nothing to do
+    }
+  }
+
+  add_bbox(walker, node);
+}

data/ext/qpdf_ruby/mcid_node.cpp

@@ -0,0 +1,15 @@
+#include "struct_node.hpp"
+
+int McidNode::getMcid() const { return mcid; }
+
+void McidNode::setPage(int page) { pageNumber = page; }
+
+std::string McidNode::to_string(int level, PDFStructWalker& walker) {
+  std::ostringstream oss;
+  IndentHelper::indent(oss, level);
+  oss << "[MCID: " << mcid;
+
+  oss << "]" << std::endl;
+
+  return oss.str();
+}