pdfrb 0.6.0 → 0.7.1

data/lib/pdfrb/image_loader/png.rb

@@ -10,46 +10,103 @@ module Pdfrb
         info = parse_header(data)
         return nil if info.empty?
 
-        image = document.add(
-          {
-            Type: :XObject,
-            Subtype: :Image,
-            Width: info[:width],
-            Height: info[:height],
-            ColorSpace: info[:color_space],
-            BitsPerComponent: info[:bits],
-            Filter: :FlateDecode,
-            DecodeParms: { Predictor: 15, Columns: info[:width] },
-            Length: 0,
-          },
-          type: Pdfrb::Model::Type::XObjectImage
-        )
+        dict = {
+          Type: :XObject,
+          Subtype: :Image,
+          Width: info[:width],
+          Height: info[:height],
+          ColorSpace: info[:color_space],
+          BitsPerComponent: info[:bits],
+          Filter: :FlateDecode,
+          DecodeParms: { Predictor: 15, Columns: info[:width] },
+          Length: 0,
+        }
+        mask = color_key_mask(info)
+        dict[:Mask] = mask if mask
+
+        image = document.add(dict, type: Pdfrb::Model::Type::XObjectImage)
         image.stream = ""
         image
       end
 
       def parse_header(data)
-        return {} unless data.is_a?(String) && data.bytesize >= 24
+        return {} unless data.is_a?(::String) && data.bytesize >= 24
         return {} unless data.start_with?("\x89PNG\r\n\x1A\n".b)
         return {} unless data.bytes[12, 4].pack("C*") == "IHDR"
 
         off = 16
-        {
+        color_type = data.getbyte(off + 9)
+        result = {
           width: read_u32(data, off),
           height: read_u32(data, off + 4),
           bits: data.getbyte(off + 8),
-          color_type: data.getbyte(off + 9),
-          color_space: case data.getbyte(off + 9)
+          color_type: color_type,
+          color_space: case color_type
                        when 0, 4 then :DeviceGray
                        when 2, 6 then :DeviceRGB
                        when 3 then :Indexed
                        else :DeviceRGB
                        end,
         }
+        result[:trns] = read_trns_chunk(data, color_type)
+        result
+      end
+
+      # Walk the PNG chunks looking for tRNS. Returns the raw tRNS
+      # payload bytes, or nil if absent. Stops at IDAT to avoid
+      # scanning the whole file.
+      def read_trns_chunk(data, color_type)
+        offset = 8 # skip PNG signature
+        while offset + 8 <= data.bytesize
+          length = read_u32(data, offset)
+          chunk_type = data.byteslice(offset + 4, 4)
+          offset += 8
+          case chunk_type
+          when "IHDR" # already parsed; skip
+            offset += length + 4
+          when "tRNS"
+            return data.byteslice(offset, length)
+          when "IDAT", "IEND"
+            return nil
+          else
+            offset += length + 4
+          end
+        end
+        nil
+      end
+
+      # Build a PDF /Mask color-key array from the tRNS chunk. Each
+      # entry is [min, max] per channel. Returns nil if tRNS is
+      # absent or for indexed color (which uses /SMask instead).
+      def color_key_mask(info)
+        trns = info[:trns]
+        return nil unless trns
+        return nil if info[:color_type] == 3 # palette uses /SMask
+
+        case info[:color_type]
+        when 0 # grayscale: 1 two-byte value
+          v = read_u16(trns, 0)
+          [v, v]
+        when 2, 6 # RGB: 3 two-byte values
+          r = read_u16(trns, 0)
+          g = read_u16(trns, 2)
+          b = read_u16(trns, 4)
+          [r, r, g, g, b, b]
+        when 4 # grayscale+alpha: same as grayscale
+          v = read_u16(trns, 0)
+          [v, v]
+        end
+      end
+
+      def read_u16(data, off)
+        return 0 unless data && data.bytesize >= off + 2
+
+        (data.getbyte(off) << 8) | data.getbyte(off + 1)
       end
 
       def read_u32(data, off)
-        (data.getbyte(off) << 24) | (data.getbyte(off + 1) << 16) | (data.getbyte(off + 2) << 8) | data.getbyte(off + 3)
+        (data.getbyte(off) << 24) | (data.getbyte(off + 1) << 16) |
+          (data.getbyte(off + 2) << 8) | data.getbyte(off + 3)
       end
     end
   end

data/lib/pdfrb/model/type/page_piece_info.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Page-piece dictionary (s14.5). Per-page metadata recording
+      # application-specific private data. The dictionary hangs off
+      # a page's /PieceInfo key and is keyed by application name;
+      # each value carries /LastModified, /Private, and (optionally)
+      # an /ASFStream reference for a stream-encoded private payload.
+      #
+      # Conforming readers MUST NOT interpret application-private
+      # data; it survives round-trips and incremental updates intact.
+      class PagePieceInfo < Pdfrb::Model::Cos::Dictionary
+        # The application-name key (e.g. :Adobe, :Pdfrb). Multiple
+        # applications may each have their own entry in the same
+        # /PieceInfo dict.
+        def application_name
+          value.key?(:Application) ? value[:Application] : nil
+        end
+
+        # /LastModified — PDF date string, parsed to a Time.
+        def last_modified
+          v = value[:LastModified]
+          return nil unless v.is_a?(::String)
+
+          Pdfrb::Model::Date.parse(v)
+        end
+
+        # /Private — application-private dict. Untyped on purpose:
+        # the contents are app-defined.
+        def private_data
+          value[:Private]
+        end
+
+        # Set the application's /LastModified to +time+. +time+ is
+        # converted to a PDF date string.
+        def last_modified=(time)
+          value[:LastModified] = Pdfrb::Model::Date.format(time)
+        end
+
+        # Merge +hash+ into /Private. If /Private is absent, it is
+        # created from the hash.
+        def merge_private!(hash)
+          existing = value[:Private]
+          if existing.is_a?(Pdfrb::Model::Cos::Dictionary)
+            existing.value.merge!(hash)
+          elsif existing.is_a?(::Hash)
+            existing.merge!(hash)
+          else
+            value[:Private] = hash
+          end
+          self
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type.rb

@@ -353,6 +353,9 @@ module Pdfrb
       # Structure types (s14.7).
       autoload :StructureAttributes, "pdfrb/model/type/structure_attributes"
       autoload :StructureElementKid, "pdfrb/model/type/structure_element_kid"
+
+      # Page-piece dictionary (s14.5).
+      autoload :PagePieceInfo, "pdfrb/model/type/page_piece_info"
     end
   end
 end

data/lib/pdfrb/task/regenerate_appearances.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Task
+    # Walks every widget annotation in the document and regenerates
+    # the /AP /N appearance stream via Appearance::Generator. Use
+    # after mutating field values directly (e.g. via Form#set_value)
+    # or to repair documents with /NeedAppearances set so viewers
+    # don't have to synthesise appearances on the fly.
+    #
+    # Per ISO 32000-2 §12.5.5, an annotation's /AP /N is the normal
+    # appearance; PDF/A requires it for every widget. This task
+    # also clears /NeedAppearances on /AcroForm since by definition
+    # all fields now have a computed appearance.
+    module RegenerateAppearances
+      module_function
+
+      # @param document [Pdfrb::Document]
+      # @param only: [Array<Symbol>, nil] limit to the given FT values
+      #   (e.g. [:Tx, :Btn]). Default: all field types.
+      # @return [Integer] count of appearances regenerated.
+      def call(document, only: nil)
+        generator = Pdfrb::Appearance::Generator.new(document)
+        widgets = each_widget(document).to_a
+        count = 0
+        widgets.each do |widget|
+          next unless matching?(widget, only)
+
+          regenerated = regenerate(generator, widget)
+          count += 1 if regenerated
+        end
+        clear_need_appearances(document)
+        count
+      end
+
+      def each_widget(document)
+        return enum_for(:each_widget, document) unless block_given?
+
+        document.each_indirect_object do |obj|
+          next unless obj.value.is_a?(::Hash)
+
+          subtype = obj.value[:Subtype]
+          yield obj if subtype == :Widget
+        end
+      end
+
+      def matching?(widget, only)
+        return true if only.nil?
+
+        ft = widget.value[:FT]
+        ft && only.include?(ft.to_sym)
+      end
+
+      def regenerate(generator, widget)
+        ft = widget.value[:FT]&.to_sym
+        value = widget.value[:V]
+        case ft
+        when :Tx
+          generator.text_field(widget, value: value.to_s)
+          true
+        when :Btn
+          if value.is_a?(::Hash)
+            # Multi-state radio; regenerate each state's appearance.
+            value.each_key do |state|
+              generator.checkbox(widget, checked: state != :Off)
+            end
+          else
+            generator.checkbox(widget, checked: [:Yes, true].include?(value))
+          end
+          true
+        when :Ch
+          generator.combo(widget, value: value.to_s)
+          true
+        else
+          false
+        end
+      rescue StandardError
+        # Appearance generation is best-effort; if a single field
+        # raises, skip it rather than aborting the whole sweep.
+        false
+      end
+
+      def clear_need_appearances(document)
+        catalog = document.catalog
+        return unless catalog
+
+        acroform = catalog.value[:AcroForm]
+        return unless acroform
+
+        if acroform.is_a?(Pdfrb::Model::Cos::Dictionary)
+          acroform.value.delete(:NeedAppearances)
+        elsif acroform.is_a?(::Hash)
+          acroform.delete(:NeedAppearances)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/task.rb

@@ -9,5 +9,6 @@ module Pdfrb
     autoload :GenerateCorpus, "pdfrb/task/generate_corpus"
     autoload :Benchmark, "pdfrb/task/benchmark"
     autoload :MemoryProfile, "pdfrb/task/memory_profile"
+    autoload :RegenerateAppearances, "pdfrb/task/regenerate_appearances"
   end
 end

data/lib/pdfrb/version.rb

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

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pdfrb
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Ribose Inc.
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -774,6 +775,7 @@ files:
 - lib/pdfrb/content/operators/color.rb
 - lib/pdfrb/content/operators/general.rb
 - lib/pdfrb/content/operators/graphics_state_params.rb
+- lib/pdfrb/content/operators/inline_image.rb
 - lib/pdfrb/content/operators/marked_content.rb
 - lib/pdfrb/content/operators/painting.rb
 - lib/pdfrb/content/operators/path.rb
@@ -1057,6 +1059,7 @@ files:
 - lib/pdfrb/model/type/output_intent.rb
 - lib/pdfrb/model/type/page.rb
 - lib/pdfrb/model/type/page_label.rb
+- lib/pdfrb/model/type/page_piece_info.rb
 - lib/pdfrb/model/type/page_tree_node.rb
 - lib/pdfrb/model/type/page_tree_node_root.rb
 - lib/pdfrb/model/type/pattern.rb
@@ -1160,6 +1163,7 @@ files:
 - lib/pdfrb/task/memory_profile.rb
 - lib/pdfrb/task/merge.rb
 - lib/pdfrb/task/optimize.rb
+- lib/pdfrb/task/regenerate_appearances.rb
 - lib/pdfrb/test_utils.rb
 - lib/pdfrb/validator.rb
 - lib/pdfrb/version.rb
@@ -1181,6 +1185,7 @@ metadata:
   changelog_uri: https://github.com/claricle/pdfrb/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/claricle/pdfrb/issues
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -1195,7 +1200,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Pure-Ruby PDF parser, Arlington-model-driven domain model, and serializer
 test_files: []