prawn-svg 0.37.0 → 0.40.2

data/lib/prawn/svg/css/font_face_parser.rb

@@ -0,0 +1,72 @@
+module Prawn::SVG::CSS
+  class FontFaceParser
+    SUPPORTED_FORMATS = %w[truetype opentype].freeze
+
+    class << self
+      def parse_src(src)
+        split_sources(src).filter_map { |entry| parse_source_entry(entry.strip) }
+      end
+
+      private
+
+      def split_sources(value)
+        entries = []
+        current = +''
+        depth = 0
+        in_quote = nil
+
+        value.each_char do |char|
+          if in_quote
+            current << char
+            in_quote = nil if char == in_quote
+          elsif ['"', "'"].include?(char)
+            in_quote = char
+            current << char
+          elsif char == '('
+            depth += 1
+            current << char
+          elsif char == ')'
+            depth -= 1
+            current << char
+          elsif char == ',' && depth.zero?
+            entries << current
+            current = +''
+          else
+            current << char
+          end
+        end
+
+        entries << current unless current.strip.empty?
+        entries
+      end
+
+      def parse_source_entry(entry)
+        parts = Prawn::SVG::CSS::ValuesParser.parse(entry)
+        return if parts.empty?
+
+        first = parts[0]
+        return unless first.is_a?(Array)
+
+        case first[0]
+        when 'url'
+          url = first[1][0]
+          return unless url
+
+          format = extract_format(parts[1])
+          { type: :url, url: url, format: format }
+        when 'local'
+          name = first[1][0]
+          return unless name
+
+          { type: :local, name: name }
+        end
+      end
+
+      def extract_format(part)
+        return unless part.is_a?(Array) && part[0] == 'format'
+
+        part[1][0]
+      end
+    end
+  end
+end

data/lib/prawn/svg/css/stylesheets.rb

@@ -1,11 +1,16 @@
 module Prawn::SVG::CSS
   class Stylesheets
-    attr_reader :css_parser, :root, :media
+    attr_reader :css_parser, :root, :media, :font_face_rules
 
-    def initialize(css_parser, root, media = :all)
+    def initialize(css_parser, root, media = :all, url_loader: nil, warnings: [])
       @css_parser = css_parser
       @root = root
       @media = media
+      @warnings = warnings
+      @font_face_rules = []
+
+      @has_url_loader = !url_loader.nil?
+      install_url_loader_on_css_parser(url_loader) if url_loader
     end
 
     def load
@@ -16,10 +21,35 @@ module Prawn::SVG::CSS
 
     private
 
+    def install_url_loader_on_css_parser(url_loader)
+      warnings = @warnings
+
+      css_parser.define_singleton_method(:load_uri!) do |uri, options = {}, _deprecated = nil|
+        uri = Addressable::URI.parse(uri) unless uri.respond_to?(:scheme)
+        import_url = uri.to_s
+
+        begin
+          return unless circular_reference_check(import_url)
+
+          src = url_loader.load(import_url)
+          add_block!(src, options) if src
+        rescue CssParser::CircularReferenceError
+          # Silently ignore circular @import references
+        rescue Prawn::SVG::UrlLoader::Error => e
+          warnings << "Failed to load @import CSS from #{import_url}: #{e.message}"
+        end
+      end
+    end
+
     def load_style_elements
       REXML::XPath.match(root, '//style').each do |source|
         data = source.texts.map(&:value).join
-        css_parser.add_block!(data)
+
+        if @has_url_loader
+          css_parser.add_block!(data, base_uri: '')
+        else
+          css_parser.add_block!(data)
+        end
       end
     end
 
@@ -32,6 +62,11 @@ module Prawn::SVG::CSS
         rule_set.each_declaration { |*data| declarations << data }
 
         rule_set.selectors.each do |selector_text|
+          if selector_text.strip == '@font-face'
+            @font_face_rules << declarations
+            next
+          end
+
           next unless (selector = Prawn::SVG::CSS::SelectorParser.parse(selector_text))
 
           xpath = css_selector_to_xpath(selector)
@@ -62,10 +97,13 @@ module Prawn::SVG::CSS
       %("#{value.gsub('\\', '\\\\').gsub('"', '\\"')}") if value
     end
 
+    RECOGNIZED_PSEUDO_CLASSES = %w[first-child last-child link visited hover active focus].freeze
+
     def css_selector_to_xpath(selector)
       selector.map do |element|
         pseudo_classes = Set.new(element[:pseudo_class])
         require_function_name = false
+        never_match = false
 
         result = case element[:combinator]
                  when :child
@@ -80,11 +118,18 @@ module Prawn::SVG::CSS
                  end
 
         positions = []
+        lang_predicates = []
+        href_predicates = []
         pseudo_classes.each do |pc|
           case pc
           when 'first-child' then positions << '1'
           when 'last-child'  then positions << 'last()'
-          when /^nth-child\((\d+)\)$/ then positions << $1
+          when /^nth-child\((.+)\)$/ then positions << parse_nth_child_expression($1)
+          when /^lang\((.+)\)$/ then lang_predicates << $1
+          when 'link' then href_predicates << true
+          when 'visited', 'hover', 'active', 'focus' then never_match = true
+          else
+            never_match = true unless RECOGNIZED_PSEUDO_CLASSES.include?(pc)
           end
         end
 
@@ -119,7 +164,7 @@ module Prawn::SVG::CSS
           when '^='
             result << "[starts-with(@#{key}, #{xpath_quote value})]"
           when '$='
-            result << "[substring(@#{key}, string-length(@#{key}) - #{value.length - 1}) = #{xpath_quote value})]"
+            result << "[substring(@#{key}, string-length(@#{key}) - #{value.length - 1}) = #{xpath_quote value}]"
           when '*='
             result << "[contains(@#{key}, #{xpath_quote value})]"
           when '~='
@@ -129,10 +174,52 @@ module Prawn::SVG::CSS
           end
         end
 
+        lang_predicates.each do |lang|
+          result << "[lang(#{xpath_quote lang})]"
+        end
+
+        result << '[@href or @xlink:href]' unless href_predicates.empty?
+
+        result << '[false()]' if never_match
+
         result
       end.join
     end
 
+    def parse_nth_child_expression(expr)
+      expr = expr.strip
+
+      return '(position() mod 2 = 1)' if expr == 'odd'
+      return '(position() mod 2 = 0)' if expr == 'even'
+      return expr if expr.match?(/\A\d+\z/)
+
+      match = expr.match(/\A(-?\d*)n\s*([+-]\s*\d+)?\z/)
+      return 'false()' unless match
+
+      a = case match[1]
+          when '', '+' then 1
+          when '-' then -1
+          else match[1].to_i
+          end
+      b = match[2] ? match[2].gsub(/\s/, '').to_i : 0
+
+      if a.zero?
+        b.to_s
+      elsif a.positive?
+        if b <= 0
+          "(position() mod #{a} = #{b % a} and position() >= #{[b, 1].max})"
+        else
+          "(position() mod #{a} = #{b % a} and position() >= #{b})"
+        end
+      elsif b <= 0
+        # a is negative: matches positions b, b+a, b+2a, ... while > 0
+        # i.e. position() <= b and (position() - b) mod |a| = 0
+        'false()'
+      else
+        "((position() - #{b}) mod #{a.abs} = 0 and position() >= 1 and position() <= #{b})"
+      end
+    end
+
     def calculate_specificity(selector)
       selector.reduce([0, 0, 0]) do |(a, b, c), element|
         [

data/lib/prawn/svg/document.rb

@@ -1,9 +1,15 @@
+require 'tempfile'
+
 class Prawn::SVG::Document
   Error = Class.new(StandardError)
   InvalidSVGData = Class.new(Error)
 
   DEFAULT_FALLBACK_FONT_NAME = 'Times-Roman'.freeze
 
+  class << self
+    attr_accessor :enable_web_requests_warned
+  end
+
   # An +Array+ of warnings that occurred while parsing the SVG data.
   attr_reader :warnings
 
@@ -14,7 +20,8 @@ class Prawn::SVG::Document
     :url_loader,
     :elements_by_id, :gradients,
     :element_styles,
-    :color_mode
+    :color_mode,
+    :external_svg_cache
 
   def initialize(data, bounds, options, font_registry: nil, css_parser: CssParser::Parser.new, attribute_overrides: {})
     begin
@@ -27,9 +34,18 @@ class Prawn::SVG::Document
     @options = options
     @elements_by_id = {}
     @gradients = Prawn::SVG::Gradients.new(self)
+    @external_svg_cache = {}
     @fallback_font_name = options.fetch(:fallback_font_name, DEFAULT_FALLBACK_FONT_NAME)
     @font_registry = font_registry
     @color_mode = load_color_mode
+    @font_face_tempfiles = []
+
+    if !options.key?(:enable_web_requests) && !self.class.enable_web_requests_warned
+      self.class.enable_web_requests_warned = true
+      warn '[prawn-svg] WARNING: :enable_web_requests is not set and currently defaults to true. ' \
+           'In prawn-svg 1.0, this will default to false. ' \
+           'Please explicitly pass enable_web_requests: true or enable_web_requests: false to suppress this warning.'
+    end
 
     @url_loader = Prawn::SVG::UrlLoader.new(
       enable_cache:          options[:cache_images],
@@ -43,7 +59,9 @@ class Prawn::SVG::Document
     @sizing = Prawn::SVG::Calculators::DocumentSizing.new(bounds, attributes)
     calculate_sizing(requested_width: options[:width], requested_height: options[:height])
 
-    @element_styles = Prawn::SVG::CSS::Stylesheets.new(css_parser, root).load
+    stylesheets = Prawn::SVG::CSS::Stylesheets.new(css_parser, root, url_loader: url_loader, warnings: warnings)
+    @element_styles = stylesheets.load
+    process_font_face_rules(stylesheets.font_face_rules)
 
     yield self if block_given?
   end
@@ -54,8 +72,86 @@ class Prawn::SVG::Document
     sizing.calculate
   end
 
+  def with_sizing(temporary_sizing)
+    original = @sizing
+    @sizing = temporary_sizing
+    yield
+  ensure
+    @sizing = original
+  end
+
   private
 
+  def process_font_face_rules(rules)
+    return unless font_registry
+
+    rules.each do |declarations|
+      decl_hash = {}
+      declarations.each { |name, value, _| decl_hash[name] = value }
+
+      family = unquote_css_string(decl_hash['font-family'])
+      next unless family
+
+      src = decl_hash['src']
+      next unless src
+
+      weight = decl_hash['font-weight']
+      style = decl_hash['font-style']
+      stretch = decl_hash['font-stretch']
+
+      load_font_face_source(family, weight, style, stretch, src)
+    end
+  end
+
+  def load_font_face_source(family, weight, style, stretch, src)
+    sources = Prawn::SVG::CSS::FontFaceParser.parse_src(src)
+
+    sources.detect do |source|
+      case source[:type]
+      when :local
+        load_local_font_face(family, weight, style, stretch, source[:name])
+      when :url
+        load_url_font_face(family, weight, style, stretch, source)
+      end
+    end
+  end
+
+  def load_local_font_face(family, weight, style, stretch, local_name)
+    font_data = font_registry.find_local_font_data(local_name, weight, style, stretch)
+    return unless font_data
+
+    font_registry.register_font_face(family, weight, style, stretch, font_data)
+    true
+  end
+
+  def load_url_font_face(family, weight, style, stretch, source)
+    return if source[:format] && !Prawn::SVG::CSS::FontFaceParser::SUPPORTED_FORMATS.include?(source[:format])
+
+    data = url_loader.load(source[:url])
+    tempfile = Tempfile.new(['prawn-svg-font', '.ttf'])
+    tempfile.binmode
+    tempfile.write(data)
+    tempfile.close
+    @font_face_tempfiles << tempfile
+
+    font_registry.register_font_face(family, weight, style, stretch, tempfile.path)
+    true
+  rescue Prawn::SVG::UrlLoader::Error => e
+    warnings << "Failed to load @font-face font from #{source[:url]}: #{e.message}"
+    false
+  end
+
+  def unquote_css_string(value)
+    return unless value
+
+    value = value.strip
+    if (value.start_with?('"') && value.end_with?('"')) || (value.start_with?("'") && value.end_with?("'"))
+      value[1..-2]
+    else
+      value
+    end
+  end
+
   def load_color_mode
     case @options[:color_mode]
     when nil, :rgb then :rgb

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

@@ -0,0 +1,9 @@
+class Prawn::SVG::Elements::Anchor < Prawn::SVG::Elements::Base
+  def parse
+    state.anchor_href = href_attribute
+  end
+
+  def container?
+    true
+  end
+end

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

@@ -2,12 +2,14 @@ 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
 
@@ -36,7 +38,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
 
@@ -56,6 +58,10 @@ class Prawn::SVG::Elements::Base
     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'
@@ -114,6 +120,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
@@ -150,6 +160,7 @@ class Prawn::SVG::Elements::Base
     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
@@ -191,6 +202,9 @@ class Prawn::SVG::Elements::Base
           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
@@ -269,6 +283,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
@@ -282,4 +304,9 @@ class Prawn::SVG::Elements::Base
     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/clip_path.rb

@@ -1,11 +1,26 @@
 class Prawn::SVG::Elements::ClipPath < Prawn::SVG::Elements::Base
   def parse
     state.inside_clip_path = true
-    properties.display = 'none'
-    computed_properties.display = 'none'
+    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

@@ -7,11 +7,4 @@ class Prawn::SVG::Elements::Container < Prawn::SVG::Elements::Base
   def container?
     true
   end
-
-  private
-
-  def set_display_none
-    properties.display = 'none'
-    computed_properties.display = 'none'
-  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/gradient.rb

@@ -181,23 +181,4 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
       end
     end
   end
-
-  def percentage_or_proportion(string, default = 0)
-    string = string.to_s.strip
-    percentage = false
-
-    if string[-1] == '%'
-      percentage = true
-      string = string[0..-2]
-    end
-
-    value = Float(string, exception: false)
-    return default unless value
-
-    if percentage
-      value / 100.0
-    else
-      value
-    end
-  end
 end