prawn-svg 0.37.0 → 0.38.0

data/lib/prawn/svg/elements/text_node.rb

@@ -0,0 +1,174 @@
+module Prawn::SVG
+  class Elements::TextNode
+    Chunk = Struct.new(:text, :x, :y, :dx, :dy, :rotate, :base_width, :offset, :fixed_width)
+
+    attr_reader :component, :chunks
+    attr_accessor :text
+
+    def initialize(component, text, leading_space, trailing_space)
+      @component = component
+      @text = text
+      @leading_space = leading_space
+      @trailing_space = trailing_space
+    end
+
+    def leading_space?
+      @leading_space
+    end
+
+    def trailing_space?
+      @trailing_space
+    end
+
+    def calculated_width
+      @chunks.reduce(0) do |total, chunk|
+        total + (chunk.fixed_width || chunk.base_width) + chunk.offset
+      end
+    end
+
+    def total_flexible_and_fixed_width
+      flexible = fixed = 0
+      chunks.each do |chunk|
+        if chunk.fixed_width.nil?
+          flexible += chunk.base_width
+          fixed += chunk.offset
+        else
+          fixed += chunk.offset + chunk.fixed_width
+        end
+      end
+      [flexible, fixed]
+    end
+
+    def lay_out(prawn)
+      remaining_text = @text
+      @chunks = []
+
+      while remaining_text != ''
+        x = y = dx = dy = rotate = nil
+        remaining = rotation_remaining = false
+
+        comp = component
+        while comp
+          shifted = comp.x_values.shift
+          x ||= shifted
+          shifted = comp.y_values.shift
+          y ||= shifted
+          shifted = comp.dx.shift
+          dx ||= shifted
+          shifted = comp.dy.shift
+          dy ||= shifted
+
+          shifted = comp.rotation.length > 1 ? comp.rotation.shift : comp.rotation.first
+          if shifted && rotate.nil?
+            rotate = shifted
+            remaining ||= comp.rotation != [0]
+          end
+
+          remaining ||= comp.x_values.any? || comp.y_values.any? || comp.dx.any? || comp.dy.any? || (rotate && rotate != 0)
+          rotation_remaining ||= comp.rotation.length > 1
+          comp = comp.parent_component
+        end
+
+        rotate = (-rotate if rotate && rotate != 0)
+
+        text_to_draw = remaining ? remaining_text[0..0] : remaining_text
+
+        opts = { size: component.computed_properties.numeric_font_size, kerning: true }
+
+        total_spacing = text_to_draw.length > 1 ? (component.letter_spacing_pixels || 0) * (text_to_draw.length - 1) : 0
+        base_width = prawn.width_of(text_to_draw, opts) + total_spacing
+
+        offset = dx ? [0, dx].max : 0
+
+        @chunks << Chunk.new(text_to_draw, x, y, dx, dy, rotate, base_width, offset, nil)
+
+        if remaining
+          remaining_text = remaining_text[1..]
+        else
+          # we can get to this path with rotations still pending
+          # solve this by shifting them out by the number of
+          # characters we've just drawn
+          shift = remaining_text.length - 1
+          if rotation_remaining && shift.positive?
+            comp = component
+            while comp
+              count = [shift, comp.rotation.length - 1].min
+              comp.rotation.shift(count) if count.positive?
+              comp = comp.parent_component
+            end
+          end
+
+          break
+        end
+      end
+    end
+
+    def render(prawn, size, cursor, y_offset)
+      chunks.each do |chunk|
+        cursor.x = chunk.x if chunk.x
+        cursor.x += chunk.dx if chunk.dx
+        cursor.y = chunk.y if chunk.y
+        cursor.y -= chunk.dy if chunk.dy
+
+        render_underline(prawn, size, cursor, y_offset, chunk.fixed_width || chunk.base_width) if component.computed_properties.text_decoration == 'underline'
+
+        opts = { size: size, at: [cursor.x, cursor.y + (y_offset || 0)] }
+        opts[:rotate] = chunk.rotate if chunk.rotate
+
+        scaling =
+          if chunk.fixed_width && component.current_length_adjust_is_scaling?
+            chunk.fixed_width * 100 / chunk.base_width
+          else
+            100
+          end
+
+        spacing_enabled = chunk.fixed_width && !component.current_length_adjust_is_scaling? && chunk.text.length > 1
+
+        # This isn't perfect.  It assumes the parent component which started the textLength context
+        # has a character at the end of its text nodes.  If it doesn't, the last character in its
+        # children should not take the space.  This is possible but would involve a lot more work so
+        # I will park it for now.
+        parent_spacing = spacing_enabled && !component.text_length
+        spacing =
+          if spacing_enabled
+            ((chunk.fixed_width - chunk.base_width) / (chunk.text.length - (parent_spacing ? 0 : 1))) + (component.letter_spacing_pixels || 0)
+          end
+
+        prawn.horizontal_text_scaling(scaling) do
+          prawn.character_spacing(spacing || component.letter_spacing_pixels || prawn.character_spacing) do
+            prawn.text_rendering_mode(calculate_text_rendering_mode) do
+              prawn.draw_text(chunk.text, **opts)
+            end
+          end
+        end
+
+        cursor.x += chunk.fixed_width || chunk.base_width
+
+        # If we're in a textLength context for one of our parents, we'll need to add spacing
+        # to the end of our string.  See comment above for why this isn't quite right.
+        cursor.x += spacing if parent_spacing
+      end
+    end
+
+    def render_underline(prawn, size, cursor, y_offset, width)
+      offset, thickness = FontMetrics.underline_metrics(prawn, size)
+
+      prawn.fill_rectangle [cursor.x, cursor.y + (y_offset || 0) + offset + (thickness / 2.0)], width, thickness
+    end
+
+    def calculate_text_rendering_mode
+      fill = !component.computed_properties.fill.none? # rubocop:disable Style/InverseMethods
+      stroke = !component.computed_properties.stroke.none? # rubocop:disable Style/InverseMethods
+
+      if fill && stroke
+        :fill_stroke
+      elsif fill
+        :fill
+      elsif stroke
+        :stroke
+      else
+        :invisible
+      end
+    end
+  end
+end

data/lib/prawn/svg/elements.rb

@@ -4,7 +4,7 @@ end
 
 require 'prawn/svg/elements/call_duplicator'
 
-%w[base depth_first_base root container clip_path viewport text text_component line polyline polygon circle ellipse
+%w[base direct_render_base root container clip_path viewport text text_component text_node line polyline polygon circle ellipse
    rect path use image gradient marker ignored].each do |filename|
   require "prawn/svg/elements/#{filename}"
 end

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,139 @@
-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)
 
-    def load_external_fonts
-      @external_font_families = {}
+      return unless (subfamilies = installed_fonts[name])
+      return if subfamilies.empty?
 
-      external_font_paths.each do |filename|
-        ttf = Prawn::SVG::TTF.new(filename)
-        next unless ttf.family
+      while weight
+        font = Font.new(name, weight, style)
+        return font if installed?(font)
+
+        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
 
-    def external_font_paths
-      font_path
-        .uniq
-        .flat_map { |path| Dir["#{path}/**/*"] }
-        .uniq
-        .select { |path| File.file?(path) }
+    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
+
+          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,32 @@ 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
-              prawn.send(call, *arguments)
-            end
-          elsif RUBY_VERSION >= '2.7' || !kwarguments.empty?
-            prawn.send(call, *arguments, **kwarguments, &proc_creator(prawn, children))
+            prawn.send(call, *arguments, **kwarguments)
           else
-            prawn.send(call, *arguments, &proc_creator(prawn, children))
+            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]]
-          end
-
-          if (offset = options.delete(:offset))
-            at[0] += offset[0]
-            at[1] -= offset[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
 
-          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.0'.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'