prawn-svg 0.37.0 → 0.38.1

data/lib/prawn/svg/font.rb

@@ -1,65 +1,21 @@
-class Prawn::SVG::Font
-  GENERIC_CSS_FONT_MAPPING = {
-    'serif'      => 'Times-Roman',
-    'sans-serif' => 'Helvetica',
-    'cursive'    => 'Times-Roman',
-    'fantasy'    => 'Times-Roman',
-    'monospace'  => 'Courier'
-  }.freeze
+module Prawn::SVG
+  class Font
+    attr_reader :name, :weight, :style
 
-  attr_reader :name, :weight, :style
-
-  def self.weight_for_css_font_weight(weight)
-    case weight
-    when '100', '200', '300'    then :light
-    when '400', '500', 'normal' then :normal
-    when '600'                  then :semibold
-    when '700', 'bold'          then :bold
-    when '800'                  then :extrabold
-    when '900'                  then :black
-    end
-  end
-
-  def initialize(name, weight, style, font_registry: nil)
-    @font_registry = font_registry
-    unless font_registry.installed_fonts.key?(name)
-      # map generic font name to one of the built-in PDF fonts if not already mapped
-      name = GENERIC_CSS_FONT_MAPPING[name] || name
+    def initialize(name, weight, style)
+      @name = name
+      @weight = weight
+      @style = style
     end
-    @name = font_registry.correctly_cased_font_name(name) || name
-    @weight = weight
-    @style = style
-  end
-
-  def installed?
-    subfamilies = @font_registry.installed_fonts[name]
-    !subfamilies.nil? && subfamilies.key?(subfamily)
-  end
 
-  # Construct a subfamily name, ensuring that the subfamily is a valid one for the font.
-  def subfamily
-    if (subfamilies = @font_registry.installed_fonts[name])
-      if subfamilies.key?(subfamily_name)
-        subfamily_name
-      elsif subfamilies.key?(:normal)
-        :normal
+    def subfamily
+      if weight == :normal && style
+        style
+      elsif weight || style
+        [weight, style].compact.join('_').to_sym
       else
-        subfamilies.keys.first
+        :normal
       end
     end
   end
-
-  private
-
-  # Construct a subfamily name from the weight and style information.
-  # Note that this name might not actually exist in the font.
-  def subfamily_name
-    if weight == :normal && style
-      style
-    elsif weight || style
-      [weight, style].compact.join('_').to_sym
-    else
-      :normal
-    end
-  end
 end

data/lib/prawn/svg/font_metrics.rb

@@ -0,0 +1,97 @@
+class Prawn::SVG::FontMetrics
+  class << self
+    # Default x-height as a fraction of font size (typical for most fonts)
+    DEFAULT_X_HEIGHT_RATIO = 0.5
+
+    def x_height_in_points(pdf, font_size)
+      @x_height_cache ||= {}
+
+      cache_key = cache_key_for(pdf)
+
+      @x_height_cache[cache_key] ||= calculate_x_height_ratio(pdf)
+      @x_height_cache[cache_key] * font_size
+    end
+
+    def underline_metrics(pdf, size)
+      @underline_metrics_cache ||= {}
+
+      cache_key = cache_key_for(pdf)
+
+      @underline_metrics_cache[cache_key] ||= fetch_underline_metrics(pdf, size)
+      @underline_metrics_cache[cache_key]
+    end
+
+    private
+
+    def cache_key_for(pdf)
+      return 'default' unless pdf && pdf.font.is_a?(Prawn::Fonts::TTF)
+
+      ttf = pdf.font.ttf
+      return 'default' unless ttf
+
+      # Use font family name from TTF metadata, which doesn't include size
+      ttf.name&.font_family&.first || pdf&.font&.name || 'default'
+    end
+
+    def calculate_x_height_ratio(pdf)
+      return DEFAULT_X_HEIGHT_RATIO unless pdf && pdf.font.is_a?(Prawn::Fonts::TTF)
+
+      ttf = pdf.font.ttf
+      return DEFAULT_X_HEIGHT_RATIO unless ttf
+
+      units_per_em = ttf.header&.units_per_em&.to_f
+      return DEFAULT_X_HEIGHT_RATIO unless units_per_em&.positive?
+
+      cmap = ttf.cmap&.unicode&.first
+      return DEFAULT_X_HEIGHT_RATIO unless cmap
+
+      xid = cmap['x'.ord]
+      return DEFAULT_X_HEIGHT_RATIO unless xid
+
+      bbox = ttf.glyph_outlines&.for(xid)
+      return DEFAULT_X_HEIGHT_RATIO unless bbox
+
+      y_max = bbox.y_max
+      y_min = bbox.y_min
+      return DEFAULT_X_HEIGHT_RATIO unless y_max && y_min
+
+      glyph_height_units = y_max - y_min
+      return DEFAULT_X_HEIGHT_RATIO if glyph_height_units <= 0
+
+      glyph_height_units / units_per_em
+    end
+
+    def fetch_underline_metrics(pdf, size)
+      units_per_em = nil
+      pos_units = thick_units = nil
+      if pdf.font.is_a?(Prawn::Font::TTF)
+        ttf = begin
+          pdf.font.ttf
+        rescue StandardError
+          nil
+        end
+        if ttf.respond_to?(:post) && ttf.post && ttf.respond_to?(:header) && ttf.header
+          units_per_em = ttf.header.units_per_em.to_f
+          pos_units = ttf.post.underline_position.to_f
+          thick_units = ttf.post.underline_thickness.to_f
+        end
+      end
+
+      offset =
+        if units_per_em && pos_units
+          (pos_units / units_per_em) * size
+        else
+          -0.12 * size
+        end
+
+      thick =
+        if units_per_em && thick_units&.positive?
+          [(thick_units / units_per_em) * size, 0.5].max
+        else
+          [size * 0.06, 0.5].max
+        end
+
+      [offset, thick]
+    end
+  end
+end

data/lib/prawn/svg/font_registry.rb

@@ -1,75 +1,140 @@
-class Prawn::SVG::FontRegistry
-  DEFAULT_FONT_PATHS = [
-    '/Library/Fonts',
-    '/System/Library/Fonts',
-    "#{Dir.home}/Library/Fonts",
-    '/usr/share/fonts/truetype',
-    '/mnt/c/Windows/Fonts' # Bash on Ubuntu on Windows
-  ].freeze
-
-  @font_path = DEFAULT_FONT_PATHS.select { |path| Dir.exist?(path) }
-
-  def initialize(font_families)
-    @font_families = font_families
-  end
+module Prawn::SVG
+  class FontRegistry
+    GENERIC_CSS_FONT_MAPPING = {
+      'serif'      => 'Times-Roman',
+      'sans-serif' => 'Helvetica',
+      'cursive'    => 'Times-Roman',
+      'fantasy'    => 'Times-Roman',
+      'monospace'  => 'Courier'
+    }.freeze
 
-  def installed_fonts
-    merge_external_fonts
-    @font_families
-  end
+    FONT_WEIGHT_FALLBACKS = {
+      light:     :normal,
+      normal:    nil,
+      semibold:  :bold,
+      bold:      :normal,
+      extrabold: :bold,
+      black:     :extrabold
+    }.freeze
 
-  def correctly_cased_font_name(name)
-    merge_external_fonts
-    @font_case_mapping[name.downcase]
-  end
+    FONT_WEIGHTS = FONT_WEIGHT_FALLBACKS.keys.freeze
+
+    DEFAULT_FONT_PATHS = [
+      '/Library/Fonts',
+      '/System/Library/Fonts',
+      "#{Dir.home}/Library/Fonts",
+      '/usr/share/fonts/truetype',
+      '/mnt/c/Windows/Fonts' # Bash on Ubuntu on Windows
+    ].freeze
 
-  def load(family, weight = nil, style = nil)
-    Prawn::SVG::CSS::FontFamilyParser.parse(family).detect do |name|
-      name = name.gsub(/\s{2,}/, ' ').downcase
+    @font_path = DEFAULT_FONT_PATHS.select { |path| Dir.exist?(path) }
 
-      font = Prawn::SVG::Font.new(name, weight, style, font_registry: self)
-      break font if font.installed?
+    def initialize(font_families)
+      @font_families = font_families
     end
-  end
 
-  private
+    def installed_fonts
+      merge_external_fonts
+      @font_families
+    end
 
-  def merge_external_fonts
-    if @font_case_mapping.nil?
-      self.class.load_external_fonts unless self.class.external_font_families
-      @font_families.merge!(self.class.external_font_families) do |_key, v1, _v2|
-        v1
-      end
-      @font_case_mapping = @font_families.keys.each.with_object({}) do |key, result|
-        result[key.downcase] = key
+    def correctly_cased_font_name(name)
+      merge_external_fonts
+      @font_case_mapping[name.downcase]
+    end
+
+    def load(family, weight = nil, style = nil)
+      weight = weight_for_css_font_weight(weight) unless FONT_WEIGHTS.include?(weight)
+
+      CSS::FontFamilyParser.parse(family).detect do |name|
+        name = name.gsub(/\s{2,}/, ' ')
+
+        font = find_suitable_font(name, weight, style)
+        break font if font
       end
     end
-  end
 
-  class << self
-    attr_reader :external_font_families, :font_path
+    private
+
+    def find_suitable_font(name, weight, style)
+      name = correctly_cased_font_name(name) || name
+
+      name = GENERIC_CSS_FONT_MAPPING[name] if GENERIC_CSS_FONT_MAPPING.key?(name) && !installed_fonts.key?(name)
+
+      return unless (subfamilies = installed_fonts[name])
+      return if subfamilies.empty?
 
-    def load_external_fonts
-      @external_font_families = {}
+      while weight
+        font = Font.new(name, weight, style)
+        return font if installed?(font)
 
-      external_font_paths.each do |filename|
-        ttf = Prawn::SVG::TTF.new(filename)
-        next unless ttf.family
+        weight = FONT_WEIGHT_FALLBACKS[weight]
+      end
 
-        subfamily = (ttf.subfamily || 'normal').gsub(/\s+/, '_').downcase.to_sym
-        subfamily = :normal if subfamily == :regular
-        (external_font_families[ttf.family] ||= {})[subfamily] ||= filename
+      if style
+        find_suitable_font(name, weight, nil) unless style.nil?
+      else
+        Font.new(name, subfamilies.keys.first, nil)
       end
     end
 
-    private
+    def installed?(font)
+      subfamilies = installed_fonts[font.name]
+      !subfamilies.nil? && subfamilies.key?(font.subfamily)
+    end
+
+    def weight_for_css_font_weight(weight)
+      case weight
+      when '100', '200', '300'    then :light
+      when '400', '500', 'normal' then :normal
+      when '600'                  then :semibold
+      when '700', 'bold'          then :bold
+      when '800'                  then :extrabold
+      when '900'                  then :black
+      else :normal # rubocop:disable Lint/DuplicateBranch
+      end
+    end
+
+    def merge_external_fonts
+      if @font_case_mapping.nil?
+        self.class.load_external_fonts unless self.class.external_font_families
+        @font_families.merge!(self.class.external_font_families) do |_key, v1, _v2|
+          v1
+        end
+        @font_case_mapping = @font_families.keys.each.with_object({}) do |key, result|
+          result[key.downcase] = key
+        end
+        GENERIC_CSS_FONT_MAPPING.each_key do |generic|
+          @font_case_mapping[generic] = generic
+        end
+      end
+    end
+
+    class << self
+      attr_reader :external_font_families, :font_path
+
+      def load_external_fonts
+        @external_font_families = {}
+
+        external_font_paths.each do |filename|
+          ttf = TTF.new(filename)
+          next unless ttf.family
 
-    def external_font_paths
-      font_path
-        .uniq
-        .flat_map { |path| Dir["#{path}/**/*"] }
-        .uniq
-        .select { |path| File.file?(path) }
+          subfamily = (ttf.subfamily || 'normal').gsub(/\s+/, '_').downcase.to_sym
+          subfamily = :normal if subfamily == :regular
+          (external_font_families[ttf.family] ||= {})[subfamily] ||= filename
+        end
+      end
+
+      private
+
+      def external_font_paths
+        font_path
+          .uniq
+          .flat_map { |path| Dir["#{path}/**/*"] }
+          .uniq
+          .select { |path| File.file?(path) }
+      end
     end
   end
 end

data/lib/prawn/svg/renderer.rb

@@ -50,6 +50,10 @@ module Prawn
         options[:at] || [x_based_on_requested_alignment, y_based_on_requested_alignment]
       end
 
+      def render_calls(prawn, calls)
+        issue_prawn_command(prawn, calls)
+      end
+
       private
 
       def x_based_on_requested_alignment
@@ -100,80 +104,38 @@ module Prawn
           if skip
             # the call has been overridden
           elsif children.empty? && call != 'transparent' # some prawn calls complain if they aren't supplied a block
-            if RUBY_VERSION >= '2.7' || !kwarguments.empty?
-              prawn.send(call, *arguments, **kwarguments)
-            else
+            if kwarguments.empty?
               prawn.send(call, *arguments)
+            else
+              prawn.send(call, *arguments, **kwarguments)
             end
-          elsif RUBY_VERSION >= '2.7' || !kwarguments.empty?
-            prawn.send(call, *arguments, **kwarguments, &proc_creator(prawn, children))
-          else
+          elsif kwarguments.empty?
             prawn.send(call, *arguments, &proc_creator(prawn, children))
+          else
+            prawn.send(call, *arguments, **kwarguments, &proc_creator(prawn, children))
           end
         end
       end
 
       def rewrite_call_arguments(prawn, call, arguments, kwarguments)
         case call
-        when 'text_group'
-          @cursor = [0, sizing.output_height]
-          yield
-
-        when 'draw_text'
-          text = arguments.first
-          options = kwarguments
-
-          at = options.fetch(:at)
-
-          at[0] = @cursor[0] if at[0] == :relative
-          at[1] = @cursor[1] if at[1] == :relative
-
-          case options.delete(:dominant_baseline)
-          when 'middle'
-            height = prawn.font.height
-            at[1] -= height / 2.0
-            @cursor = [at[0], at[1]]
+        when 'svg:render'
+          element = arguments.first
+          raise ArgumentError, "Expected a Prawn::SVG::Elements::DirectRenderBase, got #{element.class}" unless element.is_a?(Prawn::SVG::Elements::DirectRenderBase)
+
+          begin
+            element.render(prawn, self)
+          rescue Prawn::SVG::Elements::Base::SkipElementQuietly
+          rescue Prawn::SVG::Elements::Base::SkipElementError => e
+            @document.warnings << e.message
           end
 
-          if (offset = options.delete(:offset))
-            at[0] += offset[0]
-            at[1] -= offset[1]
-          end
-
-          width = prawn.width_of(text, options.merge(kerning: true))
-
-          if (stretch_to_width = options.delete(:stretch_to_width))
-            factor = stretch_to_width.to_f * 100 / width.to_f
-            prawn.add_content "#{factor} Tz"
-            width = stretch_to_width.to_f
-          end
-
-          if (pad_to_width = options.delete(:pad_to_width))
-            padding_required = pad_to_width.to_f - width.to_f
-            padding_per_character = padding_required / text.length.to_f
-            prawn.add_content "#{padding_per_character} Tc"
-            width = pad_to_width.to_f
-          end
-
-          case options.delete(:text_anchor)
-          when 'middle'
-            at[0] -= width / 2
-            @cursor = [at[0] + (width / 2), at[1]]
-          when 'end'
-            at[0] -= width
-            @cursor = at.dup
-          else
-            @cursor = [at[0] + width, at[1]]
-          end
+          yield
 
-          decoration = options.delete(:decoration)
-          if decoration == 'underline'
-            prawn.save_graphics_state do
-              prawn.line_width 1
-              prawn.line [at[0], at[1] - 1.25], [at[0] + width, at[1] - 1.25]
-              prawn.stroke
-            end
-          end
+        when 'svg:yield'
+          block = arguments.first
+          block.call
+          yield
 
         when 'transformation_matrix'
           left = prawn.bounds.absolute_left

data/lib/prawn/svg/version.rb

@@ -1,5 +1,5 @@
 module Prawn
   module SVG
-    VERSION = '0.37.0'.freeze
+    VERSION = '0.38.1'.freeze
   end
 end

data/lib/prawn-svg.rb

@@ -6,6 +6,7 @@ require 'prawn/svg/version'
 require 'css_parser'
 
 require 'prawn/svg/font_registry'
+require 'prawn/svg/font_metrics'
 require 'prawn/svg/calculators/arc_to_bezier_curve'
 require 'prawn/svg/calculators/aspect_ratio'
 require 'prawn/svg/calculators/document_sizing'

data/prawn-svg.gemspec

@@ -22,5 +22,5 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'css_parser', '~> 1.6'
   gem.add_dependency 'matrix', '~> 0.4.2'
   gem.add_dependency 'prawn', '>= 0.11.1', '< 3'
-  gem.add_dependency 'rexml', '>= 3.3.9', '< 4'
+  gem.add_dependency 'rexml', '>= 3.4.2', '< 4'
 end

data/scripts/compare_samples

@@ -0,0 +1,25 @@
+#!/usr/bin/env fish
+
+if test (count $argv) -ne 2
+    echo "Usage: compare_samples [file containing sample output files] [new branch name]"
+    echo
+    echo A handy script that generates a sample SVG on both the main branch and the specified branch, and displays
+    echo them alongside the original SVG as rendered by Arc.  Used to see whether there have been regressions or
+    echo improvements in rendering code changes.
+    exit 1
+end
+
+set files $argv[1]
+set branch $argv[2]
+
+set i (cat $files | string trim | fzf)
+and echo $i
+and git switch main
+and bundle exec rspec -e (echo $i | string replace 'spec/sample_output/' '' | string replace '.pdf' '')
+and cp $i original.pdf
+and git switch $branch
+and bundle exec rspec -e (echo $i | string replace 'spec/sample_output/' '' | string replace '.pdf' '')
+and cp $i new.pdf
+and open -n original.pdf
+and open -n new.pdf
+and open -a Arc (echo $i | string replace sample_output sample_svg | string replace .pdf '')

data/spec/prawn/svg/attributes/transform_spec.rb

@@ -10,6 +10,10 @@ describe Prawn::SVG::Attributes::Transform do
       @warnings = []
       @attributes = {}
     end
+
+    def transformable?
+      true
+    end
   end
 
   let(:element) { TransformTestElement.new }

data/spec/prawn/svg/css/stylesheets_spec.rb

@@ -73,7 +73,7 @@ RSpec.describe Prawn::SVG::CSS::Stylesheets do
       ]
 
       expected << [5,
-                   [['fill', '#ff0000', false], ['fill', '#330000', false], ['fill', '#330000', false], ['fill', '#440000', false],
+                   [['fill', '#ff0000', false], ['fill', '#330000', false], ['fill', '#440000', false],
                     ['fill', '#00ff00', false]]]
 
       expected.push(