pdfrb 0.1.0

data/lib/pdfrb/font/encoding.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module Encoding
+      autoload :PDFDocEncoding, "pdfrb/font/encoding/pdf_doc_encoding"
+      autoload :StandardEncoding, "pdfrb/font/encoding/standard_encoding"
+      autoload :WinAnsiEncoding, "pdfrb/font/encoding/win_ansi_encoding"
+      autoload :MacRomanEncoding, "pdfrb/font/encoding/mac_roman_encoding"
+      autoload :ZapfDingbatsEncoding, "pdfrb/font/encoding/zapf_dingbats_encoding"
+
+      class << self
+        # Decode +bytes+ (one byte per glyph) using +encoding_name+
+        # (a Symbol like :WinAnsiEncoding) to Unicode.
+        def decode(encoding_name, bytes)
+          table = table_for(encoding_name)
+          return bytes unless table
+
+          bytes.each_byte.with_object(+"") do |b, buf|
+            buf << (table[b] ? [table[b]].pack("U") : "?")
+          end.encode("UTF-8")
+        end
+
+        def table_for(name)
+          case name.to_sym
+          when :WinAnsiEncoding then WinAnsiEncoding::TABLE
+          when :MacRomanEncoding then MacRomanEncoding::TABLE
+          when :StandardEncoding then StandardEncoding::TABLE
+          when :PDFDocEncoding then PDFDocEncoding::TABLE
+          when :ZapfDingbatsEncoding then ZapfDingbatsEncoding::TABLE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/font/glyph_list.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    # Adobe Glyph List — maps glyph names to Unicode codepoints.
+    # Loaded from data/pdfrb/glyphlist.txt on first access.
+    module GlyphList
+      @table = nil
+
+      class << self
+        def table
+          return @table if @table
+
+          path = File.join(Pdfrb::DataDir.root, "glyphlist.txt")
+          @table = if File.exist?(path)
+                     parse(File.read(path, encoding: "UTF-8"))
+                   else
+                     {}
+                   end
+        end
+
+        def [](glyph_name)
+          table[glyph_name]
+        end
+
+        def unicode_for(glyph_name)
+          table[glyph_name]
+        end
+
+        private
+
+        def parse(text)
+          text.each_line.with_object({}) do |line, h|
+            next if line.start_with?("#")
+
+            parts = line.strip.split(";")
+            next unless parts.length >= 2
+
+            name = parts[0]
+            value = parts[1]
+            # Glyphlist files come in two formats: Adobe's canonical
+            # ("2013 2014" — hex codepoints space-separated) and
+            # repackagings that use literal Unicode ("–"). Detect by
+            # whether the value is all-hex.
+            h[name] = if !value.empty? && value.match?(/\A[0-9A-Fa-f ]+\z/)
+                        unicodes = value.split.map { |hex| hex.to_i(16) }
+                        unicodes.map { |cp| [cp].pack("U") }.join
+                      else
+                        value
+                      end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      # `cmap` table parser. Resolves Unicode codepoints to glyph IDs
+      # by picking the best available subtable and applying its
+      # format-specific decoding.
+      #
+      # Supported subtable formats:
+      #   * 0  — byte encoding (256 entries)
+      #   * 4  — segment mapping (BMP)
+      #   * 6  — trimmed table (range)
+      #   * 12 — sparse coverage (full Unicode)
+      #
+      # Subtable selection prefers Unicode platforms:
+      #   (3,10) Windows Unicode full > (0,* ) Unicode > (3,1) Windows BMP
+      class Cmap
+        attr_reader :subtable_offset, :platform_id, :encoding_id, :format
+
+        PREFERRED_SUBTABLES = [
+          [3, 12], # Windows Unicode full repertoire
+          [0, 6],  # Unicode full (format 12-style)
+          [0, 4],  # Unicode 2.0+ BMP
+          [3, 1],  # Windows BMP
+          [0, 0],  # Unicode 1.0
+          [0, 1],  # Unicode 1.1
+          [0, 2],  # Unicode 2.0 (no format declared)
+          [0, 3], # Unicode 2.0+ BMP
+        ].freeze
+        private_constant :PREFERRED_SUBTABLES
+
+        def initialize(data)
+          @data = data
+          @glyph_cache = {}
+          return unless data && data.bytesize >= 4
+
+          choose_subtable
+        end
+
+        # Unicode codepoint → glyph ID. Returns 0 (.notdef) if no
+        # mapping exists.
+        def glyph_id_for(unicode)
+          return 0 if @format.nil?
+
+          @glyph_cache[unicode] ||= lookup(unicode)
+        end
+
+        private
+
+        def choose_subtable
+          num_tables = u16(2)
+          entries = []
+          num_tables.times do |i|
+            base = 4 + (i * 8)
+            entries << {
+              platform_id: u16(base),
+              encoding_id: u16(base + 2),
+              offset: u32(base + 4),
+            }
+          end
+          pick = PREFERRED_SUBTABLES.each do |plat, enc|
+            found = entries.find { |e| e[:platform_id] == plat && e[:encoding_id] == enc }
+            break found if found
+          end
+          return unless pick.is_a?(::Hash)
+
+          @platform_id = pick[:platform_id]
+          @encoding_id = pick[:encoding_id]
+          @subtable_offset = pick[:offset]
+          read_format_header
+        end
+
+        def read_format_header
+          @format = u16(@subtable_offset)
+          case @format
+          when 0 then parse_format_0
+          when 4 then parse_format_4
+          when 6 then parse_format_6
+          when 12 then parse_format_12
+          else
+            @format = nil
+          end
+        end
+
+        def lookup(unicode)
+          case @format
+          when 0 then lookup_format_0(unicode)
+          when 4 then lookup_format_4(unicode)
+          when 6 then lookup_format_6(unicode)
+          when 12 then lookup_format_12(unicode)
+          else 0
+          end
+        end
+
+        # Format 0: 256-entry byte table.
+        def parse_format_0
+          @f0_glyph_ids = (0..255).map { |i| u8(@subtable_offset + 6 + i) }
+        end
+
+        def lookup_format_0(unicode)
+          return 0 unless unicode < 256
+
+          @f0_glyph_ids[unicode]
+        end
+
+        # Format 4: segment mapping. BMP only.
+        def parse_format_4
+          seg_count_x2 = u16(@subtable_offset + 6)
+          seg_count = seg_count_x2 / 2
+          end_codes_off = @subtable_offset + 14
+          start_codes_off = end_codes_off + seg_count_x2 + 2
+          id_deltas_off = start_codes_off + seg_count_x2
+          id_range_offsets_off = id_deltas_off + seg_count_x2
+          glyph_ids_off = id_range_offsets_off + seg_count_x2
+          @f4 = {
+            seg_count: seg_count,
+            end_codes: read_u16s(end_codes_off, seg_count),
+            start_codes: read_u16s(start_codes_off, seg_count),
+            id_deltas: read_s16s(id_deltas_off, seg_count),
+            id_range_offsets: read_u16s(id_range_offsets_off, seg_count),
+            glyph_ids_off: glyph_ids_off,
+          }
+        end
+
+        def lookup_format_4(unicode)
+          return 0 unless @f4
+
+          seg = @f4
+          seg[:seg_count].times do |i|
+            next if unicode > seg[:end_codes][i]
+
+            return 0 if unicode < seg[:start_codes][i]
+
+            delta = seg[:id_deltas][i]
+            range_off = seg[:id_range_offsets][i]
+            if range_off.zero?
+              return (unicode + delta) & 0xFFFF
+            end
+
+            # Indirect: glyph_id_addr = id_range_offset + 2*(c - startCode) + addressof(idRangeOffsets[i])
+            seg[:id_range_offsets_offset] + (i * 2) + range_off + ((unicode - seg[:start_codes][i]) * 2)
+            abs_off = id_range_offset_abs(i, range_off, unicode, seg[:start_codes][i])
+            gid = u16(abs_off)
+            gid.zero? ? 0 : (gid + delta) & 0xFFFF
+          end
+          0
+        end
+
+        def id_range_offset_abs(i, range_off, unicode, start_code)
+          seg = @f4
+          base = seg[:id_range_offsets_offset] + (i * 2)
+          base + range_off + ((unicode - start_code) * 2)
+        end
+
+        # Format 6: trimmed table.
+        def parse_format_6
+          first = u16(@subtable_offset + 6)
+          count = u16(@subtable_offset + 8)
+          @f6 = {
+            first_code: first,
+            count: count,
+            glyph_ids: read_u16s(@subtable_offset + 10, count),
+          }
+        end
+
+        def lookup_format_6(unicode)
+          return 0 unless @f6
+
+          idx = unicode - @f6[:first_code]
+          return 0 unless idx >= 0 && idx < @f6[:count]
+
+          @f6[:glyph_ids][idx]
+        end
+
+        # Format 12: sparse coverage, full Unicode.
+        def parse_format_12
+          num_groups = u32(@subtable_offset + 12)
+          @f12 = []
+          num_groups.times do |i|
+            base = @subtable_offset + 16 + (i * 12)
+            @f12 << {
+              start_char: u32(base),
+              end_char: u32(base + 4),
+              start_gid: u32(base + 8),
+            }
+          end
+        end
+
+        def lookup_format_12(unicode)
+          return 0 unless @f12
+
+          # Binary search for the group covering this codepoint.
+          lo = 0
+          hi = @f12.length - 1
+          while lo <= hi
+            mid = (lo + hi) / 2
+            g = @f12[mid]
+            if unicode < g[:start_char]
+              hi = mid - 1
+            elsif unicode > g[:end_char]
+              lo = mid + 1
+            else
+              return g[:start_gid] + (unicode - g[:start_char])
+            end
+          end
+          0
+        end
+
+        def u8(off); @data.getbyte(off); end
+
+        def u16(off)
+          return 0 if off.nil? || off + 1 >= @data.bytesize
+
+          (@data.getbyte(off) * 256) + @data.getbyte(off + 1)
+        end
+
+        def u32(off)
+          return 0 if off.nil? || off + 3 >= @data.bytesize
+
+          (((@data.getbyte(off) * 256) + @data.getbyte(off + 1)) * 65536) +
+            ((@data.getbyte(off + 2) * 256) + @data.getbyte(off + 3))
+        end
+
+        def s16(off)
+          v = u16(off)
+          v >= 0x8000 ? v - 0x10000 : v
+        end
+
+        def read_u16s(off, count)
+          Array.new(count) { |i| u16(off + (i * 2)) }
+        end
+
+        def read_s16s(off, count)
+          Array.new(count) { |i| s16(off + (i * 2)) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      # Minimal TrueType / OpenType font file reader. Parses the
+      # sfnt header + table directory; lazy-loads individual tables
+      # on access.
+      class File
+        attr_reader :tables, :num_tables
+
+        def initialize(data)
+          @data = data.b
+          @tables = {}
+          parse_directory
+        end
+
+        def self.read(path)
+          new(::File.binread(path))
+        end
+
+        def table(tag)
+          return @tables[tag][:data] if @tables[tag]
+
+          entry = find_table_entry(tag)
+          return nil unless entry
+
+          offset = entry[:offset]
+          length = entry[:length]
+          @data.byteslice(offset, length).force_encoding(::Encoding::BINARY)
+        end
+
+        def cmap_table; table("cmap"); end
+        def head_table; table("head"); end
+        def hhea_table; table("hhea"); end
+        def hmtx_table; table("hmtx"); end
+        def name_table; table("name"); end
+        def maxp_table; table("maxp"); end
+        def post_table; table("post"); end
+        def os2_table; table("OS/2"); end
+        def glyf_table; table("glyf"); end
+        def loca_table; table("loca"); end
+
+        # Parsed-table accessors. Lazy and memoised on the instance.
+        def head; @head ||= Head.new(head_table); end
+        def hhea; @hhea ||= Hhea.new(hhea_table); end
+        def os2; @os2 ||= OS2.new(os2_table); end
+        def cmap; @cmap ||= Cmap.new(cmap_table); end
+
+        def hmtx
+          @hmtx ||= Hmtx.new(hmtx_table, number_of_hmetrics: hhea.number_of_hmetrics || 0)
+        end
+
+        def num_glyphs
+          return 0 unless maxp_table
+
+          maxp_table.getbyte(4) * 256 + maxp_table.getbyte(5)
+        end
+
+        private
+
+        def parse_directory
+          return if @data.bytesize < 12
+
+          sfnt_version = @data.getbyte(0) * 256 + @data.getbyte(1)
+          @num_tables = @data.getbyte(4) * 256 + @data.getbyte(5)
+          @raw_entries = []
+          @num_tables.times do |i|
+            base = 12 + i * 16
+            tag = @data.byteslice(base, 4)
+            checksum = @data.byteslice(base + 4, 4).unpack1("N")
+            offset = @data.byteslice(base + 8, 4).unpack1("N")
+            length = @data.byteslice(base + 12, 4).unpack1("N")
+            @raw_entries << { tag: tag, checksum: checksum,
+                              offset: offset, length: length }
+          end
+        end
+
+        def find_table_entry(tag)
+          @raw_entries&.find { |e| e[:tag] == tag }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      # `head` table parser. Exposes units_per_em, bbox, index_format
+      # (loca long vs short), mac_style flags.
+      #
+      # Spec: OpenType "head" v1.0 — 54 bytes.
+      class Head
+        attr_reader :units_per_em, :bbox, :index_to_loc_format,
+                    :mac_style, :lowest_rec_ppem, :font_direction_hint
+
+        def initialize(data)
+          @data = data
+          return unless data && data.bytesize >= 54
+
+          @units_per_em = u16(18)
+          @bbox = [s16(36), s16(38), s16(40), s16(42)]
+          @index_to_loc_format = s16(50)
+          @mac_style = u16(44)
+          @lowest_rec_ppem = u16(48)
+          @font_direction_hint = s16(52)
+        end
+
+        def long_loca?; @index_to_loc_format == 1; end
+        def short_loca?; @index_to_loc_format.zero?; end
+
+        def bold?; (@mac_style || 0) & 0x01 != 0; end
+        def italic?; (@mac_style || 0) & 0x02 != 0; end
+
+        private
+
+        def u16(off); (@data.getbyte(off) * 256) + @data.getbyte(off + 1); end
+
+        def s16(off)
+          v = u16(off)
+          v >= 0x8000 ? v - 0x10000 : v
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      # `hhea` (Horizontal Header) table parser. Exposes ascender,
+      # descender, line_gap, number_of_hmetrics (used by `hmtx`).
+      #
+      # Spec: OpenType "hhea" v1.0 — 36 bytes.
+      class Hhea
+        attr_reader :ascender, :descender, :line_gap,
+                    :number_of_hmetrics, :advance_width_max
+
+        def initialize(data)
+          @data = data
+          return unless data && data.bytesize >= 36
+
+          @ascender = s16(4)
+          @descender = s16(6)
+          @line_gap = s16(8)
+          @advance_width_max = u16(10)
+          @number_of_hmetrics = u16(34)
+        end
+
+        private
+
+        def u16(off); (@data.getbyte(off) * 256) + @data.getbyte(off + 1); end
+
+        def s16(off)
+          v = u16(off)
+          v >= 0x8000 ? v - 0x10000 : v
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      # `hmtx` (Horizontal Metrics) table parser. Provides per-glyph
+      # advance widths and left-side bearings.
+      #
+      # Layout: `numberOfHMetrics` records of (u16 advance, u16 lsb),
+      # followed by (`numGlyphs - numberOfHMetrics`) u16 lsbs (those
+      # glyphs share the last advance width).
+      class Hmtx
+        attr_reader :advances, :lsbs, :number_of_hmetrics
+
+        def initialize(data, number_of_hmetrics:)
+          @data = data || "".b
+          @number_of_hmetrics = number_of_hmetrics
+          parse
+        end
+
+        def advance_width(glyph_id)
+          return 0 if @advances.empty?
+
+          if glyph_id < @number_of_hmetrics
+            @advances[glyph_id]
+          else
+            @advances.last
+          end
+        end
+
+        def lsb(glyph_id)
+          @lsbs[glyph_id] || @lsbs.last || 0
+        end
+
+        private
+
+        def parse
+          @advances = []
+          @lsbs = []
+          return if @data.bytesize < @number_of_hmetrics * 4
+
+          @number_of_hmetrics.times do |i|
+            base = i * 4
+            @advances << u16(base)
+            @lsbs << s16(base + 2)
+          end
+        end
+
+        def u16(off); (@data.getbyte(off) * 256) + @data.getbyte(off + 1); end
+
+        def s16(off)
+          v = u16(off)
+          v >= 0x8000 ? v - 0x10000 : v
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      # `OS/2` table parser. Exposes typographic extents and Windows
+      # metrics used to compute font ascent / descent / cap height
+      # for layout.
+      #
+      # Spec: OpenType "OS/2" versions 1–5; offsets vary by version.
+      # Only the fields relevant to layout are exposed.
+      class OS2
+        attr_reader :version, :s_typo_ascender, :s_typo_descender,
+                    :s_typo_line_gap, :us_win_ascent, :us_win_descent,
+                    :sx_height, :s_cap_height, :us_weight_class,
+                    :fs_selection
+
+        def initialize(data)
+          @data = data
+          return unless data && data.bytesize >= 78
+
+          @version = u16(0)
+          @s_typo_ascender = s16(68)
+          @s_typo_descender = s16(70)
+          @s_typo_line_gap = s16(72)
+          @us_win_ascent = u16(74)
+          @us_win_descent = u16(76)
+
+          return unless @version >= 2 && data.bytesize >= 96
+
+          @sx_height = s16(86)
+          @s_cap_height = s16(88)
+          @us_weight_class = u16(4)
+          @fs_selection = u16(62)
+        end
+
+        def bold?; (@fs_selection || 0) & 0x20 != 0; end
+        def italic?; (@fs_selection || 0) & 0x01 != 0; end
+
+        private
+
+        def u16(off); (@data.getbyte(off) * 256) + @data.getbyte(off + 1); end
+
+        def s16(off)
+          v = u16(off)
+          v >= 0x8000 ? v - 0x10000 : v
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      # Glyph subsetting for embedded TrueType fonts. Given a set of
+      # used glyph IDs, produces a new TTF with only those glyphs.
+      # This is a stub — full subsetting (table rewriting, composite
+      # glyph handling, CMap format 4 rewrite) is complex.
+      class Subsetter
+        attr_reader :source_file, :glyph_ids
+
+        def initialize(source_file, glyph_ids)
+          @source_file = source_file
+          @glyph_ids = glyph_ids.sort.uniq
+        end
+
+        # Returns the subset font bytes. Currently a stub that
+        # returns the original file unmodified (no subsetting).
+        # Full implementation would rewrite glyf, loca, cmap, hmtx,
+        # maxp, OS/2 tables.
+        def subset
+          @source_file.instance_variable_get(:@data)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/font/true_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      autoload :File, "pdfrb/font/true_type/file"
+      autoload :Head, "pdfrb/font/true_type/head"
+      autoload :Hhea, "pdfrb/font/true_type/hhea"
+      autoload :Hmtx, "pdfrb/font/true_type/hmtx"
+      autoload :Cmap, "pdfrb/font/true_type/cmap"
+      autoload :OS2, "pdfrb/font/true_type/os2"
+    end
+  end
+end

data/lib/pdfrb/font/type1/font_metrics.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module Type1
+      # Type1 font metrics wrapper. Delegates to AFMParser for the
+      # 14 standard fonts; provides glyph-width lookup.
+      class FontMetrics
+        attr_reader :font_name, :metrics
+
+        def initialize(font_name, metrics)
+          @font_name = font_name
+          @metrics = metrics
+        end
+
+        def self.for_standard_font(name)
+          afm_path = File.join(Pdfrb::DataDir.root, "afm", "#{name}.afm")
+          return nil unless File.exist?(afm_path)
+
+          metrics = AFMParser.from_file(afm_path)
+          new(name, metrics)
+        end
+
+        def width_for(glyph_name)
+          @metrics.width_for(glyph_name)
+        end
+
+        def bbox
+          @metrics.bbox
+        end
+
+        def ascender
+          @metrics.ascender
+        end
+
+        def descender
+          @metrics.descender
+        end
+
+        def cap_height
+          @metrics.cap_height
+        end
+      end
+    end
+  end
+end