prawnx 0.1.1

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

@@ -0,0 +1,178 @@
+module Prawn::SVG::CSS
+  class SelectorParser
+    def self.parse(selector)
+      tokens = tokenise_css_selector(selector) or return
+
+      result = [{}]
+      part = nil
+
+      tokens.each do |token|
+        case token
+        when Modifier
+          part = token.type
+          result.last[part] ||= part == :name ? +'' : []
+        when Identifier
+          return unless part
+
+          result.last[part] << token.name
+        when Attribute
+          return unless ['=', '*=', '~=', '^=', '|=', '$=', nil].include?(token.operator)
+
+          (result.last[:attribute] ||= []) << [token.key, token.operator, token.value]
+        when Combinator
+          result << { combinator: token.type }
+          part = nil
+        end
+      end
+
+      result
+    end
+
+    VALID_CSS_IDENTIFIER_CHAR = /[a-zA-Z0-9_\u00a0-\uffff-]/.freeze
+    Identifier = Struct.new(:name)
+    Modifier = Struct.new(:type)
+    Combinator = Struct.new(:type)
+    Attribute = Struct.new(:key, :operator, :value)
+
+    def self.tokenise_css_selector(selector)
+      result = []
+      brackets = false
+      attribute = false
+      quote = false
+
+      selector.strip.chars do |char|
+        if brackets
+          result.last.name << char
+          brackets = false if char == ')'
+        elsif attribute
+          case attribute
+          when :pre_key
+            if VALID_CSS_IDENTIFIER_CHAR.match(char)
+              result.last.key = String.new(char)
+              attribute = :key
+            elsif char != ' ' && char != "\t"
+              return
+            end
+
+          when :key
+            if VALID_CSS_IDENTIFIER_CHAR.match(char)
+              result.last.key << char
+            elsif char == ']'
+              attribute = nil
+            elsif '=*~^|$'.include?(char)
+              result.last.operator = String.new(char)
+              attribute = :operator
+            elsif [' ', "\t"].include?(char)
+              attribute = :pre_operator
+            else
+              return
+            end
+
+          when :pre_operator
+            if '=*~^|$'.include?(char)
+              result.last.operator = String.new(char)
+              attribute = :operator
+            elsif char != ' ' && char != "\t"
+              return
+            end
+
+          when :operator
+            if '=*~^|$'.include?(char)
+              result.last.operator << char
+            elsif [' ', "\t"].include?(char)
+              attribute = :pre_value
+            elsif ['"', "'"].include?(char)
+              result.last.value = +''
+              attribute = String.new(char)
+            else
+              result.last.value = String.new(char)
+              attribute = :value
+            end
+
+          when :pre_value
+            if ['"', "'"].include?(char)
+              result.last.value = +''
+              attribute = String.new(char)
+            elsif char != ' ' && char != "\t"
+              result.last.value = String.new(char)
+              attribute = :value
+            end
+
+          when :value
+            if char == ']'
+              result.last.value = String.new(result.last.value.rstrip)
+              attribute = nil
+            else
+              result.last.value << char
+            end
+
+          when '"', "'"
+            if char == '\\' && !quote
+              quote = true
+            elsif char == attribute && !quote
+              attribute = :post_string
+            else
+              quote = false
+              result.last.value << char
+            end
+
+          when :post_string
+            if char == ']'
+              attribute = nil
+            elsif char != ' ' && char != "\t"
+              return
+            end
+          end
+
+        elsif VALID_CSS_IDENTIFIER_CHAR.match(char)
+          case result.last
+          when Identifier
+            result.last.name << char
+          else
+            result << Modifier.new(:name) unless result.last.is_a?(Modifier)
+            result << Identifier.new(char)
+          end
+        else
+          case char
+          when '.'
+            result << Modifier.new(:class)
+          when '#'
+            result << Modifier.new(:id)
+          when ':'
+            result << Modifier.new(:pseudo_class)
+          when ' ', "\t"
+            result << Combinator.new(:descendant) unless result.last.is_a?(Combinator)
+          when '>'
+            result.pop if result.last == Combinator.new(:descendant)
+            result << Combinator.new(:child)
+          when '+'
+            result.pop if result.last == Combinator.new(:descendant)
+            result << Combinator.new(:adjacent)
+          when '~'
+            result.pop if result.last == Combinator.new(:descendant)
+            result << Combinator.new(:siblings)
+          when '*'
+            return unless result.empty? || result.last.is_a?(Combinator)
+
+            result << Modifier.new(:name)
+            result << Identifier.new('*')
+          when '(' # e.g. :nth-child(3n+4)
+            unless result.last.is_a?(Identifier) && result[-2] && result[-2].is_a?(Modifier) && result[-2].type == :pseudo_class
+              return
+            end
+
+            result.last.name << '('
+            brackets = true
+          when '['
+            result << Attribute.new
+            attribute = :pre_key
+          else
+            return # unsupported Combinator
+          end
+        end
+      end
+
+      result unless brackets || attribute
+    end
+  end
+end

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

@@ -0,0 +1,233 @@
+module Prawn::SVG::CSS
+  class Stylesheets
+    attr_reader :css_parser, :root, :media, :font_face_rules
+
+    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
+      load_style_elements
+      xpath_styles = gather_xpath_styles
+      associate_xpath_styles_with_elements(xpath_styles)
+    end
+
+    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
+
+        if @has_url_loader
+          css_parser.add_block!(data, base_uri: '')
+        else
+          css_parser.add_block!(data)
+        end
+      end
+    end
+
+    def gather_xpath_styles
+      xpath_styles = []
+      order = 0
+
+      css_parser.each_rule_set(media) do |rule_set, _|
+        declarations = []
+        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)
+          specificity = calculate_specificity(selector)
+          specificity << order
+          order += 1
+
+          xpath_styles << [xpath, declarations, specificity]
+        end
+      end
+
+      xpath_styles.sort_by(&:last)
+    end
+
+    def associate_xpath_styles_with_elements(xpath_styles)
+      element_styles = {}
+
+      xpath_styles.each do |xpath, declarations, _|
+        REXML::XPath.match(root, xpath).each do |element|
+          (element_styles[element] ||= []).concat declarations
+        end
+      end
+
+      element_styles
+    end
+
+    def xpath_quote(value)
+      %("#{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
+                   +'/'
+                 when :adjacent
+                   pseudo_classes << 'first-child'
+                   +'/following-sibling::'
+                 when :siblings
+                   +'/following-sibling::'
+                 else
+                   +'//'
+                 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\((.+)\)$/ 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
+
+        unless positions.empty?
+          result << '*' unless require_function_name
+          require_function_name = true
+
+          logic = if positions.length == 1
+                    positions.first
+                  else
+                    positions.map { |position| "position()=#{position}" }.join(' and ')
+                  end
+
+          result << "[#{logic}]"
+        end
+
+        if require_function_name
+          result << "[name()=#{xpath_quote element[:name]}]" if element[:name]
+        else
+          result << (element[:name] || '*')
+        end
+
+        result << ((element[:class] || []).map { |name| "[contains(concat(' ',@class,' '), ' #{name} ')]" }.join)
+        result << ((element[:id] || []).map { |name| "[@id='#{name}']" }.join)
+
+        (element[:attribute] || []).each do |key, operator, value|
+          case operator
+          when nil
+            result << "[@#{key}]"
+          when '='
+            result << "[@#{key}=#{xpath_quote value}]"
+          when '^='
+            result << "[starts-with(@#{key}, #{xpath_quote value})]"
+          when '$='
+            result << "[substring(@#{key}, string-length(@#{key}) - #{value.length - 1}) = #{xpath_quote value}]"
+          when '*='
+            result << "[contains(@#{key}, #{xpath_quote value})]"
+          when '~='
+            result << "[contains(concat(' ',@#{key},' '), #{xpath_quote " #{value} "})]"
+          when '|='
+            result << "[contains(concat('-',@#{key},'-'), #{xpath_quote "-#{value}-"})]"
+          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|
+        [
+          a + (element[:id] || []).length,
+          b + (element[:class] || []).length + (element[:attribute] || []).length + (element[:pseudo_class] || []).length,
+          c + (element[:name] && element[:name] != '*' ? 1 : 0)
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Prawn::SVG::CSS
+  class ValuesParser
+    class << self
+      def parse(values)
+        result = []
+
+        while values
+          value, remainder = parse_next(values)
+          break unless value
+
+          result << value
+          values = remainder
+        end
+
+        result
+      end
+
+      private
+
+      def parse_next(values)
+        values = values.strip
+        return if values.empty?
+
+        if (matches = values.match(/\A([a-z-]+)\(\s*(.+)/i))
+          parse_function_call(matches[1].downcase, matches[2])
+        else
+          values.split(/\s+/, 2)
+        end
+      end
+
+      # Note this does not support space-separated arguments.
+      # I don't think CSS 2 has any, but in case it does here is the place to add them.
+      def parse_function_call(name, rest)
+        arguments = []
+        in_quote = nil
+        in_escape = false
+        current = +''
+
+        rest.each_char.with_index do |char, index|
+          if in_escape
+            current << char
+            in_escape = false
+          elsif %w[" '].include?(char)
+            if in_quote == char
+              in_quote = nil
+            elsif in_quote.nil?
+              in_quote = char
+            else
+              current << char
+            end
+          elsif char == '\\'
+            in_escape = true
+          elsif in_quote.nil? && char == ','
+            arguments << current.strip
+            current = +''
+          elsif in_quote.nil? && char == ')'
+            arguments << current.strip
+            return [[name, arguments], rest[index + 1..]]
+          else
+            current << char
+          end
+        end
+
+        [rest, nil]
+      end
+    end
+  end
+end

data/lib/prawn/svg/document.rb

@@ -0,0 +1,170 @@
+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
+
+  attr_reader :root,
+    :sizing,
+    :fallback_font_name,
+    :font_registry,
+    :url_loader,
+    :elements_by_id, :gradients,
+    :element_styles,
+    :color_mode,
+    :external_svg_cache
+
+  def initialize(data, bounds, options, font_registry: nil, css_parser: CssParser::Parser.new, attribute_overrides: {})
+    begin
+      @root = REXML::Document.new(data).root or raise_parse_error(data)
+    rescue REXML::ParseException => e
+      raise_parse_error(data, e.message)
+    end
+
+    @warnings = []
+    @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 = []
+
+
+    @url_loader = Prawn::SVG::UrlLoader.new(
+      enable_cache:          options[:cache_images],
+      # PrawnX: no web request unless asked for, since an SVG could otherwise make the server fetch any URL.
+      enable_web:            options.fetch(:enable_web_requests, false),
+      enable_file_with_root: options[:enable_file_requests_with_root]
+    )
+
+    attributes = @root.attributes.dup
+    attribute_overrides.each { |key, value| attributes.add(REXML::Attribute.new(key, value)) }
+
+    @sizing = Prawn::SVG::Calculators::DocumentSizing.new(bounds, attributes)
+    calculate_sizing(requested_width: options[:width], requested_height: options[:height])
+
+    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
+
+  def calculate_sizing(requested_width: nil, requested_height: nil)
+    sizing.requested_width = requested_width
+    sizing.requested_height = requested_height
+    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
+    when :cmyk then :cmyk
+    else
+      raise ArgumentError, ':color_mode must be set to :rgb (default) or :cmyk'
+    end
+  end
+
+  def raise_parse_error(data, exception_message = nil)
+    message = 'The data supplied is not a valid SVG document.'
+
+    if data.respond_to?(:end_with?) && data.end_with?('.svg')
+      message += "  It looks like you've supplied a filename instead; use File.read(filename) to get the data from the file before you pass it to prawn-svg."
+    end
+
+    message += "\n#{exception_message}" if exception_message
+
+    raise InvalidSVGData, message
+  end
+end

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

@@ -0,0 +1,10 @@
+class Prawn::SVG::Elements::Anchor < Prawn::SVG::Elements::Base
+  def parse
+    href = href_attribute
+    state.anchor_href = href unless href.nil? || href.strip.empty?
+  end
+
+  def container?
+    true
+  end
+end