arrolio 0.1.0

data/lib/arrolio/font/text_encoder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Font
+    # Converts a Unicode string into a 2-byte-big-endian
+    # glyph-ID sequence for an Identity-H-encoded CIDFont.
+    class TextEncoder
+      attr_reader :embedder
+
+      def initialize(embedder)
+        @embedder = embedder
+      end
+
+      # Returns a binary-encoded String of 2-byte GIDs for the
+      # codepoints in +text+. The renderer passes this to
+      # +canvas.text+ instead of the Unicode string.
+      def encode(text)
+        bytes = String.new.force_encoding(Encoding::BINARY)
+        text.each_codepoint do |cp|
+          gid = @embedder.subset_gid_for_codepoint(cp)
+          bytes << (gid >> 8).chr(Encoding::BINARY)
+          bytes << (gid & 0xff).chr(Encoding::BINARY)
+        end
+        bytes
+      end
+    end
+  end
+end

data/lib/arrolio/font.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Font
+    autoload :TextEncoder, 'arrolio/font/text_encoder'
+    autoload :Embedder, 'arrolio/font/embedder'
+    autoload :Manifest, 'arrolio/font/manifest'
+    autoload :Resolver, 'arrolio/font/resolver'
+  end
+end

data/lib/arrolio/font_metrics/afm_metrics.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module FontMetrics
+    # Glyph-width lookup against Pdfrb's AFM data for one of the 14
+    # PDF standard Type1 fonts.
+    class AfmMetrics
+      UNITS_PER_EM = 1000
+
+      attr_reader :font_name, :afm
+
+      def initialize(font_name, afm)
+        @font_name = font_name.to_s
+        @afm = afm
+      end
+
+      def self.for_name(name)
+        afm = Pdfrb::Font::Type1::FontMetrics.for_standard_font(name.to_s)
+        return nil unless afm
+
+        new(name, afm)
+      end
+
+      def units_per_em
+        UNITS_PER_EM
+      end
+
+      def advance_width(char)
+        metric = metric_for(char)
+        metric ? metric[:width] : 0
+      end
+
+      def width_of_string(str, font_size:)
+        scale = font_size.to_f / units_per_em
+        str.each_char.sum { |c| advance_width(c) * scale }
+      end
+
+      def ascender(font_size: 12)
+        (afm.ascender || 800) * font_size.to_f / units_per_em
+      end
+
+      def descender(font_size: 12)
+        (afm.descender || -200) * font_size.to_f / units_per_em
+      end
+
+      def cap_height(font_size: 12)
+        (afm.cap_height || 700) * font_size.to_f / units_per_em
+      end
+
+      def line_height(font_size:, line_spacing: 1.2)
+        ((afm.ascender || 800).to_f - (afm.descender || -200).to_f) *
+          font_size.to_f / units_per_em * line_spacing.to_f
+      end
+
+      private
+
+      def metric_for(char)
+        codepoint = char.ord
+        if codepoint < 0x80
+          m = afm.metrics.char_metrics[codepoint]
+          return m if m
+        end
+
+        name = glyph_name_for(char)
+        afm.metrics.char_metrics[name] if name
+      end
+
+      def glyph_name_for(char)
+        @glyph_name_cache ||= {}
+        return @glyph_name_cache[char] if @glyph_name_cache.key?(char)
+
+        @glyph_name_cache[char] = unicode_to_name[char.ord]
+      end
+
+      def unicode_to_name
+        return @unicode_to_name if @unicode_to_name
+
+        table = Pdfrb::Font::GlyphList.table
+        @unicode_to_name = {}
+        table.each do |gname, str|
+          cp = str.ord
+          @unicode_to_name[cp] ||= gname if cp
+        end
+        (0x21..0x7E).each do |cp|
+          @unicode_to_name[cp] ||= cp.chr
+        end
+        @unicode_to_name
+      end
+    end
+  end
+end

data/lib/arrolio/font_metrics/registry.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module FontMetrics
+    module Registry
+      @cache = {}
+      @ttf_paths = {}
+
+      class << self
+        attr_reader :ttf_paths
+
+        def register_ttf(font_name, path)
+          @ttf_paths[font_name.to_s] = path
+          @cache.delete(font_name.to_s)
+        end
+
+        def register_ttf_all(paths, strict: false)
+          missing = []
+          paths.each do |name, path|
+            register_ttf(name, path)
+            missing << [name, path] if strict && path && File.exist?(path) == false
+          end
+          return unless strict && missing.any?
+
+          raise Arrolio::RenderError.new(
+            'strict mode: missing required font files: ' +
+              missing.map { |name, path| "#{name}=#{path}" }.join(', '),
+            missing_fonts: missing
+          )
+        end
+
+        def [](font_name)
+          key = font_name.to_s
+          return @cache[key] if @cache.key?(key)
+
+          if @ttf_paths.key?(key) && File.exist?(@ttf_paths[key])
+            @cache[key] = TrueTypeMetrics.from_file(key, @ttf_paths[key])
+            return @cache[key]
+          end
+
+          @cache[key] = AfmMetrics.for_name(key)
+        end
+
+        def reset!
+          @cache.clear
+          @ttf_paths.clear
+        end
+
+        def known?(font_name)
+          !self[font_name].nil?
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/font_metrics/true_type_metrics.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'fontisan'
+
+module Arrolio
+  module FontMetrics
+    # Glyph-width lookup from a TrueType/OpenType font file.
+    # Reads head, hhea, hmtx, cmap, OS/2 tables via Fontisan.
+    # Same interface as AfmMetrics so callers can swap freely.
+    class TrueTypeMetrics
+      attr_reader :font_name, :fontisan_font
+
+      def initialize(font_name, fontisan_font)
+        @font_name = font_name.to_s
+        @fontisan_font = fontisan_font
+        @cmap = fontisan_font.table('cmap')
+        @unicode_to_gid = @cmap ? @cmap.unicode_mappings.transform_keys(&:to_i) : {}
+        @head = fontisan_font.table('head')
+        @hhea = fontisan_font.table('hhea')
+        @os2 = fontisan_font.table('OS/2')
+        @hmtx = fontisan_font.table('hmtx')
+        parse_hmtx
+      end
+
+      def parse_hmtx
+        return unless @hmtx && @hhea
+
+        maxp = @fontisan_font.table('maxp')
+        num_metrics = @hhea.number_of_h_metrics rescue nil
+        num_glyphs = maxp&.num_glyphs
+        return unless num_metrics && num_glyphs
+
+        @hmtx.parse_with_context(num_metrics, num_glyphs)
+      rescue StandardError
+        nil
+      end
+
+      def self.from_file(font_name, path)
+        font = Fontisan::FontLoader.load(path)
+        new(font_name, font)
+      end
+
+      def units_per_em
+        @head ? @head.units_per_em : 1000
+      rescue StandardError
+        1000
+      end
+
+      def advance_width(char)
+        gid = @unicode_to_gid[char.ord]
+        return 0 unless gid && @hmtx
+
+        metric = @hmtx.metric_for(gid)
+        metric ? metric[:advance_width] : 0
+      rescue StandardError
+        0
+      end
+
+      def width_of_string(str, font_size:)
+        scale = font_size.to_f / units_per_em
+        str.each_char.sum { |c| advance_width(c) * scale }
+      end
+
+      def ascender(font_size: 12)
+        return font_size * 0.8 unless @hhea
+
+        ((@hhea.ascender || 800).to_f / units_per_em) * font_size.to_f
+      rescue StandardError
+        font_size * 0.8
+      end
+
+      def descender(font_size: 12)
+        return -font_size * 0.2 unless @hhea
+
+        ((@hhea.descender || -200).to_f / units_per_em) * font_size.to_f
+      rescue StandardError
+        -font_size * 0.2
+      end
+
+      def cap_height(font_size: 12)
+        return font_size * 0.7 unless @os2
+
+        ((@os2.cap_height || 700).to_f / units_per_em) * font_size.to_f
+      rescue StandardError
+        font_size * 0.7
+      end
+
+      def line_height(font_size:, line_spacing: 1.2)
+        # CSS/XSL convention: line-height is a multiplier of font-size,
+        # NOT derived from the font ascender/descender ratio.
+        font_size.to_f * line_spacing.to_f
+      end
+    end
+  end
+end

data/lib/arrolio/font_metrics.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Arrolio::FontMetrics — glyph-width lookup.
+module Arrolio
+  module FontMetrics
+    autoload :TrueTypeMetrics, 'arrolio/font_metrics/true_type_metrics'
+    autoload :AfmMetrics, 'arrolio/font_metrics/afm_metrics'
+    autoload :Registry, 'arrolio/font_metrics/registry'
+  end
+end

data/lib/arrolio/frame.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Arrolio
+  class Frame
+    attr_reader :x, :y, :width, :height, :consumed
+
+    def initialize(x:, y:, width:, height:, consumed: 0.0)
+      @x = x.to_f
+      @y = y.to_f
+      @width = width.to_f
+      @height = height.to_f
+      @consumed = consumed.to_f
+    end
+
+    def remaining_height
+      @height - @consumed
+    end
+
+    def full?
+      remaining_height <= 0.5
+    end
+
+    def consume!(h)
+      @consumed += h.to_f if h.to_f.positive?
+      self
+    end
+
+    def cursor_y
+      @y + @height - @consumed
+    end
+
+    def clone_empty
+      self.class.new(x: @x, y: @y, width: @width, height: @height)
+    end
+  end
+end