pdfrb 0.3.0 → 0.7.1

data/lib/pdfrb/font/afm_parser.rb

@@ -7,10 +7,13 @@ module Pdfrb
     class AFMParser
       attr_reader :font_name, :full_name, :family_name,
                   :encoding_scheme, :bbox, :cap_height, :x_height,
-                  :ascender, :descender, :char_metrics
+                  :ascender, :descender, :italic_angle,
+                  :average_width, :max_width, :char_metrics
 
       def initialize
         @char_metrics = {}
+        @average_width = nil
+        @max_width = nil
       end
 
       def self.parse(text)
@@ -25,35 +28,48 @@ module Pdfrb
         in_char_metrics = false
         text.each_line do |line|
           line = line.strip
-          if line.start_with?("FontName ")
-            @font_name = line.split(" ", 2)[1]
-          elsif line.start_with?("FullName ")
-            @full_name = line.split(" ", 2)[1]
-          elsif line.start_with?("FamilyName ")
-            @family_name = line.split(" ", 2)[1]
-          elsif line.start_with?("EncodingScheme ")
-            @encoding_scheme = line.split(" ", 2)[1]
-          elsif line.start_with?("FontBBox ")
-            @bbox = line.split.drop(1).map(&:to_f)
-          elsif line.start_with?("CapHeight ")
-            @cap_height = line.split[1].to_f
-          elsif line.start_with?("XHeight ")
-            @x_height = line.split[1].to_f
-          elsif line.start_with?("Ascender ")
-            @ascender = line.split[1].to_f
-          elsif line.start_with?("Descender ")
-            @descender = line.split[1].to_f
-          elsif line == "StartCharMetrics" || line.start_with?("StartCharMetrics ")
-            in_char_metrics = true
-          elsif line == "EndCharMetrics" || line.start_with?("EndCharMetrics")
-            in_char_metrics = false
-          elsif in_char_metrics && line.start_with?("C ")
-            parse_char_metric(line)
-          end
+          in_char_metrics = parse_line(line, in_char_metrics)
         end
         self
       end
 
+      def parse_line(line, in_char_metrics)
+        return handle_state_change(line, in_char_metrics) if parse_global_metric(line) == :handled
+
+        handle_state_change(line, in_char_metrics)
+      end
+
+      def handle_state_change(line, in_char_metrics)
+        if line.start_with?("StartCharMetrics")
+          true
+        elsif line.start_with?("EndCharMetrics")
+          compute_average_and_max_widths
+          false
+        elsif in_char_metrics && line.start_with?("C ")
+          parse_char_metric(line)
+          in_char_metrics
+        else
+          in_char_metrics
+        end
+      end
+
+      def parse_global_metric(line)
+        case line
+        when /\AFontName / then @font_name = line.split(" ", 2)[1]
+        when /\AFullName / then @full_name = line.split(" ", 2)[1]
+        when /\AFamilyName / then @family_name = line.split(" ", 2)[1]
+        when /\AEncodingScheme / then @encoding_scheme = line.split(" ", 2)[1]
+        when /\AFontBBox / then @bbox = line.split.drop(1).map(&:to_f)
+        when /\ACapHeight / then @cap_height = line.split[1].to_f
+        when /\AXHeight / then @x_height = line.split[1].to_f
+        when /\AAscender / then @ascender = line.split[1].to_f
+        when /\ADescender / then @descender = line.split[1].to_f
+        when /\AItalicAngle / then @italic_angle = line.split[1].to_f
+        else return nil
+        end
+        :handled
+      end
+
       def width_for(glyph_name_or_code)
         metric = @char_metrics[glyph_name_or_code] ||
                  @char_metrics[glyph_name_or_code.to_i]
@@ -62,6 +78,14 @@ module Pdfrb
 
       private
 
+      def compute_average_and_max_widths
+        widths = @char_metrics.values.filter_map { |m| m[:width] }
+        return if widths.empty?
+
+        @average_width = widths.sum / widths.length
+        @max_width = widths.max
+      end
+
       def parse_char_metric(line)
         parts = line.split(";").map(&:strip)
         code = nil

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

@@ -12,6 +12,15 @@ module Pdfrb
       # chunking of bfchar sections (max 100 entries per section per
       # the PDF spec).
       class Writer
+        def self.write(mapping, name: "Adobe-Identity-UCS")
+          str_mapping = mapping.transform_values { |cp| [cp].pack("U") }
+          new(
+            cmap_name: name,
+            cid_system_info: { registry: "Adobe", ordering: "UCS", supplement: 0 },
+            mapping: str_mapping,
+            code_size: 1,
+          ).to_s
+        end
         MAX_BFCHAR_ENTRIES = 100
 
         attr_reader :cmap_name, :cid_system_info, :mapping

data/lib/pdfrb/font/encoding/win_ansi_encoding.rb

@@ -19,6 +19,23 @@ module Pdfrb
         }.each { |b, cp| TABLE[b] = cp }
         (0xA0..0xFF).each { |b| TABLE[b] = b }
         TABLE.freeze
+
+        class << self
+          def encode(text)
+            Pdfrb::Font::Encoding.encode(:WinAnsiEncoding, text)
+          end
+
+          def decode(bytes)
+            Pdfrb::Font::Encoding.decode(:WinAnsiEncoding, bytes)
+          end
+
+          def encodable?(codepoint)
+            return true if codepoint < 0x80
+
+            reverse = Pdfrb::Font::Encoding.reverse_table_for(:WinAnsiEncoding)
+            !reverse[codepoint].nil?
+          end
+        end
       end
     end
   end

data/lib/pdfrb/font/encoding.rb

@@ -10,17 +10,28 @@ module Pdfrb
       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") : "?")
+            cp = table.is_a?(::Array) ? table[b] : table[b.to_s.to_sym]
+            buf << (cp ? [cp].pack("U") : "?")
           end.encode("UTF-8")
         end
 
+        def encode(encoding_name, text)
+          table = table_for(encoding_name)
+          return text.to_s.b unless table
+
+          reverse = reverse_table_for(encoding_name)
+          text.to_s.each_char.with_object(+"") do |ch, buf|
+            cp = ch.ord
+            byte = reverse[cp] || (cp < 0x80 ? cp : nil)
+            buf << [byte || 0x3F].pack("C")
+          end.b
+        end
+
         def table_for(name)
           case name.to_sym
           when :WinAnsiEncoding then WinAnsiEncoding::TABLE
@@ -30,6 +41,24 @@ module Pdfrb
           when :ZapfDingbatsEncoding then ZapfDingbatsEncoding::TABLE
           end
         end
+
+        def reverse_table_for(name)
+          @reverse_tables ||= {}
+          @reverse_tables[name] ||= build_reverse_table(name)
+        end
+
+        def build_reverse_table(name)
+          table = table_for(name)
+          return {} unless table
+
+          if table.is_a?(::Array)
+            table.each_with_index.with_object({}) do |(cp, byte), h|
+              h[cp] = byte if cp
+            end
+          else
+            table.each_with_object({}) { |(byte, cp), h| h[cp] = byte }
+          end
+        end
       end
     end
   end

data/lib/pdfrb/font/metrics_helper.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    # Metrics value object + lookup helper. Returns ascent/descent/
+    # cap_height/x_height/line_gap/avg_width for any font (Standard 14
+    # via AFM, embedded TTF/OTF via head/hhea/OS2 tables).
+    Metrics = Struct.new(:font_name, :units_per_em, :ascent, :descent,
+                         :cap_height, :x_height, :line_gap, :avg_width,
+                         :max_width, :stem_v, :italic_angle, :bbox,
+                         keyword_init: true) do
+      def line_height(font_size)
+        ((ascent || 800) - (descent || -200) + (line_gap || 0)) *
+          font_size.to_f / (units_per_em || 1000)
+      end
+
+      def ascender(font_size)
+        (ascent || 800) * font_size.to_f / (units_per_em || 1000)
+      end
+
+      def descender(font_size)
+        (descent || -200) * font_size.to_f / (units_per_em || 1000)
+      end
+    end
+
+    module MetricsHelper
+      module_function
+
+      # Look up metrics for a Standard 14 font name.
+      # @param font_name [String, Symbol] e.g., "Helvetica", "Times-Roman".
+      # @return [Pdfrb::Font::Metrics, nil]
+      def metrics_for_standard14(font_name)
+        afm = afm_for(font_name.to_s)
+        return nil unless afm
+
+        Metrics.new(
+          font_name: font_name.to_s,
+          units_per_em: 1000,
+          ascent: afm.ascender,
+          descent: afm.descender,
+          cap_height: afm.cap_height,
+          x_height: afm.x_height,
+          line_gap: 0,
+          avg_width: afm.average_width,
+          max_width: afm.max_width,
+          stem_v: 80,
+          italic_angle: afm.italic_angle || 0,
+          bbox: afm.bbox
+        )
+      rescue StandardError
+        nil
+      end
+
+      # Look up metrics from raw TTF/OTF bytes.
+      # @param font_data [String] raw TTF or OTF bytes.
+      # @return [Pdfrb::Font::Metrics, nil]
+      def metrics_for_ttf(font_data)
+        return nil unless font_data && font_data.bytesize >= 4
+
+        ttf = Pdfrb::Font::TrueType::File.new(font_data)
+        head = ttf.head_table_parsed
+        hhea = ttf.hhea_table_parsed
+        os2 = ttf.os2_table_parsed
+        return nil unless head && hhea
+
+        Metrics.new(
+          font_name: ttf.name_table_parsed&.ps_name || "EmbeddedFont",
+          units_per_em: head.units_per_em || 1000,
+          ascent: hhea.ascender || os2&.s_typo_ascender || 800,
+          descent: hhea.descender || os2&.s_typo_descender || -200,
+          cap_height: os2&.s_cap_height || 700,
+          x_height: 500,
+          line_gap: hhea.line_gap || 0,
+          avg_width: 500,
+          max_width: hhea.advance_width_max || 1000,
+          stem_v: 80,
+          italic_angle: (head.italic? ? -12 : 0),
+          bbox: head.bbox
+        )
+      rescue StandardError
+        nil
+      end
+
+      # Convenience: dispatch on font_name vs raw bytes.
+      def metrics_for(font_name_or_data)
+        case font_name_or_data
+        when String
+          if font_name_or_data.bytesize >= 4 && valid_magic?(font_name_or_data)
+            metrics_for_ttf(font_name_or_data)
+          else
+            metrics_for_standard14(font_name_or_data)
+          end
+        when Symbol then metrics_for_standard14(font_name_or_data)
+        end
+      end
+
+      def valid_magic?(bytes)
+        magic = bytes.byteslice(0, 4)
+        ["\x00\x01\x00\x00".b, "OTTO".b, "true".b, "ttcf".b].include?(magic)
+      end
+
+      def afm_for(name)
+        @afm_cache ||= {}
+        return @afm_cache[name] if @afm_cache.key?(name)
+
+        path = standard14_afm_path(name)
+        return @afm_cache[name] = nil unless path && File.exist?(path)
+
+        @afm_cache[name] = Pdfrb::Font::AFMParser.parse(File.read(path))
+      end
+
+      def standard14_afm_path(name)
+        # __dir__ is lib/pdfrb/font/. Three .. gets to project root
+        # (lib/pdfrb/font → lib/pdfrb → lib → project root). Data
+        # files live at <root>/data/pdfrb/afm/.
+        base = File.expand_path("../../../data/pdfrb/afm", __dir__)
+        File.join(base, "#{name}.afm")
+      end
+    end
+  end
+end

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

@@ -7,10 +7,11 @@ module Pdfrb
       # sfnt header + table directory; lazy-loads individual tables
       # on access.
       class File
-        attr_reader :tables, :num_tables
+        attr_reader :tables, :num_tables, :raw_data
 
         def initialize(data)
           @data = data.b
+          @raw_data = @data
           @tables = {}
           parse_directory
         end
@@ -40,9 +41,17 @@ module Pdfrb
         def os2_table; table("OS/2"); end
         def glyf_table; table("glyf"); end
         def loca_table; table("loca"); end
+        def kern_table; table("kern"); end
 
         # Parsed-table accessors. Lazy and memoised on the instance.
         def head; @head ||= Head.new(head_table); end
+
+        def maxp; @maxp ||= Maxp.new(maxp_table); end
+        def post; @post ||= Post.new(post_table); end
+        def name_table_parsed; @name_table_parsed ||= Name.new(name_table); end
+        def loca_parsed; @loca_parsed ||= Loca.new(loca_table, long_format: head.long_loca?, num_glyphs: maxp.num_glyphs); end
+        def glyf_parsed; @glyf_parsed ||= Glyf.new(glyf_table, loca_parsed); end
+        def kern_parsed; @kern_parsed ||= Kern.new(kern_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

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      class Glyf
+        attr_reader :data, :loca
+
+        def initialize(data, loca = nil)
+          @data = data
+          @loca = loca
+        end
+
+        def glyph_data(glyph_id)
+          return nil unless @data && @loca
+          return nil if glyph_id >= @loca.offsets.length - 1
+
+          offset = @loca.glyph_offset(glyph_id)
+          length = @loca.glyph_length(glyph_id)
+          return nil if offset.nil? || length.zero?
+
+          @data.byteslice(offset, length)
+        end
+
+        def glyph_header(glyph_id)
+          g = glyph_data(glyph_id)
+          return nil unless g && g.bytesize >= 10
+
+          {
+            number_of_contours: s16(g, 0),
+            x_min: s16(g, 2),
+            y_min: s16(g, 4),
+            x_max: s16(g, 6),
+            y_max: s16(g, 8),
+          }
+        end
+
+        def composite?(glyph_id)
+          h = glyph_header(glyph_id)
+          h && h[:number_of_contours].negative?
+        end
+
+        def empty?(glyph_id)
+          length = @loca&.glyph_length(glyph_id) || 0
+          length.zero?
+        end
+
+        def component_glyphs(glyph_id)
+          return [] unless composite?(glyph_id)
+
+          g = glyph_data(glyph_id)
+          return [] unless g
+
+          components = []
+          offset = 10
+          loop do
+            break if offset + 4 > g.bytesize
+
+            flags = u16(g, offset)
+            glyph_index = u16(g, offset + 2)
+            components << glyph_index
+            offset += 4
+
+            offset += 4 if flags & 0x0001 != 0
+            offset += 2 if flags & 0x0002 != 0
+            break if flags.nobits?(0x0020)
+          end
+          components
+        end
+
+        private
+
+        def u16(d, o); (d.getbyte(o) << 8) | d.getbyte(o + 1); end
+
+        def s16(d, o)
+          v = u16(d, o)
+          v >= 32768 ? v - 65536 : v
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      class Kern
+        attr_reader :pairs
+
+        def initialize(data)
+          @pairs = {}
+          return unless data && data.bytesize >= 4
+
+          version = u16(data, 0)
+          n_tables = u16(data, 2)
+
+          offset = 4
+          n_tables.times do
+            break if offset + 6 > data.bytesize
+
+            u16(data, offset)
+            sub_length = u16(data, offset + 2)
+            coverage = u16(data, offset + 4)
+
+            if version.zero? && coverage & 0x0001 != 0
+              n_pairs = u16(data, offset + 6)
+              pair_offset = offset + 14
+
+              n_pairs.times do |_p|
+                break if pair_offset + 6 > data.bytesize
+
+                left = u16(data, pair_offset)
+                right = u16(data, pair_offset + 2)
+                value = s16(data, pair_offset + 4)
+                @pairs[[left, right]] = value
+                pair_offset += 6
+              end
+            end
+
+            offset += sub_length
+          end
+        end
+
+        def kerning(left_glyph, right_glyph)
+          @pairs[[left_glyph, right_glyph]] || 0
+        end
+
+        private
+
+        def u16(d, o); (d.getbyte(o) << 8) | d.getbyte(o + 1); end
+
+        def s16(d, o)
+          v = u16(d, o)
+          v >= 32768 ? v - 65536 : v
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      class Loca
+        attr_reader :offsets
+
+        def initialize(data, long_format: false, num_glyphs: 0)
+          @offsets = []
+          return unless data
+
+          count = num_glyphs + 1
+          count.times do |i|
+            @offsets << if long_format
+                          u32(data, i * 4)
+                        else
+                          (u16(data, i * 2) * 2)
+                        end
+          end
+        end
+
+        def glyph_offset(index)
+          return nil if index.nil? || index >= @offsets.length
+
+          @offsets[index]
+        end
+
+        def glyph_length(index)
+          return 0 if index.nil? || index + 1 >= @offsets.length
+
+          @offsets[index + 1] - @offsets[index]
+        end
+
+        private
+
+        def u16(data, off); (data.getbyte(off) << 8) | data.getbyte(off + 1); end
+        def u32(data, off); (data.getbyte(off) << 24) | (data.getbyte(off + 1) << 16) | (data.getbyte(off + 2) << 8) | data.getbyte(off + 3); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      class Maxp
+        attr_reader :version, :num_glyphs, :max_points, :max_contours,
+                    :max_composite_points, :max_composite_contours,
+                    :max_zones, :max_twilight_points, :max_storage,
+                    :max_function_defs, :max_instruction_defs,
+                    :max_stack_elements, :max_size_of_instructions,
+                    :max_component_elements, :max_component_depth
+
+        def initialize(data)
+          return unless data && data.bytesize >= 6
+
+          @version = data.bytes[0, 4].pack("C*").unpack1("N")
+          @num_glyphs = u16(data, 4)
+          return unless @version == 0x00010000 && data.bytesize >= 32
+
+          @max_points = u16(data, 6)
+          @max_contours = u16(data, 8)
+          @max_composite_points = u16(data, 10)
+          @max_composite_contours = u16(data, 12)
+          @max_zones = u16(data, 14)
+          @max_twilight_points = u16(data, 16)
+          @max_storage = u16(data, 18)
+          @max_function_defs = u16(data, 20)
+          @max_instruction_defs = u16(data, 22)
+          @max_stack_elements = u16(data, 24)
+          @max_size_of_instructions = u16(data, 26)
+          @max_component_elements = u16(data, 28)
+          @max_component_depth = u16(data, 30)
+        end
+
+        private
+
+        def u16(data, off)
+          (data.getbyte(off) << 8) | data.getbyte(off + 1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Font
+    module TrueType
+      class Name
+        attr_reader :format, :count, :records
+
+        def initialize(data)
+          @records = {}
+          return unless data && data.bytesize >= 6
+
+          @format = u16(data, 0)
+          @count = u16(data, 2)
+          string_offset = u16(data, 4)
+
+          @count.times do |i|
+            offset = 6 + (i * 12)
+            break if offset + 12 > data.bytesize
+
+            platform_id = u16(data, offset)
+            u16(data, offset + 2)
+            _lang_id = u16(data, offset + 4)
+            name_id = u16(data, offset + 6)
+            length = u16(data, offset + 8)
+            str_offset = u16(data, offset + 10)
+
+            next unless [1, 3].include?(platform_id)
+
+            raw = data.byteslice(string_offset + str_offset, length)
+            next unless raw
+
+            str = if platform_id == 3
+                    raw.bytes.each_slice(2).map { |b| (b[0] << 8) | (b[1] || 0) }.pack("U*")
+                  else
+                    raw.force_encoding("UTF-8")
+                  end
+            @records[name_id] = str
+          end
+        end
+
+        def family; @records[1] || @records[16]; end
+        def subfamily; @records[2] || @records[17]; end
+        def ps_name; @records[6]; end
+        def full_name; @records[4]; end
+
+        private
+
+        def u16(data, off); (data.getbyte(off) << 8) | data.getbyte(off + 1); end
+      end
+    end
+  end
+end