pdfrb 0.7.45 → 0.7.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9283c2555bc64be8606a06fb6fc62c9498382499c30c7eea8afd36c4dcfc6a82
-  data.tar.gz: e93caaff66db1dcf3944873ad5b41fe9a8876623d33ae0c53918461a6f0a4c49
+  metadata.gz: 28f2fc6a03f24e2ad53f50a61e50221057c15d88d3db91a3c0d8487fa1e47186
+  data.tar.gz: 50fa314624a65f648a4e190f6464e335bdfa14f06301d4a280bbaf94c45a01f6
 SHA512:
-  metadata.gz: 16b7e2394f0275d631d4ba0946e3b0d5f2973240f9fe1d4f5eebfbb4998e666e6e0ff9e62dd50fd43eebb5ecb7b418846d6ded5be052b1c3462f0d3033cbd1a3
-  data.tar.gz: 4219346da2b075bb87024963f248c1a8e26852f9e928c24f0155291e242bd8d4ff28175f74ef1719c05812fc34aa0782d4f81d2a226c108e996d5940d48ab6fe
+  metadata.gz: f00c0cc7abf3e0caebf3c47095e6bedc8c8c1c884565a14243df2a59fbec04f1731b478253471045ff872aa83024949ff17d4eea13d08b8118d71288f9a6c268
+  data.tar.gz: d68c928edc696a330b782321c104a99d876510bb2b1723a30b4f42cc9956f5ac82ca3e5a9d02aff9ac29c4501501088a8c242b10a5e1e9dadff9b843bd85ca98

data/lib/pdfrb/content/canvas.rb

@@ -363,6 +363,7 @@ module Pdfrb
 
       def text(str, at:, font:, size:, char_spacing: nil, word_spacing: nil)
         @used_fonts[font] = size
+        @document&.fonts&.register_usage(font, str)
         encoded = encode_for_font(str.to_s, font)
         emit_op(Pdfrb::Content::Operator::BeginText)
         emit_op(Pdfrb::Content::Operator::SetTextMatrix, 1, 0, 0, 1, at[0], at[1])

data/lib/pdfrb/document/fonts.rb

@@ -61,6 +61,15 @@ module Pdfrb
       end
 
       def used_codepoints(resource); @used_codepoints[resource]; end
+
+      # Record that +text+ was drawn with +font_dict+ so the
+      # write-time subsetter knows which codepoints each embedded
+      # font must retain.
+      def register_usage(font_dict, text)
+        resource = @font_dicts.key(font_dict)
+        track(resource, text) if resource
+      end
+
       def encoding_for(resource); @encodings[resource]; end
 
       def encode_text(text, resource)
@@ -144,21 +153,7 @@ module Pdfrb
           next if codepoints.empty?
 
           begin
-            ttf = Pdfrb::Font::TrueType::File.new(data)
-            subsetter = Pdfrb::Font::TrueType::Subsetter.new(ttf)
-            subset = subsetter.subset(codepoints.to_a)
-            dict = @font_dicts[resource]
-            next unless dict
-
-            desc_ref = dict.value[:FontDescriptor]
-            next unless desc_ref
-
-            desc = desc_ref.is_a?(Pdfrb::Model::Reference) ? document.object(desc_ref) : desc_ref
-            next unless desc
-
-            fd_stream = document.add({ Length: subset.bytesize }, type: Pdfrb::Model::Cos::Stream)
-            fd_stream.stream = subset
-            desc.value[:FontFile2] = Pdfrb::Model::Reference.new(fd_stream.oid, fd_stream.gen)
+            subset_font(resource, data, codepoints)
           rescue StandardError
             next
           end
@@ -481,12 +476,51 @@ module Pdfrb
         }, type: subtype == :TrueType ? Pdfrb::Model::Type::FontTrueType : Pdfrb::Model::Type::FontType1)
       end
 
+      # Build the subsetted font bytes for +resource+ and replace the
+      # descriptor's font-file stream (FontFile2 for TrueType
+      # outlines, FontFile3/OpenType for CFF).
+      def subset_font(resource, data, codepoints)
+        subset, font_file_key =
+          if data.byteslice(0, 4) == "OTTO".b
+            # CFF outlines: map codepoints to glyph IDs via the OTF
+            # cmap (it addresses CFF glyphs too), subset the 'CFF '
+            # table, and rebuild the OTF container.
+            cmap = Pdfrb::Font::TrueType::File.new(data).cmap
+            gids = codepoints.filter_map { |cp| cmap.glyph_id_for(cp) }.uniq
+            [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]
+          end
+        dict = @font_dicts[resource]
+        return unless dict
+
+        desc_ref = dict.value[:FontDescriptor]
+        return unless desc_ref
+
+        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
+        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
+      # inherits them (s7.7.3.2 resource inheritance). Attaching to
+      # the Catalog instead — as this used to — produced a stray key
+      # no viewer honours, leaving written pages without fonts.
       def attach_to_resources(resource, font_dict)
         ref = Pdfrb::Model::Reference.new(font_dict.oid, font_dict.gen)
-        catalog = document.catalog
-        catalog.value[:Resources] ||= {}
-        catalog.value[:Resources][:Font] ||= {}
-        catalog.value[:Resources][:Font][resource] = ref
+        root = document.pages.pages_root
+        root.value[:Resources] ||= {}
+        root.value[:Resources][:Font] ||= {}
+        root.value[:Resources][:Font][resource] = ref
       end
     end
   end

data/lib/pdfrb/document/images.rb

@@ -47,10 +47,11 @@ module Pdfrb
 
       def attach_to_resources(name, image)
         ref = Pdfrb::Model::Reference.new(image.oid, image.gen)
-        catalog = document.catalog
-        catalog.value[:Resources] ||= {}
-        catalog.value[:Resources][:XObject] ||= {}
-        catalog.value[:Resources][:XObject][name] = ref
+        # Page-tree root so every page inherits it (s7.7.3.2).
+        root = document.pages.pages_root
+        root.value[:Resources] ||= {}
+        root.value[:Resources][:XObject] ||= {}
+        root.value[:Resources][:XObject][name] = ref
       end
     end
   end

data/lib/pdfrb/document/pages.rb

@@ -26,11 +26,13 @@ module Pdfrb
         media_box ||= (width && height ? [0, 0, width, height] : [0, 0, 612, 792])
         root = pages_root
         contents = document.add({}, type: Pdfrb::Model::Cos::Stream)
+        # No eager /Resources: an empty page-level dict would override
+        # the inheritable root resources (s7.7.3.2). The canvas seeds
+        # one lazily when it attaches XObjects.
         page_hash = {
           Type: :Page,
           Parent: Pdfrb::Model::Reference.new(root.oid, root.gen),
           MediaBox: media_box,
-          Resources: {},
           Contents: Pdfrb::Model::Reference.new(contents.oid, 0)
         }
         page_hash[:BleedBox] = bleed_box if bleed_box
@@ -134,8 +136,9 @@ module Pdfrb
         end
       end
 
-      private
-
+      # The page-tree root (Catalog /Pages), seeding an empty tree if
+      # needed. Resources placed here are inherited by every page
+      # (s7.7.3.2).
       def pages_root
         catalog = document.catalog
         raise Pdfrb::Error, "Document has no Catalog" unless catalog
@@ -150,6 +153,8 @@ module Pdfrb
         root
       end
 
+      private
+
       def walk(node, &block)
         kids = node.is_a?(Pdfrb::Model::Cos::Dictionary) ? node.value[:Kids] : node[:Kids]
         return unless kids

data/lib/pdfrb/document/shadings.rb

@@ -142,10 +142,13 @@ module Pdfrb
 
       def register(name, shading_obj)
         @registry[name] = shading_obj
-        catalog = document.catalog
-        catalog.value[:Resources] ||= {}
-        catalog.value[:Resources][:Shading] ||= {}
-        catalog.value[:Resources][:Shading][name] =
+        document.catalog
+        # Attach to the page-tree root so every page inherits it
+        # (s7.7.3.2); the Catalog has no /Resources key in PDF.
+        root = document.pages.pages_root
+        root.value[:Resources] ||= {}
+        root.value[:Resources][:Shading] ||= {}
+        root.value[:Resources][:Shading][name] =
           Pdfrb::Model::Reference.new(shading_obj.oid, shading_obj.gen)
       end
 

data/lib/pdfrb/document.rb

@@ -223,6 +223,7 @@ module Pdfrb
       target = io || (path && File.open(path, "wb"))
       raise ArgumentError, "write needs a path or io:" unless target
 
+      fonts.subset_fonts! if config["writer.subset_fonts"] != false
       Pdfrb::Writer.write(self, target)
       target.close if path && io.nil? && target.is_a?(IO)
       self

data/lib/pdfrb/font/cff/dict.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module CFF
+      # DICT data parsing (TN5176 s4): a sequence of operands (from
+      # the b0 byte ranges) followed by an operator byte.
+      #
+      # Used both to READ the Top DICT (CharStrings offset, Private
+      # [size offset], charset) and to locate operator positions so a
+      # subsetter can patch offsets in place.
+      class Dict
+        # One operator plus its trailing operands, with the byte
+        # range it occupied in the source DICT.
+        Entry = Struct.new(:operator, :operands, :start, :finish) do
+          def int_operand(i = 0)
+            v = operands[i]
+            v.is_a?(Integer) ? v : nil
+          end
+        end
+
+        attr_reader :entries, :raw
+
+        def self.parse(data)
+          entries = []
+          operands = []
+          pos = 0
+          entry_start = 0
+          while pos < data.bytesize
+            b0 = data.getbyte(pos)
+            case b0
+            when 28 then operands << data.byteslice(pos + 1, 2).unpack1("n")
+                         pos += 3
+            when 29 then operands << data.byteslice(pos + 1, 4).unpack1("N")
+                         pos += 5
+            when 30
+              real, pos = parse_real(data, pos + 1)
+              operands << real
+            when 32..246
+              operands << (b0 - 139)
+              pos += 1
+            when 247..250
+              operands << (((b0 - 247) * 256) + data.getbyte(pos + 1) + 108)
+              pos += 2
+            when 251..254
+              operands << ((-(b0 - 251) * 256) - data.getbyte(pos + 1) - 108)
+              pos += 2
+            else
+              # Operator (0..21, with 12 x for two-byte ops).
+              if b0 == 12
+                op = [12, data.getbyte(pos + 1)]
+                pos += 2
+              else
+                op = b0
+                pos += 1
+              end
+              entries << Entry.new(op, operands, entry_start, pos)
+              operands = []
+              entry_start = pos
+            end
+          end
+          new(data, entries)
+        end
+
+        NIBBLE_CHARS = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ".", "E", "E-", nil, "-"].freeze
+        private_constant :NIBBLE_CHARS
+
+        # Real operand (b0 30): nibble-encoded decimal terminated by
+        # 0xF. Returns [Float, next_pos].
+        def self.parse_real(data, pos)
+          buf = +""
+          while pos < data.bytesize
+            nibble_pair = data.getbyte(pos)
+            pos += 1
+            hi = nibble_pair >> 4
+            lo = nibble_pair & 0xF
+            break if hi == 0xF
+
+            buf << NIBBLE_CHARS[hi]
+            break if lo == 0xF
+
+            buf << NIBBLE_CHARS[lo]
+          end
+          [buf.to_f, pos]
+        end
+
+        def initialize(raw, entries)
+          @raw = raw
+          @entries = entries
+        end
+
+        # Entry for a one-byte Integer operator or a two-byte
+        # [12, x] operator.
+        def entry_for(operator)
+          entries.find { |e| e.operator == operator }
+        end
+
+        # Top DICT helpers (operator numbers per TN5176 Table 6):
+        #   15 charset, 17 CharStrings, 18 Private [size offset].
+        def charset_offset
+          entry_for(15)&.int_operand
+        end
+
+        def charstrings_offset
+          entry_for(17)&.int_operand
+        end
+
+        # Returns [size, offset].
+        def private_size_offset
+          e = entry_for(18)
+          return nil unless e
+
+          [e.int_operand(0), e.int_operand(1)]
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/font/cff/file.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module CFF
+      # Parsed CFF table (TN5176). Exposes the pieces a subsetter
+      # needs: header span, Name/String/Global-Subr INDEXes, Top DICT,
+      # charset (format 0), CharStrings INDEX, Private DICT span, and
+      # the Local Subr INDEX when present.
+      class File
+        attr_reader :data, :header_size, :name_index, :top_dict,
+                    :string_index, :global_subrs, :charset_format,
+                    :charset_sids, :charstrings, :private_span,
+                    :local_subrs
+
+        def initialize(data)
+          @data = data.b
+          parse
+        end
+
+        def num_glyphs
+          charstrings&.size || 0
+        end
+
+        def charstring(gid)
+          charstrings[gid] if charstrings
+        end
+
+        # Charset (format 0 only): gid -> SID, with .notdef implicit
+        # at gid 0.
+        def sid_for_gid(gid)
+          return 0 if gid.zero?
+
+          @charset_sids[gid - 1]
+        end
+
+        # Reverse charset: SID -> gid (first wins).
+        def gid_for_sid(sid)
+          @gid_by_sid ||= begin
+            map = { 0 => 0 }
+            @charset_sids.each_with_index { |s, i| map[s] ||= i + 1 }
+            map
+          end
+          @gid_by_sid[sid]
+        end
+
+        private
+
+        def parse
+          @header_size = @data.getbyte(2)
+          pos = @header_size
+
+          @name_index, pos = Index.parse(@data, pos)
+          top_index, pos = Index.parse(@data, pos)
+          @top_dict = Dict.parse(top_index.items.first || "".b)
+          @string_index, pos = Index.parse(@data, pos)
+          @global_subrs, = Index.parse(@data, pos)
+
+          # CharStrings first: the format-0 charset reader needs the
+          # glyph count.
+          parse_charstrings
+          parse_charset
+          parse_private
+        end
+
+        def parse_charset
+          off = @top_dict.charset_offset
+          @charset_sids = []
+          if off.nil? || off.zero?
+            @charset_format = :iso_glyph_order
+            return
+          end
+
+          format = @data.getbyte(off)
+          @charset_format = format
+          case format
+          when 0
+            (@charstrings&.size || 0).times do |i|
+              @charset_sids << @data.byteslice(off + 1 + (i * 2), 2).unpack1("n")
+            end
+          when 1, 2
+            parse_range_charset(off, format)
+          end
+        end
+
+        # Formats 1/2 (TN5176 s18): [first(n2) nLeft(C1|n2)]* ranges;
+        # SIDs run consecutively from first for nLeft+1 entries.
+        def parse_range_charset(off, format)
+          pos = off + 1
+          count = @charstrings&.size || 0
+          while @charset_sids.size < count && pos < @data.bytesize
+            first = @data.byteslice(pos, 2).unpack1("n")
+            pos += 2
+            n_left = format == 1 ? @data.getbyte(pos) : @data.byteslice(pos, 2).unpack1("n")
+            pos += format == 1 ? 1 : 2
+            (0..n_left).each do |i|
+              @charset_sids << (first + i)
+            end
+          end
+        end
+
+        def parse_charstrings
+          off = @top_dict.charstrings_offset
+          return if off.nil? || off.zero?
+
+          @charstrings, = Index.parse(@data, off)
+        end
+
+        def parse_private
+          span = @top_dict.private_size_offset
+          return if span.nil?
+
+          size, offset = span
+          @private_span = [offset, size]
+
+          priv = Dict.parse(@data.byteslice(offset, size))
+          subrs_entry = priv.entry_for(19)
+          return unless subrs_entry
+
+          subrs_off = subrs_entry.int_operand
+          @local_subrs, = Index.parse(@data, offset + subrs_off) if subrs_off&.positive?
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/font/cff/index.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module CFF
+      # CFF INDEX structure (TN5176 s5): count (Card16), offSize
+      # (OffSize), offsets (count+1 × offSize bytes, 1-based), then
+      # the data items.
+      class Index
+        attr_reader :items
+
+        # Parse an INDEX at +offset+ in +data+; returns [index,
+        # next_offset].
+        def self.parse(data, offset)
+          count = data.byteslice(offset, 2).unpack1("n")
+          return [new([]), offset + 2] if count.zero?
+
+          off_size = data.getbyte(offset + 2)
+          offsets_base = offset + 3
+          offsets = (0..count).map do |i|
+            read_off(data, offsets_base + (i * off_size), off_size)
+          end
+          data_base = offsets_base + ((count + 1) * off_size)
+          items = (0...count).map do |i|
+            start = data_base + offsets[i] - 1
+            len = offsets[i + 1] - offsets[i]
+            data.byteslice(start, len)
+          end
+          [new(items), data_base + offsets[count] - 1]
+        end
+
+        def self.read_off(data, pos, size)
+          value = 0
+          size.times { |i| value = (value * 256) + data.getbyte(pos + i) }
+          value
+        end
+
+        def initialize(items)
+          @items = items
+        end
+
+        def each(&)
+          @items.each(&)
+        end
+
+        def size
+          @items.size
+        end
+
+        def [](i)
+          @items[i]
+        end
+
+        # Serialize back to INDEX bytes.
+        def serialize
+          return [0].pack("n") if @items.empty?
+
+          offsets = [1]
+          @items.each { |item| offsets << (offsets.last + item.bytesize) }
+          max = offsets.last
+          off_size = if max < 0x100
+                       1
+                     else
+                       (if max < 0x10000
+                          2
+                        else
+                          (max < 0x1000000 ? 3 : 4)
+                        end)
+                     end
+
+          buf = +"".b
+          buf << [@items.size].pack("n")
+          buf << off_size.chr
+          offsets.each do |o|
+            off_size.downto(1) { |i| buf << ((o >> (8 * (i - 1))) & 0xFF).chr }
+          end
+          @items.each { |item| buf << item.b }
+          buf
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/font/cff.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    # CFF (Compact Font Format, ISO 32000-2 Annex / Adobe CFF spec
+    # TN5176) parsing and safe subsetting for OTF fonts embedded via
+    # /FontFile3 /Subtype /OpenType.
+    #
+    # Layout: header, Name INDEX, Top DICT INDEX, String INDEX,
+    # Global Subr INDEX, then (at offsets recorded in the Top DICT)
+    # charset, CharStrings INDEX, Private DICT (+ Local Subr INDEX).
+    module CFF
+      autoload :Index, "pdfrb/font/cff/index"
+      autoload :Dict, "pdfrb/font/cff/dict"
+      autoload :File, "pdfrb/font/cff/file"
+      autoload :Subsetter, "pdfrb/font/cff/subsetter"
+    end
+  end
+end

data/lib/pdfrb/font.rb

@@ -9,6 +9,7 @@ module Pdfrb
     autoload :AFMParser, "pdfrb/font/afm_parser"
     autoload :CMap, "pdfrb/font/cmap"
     autoload :TrueType, "pdfrb/font/true_type"
+    autoload :CFF, "pdfrb/font/cff"
     autoload :Type1, "pdfrb/font/type1"
     autoload :Metrics, "pdfrb/font/metrics_helper"
     autoload :MetricsHelper, "pdfrb/font/metrics_helper"

data/lib/pdfrb/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pdfrb
 version: !ruby/object:Gem::Version
-  version: 0.7.45
+  version: 0.7.46
 platform: ruby
 authors:
 - Ribose Inc.
@@ -865,6 +865,11 @@ files:
 - lib/pdfrb/filter/run_length_decode.rb
 - lib/pdfrb/font.rb
 - lib/pdfrb/font/afm_parser.rb
+- lib/pdfrb/font/cff.rb
+- lib/pdfrb/font/cff/dict.rb
+- lib/pdfrb/font/cff/file.rb
+- lib/pdfrb/font/cff/index.rb
+- lib/pdfrb/font/cff/subsetter.rb
 - lib/pdfrb/font/cmap.rb
 - lib/pdfrb/font/cmap/parser.rb
 - lib/pdfrb/font/cmap/writer.rb