pdfrb 0.7.49 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94341614760eda37ab21d465f8363342d2e3129690b17264fbed0b8aef514058
-  data.tar.gz: 35d8e757ffa1098d5c1fa1122aa7e5cba573f9c708d5c56c73642c5e5719f55f
+  metadata.gz: 337b6b4b76c09f00902c8ef033eca2750dab1ca917693afd8eac09fe97e9c954
+  data.tar.gz: 9c6ff7acc3ee63cb5b680eba8b9f7469c7421cf19b514391f461de228b6eaec2
 SHA512:
-  metadata.gz: 155b88f7e6c82de7e4cf00d16027a073d7fd6a504ceac0e88c5ea07675524b403806bfa9bc4c54de070724e30ffd4585954c4bcf464e02551dc820d717a0122f
-  data.tar.gz: 0cef9fb85098dcccf6213ecfde992946888729fd82ea758b668ae744bfc42638f004b7cdc615099f66cdbb752f9bf41b89bffebc1128544efa16209b6fc31902
+  metadata.gz: b8038696cccb6196ede83f12111f0c32af4171d6200047b92e0f7fea97a9ebf86c73ee428ad6943b7512cab3306fc23802115c3f19201a2d73f68de6f52c76d0
+  data.tar.gz: de8f2bd6aff02c082a1b4c204d317d5544defcc1c50f4f6cbfe604e5f4f6a5d2e854b299d7b921cb3f13a599a1df52491ba4d8e6b8a379dabe6d8d40cc7192de

data/Rakefile

@@ -9,6 +9,36 @@ RuboCop::RakeTask.new
 
 task default: %i[spec rubocop]
 
+desc "Cross-check PDF/A output against veraPDF (needs verapdf on PATH)"
+task :verapdf do
+  require "pdfrb"
+  require "stringio"
+  check = Pdfrb::Task::VeraPdfCrossCheck
+  abort "verapdf not found on PATH (brew install verapdf)" unless check.available?
+
+  font = [
+    "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+    "/System/Library/Fonts/Supplemental/Arial.ttf",
+  ].find { |path| File.file?(path) }
+  abort "no system TTF found" unless font
+
+  doc = Pdfrb::Document.new
+  doc.enable_pdf_a!(part: 2, conformance: "B")
+  font_obj = doc.fonts.add(font)
+  doc.pages.add.canvas.text("veraPDF cross-check", at: [72, 720],
+                                                   font: font_obj, size: 24)
+  io = StringIO.new
+  doc.write(io: io)
+
+  result = check.call(io.string, flavour: :a2b)
+  puts "profile:    #{result.profile}"
+  puts "checks:     #{result.passed_checks} passed, #{result.failed_checks} failed"
+  puts "size:       #{io.string.bytesize} bytes"
+  result.failures.each { |f| puts "  #{f.clause}: #{f.message}" }
+  abort "NOT PDF/A-2b COMPLIANT" unless result.compliant?
+  puts "PDF/A-2b COMPLIANT"
+end
+
 namespace :arlington do
   desc "Re-vendor the Arlington TSVs from ~/src/pdfa/arlington-pdf-model/tsv/latest"
   task :refresh do

data/lib/pdfrb/document/fonts.rb

@@ -44,8 +44,15 @@ module Pdfrb
           @pending_io_data = nil
         end
         @pending_subtype = nil
-        if @afm_metrics[resource] && font_dict&.value&.[](:Widths)
-          font_dict.value[:Widths] = @afm_metrics[resource][:widths]
+        metrics = @afm_metrics[resource]
+        if metrics && font_dict&.value&.[](:Widths)
+          # /Widths live in the 1000-unit glyph space (s9.2.4); TTF
+          # hmtx advances are in unitsPerEm units, so scale. AFM
+          # metrics already carry 1000-unit widths (upem defaults to
+          # 1000 there, making this a no-op for standard fonts).
+          scale = 1000.0 / (metrics[:units_per_em] || 1000)
+          font_dict.value[:Widths] =
+            metrics[:widths].map { |w| (w * scale).round }
         end
         @registry[name] = resource
         resource
@@ -490,8 +497,8 @@ module Pdfrb
             [Pdfrb::Font::CFF::Subsetter.subset_otf(data, gids), :FontFile3]
           else
             ttf = Pdfrb::Font::TrueType::File.new(data)
-            subsetter = Pdfrb::Font::TrueType::Subsetter.new(ttf)
-            [subsetter.subset(codepoints.to_a), :FontFile2]
+            subsetter = Pdfrb::Font::TrueType::Subsetter.new(ttf, codepoints.to_a)
+            [subsetter.subset, :FontFile2]
           end
         dict = @font_dicts[resource]
         return unless dict
@@ -502,13 +509,20 @@ module Pdfrb
         desc = desc_ref.is_a?(Pdfrb::Model::Reference) ? document.object(desc_ref) : desc_ref
         return unless desc
 
-        fd_stream = document.add({ Length: subset.bytesize }, type: Pdfrb::Model::Cos::Stream)
-        fd_stream.stream = subset
-        if font_file_key == :FontFile3
-          fd_stream.value[:Subtype] = :OpenType
-          fd_stream.value[:Length1] = subset.bytesize
+        # Reuse the add-time stream object in place rather than
+        # allocating a replacement — a second stream would leave the
+        # full original orphaned in the file (doubling output size).
+        fd_stream = desc.value[font_file_key]
+        fd_stream = document.object(fd_stream) if fd_stream.is_a?(Pdfrb::Model::Reference)
+        if fd_stream.is_a?(Pdfrb::Model::Cos::Stream)
+          fd_stream.stream = subset
+          fd_stream.value[:Length] = subset.bytesize
+          fd_stream.value.delete(:Filter)
+          if font_file_key == :FontFile3
+            fd_stream.value[:Subtype] = :OpenType
+            fd_stream.value[:Length1] = subset.bytesize
+          end
         end
-        desc.value[font_file_key] = Pdfrb::Model::Reference.new(fd_stream.oid, fd_stream.gen)
       end
 
       # Fonts attach to the page-tree ROOT's /Resources so every page

data/lib/pdfrb/document/pdf_a.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class Document
+    # PDF/A production helper (ISO 19005-2). Installs the three
+    # things a conforming file must carry that a generic document
+    # does not:
+    #
+    #   * a GTS_PDFA1 OutputIntent with an embedded sRGB ICC
+    #     profile (DeviceGray/RGB rendering legitimacy),
+    #   * an XMP metadata stream carrying the pdfaid identification
+    #     (part + conformance) on the Catalog,
+    #   * a document Title so the XMP synchronises on write.
+    #
+    # Fonts must be EMBEDDED separately (fonts.add with a file path);
+    # the standard-14 names alone do not satisfy 6.2.11.4.1.
+    module PdfA
+      SRGB_IDENTIFIER = "sRGB IEC61966-2.1"
+      SRGB_REGISTRY = "http://www.color.org"
+
+      # @param part [Integer] 1, 2, 3, or 4.
+      # @param conformance [String] "B" (basic), "A", or "U".
+      def enable_pdf_a!(part: 2, conformance: "B")
+        self.version = part == 4 ? "2.0" : "1.7"
+
+        srgb_output_intent
+        metadata[:Title] ||= "Untitled"
+        packet = xmp || Pdfrb::XMP::Packet.new
+        packet.pdfa_id = { part: part, conformance: conformance }
+        @xmp = packet
+        @pdfa_part = part
+        @pdfa_conformance = conformance
+        self
+      end
+
+      def pdfa_part; @pdfa_part; end
+      def pdfa_conformance; @pdfa_conformance; end
+
+      private
+
+      def srgb_output_intent
+        catalog = self.catalog
+        intents = catalog.value[:OutputIntents]
+        return if intents
+
+        bytes = Pdfrb::Color::DefaultProfile.srgb_bytes
+        icc = add({ N: 3, Length: bytes.bytesize },
+                  type: Pdfrb::Model::Cos::Stream)
+        icc.stream = bytes
+        output_intents.add(
+          Pdfrb::Model::Reference.new(icc.oid, icc.gen),
+          identifier: SRGB_IDENTIFIER,
+          condition: "sRGB IEC61966-2.1",
+          registry: SRGB_REGISTRY,
+          subtype: :GTS_PDFA1
+        )
+      end
+    end
+  end
+end

data/lib/pdfrb/document.rb

@@ -21,6 +21,9 @@ module Pdfrb
     autoload :AssociatedFiles, "pdfrb/document/associated_files"
     autoload :Colors, "pdfrb/document/colors"
     autoload :Display, "pdfrb/document/display"
+    autoload :PdfA, "pdfrb/document/pdf_a"
+    include PdfA
+
     autoload :Form, "pdfrb/document/form"
     autoload :GraphicsState, "pdfrb/document/graphics_state"
     autoload :Layers, "pdfrb/document/layers"

data/lib/pdfrb/font/true_type/subsetter.rb

@@ -18,10 +18,13 @@ module Pdfrb
         attr_reader :ttf, :glyph_ids
 
         # @param ttf [Pdfrb::Font::TrueType::File] parsed TTF source.
-        # @param glyph_ids [Array<Integer>] used glyph IDs.
-        def initialize(ttf, glyph_ids)
+        # @param codepoints [Array<Integer>] used Unicode codepoints;
+        #   glyph IDs are resolved via the font's cmap.
+        def initialize(ttf, codepoints)
           @ttf = ttf
-          @glyph_ids = ([NOTDEF_GID] + glyph_ids).sort.uniq
+          @codepoint_gids = codepoints.map { |cp| [cp, ttf.cmap.glyph_id_for(cp)] }
+            .reject { |_cp, gid| gid.nil? || gid.zero? }
+          @glyph_ids = ([NOTDEF_GID] + @codepoint_gids.map(&:last)).sort.uniq
         end
 
         # Returns the subset font bytes.
@@ -104,7 +107,8 @@ module Pdfrb
         end
 
         def loca_format
-          head_table.long_loca? ? :long : :short
+          # head_table is the raw bytes; parse for indexToLocFormat.
+          @ttf.head.long_loca? ? :long : :short
         end
 
         # Get byte range [start, end) for a glyph in the glyf table.
@@ -167,7 +171,7 @@ module Pdfrb
             pad_to_even(data)
           end
           @glyf_end = data.bytesize
-          data.force_encoding(Encoding::BINARY)
+          data.force_encoding(::Encoding::BINARY)
         end
 
         def composite?(glyph_data)
@@ -214,55 +218,48 @@ module Pdfrb
           else
             offsets.each { |o| data << [o / 2].pack("n") }
           end
-          data.force_encoding(Encoding::BINARY)
+          data.force_encoding(::Encoding::BINARY)
         end
 
         def build_cmap
-          # Build a simple format 4 cmap with used codepoints.
-          # Map Unicode → new glyph IDs.
-          pairs = {}
-          @resolved.each do |old_gid|
-            glyph_map[old_gid]
-            # We don't have a reverse cmap (gid → unicode); skip for now.
-            # A real impl would use the original cmap to build this.
+          # One segment per kept codepoint (idDelta maps code to the
+          # remapped gid), plus the mandatory 0xFFFF terminator.
+          pairs = @codepoint_gids.map do |cp, old_gid|
+            [cp, glyph_map[old_gid]]
+          end.sort
+
+          segments = pairs.map do |cp, new_gid|
+            [cp, cp, ((new_gid - cp) & 0xFFFF)]
           end
+          segments << [0xFFFF, 0xFFFF, 1]
 
-          # Emit a minimal format 4 cmap with just .notdef.
-          build_format4_cmap(pairs)
-        end
-
-        def build_format4_cmap(_mapping)
-          1
-          search_range = 2
-          entry_selector = 0
-          range_shift = 0
-
-          buf = +""
-          buf << [0].pack("n")       # format 0 placeholder; we'll emit format 4
+          seg_count = segments.length
           buf = +""
-          buf << [4, 0].pack("nn")   # format=4, length placeholder
+          buf << [4, 0].pack("nn") # format=4, length placeholder
           buf << [0].pack("n") # language
-          seg_count = 1
-          buf << [seg_count * 2].pack("n") # segCountX2
-          buf << [search_range].pack("n")
-          buf << [entry_selector].pack("n")
-          buf << [range_shift].pack("n")
-          buf << [0xFFFF].pack("n")   # endCode
-          buf << [0].pack("n")        # reservedPad
-          buf << [0xFFFF].pack("n")   # startCode
-          buf << [0].pack("n")        # idDelta
-          buf << [0].pack("n")        # idRangeOffset
-
-          length = buf.bytesize
-          buf[2, 2] = [length].pack("n")
-
-          # Wrap in cmap table structure
+          buf << [seg_count * 2].pack("n")
+          search_range = (2**Math.log2(seg_count).floor) * 2
+          entry_selector = Math.log2(search_range / 2).to_i
+          range_shift = (seg_count * 2) - search_range
+          buf << [search_range, entry_selector, range_shift].pack("nnn")
+          zero = [0].pack("n")
+          segments.each { |end_c, _, _| buf << [end_c].pack("n") }
+          buf << zero # reservedPad
+          segments.each { |_, start_c, _| buf << [start_c].pack("n") }
+          # idDelta first pass then idRangeOffset zeros: format 4
+          # requires the four arrays in sequence, so delta and offset
+          # loops cannot merge with the startCode loop.
+          # rubocop:disable Style/CombinableLoops
+          segments.each { |_, _, delta| buf << [delta].pack("n") }
+          segments.each { buf << zero } # idRangeOffset: delta only
+          # rubocop:enable Style/CombinableLoops
+
+          buf[2, 2] = [buf.bytesize].pack("n")
+
           cmap = +""
-          cmap << [0, 1, 1].pack("nnn") # version, numTables, platform=1
-          cmap << [0].pack("n") # encoding=0
-          cmap << [12].pack("N") # offset to subtable
+          cmap << [0, 1, 3, 1, 12].pack("nnnnN") # version, 1 table, (3,1) Unicode BMP
           cmap << buf
-          cmap.force_encoding(Encoding::BINARY)
+          cmap.force_encoding(::Encoding::BINARY)
         end
 
         def build_hmtx
@@ -272,7 +269,7 @@ module Pdfrb
             lsb = @ttf.hmtx.lsb(old_gid)
             buf << [advance, lsb].pack("nn")
           end
-          buf.force_encoding(Encoding::BINARY)
+          buf.force_encoding(::Encoding::BINARY)
         end
 
         def build_maxp
@@ -364,7 +361,7 @@ module Pdfrb
             end
           end
 
-          out.force_encoding(Encoding::BINARY)
+          out.force_encoding(::Encoding::BINARY)
         end
 
         # rubocop:disable Naming/MethodName

data/lib/pdfrb/font/true_type.rb

@@ -16,6 +16,7 @@ module Pdfrb
       autoload :Glyf, "pdfrb/font/true_type/glyf"
       autoload :Kern, "pdfrb/font/true_type/kern"
       autoload :Wrapper, "pdfrb/font/true_type/wrapper"
+      autoload :Subsetter, "pdfrb/font/true_type/subsetter"
     end
   end
 end

data/lib/pdfrb/task/vera_pdf_cross_check.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "stringio"
+
+module Pdfrb
+  module Task
+    # Cross-check pdfrb's PDF/A output against the veraPDF validator
+    # (the reference implementation for ISO 19005 conformance).
+    #
+    # Runs the +verapdf+ binary over a PDF file and parses the XML
+    # report. The binary path is configurable via VERAPDF_BIN or the
+    # +binary:+ argument for CI environments that download a release.
+    module VeraPdfCrossCheck
+      Result = Struct.new(
+        :compliant, :passed_rules, :failed_rules,
+        :passed_checks, :failed_checks, :failures, :raw, :profile
+      ) do
+        def compliant?
+          compliant == true
+        end
+
+        def failure_messages
+          failures.map(&:message)
+        end
+      end
+
+      Failure = Struct.new(:clause, :description, :message, :context)
+
+      FLAVOURS = {
+        a1b: "1b", a1a: "1a", a2b: "2b", a2a: "2a", a2u: "2u",
+        a3b: "3b", a3a: "3a", a3u: "3u", a4b: "4b", a4f: "4f",
+        a4e: "4e", u1a: "ua1", u2a: "ua2", u3a: "ua3"
+      }.freeze
+
+      module_function
+
+      # @param pdf [String, #read] path to a PDF file, or IO/bytes.
+      # @param flavour [Symbol, String] veraPDF flavour key (:a2b) or
+      #   raw code ("2b").
+      # @param binary [String] verapdf executable path.
+      # @return [Result]
+      def call(pdf, flavour: :a2b, binary: ENV.fetch("VERAPDF_BIN", "verapdf"))
+        flavour_code = FLAVOURS.fetch(flavour.to_sym, flavour.to_s)
+        path, tempdir = materialise(pdf)
+        out, err, status = Open3.capture3(binary, "--flavour", flavour_code, path)
+
+        report = parse_report(out) if status.success? || out.include?("<report")
+        report || raise(Pdfrb::Error,
+                        "verapdf failed (#{status.exitstatus}): #{err[0, 200]}")
+      ensure
+        FileUtils.remove_entry(tempdir) if tempdir
+      end
+
+      # True when the verapdf binary is available.
+      def available?(binary: ENV.fetch("VERAPDF_BIN", "verapdf"))
+        _out, _err, status = Open3.capture3(binary, "--version")
+        status.success?
+      rescue Errno::ENOENT
+        false
+      end
+
+      def parse_report(xml)
+        require "rexml/document"
+        doc = REXML::Document.new(xml)
+
+        validation = REXML::XPath.first(doc, "//validationReport")
+        details = REXML::XPath.first(doc, "//validationReport/details")
+        result = Result.new(
+          validation&.[]("isCompliant") == "true",
+          details&.[]("passedRules").to_i,
+          details&.[]("failedRules").to_i,
+          details&.[]("passedChecks").to_i,
+          details&.[]("failedChecks").to_i,
+          [], xml, validation&.[]("profileName").to_s
+        )
+
+        REXML::XPath.each(doc, "//rule[@status='failed']") do |rule|
+          description = rule.elements["description"]&.text.to_s.strip
+          clause = "#{rule.attributes['specification']} " \
+                   "cl.#{rule.attributes['clause']}.#{rule.attributes['testNumber']}"
+          REXML::XPath.each(rule, ".//check[@status='failed']") do |check|
+            result.failures << Failure.new(
+              clause, description,
+              check.elements["errorMessage"]&.text.to_s.strip,
+              check.elements["context"]&.text.to_s.strip
+            )
+          end
+        end
+        result
+      end
+
+      # Returns [path, tempdir-or-nil]; the caller removes tempdir.
+      def materialise(pdf)
+        if pdf.is_a?(String) && !pdf.include?("\0") && File.file?(pdf)
+          return [pdf, nil]
+        end
+
+        bytes = pdf.is_a?(String) ? pdf : pdf.read
+        require "tmpdir"
+        tempdir = Dir.mktmpdir("verapdf")
+        path = File.join(tempdir, "check.pdf")
+        File.binwrite(path, bytes)
+        [path, tempdir]
+      end
+    end
+  end
+end

data/lib/pdfrb/task.rb

@@ -11,5 +11,6 @@ module Pdfrb
     autoload :MemoryProfile, "pdfrb/task/memory_profile"
     autoload :RegenerateAppearances, "pdfrb/task/regenerate_appearances"
     autoload :Thumbnail, "pdfrb/task/thumbnail"
+    autoload :VeraPdfCrossCheck, "pdfrb/task/vera_pdf_cross_check"
   end
 end

data/lib/pdfrb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pdfrb
-  VERSION = "0.7.49"
+  VERSION = "0.8.0"
 end

data/lib/pdfrb/writer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "digest"
 require "zlib"
 
 module Pdfrb
@@ -317,6 +318,42 @@ module Pdfrb
     def dispatch_before_write
       document.dispatch_message(:before_write)
       compress_content_streams if document.config["writer.compress_streams"]
+      normalize_page_resources
+      seed_file_identifier
+    end
+
+    # PDF/A (ISO 19005-2, 6.2.2) requires every page whose content
+    # references resources to carry an EXPLICIT /Resources entry;
+    # inherited-only resources fail validation. Copy the page-tree
+    # root's resources onto pages that lack their own.
+    def normalize_page_resources
+      root = document.catalog && document.object(document.catalog.value[:Pages])
+      return unless root.is_a?(Pdfrb::Model::Cos::Dictionary)
+
+      inherited = root.value[:Resources]
+      return if inherited.nil?
+
+      Array(root.value[:Kids]).each do |kid_ref|
+        page = kid_ref.is_a?(Pdfrb::Model::Reference) ? document.object(kid_ref) : kid_ref
+        next unless page.is_a?(Pdfrb::Model::Cos::Dictionary)
+        next if page.value.key?(:Resources)
+
+        page.value[:Resources] = inherited
+      end
+    end
+
+    # ISO 32000-1 s14.4: the trailer shall carry a /ID file
+    # identifier. Derived deterministically from the catalog
+    # serialization + object census so identical content yields
+    # identical identifiers.
+    def seed_file_identifier
+      existing = document.trailer || {}
+      return if existing[:ID]
+
+      fingerprint = +@serializer.serialize(document.catalog.value)
+      each_indirect_object { |obj| fingerprint << obj.oid.to_s << "," }
+      digest = ::Digest::MD5.digest(fingerprint)
+      existing[:ID] = [digest, digest]
     end
 
     def version

data/lib/pdfrb/xmp/packet.rb

@@ -21,6 +21,7 @@ module Pdfrb
         @pdf = Schemas::PDF.new
         @xmp = Schemas::XMPBasic.new
         @rights = Schemas::XMPRights.new
+        @pdfaid = nil
       end
 
       def title=(value); @dc.title = Array(value); end
@@ -43,6 +44,15 @@ module Pdfrb
       def creator_tool=(value); @xmp.creator_tool = value; end
       def creator_tool; @xmp.creator_tool; end
 
+      # PDF/A identification (ISO 19005-1 s6.7.11 / 19005-2 s6.6.4):
+      # part (e.g. 2) and conformance level ("A", "B", "U").
+      def pdfa_id=(value)
+        @pdfaid = { part: Integer(value[:part]), conformance: value[:conformance].to_s }
+      end
+
+      def pdfa_part; @pdfaid && @pdfaid[:part]; end
+      def pdfa_conformance; @pdfaid && @pdfaid[:conformance]; end
+
       def to_xmp
         XMP_BEGIN + rdf_body + XMP_END
       end
@@ -56,8 +66,10 @@ module Pdfrb
           '<rdf:Description rdf:about=""',
           '    xmlns:dc="http://purl.org/dc/elements/1.1/"',
           '    xmlns:pdf="http://ns.adobe.com/pdf/1.3/"',
-          '    xmlns:xmp="http://ns.adobe.com/xap/1.0/">',
+          '    xmlns:xmp="http://ns.adobe.com/xap/1.0/"',
         ]
+        lines << '    xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/"' if has_pdfa?
+        lines << ">"
         lines += schema_lines
         lines << "</rdf:Description>"
         lines << "</rdf:RDF>"
@@ -70,9 +82,21 @@ module Pdfrb
         parts += dc_lines if has_dc?
         parts += pdf_lines if has_pdf?
         parts += xmp_lines if has_xmp?
+        parts += pdfa_lines if has_pdfa?
         parts
       end
 
+      def has_pdfa?
+        !@pdfaid.nil?
+      end
+
+      def pdfa_lines
+        [
+          "  <pdfaid:part>#{@pdfaid[:part]}</pdfaid:part>",
+          "  <pdfaid:conformance>#{@pdfaid[:conformance]}</pdfaid:conformance>",
+        ]
+      end
+
       def has_dc?
         (@dc.title && !@dc.title.empty?) ||
           (@dc.creator && !@dc.creator.empty?) ||

data/lib/pdfrb/xmp.rb

@@ -16,6 +16,10 @@ Pdfrb::Document.prepend(Module.new do
   private
 
   def sync_xmp_metadata!
+    # PDF/A files must carry an XMP metadata stream even without a
+    # document title; sync whenever a PDF/A identification is set.
+    return sync_pdfa_metadata! if pdfa_part
+
     info = trailer&.[](:Info)
     return unless info
 
@@ -41,4 +45,22 @@ Pdfrb::Document.prepend(Module.new do
     catalog.value[:Metadata] =
       Pdfrb::Model::Reference.new(stream.oid, stream.gen)
   end
+
+  def sync_pdfa_metadata!
+    packet = begin
+      xmp
+    rescue StandardError
+      nil
+    end
+    return unless packet
+
+    xmp_data = packet.to_xmp
+    stream = add(
+      { Type: :Metadata, Subtype: :XML, Length: xmp_data.bytesize },
+      type: Pdfrb::Model::Cos::Stream
+    )
+    stream.stream = xmp_data
+    catalog.value[:Metadata] =
+      Pdfrb::Model::Reference.new(stream.oid, stream.gen)
+  end
 end)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pdfrb
 version: !ruby/object:Gem::Version
-  version: 0.7.49
+  version: 0.8.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -862,6 +876,7 @@ files:
 - lib/pdfrb/document/output_intents.rb
 - lib/pdfrb/document/page_labels.rb
 - lib/pdfrb/document/pages.rb
+- lib/pdfrb/document/pdf_a.rb
 - lib/pdfrb/document/portfolio.rb
 - lib/pdfrb/document/shadings.rb
 - lib/pdfrb/document/stamps.rb
@@ -1269,6 +1284,7 @@ files:
 - lib/pdfrb/task/optimize.rb
 - lib/pdfrb/task/regenerate_appearances.rb
 - lib/pdfrb/task/thumbnail.rb
+- lib/pdfrb/task/vera_pdf_cross_check.rb
 - lib/pdfrb/test_utils.rb
 - lib/pdfrb/validator.rb
 - lib/pdfrb/version.rb