prawn-svg 0.23.1 → 0.24.0

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

@@ -1,22 +1,23 @@
 class Prawn::SVG::Elements::Polyline < Prawn::SVG::Elements::Base
+  include Prawn::SVG::Pathable
+
   def parse
     require_attributes('points')
     @points = parse_points(attributes['points'])
   end
 
   def apply
-    raise SkipElementQuietly unless @points.length > 0
-
-    add_call 'move_to', *@points[0]
-    add_call_and_enter 'stroke'
-    @points[1..-1].each do |x, y|
-      add_call "line_to", x, y
-    end
+    apply_commands
+    apply_markers
   end
 
-  def bounding_box
-    x1, x2 = @points.map(&:first).minmax
-    y2, y1 = @points.map(&:last).minmax
-    [x1, y1, x2, y2]
+  protected
+
+  def commands
+    @commands ||= [
+      Prawn::SVG::Pathable::Move.new(@points[0])
+    ] + @points[1..-1].map { |point|
+      Prawn::SVG::Pathable::Line.new(point)
+    }
   end
 end

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

@@ -7,7 +7,9 @@ class Prawn::SVG::Elements::Root < Prawn::SVG::Elements::Base
     add_call 'fill_color', '000000'
     add_call 'transformation_matrix', @document.sizing.x_scale, 0, 0, @document.sizing.y_scale, 0, 0
     add_call 'transformation_matrix', 1, 0, 0, 1, @document.sizing.x_offset, @document.sizing.y_offset
+  end
 
-    process_child_elements
+  def container?
+    true
   end
 end

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

@@ -20,7 +20,10 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
   end
 
   def apply
-    raise SkipElementQuietly if state.display == "none"
+    raise SkipElementQuietly if computed_properties.display == "none"
+
+    font = select_font
+    apply_font(font) if font
 
     add_call_and_enter "text_group" if name == 'text'
 
@@ -28,22 +31,18 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
       add_call_and_enter "translate", document.distance(attributes['dx'] || 0), -document.distance(attributes['dy'] || 0)
     end
 
-    opts = {}
-    if size = state.font_size
-      opts[:size] = size
-    end
-    opts[:style] = state.font_subfamily
+    # text_anchor isn't a Prawn option; we have to do some math to support it
+    # and so we handle this in Prawn::SVG::Interface#rewrite_call_arguments
+    opts = {
+      size:        computed_properties.numerical_font_size,
+      style:       font && font.subfamily,
+      text_anchor: computed_properties.text_anchor
+    }
 
-    # This is not a prawn option but we can't work out how to render it here -
-    # it's handled by SVG#rewrite_call_arguments
-    if (anchor = attributes['text-anchor'] || state.text_anchor) &&
-        ['start', 'middle', 'end'].include?(anchor)
-      opts[:text_anchor] = anchor
-    end
+    spacing = computed_properties.letter_spacing
+    spacing = spacing == 'normal' ? 0 : document.points(spacing)
 
-    if spacing = attributes['letter-spacing']
-      add_call_and_enter 'character_spacing', document.points(spacing)
-    end
+    add_call_and_enter 'character_spacing', spacing
 
     source.children.each do |child|
       if child.node_type == :text
@@ -53,7 +52,6 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
           opts[:at] = [@x_positions.first, @y_positions.first]
 
           if @x_positions.length > 1 || @y_positions.length > 1
-            # TODO : isn't this just text.shift ?
             add_call 'draw_text', text[0..0], opts.dup
             text = text[1..-1]
 
@@ -73,7 +71,6 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
         new_state.text_x_positions = @x_positions
         new_state.text_y_positions = @y_positions
         new_state.text_relative = @relative
-        new_state.text_anchor = opts[:text_anchor]
 
         Prawn::SVG::Elements::Text.new(document, child, calls, new_state).process
 
@@ -83,5 +80,29 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
         warnings << "Unknown tag '#{child.name}' inside text tag; ignoring"
       end
     end
+
+    # It's possible there was no text to render.  In that case, add a 'noop' so
+    # character_spacing doesn't blow up when it finds it doesn't have a block to execute.
+    add_call 'noop' if calls.empty?
+  end
+
+  private
+
+  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)
+
+    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
+
+  def apply_font(font)
+    add_call 'font', font.name, style: font.subfamily
   end
 end

data/lib/prawn/svg/font.rb

@@ -11,12 +11,12 @@ class Prawn::SVG::Font
 
   def self.weight_for_css_font_weight(weight)
     case weight
-    when '100', '200', '300' then :light
-    when '400', '500'        then :normal
-    when '600'               then :semibold
-    when '700', 'bold'       then :bold
-    when '800'               then :extrabold
-    when '900'               then :black
+    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
 

data/lib/prawn/svg/interface.rb

@@ -169,6 +169,9 @@ module Prawn
           # never want closepath to be automatically run as it stuffs up many drawing operations, such as dashes
           # and line caps, and makes paths close that we didn't ask to be closed when fill is specified.
           prawn.add_content 'B'
+
+        when 'noop'
+          yield
         end
       end
 

data/lib/prawn/svg/pathable.rb

@@ -0,0 +1,130 @@
+module Prawn::SVG::Pathable
+  Move = Struct.new(:destination)
+  Close = Struct.new(:destination)
+  Line = Struct.new(:destination)
+  Curve = Struct.new(:destination, :point1, :point2)
+
+  def bounding_box
+    points = commands.map { |command| translate(command.destination) }
+    x1, x2 = points.map(&:first).minmax
+    y2, y1 = points.map(&:last).minmax
+
+    [x1, y1, x2, y2]
+  end
+
+  protected
+
+  def apply_commands
+    commands.each do |command|
+      case command
+      when Move
+        add_call 'move_to', translate(command.destination)
+      when Close
+        add_call 'close_path'
+      when Line
+        add_call 'line_to', translate(command.destination)
+      when Curve
+        add_call 'curve_to', translate(command.destination), bounds: [translate(command.point1), translate(command.point2)]
+      else
+        raise NotImplementedError, "Unknown path command type"
+      end
+    end
+  end
+
+  def apply_markers
+    if marker = extract_element_from_url_id_reference(properties.marker_start, "marker")
+      marker.apply_marker(self, point: commands.first.destination, angle: angles.first)
+    end
+
+    if marker = extract_element_from_url_id_reference(properties.marker_mid, "marker")
+      (1..commands.length-2).each do |index|
+        marker.apply_marker(self, point: commands[index].destination, angle: angles[index])
+      end
+    end
+
+    if marker = extract_element_from_url_id_reference(properties.marker_end, "marker")
+      marker.apply_marker(self, point: commands.last.destination, angle: angles.last)
+    end
+  end
+
+  def angles
+    return @angles if @angles
+
+    last_point = nil
+
+    destination_angles = commands.map do |command|
+      angles = case command
+      when Move
+        [nil, nil]
+      when Close, Line
+        angle = Math.atan2(command.destination[1] - last_point[1], command.destination[0] - last_point[0]) * 180.0 / Math::PI
+        [angle, angle]
+      when Curve
+        start = Math.atan2(command.point1[1] - last_point[1], command.point1[0] - last_point[0]) * 180.0 / Math::PI
+        stop = Math.atan2(command.destination[1] - command.point2[1], command.destination[0] - command.point2[0]) * 180.0 / Math::PI
+        [start, stop]
+      else
+        raise NotImplementedError, "Unknown path command type"
+      end
+
+      last_point = command.destination
+      angles
+    end
+
+    angles = destination_angles.each_cons(2).map do |first_angles, second_angles|
+      if first_angles.first.nil?
+        second_angles.first || 0
+      elsif second_angles.first.nil?
+        first_angles.last
+      else
+        first = first_angles.last
+        second = second_angles.last
+        bisect = (first + second) / 2.0
+
+        if (first - second).abs > 180
+          bisect >= 0 ? bisect - 180 : bisect + 180
+        else
+          bisect
+        end
+      end
+    end
+
+    if commands.last.is_a?(Close)
+      first = destination_angles.last.last || 0
+      second = angles.first
+      bisect = (first + second) / 2.0
+
+      angles << if (first - second).abs > 180
+        bisect >= 0 ? bisect - 180 : bisect + 180
+      else
+        bisect
+      end
+    else
+      angles << destination_angles.last.last
+    end
+
+    @angles = angles
+  end
+
+  def parse_points(points_string)
+    values = points_string.
+      to_s.
+      strip.
+      gsub(/(\d)-(\d)/, '\1 -\2').
+      split(Prawn::SVG::Elements::COMMA_WSP_REGEXP).
+      map(&:to_f)
+
+    if values.length % 2 == 1
+      document.warnings << "points attribute has an odd number of points; ignoring the last one"
+      values.pop
+    end
+
+    raise Prawn::SVG::Elements::Base::SkipElementQuietly if values.length == 0
+
+    values.each_slice(2).to_a
+  end
+
+  def translate(point)
+    [point[0].to_f, document.sizing.output_height - point[1].to_f]
+  end
+end

data/lib/prawn/svg/properties.rb

@@ -0,0 +1,122 @@
+class Prawn::SVG::Properties
+  Config = Struct.new(:default, :inheritable?, :keywords, :keyword_restricted?, :attr, :ivar)
+
+  EM = 16
+  FONT_SIZES = {
+    'xx-small' => EM / 4,
+    'x-small'  => EM / 4 * 2,
+    'small'    => EM / 4 * 3,
+    'medium'   => EM / 4 * 4,
+    'large'    => EM / 4 * 5,
+    'x-large'  => EM / 4 * 6,
+    'xx-large' => EM / 4 * 7
+  }
+
+  PROPERTIES = {
+    "clip-path"        => Config.new("none", false, %w(inherit none)),
+    "color"            => Config.new('', true),
+    "display"          => Config.new("inline", false, %w(inherit inline none), true),
+    "fill"             => Config.new("black", true, %w(inherit none currentColor)),
+    "fill-opacity"     => Config.new("1", true),
+    "font-family"      => Config.new("sans-serif", true),
+    "font-size"        => Config.new("medium", true, %w(inherit xx-small x-small small medium large x-large xx-large larger smaller)),
+    "font-style"       => Config.new("normal", true, %w(inherit normal italic oblique), true),
+    "font-variant"     => Config.new("normal", true, %w(inherit normal small-caps), true),
+    "font-weight"      => Config.new("normal", true, %w(inherit normal bold 100 200 300 400 500 600 700 800 900), true), # bolder/lighter not supported
+    "letter-spacing"   => Config.new("normal", true, %w(inherit normal)),
+    "marker-end"       => Config.new("none", true, %w(inherit none)),
+    "marker-mid"       => Config.new("none", true, %w(inherit none)),
+    "marker-start"     => Config.new("none", true, %w(inherit none)),
+    "opacity"          => Config.new("1", false),
+    "overflow"         => Config.new('visible', false, %w(inherit visible hidden scroll auto), true),
+    "stop-color"       => Config.new("black", false, %w(inherit none currentColor)),
+    "stroke"           => Config.new("none", true, %w(inherit none currentColor)),
+    "stroke-dasharray" => Config.new("none", true, %w(inherit none)),
+    "stroke-linecap"   => Config.new("butt", true, %w(inherit butt round square), true),
+    "stroke-opacity"   => Config.new("1", true),
+    "stroke-width"     => Config.new("1", true),
+    "text-anchor"      => Config.new("start", true, %w(inherit start middle end), true),
+  }.freeze
+
+  PROPERTIES.each do |name, value|
+    value.attr = name.gsub("-", "_")
+    value.ivar = "@#{value.attr}"
+  end
+
+  PROPERTY_CONFIGS = PROPERTIES.values
+  NAMES = PROPERTIES.keys
+  ATTR_NAMES = PROPERTIES.keys.map { |name| name.gsub('-', '_') }
+
+  attr_accessor *ATTR_NAMES
+
+  def load_default_stylesheet
+    PROPERTY_CONFIGS.each do |config|
+      instance_variable_set(config.ivar, config.default)
+    end
+
+    self
+  end
+
+  def set(name, value)
+    if config = PROPERTIES[name.to_s.downcase]
+      value = value.strip
+      keyword = value.downcase
+      keywords = config.keywords || ['inherit']
+
+      if keywords.include?(keyword)
+        value = keyword
+      elsif config.keyword_restricted?
+        value = config.default
+      end
+
+      instance_variable_set(config.ivar, value)
+    end
+  end
+
+  def to_h
+    PROPERTIES.each.with_object({}) do |(name, config), result|
+      result[name] = instance_variable_get(config.ivar)
+    end
+  end
+
+  def load_hash(hash)
+    hash.each { |name, value| set(name, value) if value }
+  end
+
+  def compute_properties(other)
+    PROPERTY_CONFIGS.each do |config|
+      value = other.send(config.attr)
+
+      if value && value != 'inherit'
+        value = compute_font_size_property(value).to_s if config.attr == "font_size"
+        instance_variable_set(config.ivar, value)
+
+      elsif value.nil? && !config.inheritable?
+        instance_variable_set(config.ivar, config.default)
+      end
+    end
+  end
+
+  def numerical_font_size
+    # px = pt for PDFs
+    FONT_SIZES[font_size] || font_size.to_f
+  end
+
+  private
+
+  def compute_font_size_property(value)
+    if value[-1] == "%"
+      numerical_font_size * (value.to_f / 100.0)
+    elsif value == 'larger'
+      numerical_font_size + 4
+    elsif value == 'smaller'
+      numerical_font_size - 4
+    elsif value.match(/(\d|\.)em\z/i)
+      numerical_font_size * value.to_f
+    elsif value.match(/(\d|\.)rem\z/i)
+      value.to_f * EM
+    else
+      FONT_SIZES[value] || value.to_f
+    end
+  end
+end

data/lib/prawn/svg/state.rb

@@ -1,39 +1,17 @@
 class Prawn::SVG::State
   attr_accessor :disable_drawing,
-    :color, :display,
-    :font_size, :font_weight, :font_style, :font_family, :font_subfamily,
-    :text_anchor, :text_relative, :text_x_positions, :text_y_positions, :preserve_space,
-    :fill_opacity, :stroke_opacity,
-    :fill, :stroke
+    :text_relative, :text_x_positions, :text_y_positions, :preserve_space,
+    :fill_opacity, :stroke_opacity, :stroke_width,
+    :computed_properties
 
   def initialize
-    @fill = true
-    @stroke = false
+    @stroke_width = 1
     @fill_opacity = 1
     @stroke_opacity = 1
+    @computed_properties = Prawn::SVG::Properties.new.load_default_stylesheet
   end
 
-  def enable_draw_type(type)
-    case type
-    when 'fill'   then @fill = true
-    when 'stroke' then @stroke = true
-    else raise
-    end
-  end
-
-  def disable_draw_type(type)
-    case type
-    when 'fill'   then @fill = false
-    when 'stroke' then @stroke = false
-    else raise
-    end
-  end
-
-  def draw_type(type)
-    case type
-    when 'fill'   then @fill
-    when 'stroke' then @stroke
-    else raise
-    end
+  def initialize_dup(other)
+    @computed_properties = @computed_properties.dup
   end
 end