prawn-svg 0.21.0 → 0.22.1

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

@@ -0,0 +1,228 @@
+class Prawn::SVG::Elements::Base
+  extend Forwardable
+
+  include Prawn::SVG::Attributes::Transform
+  include Prawn::SVG::Attributes::Opacity
+  include Prawn::SVG::Attributes::ClipPath
+  include Prawn::SVG::Attributes::Stroke
+  include Prawn::SVG::Attributes::Font
+  include Prawn::SVG::Attributes::Display
+
+  COMMA_WSP_REGEXP = Prawn::SVG::Elements::COMMA_WSP_REGEXP
+
+  SkipElementQuietly = Class.new(StandardError)
+  SkipElementError = Class.new(StandardError)
+  MissingAttributesError = Class.new(SkipElementError)
+
+  attr_reader :document, :source, :parent_calls, :base_calls, :state, :attributes
+  attr_accessor :calls
+
+  def_delegators :@document, :x, :y, :distance, :points, :warnings
+
+  def initialize(document, source, parent_calls, state)
+    @document = document
+    @source = source
+    @parent_calls = parent_calls
+    @state = state
+    @base_calls = @calls = []
+
+    if id = source.attributes["id"]
+      document.elements_by_id[id] = self
+    end
+  end
+
+  def process
+    combine_attributes_and_style_declarations
+    parse
+
+    apply_calls_from_standard_attributes
+    apply
+
+    append_calls_to_parent
+  rescue SkipElementQuietly
+  rescue SkipElementError => e
+    @document.warnings << e.message
+  end
+
+  def name
+    @name ||= source.name
+  end
+
+  protected
+
+  def parse
+  end
+
+  def apply
+  end
+
+  def bounding_box
+  end
+
+  def container?
+    false
+  end
+
+  def add_call(name, *arguments)
+    @calls << [name.to_s, arguments, []]
+  end
+
+  def add_call_and_enter(name, *arguments)
+    @calls << [name.to_s, arguments, []]
+    @calls = @calls.last.last
+  end
+
+  def append_calls_to_parent
+    @parent_calls.concat(@base_calls)
+  end
+
+  def add_calls_from_element(other)
+    @calls.concat other.base_calls
+  end
+
+  def process_child_elements
+    source.elements.each do |elem|
+      if element_class = Prawn::SVG::Elements::TAG_CLASS_MAPPING[elem.name.to_sym]
+        add_call "save"
+
+        child = element_class.new(@document, elem, @calls, @state.dup)
+        child.process
+
+        add_call "restore"
+      else
+        @document.warnings << "Unknown tag '#{elem.name}'; ignoring"
+      end
+    end
+  end
+
+  def apply_calls_from_standard_attributes
+    parse_transform_attribute_and_call
+    parse_opacity_attributes_and_call
+    parse_clip_path_attribute_and_call
+    draw_types = parse_fill_and_stroke_attributes_and_call
+    parse_stroke_attributes_and_call
+    parse_font_attributes_and_call
+    parse_display_attribute
+    apply_drawing_call(draw_types)
+  end
+
+  def apply_drawing_call(draw_types)
+    if !@state[:disable_drawing] && !container?
+      if draw_types.empty? || @state[:display] == "none"
+        add_call_and_enter("end_path")
+      else
+        add_call_and_enter(draw_types.join("_and_"))
+      end
+    end
+  end
+
+  def parse_fill_and_stroke_attributes_and_call
+    ["fill", "stroke"].select do |type|
+      case keyword = attribute_value_as_keyword(type)
+      when nil
+      when 'inherit'
+      when 'none'
+        state[type.to_sym] = false
+      else
+        state[type.to_sym] = false
+        color_attribute = keyword == 'currentcolor' ? 'color' : type
+        color = @attributes[color_attribute]
+
+        results = Prawn::SVG::Color.parse(color, document.gradients)
+
+        results.each do |result|
+          case result
+          when Prawn::SVG::Color::Hex
+            state[type.to_sym] = true
+            add_call "#{type}_color", result.value
+            break
+          when Prawn::SVG::Elements::Gradient
+            arguments = result.gradient_arguments(self)
+            if arguments
+              state[type.to_sym] = true
+              add_call "#{type}_gradient", **arguments
+              break
+            end
+          end
+        end
+      end
+
+      state[type.to_sym]
+    end
+  end
+
+  def clamp(value, min_value, max_value)
+    [[value, min_value].max, max_value].min
+  end
+
+  def combine_attributes_and_style_declarations
+    if @document && @document.css_parser
+      tag_style = @document.css_parser.find_by_selector(source.name)
+      id_style = @document.css_parser.find_by_selector("##{source.attributes["id"]}") if source.attributes["id"]
+
+      if classes = source.attributes["class"]
+        class_styles = classes.strip.split(/\s+/).collect do |class_name|
+          @document.css_parser.find_by_selector(".#{class_name}")
+        end
+      end
+
+      element_style = source.attributes['style']
+
+      style = [tag_style, class_styles, id_style, element_style].flatten.collect do |s|
+        s.nil? || s.strip == "" ? "" : "#{s}#{";" unless s.match(/;\s*\z/)}"
+      end.join
+    else
+      style = source.attributes['style'] || ""
+    end
+
+    @attributes = parse_css_declarations(style)
+
+    source.attributes.each do |name, value|
+      name = name.downcase # TODO : this is incorrect; attributes are case sensitive
+      @attributes[name] = value unless @attributes[name]
+    end
+  end
+
+  def parse_css_declarations(declarations)
+    # copied from css_parser
+    declarations.gsub!(/(^[\s]*)|([\s]*$)/, '')
+
+    output = {}
+    declarations.split(/[\;$]+/m).each do |decs|
+      if matches = decs.match(/\s*(.[^:]*)\s*\:\s*(.[^;]*)\s*(;|\Z)/i)
+        property, value, _ = matches.captures
+        output[property.downcase] = value
+      end
+    end
+    output
+  end
+
+  def attribute_value_as_keyword(name)
+    if value = @attributes[name]
+      value.strip.downcase
+    end
+  end
+
+  def parse_points(points_string)
+    points_string.
+      to_s.
+      strip.
+      gsub(/(\d)-(\d)/, '\1 -\2').
+      split(COMMA_WSP_REGEXP).
+      each_slice(2).
+      map {|x, y| [x(x), y(y)]}
+  end
+
+  def require_attributes(*names)
+    missing_attrs = names - attributes.keys
+    if missing_attrs.any?
+      raise MissingAttributesError, "Must have attributes #{missing_attrs.join(", ")} on tag #{name}; skipping tag"
+    end
+  end
+
+  def require_positive_value(*args)
+    if args.any? {|arg| arg.nil? || arg <= 0}
+      raise SkipElementError, "Invalid attributes on tag #{name}; skipping tag"
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+class Prawn::SVG::Elements::Circle < Prawn::SVG::Elements::Base
+  USE_NEW_CIRCLE_CALL = Prawn::Document.instance_methods.include?(:circle)
+
+  def parse
+    require_attributes 'r'
+
+    @x = x(attributes['cx'] || "0")
+    @y = y(attributes['cy'] || "0")
+    @r = distance(attributes['r'])
+
+    require_positive_value @r
+  end
+
+  def apply
+    if USE_NEW_CIRCLE_CALL
+      add_call "circle", [@x, @y], @r
+    else
+      add_call "circle_at", [@x, @y], radius: @r
+    end
+  end
+
+  def bounding_box
+    [@x - @r, @y + @r, @x + @r, @y - @r]
+  end
+end

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

@@ -0,0 +1,15 @@
+class Prawn::SVG::Elements::Container < Prawn::SVG::Elements::Base
+  def parse
+    state[:disable_drawing] = true if name == "clipPath"
+  end
+
+  def apply
+    process_child_elements
+
+    raise SkipElementQuietly if %w(symbol defs clipPath).include?(name)
+  end
+
+  def container?
+    true
+  end
+end

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

@@ -0,0 +1,23 @@
+class Prawn::SVG::Elements::Ellipse < Prawn::SVG::Elements::Base
+  USE_NEW_ELLIPSE_CALL = Prawn::Document.instance_methods.include?(:ellipse)
+
+  def parse
+    require_attributes 'rx', 'ry'
+
+    @x = x(attributes['cx'] || "0")
+    @y = y(attributes['cy'] || "0")
+    @rx = distance(attributes['rx'], :x)
+    @ry = distance(attributes['ry'], :y)
+
+    require_positive_value @rx, @ry
+  end
+
+  def apply
+    add_call USE_NEW_ELLIPSE_CALL ? "ellipse" : "ellipse_at", [@x, @y], @rx, @ry
+  end
+
+  def bounding_box
+    [@x - @rx, @y + @ry, @x + @rx, @y - @ry]
+  end
+end
+

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

@@ -0,0 +1,117 @@
+class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
+  TAG_NAME_TO_TYPE = {"linearGradient" => :linear}
+
+  def parse
+    # A gradient tag without an ID is inaccessible and can never be used
+    raise SkipElementQuietly if attributes['id'].nil?
+
+    assert_compatible_prawn_version
+    load_gradient_configuration
+    load_coordinates
+    load_stops
+
+    document.gradients[attributes['id']] = self
+
+    raise SkipElementQuietly # we don't want anything pushed onto the call stack
+  end
+
+  def gradient_arguments(element)
+    case @units
+    when :bounding_box
+      x1, y1, x2, y2 = element.bounding_box
+      return if y2.nil?
+
+      width = x2 - x1
+      height = y1 - y2
+
+      from = [x1 + width * @x1, y1 - height * @y1]
+      to   = [x1 + width * @x2, y1 - height * @y2]
+
+    when :user_space
+      from = [@x1, @y1]
+      to   = [@x2, @y2]
+    end
+
+    {from: from, to: to, stops: @stops}
+  end
+
+  private
+
+  def type
+    TAG_NAME_TO_TYPE.fetch(name)
+  end
+
+  def assert_compatible_prawn_version
+    if (Prawn::VERSION.split(".").map(&:to_i) <=> [2, 0, 4]) == -1
+      raise SkipElementError, "Prawn 2.0.4+ must be used if you'd like prawn-svg to render gradients"
+    end
+  end
+
+  def load_gradient_configuration
+    @units = attributes["gradientunits"] == 'userSpaceOnUse' ? :user_space : :bounding_box
+
+    if transform = attributes["gradienttransform"]
+      matrix = transform.split(COMMA_WSP_REGEXP).map(&:to_f)
+      if matrix != [1, 0, 0, 1, 0, 0]
+        raise SkipElementError, "prawn-svg does not yet support gradients with a non-identity gradientTransform attribute"
+      end
+    end
+
+    if (spread_method = attributes['spreadmethod']) && spread_method != "pad"
+      warnings << "prawn-svg only currently supports the 'pad' spreadMethod attribute value"
+    end
+  end
+
+  def load_coordinates
+    case @units
+    when :bounding_box
+      @x1 = parse_zero_to_one(attributes["x1"], 0)
+      @y1 = parse_zero_to_one(attributes["y1"], 0)
+      @x2 = parse_zero_to_one(attributes["x2"], 1)
+      @y2 = parse_zero_to_one(attributes["y2"], 0)
+
+    when :user_space
+      @x1 = x(attributes["x1"])
+      @y1 = y(attributes["y1"])
+      @x2 = x(attributes["x2"])
+      @y2 = y(attributes["y2"])
+    end
+  end
+
+  def load_stops
+    stop_elements = source.elements.map do |child|
+      element = Prawn::SVG::Elements::Base.new(document, child, [], {})
+      element.process
+      element
+    end.select do |element|
+      element.name == 'stop' && element.attributes["offset"]
+    end
+
+    @stops = stop_elements.each.with_object([]) do |child, result|
+      offset = parse_zero_to_one(child.attributes["offset"])
+
+      # Offsets must be strictly increasing (SVG 13.2.4)
+      if result.last && result.last.first > offset
+        offset = result.last.first
+      end
+
+      if color_hex = Prawn::SVG::Color.color_to_hex(child.attributes["stop-color"])
+        result << [offset, color_hex]
+      end
+    end
+
+    raise SkipElementError, "gradient does not have any valid stops" if @stops.empty?
+
+    @stops.unshift([0, @stops.first.last]) if @stops.first.first > 0
+    @stops.push([1, @stops.last.last])     if @stops.last.first  < 1
+  end
+
+  def parse_zero_to_one(string, default = 0)
+    string = string.to_s.strip
+    return default if string == ""
+
+    value = string.to_f
+    value /= 100.0 if string[-1..-1] == '%'
+    [0.0, value, 1.0].sort[1]
+  end
+end

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

@@ -0,0 +1,5 @@
+class Prawn::SVG::Elements::Ignored < Prawn::SVG::Elements::Base
+  def parse
+    raise SkipElementQuietly
+  end
+end

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

@@ -0,0 +1,85 @@
+class Prawn::SVG::Elements::Image < Prawn::SVG::Elements::Base
+  class FakeIO
+    def initialize(data)
+      @data = data
+    end
+    def read
+      @data
+    end
+    def rewind
+    end
+  end
+
+  def parse
+    require_attributes 'width', 'height'
+
+    raise SkipElementQuietly if state[:display] == "none"
+
+    @url = attributes['xlink:href'] || attributes['href']
+    if @url.nil?
+      raise SkipElementError, "image tag must have an xlink:href"
+    end
+
+    if !@document.url_loader.valid?(@url)
+      raise SkipElementError, "image tag xlink:href attribute must use http, https or data scheme"
+    end
+
+    x = x(attributes['x'] || 0)
+    y = y(attributes['y'] || 0)
+    width = distance(attributes['width'])
+    height = distance(attributes['height'])
+
+    raise SkipElementQuietly if width.zero? || height.zero?
+    require_positive_value width, height
+
+    @image = begin
+      @document.url_loader.load(@url)
+    rescue => e
+      raise SkipElementError, "Error retrieving URL #{@url}: #{e.message}"
+    end
+
+    @aspect = Prawn::SVG::Calculators::AspectRatio.new(attributes['preserveAspectRatio'], [width, height], image_dimensions(@image))
+
+    @clip_x = x
+    @clip_y = y
+    @clip_width = width
+    @clip_height = height
+
+    @width = @aspect.width
+    @height = @aspect.height
+    @x = x + @aspect.x
+    @y = y - @aspect.y
+  end
+
+  def apply
+    if @aspect.slice?
+      add_call "save"
+      add_call "rectangle", [@clip_x, @clip_y], @clip_width, @clip_height
+      add_call "clip"
+    end
+
+    options = {:width => @width, :height => @height, :at => [@x, @y]}
+
+    add_call "image", FakeIO.new(@image), options
+    add_call "restore" if @aspect.slice?
+  end
+
+  def bounding_box
+    [@x, @y, @x + @width, @y - @height]
+  end
+
+  protected
+
+  def image_dimensions(data)
+    handler = if data[0, 3].unpack("C*") == [255, 216, 255]
+      Prawn::Images::JPG
+    elsif data[0, 8].unpack("C*") == [137, 80, 78, 71, 13, 10, 26, 10]
+      Prawn::Images::PNG
+    else
+      raise SkipElementError, "Unsupported image type supplied to image tag; Prawn only supports JPG and PNG"
+    end
+
+    image = handler.new(data)
+    [image.width.to_f, image.height.to_f]
+  end
+end