pdfrb 0.6.0 → 0.7.10

data/lib/pdfrb/conformance/pdf_a4_deep.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+module Pdfrb
+  module Conformance
+    # PDF/A-4 deep checks (ISO 19005-4). Builds on the SHARED + A4
+    # rules in Pdfrb::Conformance::PdfA by adding additional
+    # structural requirements specific to PDF/A-4: PDF 2.0 base,
+    # XMP metadata required (not just recommended), /AF entries
+    # valid per App Note 002.
+    module PdfA4Deep
+      module_function
+
+      RULESET = RuleSet.new("PDF/A-4-deep").tap do |rs|
+        rs.register(Rule.new(
+                      id: "a4deep-1",
+                      description: "PDF/A-4 requires XMP /Metadata stream",
+                      severity: :error,
+                      spec_clause: "ISO 19005-4 6.1",
+                      check: ->(doc) {
+                        next nil if doc.catalog[:Metadata]
+
+                        Violation.new(
+                          rule_id: "a4deep-1",
+                          message: "PDF/A-4 requires /Catalog/Metadata XMP stream",
+                          object: "Catalog/Metadata",
+                          severity: :error,
+                          spec_clause: "ISO 19005-4 6.1"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "a4deep-2",
+                      description: "PDF/A-4 should have valid /OutputIntents when colour-managed",
+                      severity: :warning,
+                      spec_clause: "ISO 19005-4 6.2.4",
+                      check: ->(doc) {
+                        next nil if doc.catalog[:OutputIntents]
+
+                        # Only flag when document has ICCBased color spaces
+                        has_icc = false
+                        doc.each_indirect_object do |obj|
+                          next unless obj.value[:ColorSpace]
+
+                          cs = obj.value[:ColorSpace]
+                          cs_array = cs.is_a?(::Array) ? cs : [cs]
+                          if cs_array.any?(:ICCBased)
+                            has_icc = true
+                            break
+                          end
+                        end
+                        next nil unless has_icc
+
+                        Violation.new(
+                          rule_id: "a4deep-2",
+                          message: "ICC-based color spaces require /OutputIntents in PDF/A-4",
+                          object: "Catalog/OutputIntents",
+                          severity: :warning,
+                          spec_clause: "ISO 19005-4 6.2.4"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "a4deep-3",
+                      description: "PDF/A-4 forbids EmbeddedFile streams",
+                      severity: :error,
+                      spec_clause: "ISO 19005-4 6.4",
+                      check: ->(doc) {
+                        vs = []
+                        doc.each_indirect_object do |obj|
+                          next unless obj.value[:Type] == :EmbeddedFile
+
+                          vs << Violation.new(
+                            rule_id: "a4deep-3",
+                            message: "PDF/A-4 forbids EmbeddedFile streams",
+                            object: "EmbeddedFile",
+                            severity: :error,
+                            spec_clause: "ISO 19005-4 6.4"
+                          )
+                        end
+                        vs.empty? ? nil : vs
+                      }
+                    ))
+      end
+
+      def validate(document)
+        RULESET.validate(document)
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/pdfrb/conformance/pdf_ua2_deep.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+module Pdfrb
+  module Conformance
+    # PDF/UA-2 (ISO 14289-2) deep checks. PDF/UA-2 is rooted in
+    # PDF 2.0 and adds stricter requirements on top of PDF/UA-1:
+    #   * PDF version >= 2.0
+    #   * Structure tree with consistent /RoleMap
+    #   * Heading hierarchy (H1-H6) without skipping levels
+    #   * Every Figure, Formula, Table has /Alt or /ActualText
+    module PdfUA2Deep
+      module_function
+
+      RULESET = RuleSet.new("PDF/UA-2-deep").tap do |rs|
+        rs.register(Rule.new(
+                      id: "ua2-1",
+                      description: "PDF/UA-2 requires PDF 2.0",
+                      severity: :error,
+                      spec_clause: "ISO 14289-2 4.1",
+                      check: ->(doc) {
+                        v = doc.version.to_s
+                        next nil if v >= "2.0"
+
+                        Violation.new(
+                          rule_id: "ua2-1",
+                          message: "PDF/UA-2 requires PDF 2.0 (was #{v})",
+                          object: "Header",
+                          severity: :error,
+                          spec_clause: "ISO 14289-2 4.1"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua2-2",
+                      description: "Heading hierarchy must not skip levels",
+                      severity: :warning,
+                      spec_clause: "ISO 14289-2 7.3",
+                      check: ->(doc) {
+                        vs = []
+                        prev_level = 0
+                        TaggedPdf.walk_structure(doc) do |elem|
+                          s = elem[:S]&.to_s
+                          next unless s&.match?(/\AH([1-6])\z/)
+
+                          level = Regexp.last_match(1).to_i
+                          if level > prev_level + 1 && prev_level.positive?
+                            vs << Violation.new(
+                              rule_id: "ua2-2",
+                              message: "Heading H#{level} jumps from H#{prev_level}",
+                              object: "StructElem/#{s}",
+                              severity: :warning,
+                              spec_clause: "ISO 14289-2 7.3"
+                            )
+                          end
+                          prev_level = level
+                        end
+                        vs.empty? ? nil : vs
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua2-3",
+                      description: "Formula elements require /Alt or /ActualText",
+                      severity: :warning,
+                      spec_clause: "ISO 14289-2 7.9",
+                      check: ->(doc) {
+                        vs = []
+                        TaggedPdf.walk_structure(doc) do |elem|
+                          next unless elem[:S] == :Formula
+                          next if elem[:Alt] || elem[:ActualText]
+
+                          vs << Violation.new(
+                            rule_id: "ua2-3",
+                            message: "Formula without /Alt or /ActualText",
+                            object: "StructElem/Formula",
+                            severity: :warning,
+                            spec_clause: "ISO 14289-2 7.9"
+                          )
+                        end
+                        vs.empty? ? nil : vs
+                      }
+                    ))
+      end
+
+      def validate(document)
+        RULESET.validate(document)
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/pdfrb/conformance/pdf_ua_tagging_deep.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+module Pdfrb
+  module Conformance
+    # PDF/UA-1 deep tagging checks (ISO 14289-1 §7). Extends the
+    # baseline PDF/UA rule set with structural-tree traversal rules:
+    #   * Every /L (list) must contain /LI children
+    #   * Every /LI must contain /LBody
+    #   * Every /Table must contain /TR rows
+    #   * Every /TH and /TD must have /Scope or headers linkage
+    #   * Every /Figure, /Formula, /Table has /Alt or /ActualText
+    module PdfUATaggingDeep
+      module_function
+
+      RULESET = RuleSet.new("PDF/UA-tagging-deep").tap do |rs|
+        rs.register(Rule.new(
+                      id: "tag-deep-1",
+                      description: "List /L must have /LI children",
+                      severity: :warning,
+                      spec_clause: "ISO 14289-1 7.4",
+                      check: ->(doc) {
+                        vs = []
+                        TaggedPdf.walk_structure(doc) do |elem|
+                          next unless elem[:S] == :L
+
+                          kids = TaggedPdf.structure_kids(elem, doc)
+                          has_li = kids.any? { |k| k[:S] == :LI }
+                          next if has_li
+
+                          vs << Violation.new(
+                            rule_id: "tag-deep-1",
+                            message: "/L without /LI child",
+                            object: "StructElem/L",
+                            severity: :warning,
+                            spec_clause: "ISO 14289-1 7.4"
+                          )
+                        end
+                        vs.empty? ? nil : vs
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "tag-deep-2",
+                      description: "/LI must have /LBody",
+                      severity: :warning,
+                      spec_clause: "ISO 14289-1 7.4",
+                      check: ->(doc) {
+                        vs = []
+                        TaggedPdf.walk_structure(doc) do |elem|
+                          next unless elem[:S] == :LI
+
+                          kids = TaggedPdf.structure_kids(elem, doc)
+                          has_body = kids.any? { |k| k[:S] == :LBody }
+                          next if has_body
+
+                          vs << Violation.new(
+                            rule_id: "tag-deep-2",
+                            message: "/LI without /LBody",
+                            object: "StructElem/LI",
+                            severity: :warning,
+                            spec_clause: "ISO 14289-1 7.4"
+                          )
+                        end
+                        vs.empty? ? nil : vs
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "tag-deep-3",
+                      description: "/Table must have /TR rows",
+                      severity: :warning,
+                      spec_clause: "ISO 14289-1 7.5",
+                      check: ->(doc) {
+                        vs = []
+                        TaggedPdf.walk_structure(doc) do |elem|
+                          next unless elem[:S] == :Table
+
+                          kids = TaggedPdf.structure_kids(elem, doc)
+                          has_tr = kids.any? { |k| k[:S] == :TR }
+                          next if has_tr
+
+                          vs << Violation.new(
+                            rule_id: "tag-deep-3",
+                            message: "/Table without /TR child rows",
+                            object: "StructElem/Table",
+                            severity: :warning,
+                            spec_clause: "ISO 14289-1 7.5"
+                          )
+                        end
+                        vs.empty? ? nil : vs
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "tag-deep-4",
+                      description: "/TH cells should declare /Scope",
+                      severity: :warning,
+                      spec_clause: "ISO 14289-1 7.5",
+                      check: ->(doc) {
+                        vs = []
+                        TaggedPdf.walk_structure(doc) do |elem|
+                          next unless elem[:S] == :TH
+                          next if elem[:Scope] || elem[:Headers]
+
+                          vs << Violation.new(
+                            rule_id: "tag-deep-4",
+                            message: "/TH without /Scope or /Headers",
+                            object: "StructElem/TH",
+                            severity: :warning,
+                            spec_clause: "ISO 14289-1 7.5"
+                          )
+                        end
+                        vs.empty? ? nil : vs
+                      }
+                    ))
+      end
+
+      def validate(document)
+        RULESET.validate(document)
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/pdfrb/conformance/pdf_vt.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+module Pdfrb
+  module Conformance
+    # PDF/VT conformance per ISO 16612-2. PDF/VT is the variable
+    # data printing standard for transactional and direct mail
+    # workflows. Two conformance levels:
+    #
+    #   PDF/VT-1: rooted in PDF/X-4 (production-ready print environment)
+    #   PDF/VT-2: rooted in PDF/X-4 but allows external references
+    #
+    # Both levels require:
+    #   * /MarkInfo /Marked true (tagged)
+    #   * /OutputIntents present
+    #   * /DPartRoot dict on the Catalog (Document Part registry)
+    #   * All fonts embedded
+    #   * No encryption
+    module PdfVT
+      module_function
+
+      SHARED = RuleSet.new("PDF/VT-shared").tap do |rs|
+        rs.register(Rule.new(
+                      id: "vt-1",
+                      description: "/MarkInfo /Marked true required",
+                      severity: :error,
+                      spec_clause: "ISO 16612-2 6.2.1",
+                      check: ->(doc) {
+                        mark = doc.catalog[:MarkInfo]
+                        mark = doc.object(mark) if mark.is_a?(Pdfrb::Model::Reference)
+                        next nil if mark && mark[:Marked] == true
+
+                        Violation.new(
+                          rule_id: "vt-1",
+                          message: "PDF/VT requires /MarkInfo /Marked true",
+                          object: "Catalog/MarkInfo",
+                          severity: :error,
+                          spec_clause: "ISO 16612-2 6.2.1"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "vt-2",
+                      description: "OutputIntents required",
+                      severity: :error,
+                      spec_clause: "ISO 16612-2 6.2.2",
+                      check: ->(doc) {
+                        next nil if doc.catalog[:OutputIntents]
+
+                        Violation.new(
+                          rule_id: "vt-2",
+                          message: "PDF/VT requires /OutputIntents",
+                          object: "Catalog/OutputIntents",
+                          severity: :error,
+                          spec_clause: "ISO 16612-2 6.2.2"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "vt-3",
+                      description: "/DPartRoot required for variable data partitioning",
+                      severity: :error,
+                      spec_clause: "ISO 16612-2 6.3",
+                      check: ->(doc) {
+                        next nil if doc.catalog[:DPartRoot]
+
+                        Violation.new(
+                          rule_id: "vt-3",
+                          message: "PDF/VT requires /DPartRoot on Catalog",
+                          object: "Catalog/DPartRoot",
+                          severity: :error,
+                          spec_clause: "ISO 16612-2 6.3"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "vt-4",
+                      description: "Encryption is forbidden",
+                      severity: :error,
+                      spec_clause: "ISO 16612-2 6.2.4",
+                      check: ->(doc) {
+                        next nil unless doc.trailer && doc.trailer[:Encrypt]
+
+                        Violation.new(
+                          rule_id: "vt-4",
+                          message: "PDF/VT prohibits encryption",
+                          object: "Trailer/Encrypt",
+                          severity: :error,
+                          spec_clause: "ISO 16612-2 6.2.4"
+                        )
+                      }
+                    ))
+      end
+
+      VT1 = RuleSet.new("PDF/VT-1").tap do |rs|
+        SHARED.rules.each { |r| rs.register(r) }
+      end
+
+      VT2 = RuleSet.new("PDF/VT-2").tap do |rs|
+        SHARED.rules.each { |r| rs.register(r) }
+        rs.register(Rule.new(
+                      id: "vt2-1",
+                      description: "PDF/VT-2 permits external OutputIntents references",
+                      severity: :warning,
+                      spec_clause: "ISO 16612-2 6.4.2",
+                      check: ->(_doc) {}
+                    ))
+      end
+
+      LEVEL_RULESETS = {
+        vt1: VT1, vt2: VT2
+      }.freeze
+
+      def profiles
+        LEVEL_RULESETS.dup
+      end
+
+      def validate(document, level: :vt1)
+        rs = LEVEL_RULESETS[level] || SHARED
+        rs.validate(document)
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/pdfrb/conformance/pdf_x.rb

@@ -21,7 +21,7 @@ module Pdfrb
       module_function
 
       def profiles
-        { x1a: X1A, x3: X3, x4: X4 }
+        { x1a: X1A, x3: X3, x4: X4, x6: X6 }
       end
 
       def validate(document, level: :x4)
@@ -32,6 +32,7 @@ module Pdfrb
         case level.to_s
         when /\Ax1/i then X1A
         when /\Ax3/i then X3
+        when /\Ax6/i then X6
         else X4
         end
       end
@@ -221,6 +222,70 @@ module Pdfrb
         SHARED.rules.each { |r| rs.register(r) }
       end
 
+      # X-6 specific rules. Defined as lambdas (not module methods)
+      # so they are in scope when X6 is built.
+      X6_VERSION_RULE = Rule.new(
+        id: "x6-1",
+        description: "PDF/X-6 requires PDF 2.0",
+        severity: :error,
+        spec_clause: "ISO 15930-11 6.1",
+        check: ->(doc) {
+          v = doc.version.to_s
+          next nil if compare_versions(v, "2.0") >= 0
+
+          Violation.new(
+            rule_id: "x6-1",
+            message: "PDF/X-6 requires PDF version 2.0 (was #{v})",
+            object: "Header",
+            severity: :error,
+            spec_clause: "ISO 15930-11 6.1"
+          )
+        }
+      )
+
+      X6_OUTPUT_INTENT_RULE = Rule.new(
+        id: "x6-2",
+        description: "PDF/X-6 OutputIntents should use /S /GTS_PDFX",
+        severity: :warning,
+        spec_clause: "ISO 15930-11 6.2.4",
+        check: ->(doc) {
+          intents = doc.catalog[:OutputIntents]
+          intents_array = case intents
+                          when ::Array then intents
+                          when Pdfrb::Model::PdfArray then intents.value
+                          when nil then []
+                          else [intents]
+                          end
+          has_pdfx = intents_array.any? do |i|
+            obj = i.is_a?(Pdfrb::Model::Reference) ? doc.object(i) : i
+            obj && obj[:S] == :GTS_PDFX
+          end
+          next nil if has_pdfx
+
+          Violation.new(
+            rule_id: "x6-2",
+            message: "PDF/X-6 OutputIntents should include an entry with /S /GTS_PDFX",
+            object: "Catalog/OutputIntents",
+            severity: :warning,
+            spec_clause: "ISO 15930-11 6.2.4"
+          )
+        }
+      )
+
+      # X-6: ISO 15930-11 — PDF 2.0 based. Adds the PDF 2.0 base
+      # version requirement and PDF/X-4's relaxed rules.
+      X6 = RuleSet.new("PDF/X-6").tap do |rs|
+        SHARED.rules.each { |r| rs.register(r) }
+        rs.register(X6_VERSION_RULE)
+        rs.register(X6_OUTPUT_INTENT_RULE)
+      end
+
+      def compare_versions(a, b)
+        aa = a.to_s.split(".").map(&:to_i)
+        bb = b.to_s.split(".").map(&:to_i)
+        (aa <=> bb) || 0
+      end
+
       def scan_color_spaces(doc, &block)
         doc.each_indirect_object do |obj|
           next unless obj.is_a?(Pdfrb::Model::Cos::Dictionary)