prawn-svg 0.36.2 → 0.38.0

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

@@ -1,250 +1,228 @@
-class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
-  attr_reader :commands
-
-  Printable = Struct.new(:element, :text, :leading_space?, :trailing_space?)
-  TextState = Struct.new(:parent, :x, :y, :dx, :dy, :rotation, :spacing, :mode, :text_length, :length_adjust)
-
-  def parse
-    raise SkipElementError, '<text> elements are not supported in clip paths' if state.inside_clip_path
+module Prawn::SVG
+  class Elements::TextComponent < Elements::DirectRenderBase
+    attr_reader :children, :parent_component
+    attr_reader :x_values, :y_values, :dx, :dy, :rotation, :text_length, :length_adjust
+    attr_reader :font
+
+    def initialize(document, source, _calls, state, parent_component = nil)
+      if parent_component.nil? && source.name != 'text'
+        raise SkipElementError, 'attempted to <use> a component inside a text element, this is not supported'
+      end
 
-    if state.text.nil?
-      raise SkipElementError, 'attempted to <use> an component inside a text element, this is not supported'
+      super(document, source, [], state)
+      @parent_component = parent_component
     end
 
-    state.text.x = (attributes['x'] || '').split(COMMA_WSP_REGEXP).collect { |n| x(n) }
-    state.text.y = (attributes['y'] || '').split(COMMA_WSP_REGEXP).collect { |n| y(n) }
-    state.text.dx = (attributes['dx'] || '').split(COMMA_WSP_REGEXP).collect { |n| x_pixels(n) }
-    state.text.dy = (attributes['dy'] || '').split(COMMA_WSP_REGEXP).collect { |n| y_pixels(n) }
-    state.text.rotation = (attributes['rotate'] || '').split(COMMA_WSP_REGEXP).collect(&:to_f)
-    state.text.text_length = normalize_length(attributes['textLength'])
-    state.text.length_adjust = attributes['lengthAdjust']
-    state.text.spacing = calculate_character_spacing
-    state.text.mode = calculate_text_rendering_mode
+    def parse
+      raise SkipElementError, '<text> elements are not supported in clip paths' if state.inside_clip_path
 
-    @commands = []
+      @x_values = parse_wsp('x').map { |n| x(n) }
+      @y_values = parse_wsp('y').map { |n| y(n) }
+      @dx = parse_wsp('dx').map { |n| x_pixels(n) }
+      @dy = parse_wsp('dy').map { |n| y_pixels(n) }
+      @rotation = parse_wsp('rotate').map(&:to_f)
+      @text_length = normalize_length(attributes['textLength'])
+      @length_adjust = attributes['lengthAdjust']
 
-    svg_text_children.each do |child|
-      if child.node_type == :text
-        append_text(child)
-      else
-        case child.name
-        when 'tspan', 'tref'
-          append_child(child)
+      @font = select_font
+
+      @children = svg_text_children.flat_map do |child|
+        if child.node_type == :text
+          build_text_node(child)
         else
-          warnings << "Unknown tag '#{child.name}' inside text tag; ignoring"
+          case child.name
+          when 'tspan', 'tref'
+            build_child(child)
+          else
+            warnings << "Unknown tag '#{child.name}' inside text tag; ignoring"
+            []
+          end
         end
       end
     end
-  end
 
-  def apply
-    raise SkipElementQuietly if computed_properties.display == 'none'
-
-    font = select_font
-    apply_font(font) if font
-
-    # text_anchor and dominant_baseline aren't Prawn options; we have to do some math to support them
-    # and so we handle them in Prawn::SVG::Interface#rewrite_call_arguments
-    opts = {
-      size:        computed_properties.numeric_font_size,
-      style:       font&.subfamily,
-      text_anchor: computed_properties.text_anchor
-    }
-
-    unless computed_properties.dominant_baseline == 'auto'
-      opts[:dominant_baseline] =
-        computed_properties.dominant_baseline
-    end
-    opts[:decoration] = computed_properties.text_decoration unless computed_properties.text_decoration == 'none'
-
-    if state.text.parent
-      add_call_and_enter 'character_spacing', state.text.spacing unless state.text.spacing == state.text.parent.spacing
-      add_call_and_enter 'text_rendering_mode', state.text.mode unless state.text.mode == state.text.parent.mode
-    else
-      add_call_and_enter 'character_spacing', state.text.spacing unless state.text.spacing.zero?
-      add_call_and_enter 'text_rendering_mode', state.text.mode unless state.text.mode == :fill
-    end
-
-    @commands.each do |command|
-      case command
-      when Printable
-        apply_text(command.text, opts)
-      when self.class
-        add_call 'save'
-        command.apply_step(calls)
-        add_call 'restore'
-      else
-        raise
+    def lay_out(prawn)
+      @children.each do |child|
+        prawn.save_font do
+          prawn.font(font.name, style: font.subfamily) if font
+          child.lay_out(prawn)
+        end
       end
-    end
-
-    # It's possible there was no text to render.  In that case, add a 'noop' so character_spacing/text_rendering_mode
-    # don't blow up when they find they don't have a block to execute.
-    add_call 'noop' if calls.empty?
-  end
 
-  protected
+      if @text_length
+        flexible_width, fixed_width = total_flexible_and_fixed_width
 
-  def append_text(child)
-    if state.preserve_space
-      text = child.value.tr("\n\t", ' ')
-    else
-      text = child.value.tr("\n", '').tr("\t", ' ')
-      leading = text[0] == ' '
-      trailing = text[-1] == ' '
-      text = text.strip.gsub(/ {2,}/, ' ')
+        if flexible_width.positive?
+          target_width = [@text_length - fixed_width, 0].max
+          factor = target_width / flexible_width
+          apply_factor_to_base_width(factor)
+        end
+      end
     end
 
-    @commands << Printable.new(self, text, leading, trailing)
-  end
+    def render_component(prawn, renderer, cursor, translate_x = nil)
+      raise SkipElementQuietly if computed_properties.display == 'none'
 
-  def append_child(child)
-    new_state = state.dup
-    new_state.text = TextState.new(state.text)
+      add_yield_call do
+        prawn.translate(translate_x, 0) if translate_x
 
-    element = self.class.new(document, child, calls, new_state)
-    @commands << element
-    element.parse_step
-  end
+        size = computed_properties.numeric_font_size
 
-  def apply_text(text, opts)
-    while text != ''
-      x = y = dx = dy = rotate = nil
-      remaining = rotation_remaining = false
-
-      list = state.text
-      while list
-        shifted = list.x.shift
-        x ||= shifted
-        shifted = list.y.shift
-        y ||= shifted
-        shifted = list.dx.shift
-        dx ||= shifted
-        shifted = list.dy.shift
-        dy ||= shifted
-
-        shifted = list.rotation.length > 1 ? list.rotation.shift : list.rotation.first
-        if shifted && rotate.nil?
-          rotate = shifted
-          remaining ||= list.rotation != [0]
+        if computed_properties.dominant_baseline == 'middle'
+          height = FontMetrics.x_height_in_points(prawn, size || prawn.font_size)
+          y_offset = -height / 2.0
         end
 
-        remaining ||= list.x.any? || list.y.any? || list.dx.any? || list.dy.any? || (rotate && rotate != 0)
-        rotation_remaining ||= list.rotation.length > 1
-        list = list.parent
+        prawn.save_font do
+          prawn.font(font.name, style: font.subfamily) if font
+
+          children.each do |child|
+            case child
+            when Elements::TextNode
+              child.render(prawn, size, cursor, y_offset)
+            when self.class
+              prawn.save_graphics_state
+              child.render_component(prawn, renderer, cursor)
+              prawn.restore_graphics_state
+            else
+              raise
+            end
+          end
+        end
       end
 
-      opts[:at] = [x || :relative, y || :relative]
-      opts[:offset] = [dx || 0, dy || 0]
+      renderer.render_calls(prawn, base_calls)
+    end
+
+    def calculated_width
+      children.reduce(0) { |total, child| total + child.calculated_width }
+    end
 
-      if rotate && rotate != 0
-        opts[:rotate] = -rotate
+    def current_length_adjust_is_scaling?
+      if @text_length
+        @length_adjust == 'spacingAndGlyphs'
+      elsif parent_component
+        parent_component.current_length_adjust_is_scaling?
       else
-        opts.delete(:rotate)
+        false
       end
+    end
 
-      if state.text.text_length
-        if state.text.length_adjust == 'spacingAndGlyphs'
-          opts[:stretch_to_width] = state.text.text_length
-        else
-          opts[:pad_to_width] = state.text.text_length
-        end
+    def letter_spacing_pixels
+      if computed_properties.letter_spacing == 'normal'
+        nil
+      else
+        x_pixels(computed_properties.letter_spacing)
       end
+    end
 
-      if remaining
-        add_call 'draw_text', text[0..0], **opts.dup
-        text = text[1..]
-      else
-        add_call 'draw_text', text, **opts.dup
-
-        # 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 = text.length - 1
-        if rotation_remaining && shift.positive?
-          list = state.text
-          while list
-            count = [shift, list.rotation.length - 1].min
-            list.rotation.shift(count) if count.positive?
-            list = list.parent
-          end
-        end
+    protected
 
-        break
+    def build_text_node(child)
+      if state.preserve_space
+        text = child.value.tr("\n\t", ' ')
+      else
+        text = child.value.tr("\n", '').tr("\t", ' ')
+        leading = text[0] == ' '
+        trailing = text[-1] == ' '
+        text = text.strip.gsub(/ {2,}/, ' ')
       end
+
+      Elements::TextNode.new(self, text, leading, trailing)
+    end
+
+    def build_child(child)
+      component = self.class.new(document, child, [], state.dup, self)
+      component.process
+      component
     end
-  end
 
-  def svg_text_children
-    text_children.select do |child|
-      child.node_type == :text || (
-        child.node_type == :element && (
-          child.namespace == SVG_NAMESPACE || child.namespace == ''
+    def svg_text_children
+      text_children.select do |child|
+        child.node_type == :text || (
+          child.node_type == :element &&
+            [SVG_NAMESPACE, ''].include?(child.namespace)
+
         )
-      )
+      end
     end
-  end
 
-  def text_children
-    if name == 'tref'
-      reference = find_referenced_element
-      reference ? reference.source.children : []
-    else
-      source.children
+    def text_children
+      if name == 'tref'
+        reference = find_referenced_element
+        reference ? reference.source.children : []
+      else
+        source.children
+      end
     end
-  end
 
-  def find_referenced_element
-    href = href_attribute
+    def find_referenced_element
+      href = href_attribute
 
-    if href && href[0..0] == '#'
-      element = document.elements_by_id[href[1..]]
-      element if element.name == 'text'
+      if href && href[0..0] == '#'
+        element = document.elements_by_id[href[1..]]
+        element if element.name == 'text'
+      end
     end
-  end
 
-  def select_font
-    font_families = [computed_properties.font_family, document.fallback_font_name]
-    font_style = :italic if computed_properties.font_style == 'italic'
-    font_weight = Prawn::SVG::Font.weight_for_css_font_weight(computed_properties.font_weight)
+    def select_font
+      font_families = [computed_properties.font_family, document.fallback_font_name]
+      font_style = :italic if computed_properties.font_style == 'italic'
+      font_weight = computed_properties.font_weight
 
-    font_families.compact.each do |name|
-      font = document.font_registry.load(name, font_weight, font_style)
-      return font if font
+      font_families.compact.each do |name|
+        font = document.font_registry.load(name, font_weight, font_style)
+        return font if font
+      end
+
+      warnings << "Font family '#{computed_properties.font_family}' style '#{computed_properties.font_style}' is not a known font, and the fallback font could not be found."
+      nil
     end
 
-    warnings << "Font family '#{computed_properties.font_family}' style '#{computed_properties.font_style}' is not a known font, and the fallback font could not be found."
-    nil
-  end
+    def total_flexible_and_fixed_width
+      flexible = fixed = 0
+      @children.each do |child|
+        child.total_flexible_and_fixed_width.tap do |a, b|
+          flexible += a
+          fixed += b
+        end
+      end
+      [flexible, fixed]
+    end
 
-  def apply_font(font)
-    add_call 'font', font.name, style: font.subfamily
-  end
+    def apply_factor_to_base_width(factor)
+      @children.each do |child|
+        if child.is_a?(Elements::TextNode)
+          child.chunks.reject(&:fixed_width).each do |chunk|
+            chunk.fixed_width = chunk.base_width * factor
+          end
+        elsif child.is_a?(self.class)
+          child.apply_factor_to_base_width(factor)
+        else
+          raise
+        end
+      end
+    end
 
-  def calculate_text_rendering_mode
-    fill = !computed_properties.fill.none? # rubocop:disable Style/InverseMethods
-    stroke = !computed_properties.stroke.none? # rubocop:disable Style/InverseMethods
+    # overridden from Base, we don't want to call fill/stroke as draw_text does this for us
+    def apply_drawing_call; end
 
-    if fill && stroke
-      :fill_stroke
-    elsif fill
-      :fill
-    elsif stroke
-      :stroke
-    else
-      :invisible
+    # overridden from Base, transforms can't be applied to tspan elements
+    def transformable?
+      source.name != 'tspan'
     end
-  end
 
-  def calculate_character_spacing
-    spacing = computed_properties.letter_spacing
-    spacing == 'normal' ? 0 : pixels(spacing)
-  end
+    # overridden from Base, we want the id to point to the Text element
+    def add_to_elements_by_id?
+      source.name != 'text'
+    end
 
-  # overridden, we don't want to call fill/stroke as draw_text does this for us
-  def apply_drawing_call; end
+    def normalize_length(length)
+      x_pixels(length) if length&.match(/\d/)
+    end
 
-  def normalize_length(length)
-    x_pixels(length) if length&.match(/\d/)
+    def parse_wsp(name)
+      (attributes[name] || '').split(COMMA_WSP_REGEXP)
+    end
   end
 end

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