pdfrb 0.2.1 → 0.6.0

data/lib/pdfrb/conformance/pdf_ua.rb

@@ -1,46 +1,203 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/BlockLength
 module Pdfrb
   module Conformance
-    # PDF/UA-1 validation (ISO 14289). Checks tagged PDF, reading
-    # order, alt text, etc. Per Tech Note 001, /ActualText required
-    # for /Figure elements; per Tech Note 002, /Reference elements
-    # must wrap link annotations.
     module PdfUA
-      Result = Struct.new(:passed, :violations, keyword_init: true)
-      Violation = Struct.new(:rule, :message, :object, keyword_init: true)
-
       module_function
 
+      RULESET = RuleSet.new("PDF/UA-1").tap do |rs|
+        rs.register(Rule.new(
+                      id: "ua-1",
+                      description: "StructTreeRoot required",
+                      severity: :error,
+                      spec_clause: "ISO 14289-1 7.1",
+                      check: ->(doc) {
+                        next nil if doc.catalog[:StructTreeRoot]
+
+                        Violation.new(
+                          rule_id: "ua-1",
+                          message: "PDF/UA requires /Catalog/StructTreeRoot",
+                          object: "Catalog",
+                          severity: :error,
+                          spec_clause: "ISO 14289-1 7.1"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua-2",
+                      description: "MarkInfo /Marked true required",
+                      severity: :error,
+                      spec_clause: "ISO 14289-1 7.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: "ua-2",
+                          message: "PDF/UA requires /MarkInfo /Marked true",
+                          object: "Catalog",
+                          severity: :error,
+                          spec_clause: "ISO 14289-1 7.1"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua-3",
+                      description: "Document language required",
+                      severity: :error,
+                      spec_clause: "ISO 14289-1 7.1",
+                      check: ->(doc) {
+                        next nil if doc.catalog[:Lang]
+
+                        Violation.new(
+                          rule_id: "ua-3",
+                          message: "PDF/UA requires /Catalog/Lang",
+                          object: "Catalog",
+                          severity: :error,
+                          spec_clause: "ISO 14289-1 7.1"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua-4",
+                      description: "Reader requirements",
+                      severity: :warning,
+                      spec_clause: "ISO 14289-1 5",
+                      check: ->(_doc) {}
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua-5",
+                      description: "Figures require Alt text",
+                      severity: :error,
+                      spec_clause: "ISO 14289-1 7.1",
+                      check: ->(doc) {
+                        violations = []
+                        walk_structure(doc) do |elem|
+                          next unless elem[:S] == :Figure
+                          next if elem[:Alt] || elem[:ActualText]
+
+                          violations << Violation.new(
+                            rule_id: "ua-5",
+                            message: "Figure without Alt or ActualText",
+                            object: "StructElem/Figure",
+                            severity: :error,
+                            spec_clause: "ISO 14289-1 7.1"
+                          )
+                        end
+                        violations.empty? ? nil : violations
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua-6",
+                      description: "Heading levels must not skip",
+                      severity: :error,
+                      spec_clause: "ISO 14289-1 7.1",
+                      check: ->(doc) {
+                        headings = []
+                        walk_structure(doc) do |elem|
+                          s = elem[:S]
+                          next unless s&.to_s&.start_with?("H")
+
+                          level = s.to_s[/H(\d+)/, 1]&.to_i
+                          headings << level if level
+                        end
+
+                        prev = nil
+                        headings.each do |level|
+                          if prev && level > prev + 1
+                            return Violation.new(
+                              rule_id: "ua-6",
+                              message: "Heading H#{level} skips from H#{prev}",
+                              object: "StructElem/H#{level}",
+                              severity: :error,
+                              spec_clause: "ISO 14289-1 7.1"
+                            )
+                          end
+                          prev = level
+                        end
+                        nil
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua-7",
+                      description: "Tables should have headers",
+                      severity: :warning,
+                      spec_clause: "ISO 14289-1 7.2",
+                      check: ->(_doc) {}
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua-8",
+                      description: "Lists should have Lbl entries",
+                      severity: :warning,
+                      spec_clause: "ISO 14289-1 7.3",
+                      check: ->(_doc) {}
+                    ))
+        rs.register(Rule.new(
+                      id: "ua-9",
+                      description: "Non-standard structure types need role mapping",
+                      severity: :error,
+                      spec_clause: "ISO 14289-1 7.1",
+                      check: ->(doc) { StructureElements.validate(doc).violations.find { |v| v.rule_id == "ua-9" } }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua-10",
+                      description: "List elements must contain LI children",
+                      severity: :error,
+                      spec_clause: "ISO 14289-1 7.2",
+                      check: ->(doc) { StructureElements.validate(doc).violations.find { |v| v.rule_id == "ua-10" } }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ua-11",
+                      description: "Table elements must contain TR children",
+                      severity: :error,
+                      spec_clause: "ISO 14289-1 7.2",
+                      check: ->(doc) { StructureElements.validate(doc).violations.find { |v| v.rule_id == "ua-11" } }
+                    ))
+      end
+
       def validate(document)
-        violations = []
-        check_has_struct_tree(document, violations)
-        check_tagged(document, violations)
-        Result.new(passed: violations.empty?, violations: violations)
+        RULESET.validate(document)
       end
 
-      def check_has_struct_tree(document, violations)
-        return if document.catalog[:StructTreeRoot]
+      def walk_structure(document)
+        root_ref = document.catalog[:StructTreeRoot]
+        return unless root_ref
 
-        violations << Violation.new(
-          rule: "struct-tree-required",
-          message: "PDF/UA requires /Catalog/StructTreeRoot",
-          object: "Catalog"
-        )
-      end
-      private_class_method :check_has_struct_tree
+        root = if root_ref.is_a?(Pdfrb::Model::Reference)
+                 document.object(root_ref)
+               else
+                 root_ref
+               end
+        return unless root
 
-      def check_tagged(document, violations)
-        mark = document.catalog[:MarkInfo]
-        return if mark && mark[:Marked] == true
+        children = root[:K]
+        return unless children
 
-        violations << Violation.new(
-          rule: "marked-required",
-          message: "PDF/UA requires /MarkInfo /Marked true",
-          object: "Catalog"
-        )
+        children = Array(children) unless children.is_a?(::Array)
+        children.each do |child_ref|
+          elem = if child_ref.is_a?(Pdfrb::Model::Reference)
+                   document.object(child_ref)
+                 else
+                   child_ref
+                 end
+          next unless elem
+
+          yield elem
+        end
       end
-      private_class_method :check_tagged
     end
   end
 end
+
+# rubocop:enable Metrics/BlockLength

data/lib/pdfrb/conformance/pdf_x.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Conformance
+    # PDF/X conformance profiles (ISO 15930). PDF/X is the graphic arts
+    # exchange standard for print production. Key constraints:
+    #
+    #   PDF/X-1a (ISO 15930-1): CMYK + spot only, no RGB, no live ICC
+    #   PDF/X-3  (ISO 15930-3): allows calibrated RGB and Lab
+    #   PDF/X-4  (ISO 15930-7): allows transparency and layers
+    #   PDF/X-6  (ISO 15930-11): PDF 2.0 based
+    #
+    # Shared requirements across all X profiles:
+    #   * Output intent required (/OutputIntents with /GTS_PDFX)
+    #   * BleedBox and TrimBox required
+    #   * All fonts embedded
+    #   * No encryption
+    #   * No actions (/AA), no JavaScript
+    #   * /Trapped key present (True/False/Unknown)
+    module PdfX
+      module_function
+
+      def profiles
+        { x1a: X1A, x3: X3, x4: X4 }
+      end
+
+      def validate(document, level: :x4)
+        rule_set_for(level).validate(document)
+      end
+
+      def rule_set_for(level)
+        case level.to_s
+        when /\Ax1/i then X1A
+        when /\Ax3/i then X3
+        else X4
+        end
+      end
+
+      SHARED = RuleSet.new("PDF/X-shared").tap do |rs| # rubocop:disable Metrics/BlockLength
+        rs.register(Rule.new(
+                      id: "px-1",
+                      description: "Output intent required",
+                      severity: :error,
+                      spec_clause: "ISO 15930 §6.1",
+                      check: ->(doc) {
+                        next nil if has_pdfx_output_intent?(doc)
+
+                        Violation.new(rule_id: "px-1",
+                                      message: "PDF/X requires a /GTS_PDFX output intent",
+                                      object: "Catalog", severity: :error,
+                                      spec_clause: "ISO 15930 §6.1")
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "px-2",
+                      description: "TrimBox or ArtBox required on every page",
+                      severity: :error,
+                      spec_clause: "ISO 15930 §6.2.3",
+                      check: ->(doc) {
+                        violations = []
+                        doc.pages.each do |page|
+                          next if page.value[:TrimBox] || page.value[:ArtBox]
+
+                          violations << Violation.new(
+                            rule_id: "px-2",
+                            message: "Page missing /TrimBox (required for PDF/X)",
+                            object: page.oid, severity: :error,
+                            spec_clause: "ISO 15930 §6.2.3"
+                          )
+                        end
+                        violations.empty? ? nil : violations
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "px-3",
+                      description: "All fonts must be embedded",
+                      severity: :error,
+                      spec_clause: "ISO 15930 §6.3",
+                      check: ->(doc) {
+                        violations = []
+                        doc.pages.each do |page|
+                          resources = page.value[:Resources]
+                          next unless resources
+
+                          fonts = if resources.is_a?(Pdfrb::Model::Cos::Dictionary)
+                                    resources.value[:Font]
+                                  else
+                                    resources[:Font]
+                                  end
+                          next unless fonts
+
+                          fonts_hash = fonts.is_a?(Pdfrb::Model::Cos::Dictionary) ? fonts.value : fonts
+                          fonts_hash&.each_value do |ref|
+                            font = ref.is_a?(Pdfrb::Model::Reference) ? doc.object(ref) : ref
+                            next unless font
+
+                            fd = font[:FontDescriptor]
+                            next if fd
+
+                            violations << Violation.new(
+                              rule_id: "px-3",
+                              message: "Font /#{font[:BaseFont]} not embedded",
+                              object: font[:BaseFont], severity: :error,
+                              spec_clause: "ISO 15930 §6.3"
+                            )
+                          end
+                        end
+                        violations.empty? ? nil : violations
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "px-4",
+                      description: "Encryption prohibited",
+                      severity: :error,
+                      spec_clause: "ISO 15930 §6.1.3",
+                      check: ->(doc) {
+                        next nil unless doc.trailer && doc.trailer[:Encrypt]
+
+                        Violation.new(rule_id: "px-4",
+                                      message: "PDF/X prohibits encryption",
+                                      object: "trailer", severity: :error,
+                                      spec_clause: "ISO 15930 §6.1.3")
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "px-5",
+                      description: "/Trapped key required",
+                      severity: :error,
+                      spec_clause: "ISO 15930 §6.1.6",
+                      check: ->(doc) {
+                        info = PdfX.info_dict(doc)
+                        next nil if info && info[:Trapped]
+
+                        Violation.new(rule_id: "px-5",
+                                      message: "Document Info /Trapped key required (True, False, or Unknown)",
+                                      object: "Info", severity: :error,
+                                      spec_clause: "ISO 15930 §6.1.6")
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "px-6",
+                      description: "No JavaScript or form actions",
+                      severity: :error,
+                      spec_clause: "ISO 15930 §6.5",
+                      check: ->(doc) {
+                        violations = []
+                        doc.each_indirect_object do |obj|
+                          next unless obj.is_a?(Pdfrb::Model::Cos::Dictionary)
+
+                          s = obj[:S]
+                          next unless [:JavaScript, :JS, :Launch, :URI].include?(s)
+
+                          violations << Violation.new(
+                            rule_id: "px-6",
+                            message: "Action /#{s} prohibited in PDF/X",
+                            object: obj.oid, severity: :error,
+                            spec_clause: "ISO 15930 §6.5"
+                          )
+                        end
+                        violations.empty? ? nil : violations
+                      }
+                    ))
+      end
+
+      def has_pdfx_output_intent?(doc)
+        intents = doc.catalog.value[:OutputIntents]
+        return false unless intents
+
+        intents = [intents] unless intents.is_a?(::Array)
+        intents.any? do |ref|
+          obj = ref.is_a?(Pdfrb::Model::Reference) ? doc.object(ref) : ref
+          obj && obj.value[:S] == :GTS_PDFX
+        end
+      end
+
+      def info_dict(doc)
+        info_ref = doc.trailer && doc.trailer[:Info]
+        return nil unless info_ref
+
+        doc.object(info_ref)
+      end
+
+      # X-1a: strictest — CMYK + spot only
+      X1A = RuleSet.new("PDF/X-1a").tap do |rs|
+        SHARED.rules.each { |r| rs.register(r) }
+        rs.register(Rule.new(
+                      id: "x1a-1",
+                      description: "PDF/X-1a: no RGB or Lab color spaces",
+                      severity: :error,
+                      spec_clause: "ISO 15930-1 §6.3.8",
+                      check: ->(doc) {
+                        violations = []
+                        scan_color_spaces(doc) do |cs, oid|
+                          case cs.to_s
+                          when "DeviceRGB", "CalRGB", "CalGray", "Lab"
+                            violations << Violation.new(
+                              rule_id: "x1a-1",
+                              message: "PDF/X-1a prohibits #{cs} color space",
+                              object: oid, severity: :error,
+                              spec_clause: "ISO 15930-1 §6.3.8"
+                            )
+                          end
+                        end
+                        violations.empty? ? nil : violations
+                      }
+                    ))
+      end
+
+      # X-3: allows calibrated RGB and Lab
+      X3 = RuleSet.new("PDF/X-3").tap do |rs|
+        SHARED.rules.each { |r| rs.register(r) }
+      end
+
+      # X-4: allows transparency and layers
+      X4 = RuleSet.new("PDF/X-4").tap do |rs|
+        SHARED.rules.each { |r| rs.register(r) }
+      end
+
+      def scan_color_spaces(doc, &block)
+        doc.each_indirect_object do |obj|
+          next unless obj.is_a?(Pdfrb::Model::Cos::Dictionary)
+
+          cs = obj.value[:ColorSpace]
+          next unless cs
+
+          yield_color_space(cs, obj.oid, &block)
+        end
+      end
+
+      def yield_color_space(cs, oid, &block)
+        case cs
+        when ::Symbol then yield cs, oid
+        when ::Array
+          cs.each { |e| yield_color_space(e, oid, &block) }
+        when ::Hash
+          cs.each_value { |v| yield_color_space(v, oid, &block) }
+        end
+      end
+      private_class_method :yield_color_space
+    end
+  end
+end

data/lib/pdfrb/conformance/rule.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Conformance
+    # A single validation check. Each rule is self-contained: given a
+    # document, it returns zero or more Violations. Rules are
+    # registered into a RuleSet; adding a new check = defining a new
+    # Rule + registering it (no switch to edit — OCP).
+    Rule = Struct.new(:id, :description, :severity, :spec_clause, :check, keyword_init: true) do
+      def evaluate(document)
+        result = check.call(document)
+        return [] unless result
+
+        result.is_a?(::Array) ? result : [result]
+      end
+    end
+
+    # A rule violation found during validation.
+    Violation = Struct.new(:rule_id, :message, :object, :severity, :spec_clause,
+                           keyword_init: true) do
+      def error? = severity == :error
+      def warning? = severity == :warning
+    end
+
+    # Aggregated validation output. Knows whether the document
+    # passes (no errors) and can filter by severity.
+    ValidationResult = Struct.new(:profile, :violations, keyword_init: true) do
+      def passed? = errors.empty?
+
+      def errors = violations.select(&:error?)
+
+      def warnings = violations.select(&:warning?)
+
+      def infos = violations.reject { |v| v.error? || v.warning? }
+
+      def violation_count = violations.length
+    end
+
+    # A named collection of rules. Rules are added via #register
+    # and evaluated via #validate. Open for extension (new rules =
+    # register, no code edits), closed for modification.
+    class RuleSet
+      attr_reader :name, :rules
+
+      def initialize(name)
+        @name = name
+        @rules = []
+      end
+
+      def register(rule)
+        @rules << rule
+        self
+      end
+
+      def validate(document)
+        violations = @rules.flat_map do |rule|
+          rule.evaluate(document).map do |v|
+            ensure_violation(v, rule)
+          end
+        end
+        ValidationResult.new(profile: @name, violations: violations)
+      end
+
+      private
+
+      def ensure_violation(value, rule)
+        return value if value.is_a?(Violation)
+
+        Violation.new(
+          rule_id: rule.id,
+          message: value.to_s,
+          severity: rule.severity,
+          spec_clause: rule.spec_clause
+        )
+      end
+    end
+  end
+end