pdfrb 0.3.0 → 0.6.0

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      class Post
+        attr_reader :version, :italic_angle, :underline_position,
+                    :underline_thickness, :is_fixed_pitch, :glyph_names
+
+        def initialize(data)
+          return unless data && data.bytesize >= 32
+
+          @version = data.bytes[0, 4].pack("C*").unpack1("N")
+          @italic_angle = s32(data, 4) / 65536.0
+          @underline_position = s16(data, 8)
+          @underline_thickness = s16(data, 10)
+          @is_fixed_pitch = data.bytes[12, 4].pack("C*").unpack1("N")
+          @glyph_names = parse_names(data) if @version == 0x00020000
+        end
+
+        def glyph_name(index)
+          return nil unless @glyph_names
+          return nil if index >= @glyph_names.length
+
+          @glyph_names[index]
+        end
+
+        def s32(data, off); (data.getbyte(off) << 24) | (data.getbyte(off + 1) << 16) | (data.getbyte(off + 2) << 8) | data.getbyte(off + 3); end
+
+        STANDARD_GLYPH_NAMES = %w[
+          .notdef .null nonmarkingreturn space exclam quotedbl numbersign
+          dollar percent ampersand quotesingle parenleft parenright asterisk
+          plus comma hyphen period slash zero one two three four five six
+          seven eight nine colon semicolon less equal greater question at
+          A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+          bracketleft backslash bracketright asciicircum underscore grave
+          a b c d e f g h i j k l m n o p q r s t u v w x y z
+          braceleft bar braceright asciitilde Adieresis Aring Ccedilla Eacute
+          Ntilde Odieresis Udieresis aacute agrave acircumflex adieresis atilde
+          aring ccedilla eacute egrave ecircumflex edieresis iacute igrave
+          icircumflex idieresis ntilde oacute ograve ocircumflex odieresis
+          otilde uacute ugrave ucircumflex udieresis dagger degree cent
+          sterling section bullet paragraph germandbls registered copyright
+          trademark acute dieresis notequal AE Oslash infinity plusminus
+          lessequal greaterequal yen mu partialdiff summation product pi
+          integral ordfeminine ordmasculine Omega ae oslash questiondown
+          exclamdown logicalnot radical florin approxequal Delta guillemotleft
+          guillemotright ellipsis nonbreakingspace Agrave Atilde Otilde OE oe
+          endash emdash quotedblleft quotedblright quoteleft quoteright divide
+          lozenge ydieresis Ydieresis fraction currency guilsinglleft
+          guilsinglright fi fl daggerdbl periodcentered quotesinglbase
+          quotedblbase perthousand Acircumflex Ecircumflex Aacute Edieresis
+          Egrave Iacute Icircumflex Idieresis Eth eth Yacute yacute Thorne thorn
+          multiply minus onesuperior twosuperior threesuperior onehalf
+          onequarter threequarters franc Gbreve gbreve Idotaccent Scedilla
+          scedilla Cacute cacute Ccaron ccaron dcroat
+        ].freeze
+
+        private
+
+        def parse_names(data)
+          count = u16(data, 32)
+          indices = Array.new(count) { |i| u16(data, 34 + (i * 2)) }
+          offset = 34 + (count * 2)
+          custom_names = {}
+
+          indices.each do |idx|
+            next if idx < 258
+            next if custom_names.key?(idx)
+
+            len = data.getbyte(offset) || 0
+            offset += 1
+            custom_names[idx] = data.bytes[offset, len]&.pack("C*")&.force_encoding("UTF-8")
+            offset += len
+          end
+
+          STANDARD_GLYPH_NAMES.map.with_index do |_name, i|
+            indices[i] && indices[i] < 258 ? STANDARD_GLYPH_NAMES[indices[i]] : custom_names[indices[i]]
+          end
+        rescue StandardError
+          nil
+        end
+
+        def u16(data, off); (data.getbyte(off) << 8) | data.getbyte(off + 1); end
+
+        def s16(data, off)
+          v = u16(data, off)
+          v >= 32768 ? v - 65536 : v
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,3 @@
-require "set"
-
 # frozen_string_literal: true
 
 module Pdfrb
@@ -43,7 +41,7 @@ module Pdfrb
         private
 
         def build_subset
-          return @ttf.instance_variable_get(:@data) unless can_subset?
+          return @ttf.raw_data unless can_subset?
 
           @resolved = resolve_composites(@glyph_ids)
 
@@ -65,7 +63,7 @@ module Pdfrb
           copy_remaining_tables(tables)
           assemble_ttf(tables)
         rescue StandardError
-          @ttf.instance_variable_get(:@data)
+          @ttf.raw_data
         end
 
         def can_subset?
@@ -299,7 +297,7 @@ module Pdfrb
         end
 
         def copy_remaining_tables(tables)
-          raw = @ttf.instance_variable_get(:@data)
+          raw = @ttf.raw_data
           num_tables = (raw.getbyte(4) * 256) + raw.getbyte(5)
           num_tables.times do |i|
             base = 12 + (i * 16)

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      module Wrapper
+        module_function
+
+        def embed(document, ttf_data, **)
+          ttf = File.new(ttf_data)
+          name = ttf.name_table_parsed
+          ps_name = name&.ps_name || "EmbeddedFont"
+
+          fd = create_font_descriptor(document, ttf, ps_name)
+          widths = build_widths(ttf)
+          tu_stream = build_tounicode(document, ttf)
+          font_file = embed_font_file(document, ttf_data)
+
+          fd.value[:FontFile2] = Pdfrb::Model::Reference.new(font_file.oid, font_file.gen)
+
+          document.add(
+            {
+              Type: :Font,
+              Subtype: :TrueType,
+              BaseFont: ps_name.to_sym,
+              FirstChar: 0,
+              LastChar: 255,
+              Widths: widths,
+              FontDescriptor: Pdfrb::Model::Reference.new(fd.oid, fd.gen),
+              ToUnicode: Pdfrb::Model::Reference.new(tu_stream.oid, tu_stream.gen),
+              Encoding: :WinAnsiEncoding,
+            },
+            type: Pdfrb::Model::Type::FontTrueType
+          )
+        end
+
+        def create_font_descriptor(document, ttf, ps_name)
+          head = ttf.head
+          os2 = ttf.os2
+          document.add(
+            {
+              Type: :FontDescriptor,
+              FontName: ps_name.to_sym,
+              Flags: 32,
+              FontBBox: head&.bbox || [0, 0, 1000, 1000],
+              ItalicAngle: 0,
+              Ascent: os2&.s_typo_ascender || ttf.hhea&.ascender || 800,
+              Descent: os2&.s_typo_descender || ttf.hhea&.descender || -200,
+              CapHeight: os2&.s_cap_height || 700,
+              StemV: 80,
+            },
+            type: Pdfrb::Model::Cos::Dictionary
+          )
+        end
+
+        def build_widths(ttf)
+          widths = Array.new(256, 500)
+          table = Pdfrb::Font::Encoding::WinAnsiEncoding::TABLE
+          Maxp.new(ttf.maxp_table)
+
+          table.each_with_index do |cp, byte|
+            next unless cp
+
+            begin
+              gid = ttf.cmap.glyph_id_for(cp)
+              next unless gid&.positive?
+
+              w = ttf.hmtx.advance_width(gid)
+              widths[byte] = w if w&.positive?
+            rescue StandardError
+              next
+            end
+          end
+          widths
+        end
+
+        def build_tounicode(document, _ttf)
+          table = Pdfrb::Font::Encoding::WinAnsiEncoding::TABLE
+          mapping = {}
+          table.each_with_index { |cp, byte| mapping[byte] = cp if cp }
+
+          cmap_data = Pdfrb::Font::CMap::Writer.write(mapping)
+          stream = document.add(
+            { Length: cmap_data.bytesize },
+            type: Pdfrb::Model::Cos::Stream
+          )
+          stream.stream = cmap_data
+          stream
+        end
+
+        def embed_font_file(document, ttf_data)
+          stream = document.add(
+            { Length: ttf_data.bytesize },
+            type: Pdfrb::Model::Cos::Stream
+          )
+          stream.stream = ttf_data
+          stream
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/font/true_type.rb

@@ -9,6 +9,13 @@ module Pdfrb
       autoload :Hmtx, "pdfrb/font/true_type/hmtx"
       autoload :Cmap, "pdfrb/font/true_type/cmap"
       autoload :OS2, "pdfrb/font/true_type/os2"
+      autoload :Maxp, "pdfrb/font/true_type/maxp"
+      autoload :Post, "pdfrb/font/true_type/post"
+      autoload :Name, "pdfrb/font/true_type/name"
+      autoload :Loca, "pdfrb/font/true_type/loca"
+      autoload :Glyf, "pdfrb/font/true_type/glyf"
+      autoload :Kern, "pdfrb/font/true_type/kern"
+      autoload :Wrapper, "pdfrb/font/true_type/wrapper"
     end
   end
 end

data/lib/pdfrb/font.rb

@@ -10,6 +10,8 @@ module Pdfrb
     autoload :CMap, "pdfrb/font/cmap"
     autoload :TrueType, "pdfrb/font/true_type"
     autoload :Type1, "pdfrb/font/type1"
+    autoload :Metrics, "pdfrb/font/metrics_helper"
+    autoload :MetricsHelper, "pdfrb/font/metrics_helper"
   end
 
   # Top-level font loader registry. Extends what +Document::Fonts+

data/lib/pdfrb/font_loader/from_configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module FontLoader
+    module FromConfiguration
+      module_function
+
+      def call(document, name, **_opts)
+        config = document.config["font.#{name}"]
+        return nil unless config
+
+        case config["type"]
+        when "standard14" then Standard14.call(document, config["name"] || name)
+        when "file" then FromFile.call(document, config["path"])
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/font_loader/from_file.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module FontLoader
+    module FromFile
+      module_function
+
+      def call(document, path, **_opts)
+        return nil unless path.is_a?(String) && File.file?(path)
+
+        data = File.binread(path)
+        magic = data&.byteslice(0, 4)
+        return nil unless magic
+        return nil unless ["\x00\x01\x00\x00".b, "true".b, "OTTO".b].include?(magic)
+
+        Pdfrb::Font::TrueType::Wrapper.embed(document, data, resource_name: :F1)
+      end
+    end
+  end
+end

data/lib/pdfrb/font_loader/standard14.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module FontLoader
+    module Standard14
+      STANDARDS = %w[Helvetica Helvetica-Bold Helvetica-Oblique Helvetica-BoldOblique
+                     Times-Roman Times-Bold Times-Italic Times-BoldItalic
+                     Courier Courier-Bold Courier-Oblique Courier-BoldOblique Symbol ZapfDingbats].freeze
+
+      module_function
+
+      def call(document, name, **_opts)
+        return nil unless STANDARDS.include?(name.to_s)
+
+        document.add({ Type: :Font, Subtype: :Type1, BaseFont: name.to_sym },
+                     type: Pdfrb::Model::Type::FontType1)
+      end
+    end
+  end
+end

data/lib/pdfrb/font_loader/variant_from_name.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module FontLoader
+    module VariantFromName
+      BASE_MAP = {
+        "Helvetica" => %w[Helvetica Helvetica-Bold Helvetica-Oblique Helvetica-BoldOblique],
+        "Times" => %w[Times-Roman Times-Bold Times-Italic Times-BoldItalic],
+        "Courier" => %w[Courier Courier-Bold Courier-Oblique Courier-BoldOblique],
+      }.freeze
+
+      module_function
+
+      def call(document, name, **_opts)
+        return nil unless name.is_a?(String)
+
+        base = name.sub(/[- ](Bold|Italic|Oblique|BoldItalic|BoldOblique).*/i, "")
+        return nil unless BASE_MAP.key?(base)
+
+        idx = case name
+              when /bold.*italic|italic.*bold/i
+                3
+              when /bold/i
+                1
+              else
+                /oblique|italic/i.match?(name) ? 2 : 0
+              end
+        full_name = BASE_MAP[base][idx]
+        return nil unless full_name
+
+        document.add({ Type: :Font, Subtype: :Type1, BaseFont: full_name.to_sym },
+                     type: Pdfrb::Model::Type::FontType1)
+      end
+    end
+  end
+end

data/lib/pdfrb/font_loader.rb

@@ -6,5 +6,9 @@ module Pdfrb
   module FontLoader
     autoload :TrueType, "pdfrb/font_loader/true_type"
     autoload :Type1, "pdfrb/font_loader/type1"
+    autoload :Standard14, "pdfrb/font_loader/standard14"
+    autoload :FromFile, "pdfrb/font_loader/from_file"
+    autoload :VariantFromName, "pdfrb/font_loader/variant_from_name"
+    autoload :FromConfiguration, "pdfrb/font_loader/from_configuration"
   end
 end

data/lib/pdfrb/font_resolver.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Font file resolver. Searches system font directories for font files
+  # by family name + style. Eliminates the need for external font-finding
+  # libraries like fontisan.
+  class FontResolver
+    DEFAULT_SEARCH_PATHS = [
+      "/System/Library/Fonts",
+      "/Library/Fonts",
+      File.expand_path("~/Library/Fonts"),
+      "/usr/share/fonts",
+      File.expand_path("~/.local/share/fonts"),
+      "/usr/local/share/fonts",
+    ].freeze
+
+    FontInfo = Struct.new(:path, :family, :style, :ps_name, keyword_init: true)
+
+    attr_reader :search_paths, :cache
+
+    def initialize(search_paths: DEFAULT_SEARCH_PATHS)
+      @search_paths = search_paths.dup
+      @cache = nil
+    end
+
+    def find(family:, style: "Regular")
+      build_cache unless @cache
+      normalized_family = family.downcase.gsub(/\s+/, "")
+      normalized_style = style.downcase.gsub(/\s+/, "")
+
+      @cache.each do |info|
+        next unless info.family&.downcase&.gsub(/\s+/, "") == normalized_family
+        next unless match_style?(info.style, normalized_style)
+
+        return info.path
+      end
+      nil
+    end
+
+    def find_by_ps_name(ps_name)
+      build_cache unless @cache
+      normalized = ps_name.downcase
+
+      @cache.each do |info|
+        return info.path if info.ps_name&.downcase == normalized
+      end
+      nil
+    end
+
+    def available_fonts
+      build_cache unless @cache
+      @cache.dup
+    end
+
+    private
+
+    def match_style?(actual, requested)
+      return true if requested == "regular" && (actual.nil? || actual == "" || actual.downcase == "regular")
+      return true if actual&.downcase&.gsub(/\s+/, "") == requested
+
+      false
+    end
+
+    def build_cache
+      @cache = []
+      @search_paths.each do |dir|
+        next unless Dir.exist?(dir)
+
+        Dir.glob("**/*.{ttf,otf,ttc}", base: dir).each do |rel_path|
+          full_path = File.join(dir, rel_path)
+          info = parse_font_info(full_path)
+          @cache << info if info
+        end
+      end
+      @cache.freeze
+    end
+
+    def parse_font_info(path)
+      data = File.binread(path)
+      return nil unless valid_font_magic?(data)
+
+      ttf = Pdfrb::Font::TrueType::File.new(data)
+      name_table = ttf.name_table
+      return FontInfo.new(path: path) unless name_table
+
+      records = parse_name_table(name_table)
+      family = records[1] || records[16]
+      subfamily = records[2] || records[17]
+      ps_name = records[6]
+
+      FontInfo.new(path: path, family: family, style: subfamily, ps_name: ps_name)
+    rescue StandardError
+      FontInfo.new(path: path)
+    end
+
+    def valid_font_magic?(data)
+      return false if data.bytesize < 4
+
+      magic = data.byteslice(0, 4)
+      return true if magic == "ttcf".b
+      return true if magic == "\x00\x01\x00\x00".b
+      return true if magic == "OTTO".b
+      return true if magic == "true".b
+      return true if magic == "typ1".b
+
+      false
+    end
+
+    def parse_name_table(name_data)
+      results = {}
+      return results unless name_data && name_data.bytesize >= 6
+
+      name_data.unpack1("n")
+      count = name_data.unpack1("n", offset: 2)
+      string_offset = name_data.unpack1("n", offset: 4)
+
+      count.times do |i|
+        offset = 6 + (i * 12)
+        break if offset + 12 > name_data.bytesize
+
+        platform_id, _encoding_id, _lang_id, name_id, length, str_offset =
+          name_data.unpack("nnnnnn", offset: offset)
+        next unless [1, 3].include?(platform_id)
+
+        raw = name_data.byteslice(string_offset + str_offset, length)
+        next unless raw
+
+        str = if platform_id == 3
+                raw.unpack("n*").pack("U*")
+              else
+                raw.force_encoding("UTF-8")
+              end
+        results[name_id] = str
+      end
+      results
+    end
+  end
+end

data/lib/pdfrb/image/audit.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Image
+    # Read-only metadata extractor for embedded image XObjects. Used
+    # by Task::Optimize to find downsampling candidates and by callers
+    # that need to know what's in a document without re-parsing every
+    # stream.
+    module Audit
+      ImageInfo = Struct.new(
+        :oid, :width, :height, :bits_per_component, :color_space,
+        :filter_name, :decoded_bytesize, :stream_bytesize, :smask_oid,
+        keyword_init: true
+      )
+
+      module_function
+
+      # Enumerate every image XObject in +document+. Yields an
+      # ImageInfo per image; returns an Enumerator if no block given.
+      def each_image(document)
+        return enum_for(:each_image, document) unless block_given?
+
+        document.each_indirect_object do |obj|
+          next unless image_xobject?(obj)
+
+          yield info_for(obj)
+        end
+      end
+
+      # Return an Array of all image infos (mirror of #each_image).
+      def all(document)
+        each_image(document).to_a
+      end
+
+      # Find images whose pixel count exceeds +target_pixels+. Useful
+      # for spotting oversized images worth downsampling. Returns an
+      # Array of ImageInfo.
+      def oversized(document, target_pixels:)
+        all(document).select do |info|
+          (info.width || 0) * (info.height || 0) > target_pixels
+        end
+      end
+
+      def image_xobject?(obj)
+        return false unless obj.is_a?(Pdfrb::Model::Cos::Stream)
+
+        obj.value[:Type] == :XObject && obj.value[:Subtype] == :Image
+      end
+
+      def info_for(image)
+        ImageInfo.new(
+          oid: image.oid,
+          width: image.value[:Width],
+          height: image.value[:Height],
+          bits_per_component: image.value[:BitsPerComponent],
+          color_space: image.value[:ColorSpace],
+          filter_name: image.value[:Filter],
+          decoded_bytesize: decoded_size(image),
+          stream_bytesize: image.stream&.bytesize || 0,
+          smask_oid: smask_oid(image)
+        )
+      end
+
+      def decoded_size(image)
+        w = image.value[:Width]
+        h = image.value[:Height]
+        bpc = image.value[:BitsPerComponent] || 8
+        return nil unless w && h
+
+        channels = channels_for(image.value[:ColorSpace])
+        (w * h * channels * bpc) / 8
+      end
+
+      def channels_for(color_space)
+        case color_space
+        when :DeviceGray, :CalGray, :Indexed then 1
+        when :DeviceCMYK then 4
+        else
+          # :DeviceRGB, :CalRGB, :Lab, nil, and ICCBased (default to
+          # 3 channels when we can't introspect the profile) all share
+          # this branch.
+          3
+        end
+      end
+
+      def smask_oid(image)
+        smask = image.value[:SMask]
+        return nil unless smask.is_a?(Pdfrb::Model::Reference)
+
+        smask.oid
+      end
+    end
+  end
+end