qpdf_ruby 0.1.0

data/ext/qpdf_ruby/struct_elem_node.cpp

@@ -0,0 +1,203 @@
+#include "struct_node.hpp"
+
+void StructElemNode::ensureLayoutBBox(PDFStructWalker& walker) {
+  if (node.hasKey("/K")) {
+    QPDFObjectHandle kids = node.getKey("/K");
+
+    // Handle direct value (single child)
+    if (kids.isInteger() || kids.isDictionary() || kids.isStream()) {
+      std::unique_ptr<StructNode> childNode = StructNode::fromQPDF(kids);
+      childNode->ensureLayoutBBox(walker);
+    }
+    // Handle array of children
+    else if (kids.isArray()) {
+      for (int i = 0; i < kids.getArrayNItems(); ++i) {
+        QPDFObjectHandle kid = kids.getArrayItem(i);
+        std::unique_ptr<StructNode> childNode = StructNode::fromQPDF(kid);
+        childNode->ensureLayoutBBox(walker);
+      }
+    }
+  }
+}
+
+std::string StructElemNode::to_string(int level, PDFStructWalker& walker) {
+  std::ostringstream oss;
+  std::string tag = getStructureTag();
+  int pageNum = findPageNumber(walker);
+
+  // Print opening tag with attributes
+  printOpeningTag(oss, level, tag, pageNum, walker);
+
+  // Process children
+  processChildren(oss, level + 1, walker);
+
+  // Print closing tag
+  IndentHelper::indent(oss, level);
+  oss << "</" << tag << ">" << std::endl;
+
+  return oss.str();
+}
+
+std::string StructElemNode::getStructureTag() {
+  std::string tag = "Unknown";
+  if (node.hasKey("/S") && node.getKey("/S").isName()) {
+    std::string rawName = node.getKey("/S").getName();
+    tag = (rawName[0] == '/') ? rawName.substr(1) : rawName;
+  }
+  return tag;
+}
+
+int StructElemNode::findPageNumber(PDFStructWalker& walker) {
+  int pageNum = -1;
+  QPDFObjectHandle currentNode = this->node;
+
+  while (currentNode.isDictionary()) {
+    if (currentNode.hasKey("/Pg")) {
+      QPDFObjectHandle page_ref = currentNode.getKey("/Pg");
+      if (page_ref.isIndirect()) {
+        const auto& page_map = walker.getPageObjectMap();
+        auto og = page_ref.getObjGen();
+        if (page_map.count(og)) {
+          return page_map.at(og);
+        }
+      }
+    }
+
+    // Move to parent
+    if (currentNode.hasKey("/P")) {
+      currentNode = currentNode.getKey("/P");
+    } else {
+      break;
+    }
+  }
+  return pageNum;
+}
+
+void StructElemNode::printOpeningTag(std::ostringstream& oss, int level, const std::string& tag, int pageNum,
+                                     PDFStructWalker& walker) {
+  IndentHelper::indent(oss, level);
+  oss << "<" << tag;
+
+  // Object ID
+  if (node.isIndirect()) {
+    oss << " obj=\"" << node.getObjectID() << " " << node.getGeneration() << "\"";
+  }
+
+  addAttributeIfPresent(oss, "/Alt", "Alt");
+  addAttributeIfPresent(oss, "/ActualText", "ActualText");
+  addAttributeIfPresent(oss, "/T", "Title");
+  addAttributeIfPresent(oss, "/Lang", "Lang");
+  addAttributeIfPresent(oss, "/ID", "ID");
+
+  addClassAttribute(oss);
+  addBboxAttribute(oss);
+
+  // Artifact type
+  if (tag == "Artifact" && node.hasKey("/Type") && node.getKey("/Type").isName()) {
+    std::string artifactType = node.getKey("/Type").getName();
+    oss << " ArtifactType=\"" << (artifactType[0] == '/' ? artifactType.substr(1) : artifactType) << "\"";
+  }
+
+  addNamespaceAttribute(oss);
+  addAttributeIfPresent(oss, "/Type", "Type");
+
+  if (pageNum > 0) {
+    oss << " Page=\"" << pageNum << "\"";
+  }
+
+  oss << ">" << std::endl;
+}
+
+void StructElemNode::addAttributeIfPresent(std::ostringstream& oss, const std::string& key,
+                                           const std::string& attributeName) {
+  if (node.hasKey(key) && node.getKey(key).isString()) {
+    oss << " " << attributeName << "=\"" << node.getKey(key).getStringValue() << "\"";
+  }
+}
+
+void StructElemNode::addClassAttribute(std::ostringstream& oss) {
+  if (!node.hasKey("/C")) return;
+
+  oss << " Class=\"";
+  QPDFObjectHandle classObj = node.getKey("/C");
+  if (classObj.isName()) {
+    std::string className = classObj.getName();
+    oss << (className[0] == '/' ? className.substr(1) : className);
+  } else if (classObj.isArray()) {
+    for (int i = 0; i < classObj.getArrayNItems(); ++i) {
+      if (i > 0) oss << " ";
+      if (classObj.getArrayItem(i).isName()) {
+        std::string className = classObj.getArrayItem(i).getName();
+        oss << (className[0] == '/' ? className.substr(1) : className);
+      }
+    }
+  }
+  oss << "\"";
+}
+
+void StructElemNode::processChildren(std::ostringstream& oss, int level, PDFStructWalker& walker) {
+  if (!node.hasKey("/K")) return;
+
+  QPDFObjectHandle kids = node.getKey("/K");
+
+  // Handle direct value (single child)
+  if (!kids.isArray()) {
+    std::unique_ptr<StructNode> childNode = StructNode::fromQPDF(kids);
+    oss << childNode->to_string(level, walker);
+    return;
+  }
+
+  // Handle array of children
+  for (int i = 0; i < kids.getArrayNItems(); ++i) {
+    QPDFObjectHandle kid = kids.getArrayItem(i);
+    std::unique_ptr<StructNode> childNode = StructNode::fromQPDF(kid);
+    oss << childNode->to_string(level, walker);
+  }
+}
+
+void StructElemNode::addBboxAttribute(std::ostringstream& oss) {
+  if (node.hasKey("/BBox") && node.getKey("/BBox").isArray()) {
+    QPDFObjectHandle bbox = node.getKey("/BBox");
+    if (bbox.getArrayNItems() == 4) {
+      oss << " BBox=\"";
+      for (int i = 0; i < 4; ++i) {
+        if (i > 0) oss << " ";
+        if (bbox.getArrayItem(i).isNumber()) {
+          oss << bbox.getArrayItem(i).getNumericValue();
+        }
+      }
+      oss << "\"";
+    }
+  }
+
+  if (node.hasKey("/A")) {
+    QPDFObjectHandle A = node.getKey("/A");
+    if (A.isDictionary() && A.hasKey("/BBox")) {
+      auto bbox = A.getKey("/BBox");
+      oss << " BBox=\"[" << bbox.getArrayItem(0).getNumericValue() << ", " << bbox.getArrayItem(1).getNumericValue()
+          << ", " << bbox.getArrayItem(2).getNumericValue() << ", " << bbox.getArrayItem(3).getNumericValue() << "]\"";
+    } else if (A.isArray()) {
+      for (int i = 0; i < A.getArrayNItems(); ++i) {
+        if (A.getArrayItem(i).isDictionary() && A.getArrayItem(i).hasKey("/O") &&
+            A.getArrayItem(i).getKey("/O").getName() == "/Layout" && A.getArrayItem(i).hasKey("/BBox")) {
+          auto bbox = A.getArrayItem(i).getKey("/BBox");
+          oss << " BBox=\"[" << bbox.getArrayItem(0).getNumericValue() << ", " << bbox.getArrayItem(1).getNumericValue()
+              << ", " << bbox.getArrayItem(2).getNumericValue() << ", " << bbox.getArrayItem(3).getNumericValue()
+              << "]\"";
+          break;
+        }
+      }
+    }
+    oss << " ";
+  }
+}
+
+void StructElemNode::addNamespaceAttribute(std::ostringstream& oss) {
+  if (node.hasKey("/NS") && node.getKey("/NS").isDictionary()) {
+    QPDFObjectHandle ns = node.getKey("/NS");
+    if (ns.hasKey("/NS") && ns.getKey("/NS").isName()) {
+      std::string nsName = ns.getKey("/NS").getName();
+      oss << " NS=\"" << (nsName[0] == '/' ? nsName.substr(1) : nsName) << "\"";
+    }
+  }
+}

data/ext/qpdf_ruby/struct_node.cpp

@@ -0,0 +1,51 @@
+#include "struct_node.hpp"
+
+std::unique_ptr<StructNode> StructNode::fromQPDF(QPDFObjectHandle node) {
+  if (node.isInteger()) {
+    return std::make_unique<McidNode>(node.getIntValue());
+  }
+
+  if (node.isArray()) {
+    auto arrayNode = std::make_unique<ArrayNode>();
+    for (int i = 0; i < node.getArrayNItems(); ++i) {
+      arrayNode->addChild(fromQPDF(node.getArrayItem(i)));
+    }
+    return arrayNode;
+  }
+
+  if (node.isDictionary()) {
+    if (node.hasKey("/Type") && node.getKey("/Type").isName() && node.getKey("/Type").getName() == "MCR" &&
+        node.hasKey("/MCID") && node.hasKey("/Pg")) {
+      int mcid = node.getKey("/MCID").getIntValue();
+      QPDFObjectHandle pg = node.getKey("/Pg");
+      auto og = pg.getObjGen();
+      // Optionally, pass page number if you can look it up here
+      return std::make_unique<McrNode>(mcid, og.getObj(), og.getGen());
+    }
+
+    if (node.hasKey("/S") && node.getKey("/S").isName()) {
+      std::string tag = node.getKey("/S").getName();
+      if (tag == "/Figure") {
+        return std::make_unique<FigureNode>(node);
+      }
+    }
+
+    if (node.hasKey("/S") ||
+        (node.hasKey("/Type") && node.getKey("/Type").isName() && node.getKey("/Type").getName() == "StructElem")) {
+      return std::make_unique<StructElemNode>(node);
+    }
+    // Handle other dictionary types as needed
+    return std::make_unique<UnknownNode>("Dictionary");
+  }
+
+  if (node.isStream()) {
+    auto data = node.getStreamData();
+    return std::make_unique<StreamNode>(data->getSize());
+  }
+
+  return std::make_unique<UnknownNode>(node.getTypeName());
+}
+
+void StructNode::print(std::ostream& out, int level, PDFStructWalker& walker) { out << this->to_string(level, walker); }
+
+void StructNode::ensureLayoutBBox(PDFStructWalker& walker) {}

data/ext/qpdf_ruby/struct_node.hpp

@@ -0,0 +1,115 @@
+#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>
+
+#include "pdf_struct_walker.hpp"
+
+class StructNode {
+ public:
+  virtual ~StructNode() = default;
+  virtual std::string to_string(int level, PDFStructWalker& walker) = 0;
+  void print(std::ostream& out, int level, PDFStructWalker& walker);
+  virtual void ensureLayoutBBox(PDFStructWalker& walker);
+
+  static std::unique_ptr<StructNode> fromQPDF(QPDFObjectHandle node);
+};
+
+class StructElemNode : public StructNode {
+ protected:
+  QPDFObjectHandle node;
+
+ public:
+  StructElemNode(QPDFObjectHandle n) : node(n) {}
+  std::string to_string(int level, PDFStructWalker& walker) override;
+  void ensureLayoutBBox(PDFStructWalker& walker) override;
+
+ private:
+  std::string getStructureTag();
+  int findPageNumber(PDFStructWalker& walker);
+  void printOpeningTag(std::ostringstream& oss, int level, const std::string& tag, int pageNum,
+                       PDFStructWalker& walker);
+  void addAttributeIfPresent(std::ostringstream& oss, const std::string& key, const std::string& attributeName);
+  void addClassAttribute(std::ostringstream& oss);
+  void addBboxAttribute(std::ostringstream& oss);
+  void addNamespaceAttribute(std::ostringstream& oss);
+  void processChildren(std::ostringstream& oss, int level, PDFStructWalker& walker);
+};
+
+class FigureNode : public StructElemNode {
+ public:
+  FigureNode(QPDFObjectHandle n) : StructElemNode(n) {}
+  void ensureLayoutBBox(PDFStructWalker& walker) override;
+};
+
+class McidNode : public StructNode {
+ private:
+  int mcid;
+  int pageNumber = -1;  // Default to -1 (unknown)
+ public:
+  McidNode(int id) : mcid(id) {}
+  std::string to_string(int level, PDFStructWalker& walker) override;
+  int getMcid() const;     // Declaration only
+  void setPage(int page);  // Declaration only
+};
+
+class McrNode : public StructNode {
+ public:
+  McrNode(int mcid, int pageObj, int pageGen, int pageNumber = 0);
+  std::string to_string(int level, PDFStructWalker& walker) override;
+  int getMcid() const;
+  void setPageNumber(int pageNum);
+
+ private:
+  int mcid;
+  int pageObj;
+  int pageGen;
+  int pageNumber;
+};
+
+class ArrayNode : public StructNode {
+ private:
+  std::vector<std::unique_ptr<StructNode>> children;
+
+ public:
+  ArrayNode() = default;
+  void addChild(std::unique_ptr<StructNode> child);
+  std::string to_string(int level, PDFStructWalker& walker) override;
+  void ensureLayoutBBox(PDFStructWalker& walker) override;
+};
+
+class StreamNode : public StructNode {
+ private:
+  size_t size;
+
+ public:
+  StreamNode(size_t streamSize) : size(streamSize) {}
+  std::string to_string(int level, PDFStructWalker& walker) override;
+};
+
+class UnknownNode : public StructNode {
+ private:
+  std::string typeName;
+
+ public:
+  UnknownNode(const std::string& type) : typeName(type) {}
+  std::string to_string(int level, PDFStructWalker& walker) override;
+};
+
+class IndentHelper {
+ public:
+  static void indent(std::ostream& out, int level) {
+    for (int i = 0; i < level; ++i) {
+      out << "  ";
+    }
+  }
+};

data/ext/qpdf_ruby/unknown_node.cpp

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

data/lib/qpdf_ruby/version.rb

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

data/lib/qpdf_ruby.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "qpdf_ruby/version"
+require_relative "qpdf_ruby/qpdf_ruby"
+
+module QpdfRuby
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/qpdf_ruby.rbs

@@ -0,0 +1,4 @@
+module QpdfRuby
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: qpdf_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dieter S.
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: This gem provides a comprehensive Ruby wrapper around
+email:
+- 101627195+dieter-medium@users.noreply.github.com
+executables:
+- qpdf_ruby
+extensions:
+- ext/qpdf_ruby/extconf.rb
+extra_rdoc_files: []
+files:
+- ".clang-format"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- docker/Dockerfile
+- exe/qpdf_ruby
+- ext/qpdf_ruby/array_node.cpp
+- ext/qpdf_ruby/document_handle.cpp
+- ext/qpdf_ruby/document_handle.hpp
+- ext/qpdf_ruby/extconf.rb
+- ext/qpdf_ruby/figure_node.cpp
+- ext/qpdf_ruby/mcid_node.cpp
+- ext/qpdf_ruby/mcr_node.cpp
+- ext/qpdf_ruby/pdf_image_mapper.cpp
+- ext/qpdf_ruby/pdf_image_mapper.hpp
+- ext/qpdf_ruby/pdf_struct_walker.cpp
+- ext/qpdf_ruby/pdf_struct_walker.hpp
+- ext/qpdf_ruby/qpdf_ruby.cpp
+- ext/qpdf_ruby/qpdf_ruby.hpp
+- ext/qpdf_ruby/stream_node.cpp
+- ext/qpdf_ruby/struct_elem_node.cpp
+- ext/qpdf_ruby/struct_node.cpp
+- ext/qpdf_ruby/struct_node.hpp
+- ext/qpdf_ruby/unknown_node.cpp
+- lib/qpdf_ruby.rb
+- lib/qpdf_ruby/version.rb
+- sig/qpdf_ruby.rbs
+homepage: https://github.com/dieter-medium/qpdf_ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/dieter-medium/qpdf_ruby
+  source_code_uri: https://github.com/dieter-medium/qpdf_ruby
+  changelog_uri: https://github.com/dieter-medium/qpdf_ruby/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: A Ruby interface .
+test_files: []