prawnx 0.1.1

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

@@ -0,0 +1,312 @@
+class Prawn::SVG::Elements::Base
+  extend Forwardable
+
+  include Prawn::SVG::Elements::CallDuplicator
+  include Prawn::SVG::Elements::BboxScaling
+
+  include Prawn::SVG::Calculators::Pixels
+
+  include Prawn::SVG::Attributes::Transform
+  include Prawn::SVG::Attributes::Opacity
+  include Prawn::SVG::Attributes::ClipPath
+  include Prawn::SVG::Attributes::Mask
+  include Prawn::SVG::Attributes::Stroke
+  include Prawn::SVG::Attributes::Space
+
+  include Prawn::SVG::TransformParser
+
+  PAINT_TYPES = %w[fill stroke].freeze
+  COMMA_WSP_REGEXP = Prawn::SVG::Elements::COMMA_WSP_REGEXP
+  SVG_NAMESPACE = 'http://www.w3.org/2000/svg'.freeze
+
+  SkipElementQuietly = Class.new(StandardError)
+  SkipElementError = Class.new(StandardError)
+  MissingAttributesError = Class.new(SkipElementError)
+
+  attr_reader :document, :source, :parent_calls, :base_calls, :state, :attributes, :properties
+  attr_accessor :calls
+
+  def_delegators :@document, :warnings
+  def_delegator :@state, :computed_properties
+
+  def initialize(document, source, parent_calls, state)
+    @document = document
+    @source = source
+    @parent_calls = parent_calls
+    @state = state
+    @base_calls = @calls = []
+    @attributes = {}
+    @properties = Prawn::SVG::Properties.new
+
+    if source && add_to_elements_by_id? && !state.inside_use
+      id = source.attributes['id']
+      id = id.strip if id
+
+      document.elements_by_id[id] = self if id && id != ''
+    end
+  end
+
+  def process
+    extract_attributes_and_properties
+    parse_and_apply
+  end
+
+  def parse_and_apply
+    parse_standard_attributes
+    parse
+
+    apply_calls_from_standard_attributes
+    apply
+
+    if state.anchor_href && bounding_box
+      add_call('svg:add_link', state.anchor_href, bounding_box)
+    end
+
+    process_child_elements if container?
+
+    append_calls_to_parent unless computed_properties.display == 'none'
+  rescue SkipElementQuietly
+  rescue SkipElementError => e
+    @document.warnings << e.message
+  end
+
+  def name
+    @name ||= source ? source.name : '???'
+  end
+
+  protected
+
+  def parse; end
+
+  def apply; end
+
+  def bounding_box; end
+
+  def container?
+    false
+  end
+
+  def drawable?
+    !container?
+  end
+
+  def parse_standard_attributes
+    parse_xml_space_attribute
+  end
+
+  def add_call(name, *arguments, **kwarguments)
+    @calls << [name.to_s, arguments, kwarguments, []]
+  end
+
+  def add_call_and_enter(name, *arguments, **kwarguments)
+    @calls << [name.to_s, arguments, kwarguments, []]
+    @calls = @calls.last.last
+  end
+
+  def push_call_position
+    @call_positions ||= []
+    @call_positions << @calls
+  end
+
+  def pop_call_position
+    @calls = @call_positions.pop
+  end
+
+  def append_calls_to_parent
+    @parent_calls.concat(@base_calls)
+  end
+
+  def add_calls_from_element(other)
+    @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
+    yield
+    @calls = old_calls
+  end
+
+  def process_child_elements
+    return unless source
+
+    svg_child_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 svg_child_elements
+    source.elements.select do |elem|
+      # To be strict, we shouldn't treat namespace-less elements as SVG, but for
+      # backwards compatibility, and because it doesn't hurt, we will.
+      [SVG_NAMESPACE, ''].include?(elem.namespace)
+    end
+  end
+
+  def apply_calls_from_standard_attributes
+    parse_transform_attribute_and_call
+    parse_opacity_attributes_and_call
+    parse_clip_path_attribute_and_call
+    parse_mask_attribute_and_call
+    apply_colors
+    parse_stroke_attributes_and_call
+    apply_drawing_call
+  end
+
+  def apply_drawing_call
+    return if state.disable_drawing || !drawable?
+
+    fill   = !computed_properties.fill.none? # rubocop:disable Style/InverseMethods
+    stroke = !computed_properties.stroke.none? # rubocop:disable Style/InverseMethods
+
+    if fill
+      command = stroke ? 'fill_and_stroke' : 'fill'
+
+      if computed_properties.fill_rule == 'evenodd'
+        add_call_and_enter(command, fill_rule: :even_odd)
+      else
+        add_call_and_enter(command)
+      end
+    elsif stroke
+      add_call_and_enter('stroke')
+    else
+      add_call_and_enter('end_path')
+    end
+  end
+
+  def apply_colors
+    PAINT_TYPES.each do |type|
+      paint = properties.send(type)
+
+      case paint
+      when nil, 'inherit'
+        next
+      when Prawn::SVG::Paint
+        color = paint.resolve(document.gradients, computed_properties.color, document.color_mode)
+
+        case color
+        when Prawn::SVG::Color::RGB, Prawn::SVG::Color::CMYK
+          add_call "#{type}_color", color.value
+        when Prawn::SVG::Elements::Gradient
+          add_call 'svg:render_gradient', type.to_sym, **color.gradient_arguments(self)
+        when Prawn::SVG::Elements::Pattern
+          args = color.pattern_arguments(self)
+          add_call 'svg:render_pattern', type.to_sym, **args if args
+        when nil
+          nil
+        else
+          raise "Unknown resolved color type: #{color.inspect}"
+        end
+      else
+        raise "Unknown paint type: #{paint.inspect}"
+      end
+    end
+  end
+
+  def extract_attributes_and_properties
+    # Apply user agent stylesheet
+    if %w[svg symbol image marker pattern foreignObject].include?(source.name)
+      @properties.set('overflow', 'hidden')
+    end
+
+    # Apply presentation attributes, and set attributes that aren't presentation attributes
+    source.attributes.each do |name, value|
+      # Properties#set returns nil if it's not a recognised property name
+      @properties.set(name, value) or @attributes[name] = value
+    end
+
+    # Apply stylesheet styles
+    if (styles = document.element_styles[source])
+      styles.each do |name, value, important|
+        @properties.set(name, value, important: important)
+      end
+    end
+
+    # Apply inline styles
+    @properties.load_hash(parse_css_declarations(source.attributes['style'] || ''))
+
+    state.computed_properties.compute_properties(@properties)
+  end
+
+  def parse_css_declarations(declarations)
+    # copied from css_parser
+    declarations
+      .gsub(/(^\s*)|(\s*$)/, '')
+      .split(/[;$]+/m)
+      .each_with_object({}) do |decs, output|
+        if (matches = decs.match(/\s*(.[^:]*)\s*:\s*(.[^;]*)\s*(;|\Z)/i))
+          property, value, = matches.captures
+          output[property.downcase] = value
+        end
+      end
+  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
+
+  def extract_element_from_url_id_reference(value, expected_type = nil)
+    case value
+    when Prawn::SVG::FuncIRI
+      element = document.elements_by_id[value.url[1..]] if value.url.start_with?('#')
+      element if element && (expected_type.nil? || element.name == expected_type)
+    end
+  end
+
+  def href_attribute
+    attributes['xlink:href'] || attributes['href']
+  end
+
+  def overflow_hidden?
+    ['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
+    else
+      pixels(properties.stroke_width) || 1.0
+    end
+  end
+
+  def clone_element_source(source)
+    new_source = source.dup
+    document.element_styles[new_source] = document.element_styles[source]
+    new_source
+  end
+
+  def set_display_none
+    properties.display = 'none'
+    computed_properties.display = 'none'
+  end
+end

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

@@ -0,0 +1,78 @@
+module Prawn::SVG::Elements::BboxScaling
+  private
+
+  def build_object_bounding_box_calls(bbox, source_element = source)
+    bbox_left = bbox[0]
+    bbox_top = bbox[1]
+    bbox_right = bbox[2]
+    bbox_bottom = bbox[3]
+    bbox_w = bbox_right - bbox_left
+    bbox_h = bbox_top - bbox_bottom
+
+    unit_sizing = Prawn::SVG::Calculators::DocumentSizing.new([1, 1])
+    unit_sizing.document_width = 1
+    unit_sizing.document_height = 1
+    unit_sizing.calculate
+
+    result_calls = document.with_sizing(unit_sizing) do
+      new_state = state.dup
+      new_state.viewport_sizing = unit_sizing
+      new_state.inside_use = true
+
+      container = Prawn::SVG::Elements::Container.new(document, source_element, [], new_state)
+      container.process
+
+      container.base_calls
+    end
+
+    scale_calls_to_bbox(duplicate_calls(result_calls), bbox_left, bbox_top, bbox_w, bbox_h)
+  end
+
+  def scale_calls_to_bbox(calls, bbox_left, bbox_top, bbox_w, bbox_h)
+    calls.map do |name, args, kwargs, children|
+      new_args = case name
+                 when 'rectangle'
+                   point, width, height = args
+                   [scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h), width * bbox_w, height * bbox_h]
+                 when 'rounded_rectangle'
+                   point, width, height, radius = args
+                   [scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h), width * bbox_w, height * bbox_h, radius * bbox_w]
+                 when 'move_to', 'line_to'
+                   [scale_point(args[0], bbox_left, bbox_top, bbox_w, bbox_h)]
+                 when 'circle'
+                   point, radius = args
+                   scaled_point = scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h)
+                   if bbox_w == bbox_h
+                     [scaled_point, radius * bbox_w]
+                   else
+                     new_children = children.any? ? scale_calls_to_bbox(children, bbox_left, bbox_top, bbox_w, bbox_h) : children
+                     next ['ellipse', [scaled_point, radius * bbox_w, radius * bbox_h], kwargs, new_children]
+                   end
+                 when 'ellipse'
+                   point, rx, ry = args
+                   [scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h), rx * bbox_w, ry * bbox_h]
+                 when 'curve_to'
+                   dest = scale_point(args[0], bbox_left, bbox_top, bbox_w, bbox_h)
+                   [dest]
+                 else
+                   args
+                 end
+
+      new_kwargs = if name == 'curve_to' && kwargs[:bounds]
+                     b = kwargs[:bounds]
+                     { bounds: b.map { |p| scale_point(p, bbox_left, bbox_top, bbox_w, bbox_h) } }
+                   else
+                     kwargs
+                   end
+
+      new_children = children.any? ? scale_calls_to_bbox(children, bbox_left, bbox_top, bbox_w, bbox_h) : children
+      [name, new_args, new_kwargs, new_children]
+    end
+  end
+
+  def scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h)
+    x = bbox_left + (point[0] * bbox_w)
+    y = bbox_top - ((1.0 - point[1]) * bbox_h)
+    [x, y]
+  end
+end

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

@@ -0,0 +1,37 @@
+#
+# Unfortunately, prawn mutates arguments passed in to it.
+# When we make a copy of one of the call stacks, we need to make a deep
+# duplicate of it so that the first time prawn mutates the arguments, it
+# won't affect the subsequent calls.
+#
+module Prawn::SVG::Elements::CallDuplicator
+  private
+
+  def duplicate_calls(calls)
+    calls.map { |call| duplicate_call(call) }
+  end
+
+  def duplicate_call(call)
+    [call[0], duplicate_array(call[1]), duplicate_hash(call[2]), duplicate_calls(call[3])]
+  end
+
+  def duplicate_array(array)
+    array.map do |value|
+      case value
+      when Array then duplicate_array(value)
+      when Hash  then duplicate_hash(value)
+      else            value
+      end
+    end
+  end
+
+  def duplicate_hash(hash)
+    hash.each.with_object({}) do |(key, value), result|
+      result[key] = case value
+                    when Array then duplicate_array(value)
+                    when Hash  then duplicate_hash(value)
+                    else            value
+                    end
+    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 = pixels(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/clip_path.rb

@@ -0,0 +1,26 @@
+class Prawn::SVG::Elements::ClipPath < Prawn::SVG::Elements::Base
+  def parse
+    state.inside_clip_path = true
+    set_display_none
+  end
+
+  def container?
+    true
+  end
+
+  def build_clip_calls(element)
+    units = attributes['clipPathUnits'] || 'userSpaceOnUse'
+
+    if units == 'objectBoundingBox'
+      bbox = element.bounding_box
+      if bbox.nil?
+        document.warnings << 'clipPath with clipPathUnits="objectBoundingBox" requires element to have a bounding box'
+        return nil
+      end
+
+      build_object_bounding_box_calls(bbox)
+    else
+      duplicate_calls(base_calls)
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+class Prawn::SVG::Elements::Container < Prawn::SVG::Elements::Base
+  def parse
+    set_display_none if name == 'symbol' && !state.inside_use
+    set_display_none if name == 'defs'
+  end
+
+  def container?
+    true
+  end
+end

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/ellipse.rb

@@ -0,0 +1,22 @@
+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 = x_pixels(attributes['rx'])
+    @ry = y_pixels(attributes['ry'])
+
+    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