prawn-svg 0.37.0 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5c28b2e706923d04785979a68f0e457f14df7c71b519d16db6e0bb45e3458bc
-  data.tar.gz: 3ade59453c7005f624b4dcd36d9930f27285291c410b00fe57b3d3d278673e4c
+  metadata.gz: d9d63836ebf08ec1ebd6320b61a8f4b93c5df29e91e6e1397b53c65d548e8afe
+  data.tar.gz: 25ad6658329c42589d086e592589908a1c556a631503578219c308ab095fa513
 SHA512:
-  metadata.gz: 250c187430ff8042898b9ee55a595162824613e13a9760a8e32dd21e5a026dfabe012a80f3c19442b3a97635ab020aa1eb113cd70dcc86ffef888f6bc2d39fa1
-  data.tar.gz: 1d79258d401547d57dd694878e08d9a50d0166cce4fefd9351cfda0ef6a7c3096910a88a29650993f0eeadd44d7f2fba21d25f438e31660750cc4b847cacc760
+  metadata.gz: d73e5adc3fa832d2ed9159cf02cea3b47cf3923ff0e145af4de426effeb6157d4d133d600bf708ccd963a736d517fccb8a7c8d410ee479025288193659d34859
+  data.tar.gz: 20d5d9f28438c3ca4c23454541f763b1766f3df9719ced30a3451abc08e21913cf4276d2c148d9af695bab9e4670b01dcc1985fe5d9a9ebd94cfc08cee755818

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    prawn-svg (0.37.0)
+    prawn-svg (0.38.0)
       css_parser (~> 1.6)
       matrix (~> 0.4.2)
       prawn (>= 0.11.1, < 3)

data/lib/prawn/svg/attributes/transform.rb

@@ -1,5 +1,7 @@
 module Prawn::SVG::Attributes::Transform
   def parse_transform_attribute_and_call
+    # Some elements do not support transforms
+    return unless transformable?
     return unless (transform = attributes['transform'])
 
     matrix = matrix_for_pdf(parse_transform_attribute(transform))

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

@@ -36,7 +36,7 @@ class Prawn::SVG::Elements::Base
     @attributes = {}
     @properties = Prawn::SVG::Properties.new
 
-    if source && !state.inside_use
+    if source && add_to_elements_by_id? && !state.inside_use
       id = source.attributes['id']
       id = id.strip if id
 
@@ -114,6 +114,10 @@ class Prawn::SVG::Elements::Base
     @calls.concat duplicate_calls(other.base_calls)
   end
 
+  def add_yield_call(&block)
+    add_call('svg:yield', block)
+  end
+
   def new_call_context_from_base
     old_calls = @calls
     @calls = @base_calls
@@ -269,6 +273,14 @@ class Prawn::SVG::Elements::Base
     ['hidden', 'scroll'].include?(computed_properties.overflow)
   end
 
+  def transformable?
+    true
+  end
+
+  def add_to_elements_by_id?
+    true
+  end
+
   def stroke_width
     if computed_properties.stroke.none?
       0

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

@@ -0,0 +1,27 @@
+#
+# This element base class is used for elements that render directly to the Prawn canvas.
+#
+# Initially when I wrote prawn-svg, I was expecting to have multiple renderers and thought separating the codebase
+# from the Prawn renderer would be a good idea.  However, it turns out that the Prawn renderer was the only one
+# that was targeted, and it ended up being tightly coupled with the Prawn library.
+#
+# This class is probably how I should have written it.  Direct render is required to do text rendering properly
+# because we need to know the width of all the things we print.  As of the time of this comment it's the only
+# system that uses DirectRenderBase in prawn-svg.
+#
+class Prawn::SVG::Elements::DirectRenderBase < Prawn::SVG::Elements::Base
+  # Called by Renderer when it finds the svg:render call added below.
+  def render(prawn, renderer); end
+
+  protected
+
+  def parse_and_apply
+    parse_standard_attributes
+    parse
+    apply_calls_from_standard_attributes
+    @parent_calls << ['svg:render', [self], [], []] unless computed_properties.display == 'none'
+  rescue SkipElementQuietly
+  rescue SkipElementError => e
+    @document.warnings << e.message
+  end
+end

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

@@ -16,9 +16,9 @@ class Prawn::SVG::Elements::Polygon < Prawn::SVG::Elements::Base
   def commands
     @commands ||= [
       Prawn::SVG::Pathable::Move.new(@points[0])
-    ] + @points[1..].map { |point|
+    ] + @points[1..].map do |point|
       Prawn::SVG::Pathable::Line.new(point)
-    } + [
+    end + [
       Prawn::SVG::Pathable::Close.new(@points[0])
     ]
   end

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

@@ -1,70 +1,72 @@
-class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::DepthFirstBase
-  private
+module Prawn::SVG
+  class Elements::Text < Elements::DirectRenderBase
+    Cursor = Struct.new(:x, :y)
 
-  # This class doesn't represent an element in the SVG document; it's here
-  # to hold together text information.  Because of this, we overload the
-  # parse_step and apply_step methods, and bypass all the normal processing
-  # of the element, delegating it to our root text component.
+    def parse
+      @root_component = Elements::TextComponent.new(document, source, [], state.dup)
+      @root_component.process
 
-  def parse_step
-    state.text = Prawn::SVG::Elements::TextComponent::TextState.new
+      reintroduce_trailing_and_leading_whitespace
+    end
 
-    @text_root = Prawn::SVG::Elements::TextComponent.new(document, source, nil, state.dup)
-    @text_root.parse_step
+    def render(prawn, renderer)
+      @root_component.lay_out(prawn)
 
-    reintroduce_trailing_and_leading_whitespace
-  end
+      translate_x =
+        case @root_component.computed_properties.text_anchor
+        when 'middle'
+          -@root_component.calculated_width / 2.0
+        when 'end'
+          -@root_component.calculated_width
+        end
 
-  def apply_step(calls)
-    @base_calls = @calls = calls
-    add_call_and_enter 'text_group'
-    @text_root.apply_step(@calls)
-  end
+      cursor = Cursor.new(0, document.sizing.output_height)
+      @root_component.render_component(prawn, renderer, cursor, translate_x)
+    end
 
-  def drawable?
-    false
-  end
+    private
 
-  def reintroduce_trailing_and_leading_whitespace
-    printables = []
-    built_printable_queue(printables, @text_root)
+    def reintroduce_trailing_and_leading_whitespace
+      text_nodes = []
+      build_text_node_queue(text_nodes, @root_component)
 
-    remove_whitespace_only_printables_and_start_and_end(printables)
-    remove_printables_that_are_completely_empty(printables)
-    apportion_leading_and_trailing_spaces(printables)
-  end
+      remove_whitespace_only_text_nodes_and_start_and_end(text_nodes)
+      remove_text_nodes_that_are_completely_empty(text_nodes)
+      apportion_leading_and_trailing_spaces(text_nodes)
+    end
 
-  def built_printable_queue(queue, component)
-    component.commands.each do |command|
-      case command
-      when Prawn::SVG::Elements::TextComponent::Printable
-        queue << command
-      else
-        built_printable_queue(queue, command)
+    def build_text_node_queue(queue, component)
+      component.children.each do |element|
+        case element
+        when Elements::TextNode
+          queue << element
+        else
+          build_text_node_queue(queue, element)
+        end
       end
     end
-  end
 
-  def remove_whitespace_only_printables_and_start_and_end(printables)
-    printables.pop   while printables.last  && printables.last.text.empty?
-    printables.shift while printables.first && printables.first.text.empty?
-  end
+    def remove_whitespace_only_text_nodes_and_start_and_end(text_nodes)
+      text_nodes.pop   while text_nodes.last  && text_nodes.last.text.empty?
+      text_nodes.shift while text_nodes.first && text_nodes.first.text.empty?
+    end
 
-  def remove_printables_that_are_completely_empty(printables)
-    printables.reject! do |printable|
-      printable.text.empty? && !printable.trailing_space? && !printable.leading_space?
+    def remove_text_nodes_that_are_completely_empty(text_nodes)
+      text_nodes.reject! do |text_node|
+        text_node.text.empty? && !text_node.trailing_space? && !text_node.leading_space?
+      end
     end
-  end
 
-  def apportion_leading_and_trailing_spaces(printables)
-    printables.each_cons(2) do |a, b|
-      if a.text.empty?
-        # Empty strings can only get a leading space from the previous non-empty text,
-        # and never get a trailing space
-      elsif a.trailing_space?
-        a.text += ' '
-      elsif b.leading_space?
-        b.text = " #{b.text}"
+    def apportion_leading_and_trailing_spaces(text_nodes)
+      text_nodes.each_cons(2) do |a, b|
+        if a.text.empty?
+          # Empty strings can only get a leading space from the previous non-empty text,
+          # and never get a trailing space
+        elsif a.trailing_space?
+          a.text += ' '
+        elsif b.leading_space?
+          b.text = " #{b.text}"
+        end
       end
     end
   end

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