gamba 2.0.0

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

@@ -0,0 +1,315 @@
+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:)
+      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?("#") # rubocop:disable Performance/ArraySemiInfiniteRangeSlice -- String
+      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,19 @@
+class Prawn::SVG::Elements::Circle < Prawn::SVG::Elements::Base
+  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
+    add_call "circle", [@x, @y], @r
+  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,28 @@
+#
+# 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,20 @@
+class Prawn::SVG::Elements::Ellipse < Prawn::SVG::Elements::Base
+  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 "ellipse", [@x, @y], @rx, @ry
+  end
+
+  def bounding_box
+    [@x - @rx, @y + @ry, @x + @rx, @y - @ry]
+  end
+end