gamba 2.0.0

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

@@ -0,0 +1,46 @@
+module Prawn::SVG::CSS
+  class FontParser
+    def self.parse(string)
+      in_quote = nil
+      in_escape = false
+      in_list_delimiter = false
+      current = nil
+      values = []
+
+      string.each_char do |char|
+        if in_escape
+          in_escape = false
+          if current.nil?
+            current = char
+            values << current
+          else
+            current << char
+          end
+        elsif char == "," && in_quote.nil? && !in_escape && current
+          current << char
+          in_list_delimiter = true
+        elsif char == "\\"
+          in_escape = true
+        elsif current.nil?
+          if char.match(/\s/).nil?
+            in_list_delimiter = false
+            current = char
+            values << current
+          end
+        elsif !in_quote && !in_escape && !in_list_delimiter && char.match(/\s/)
+          current = nil
+        else
+          current << char
+        end
+
+        if char == in_quote
+          in_quote = nil
+        elsif in_quote.nil? && ['"', "'"].include?(char)
+          in_quote = char
+        end
+      end
+
+      values.map(&:rstrip)
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+module Prawn::SVG::CSS
+  class SelectorParser
+    ATTRIBUTE_OPERATORS = ["=", "*=", "~=", "^=", "|=", "$=", nil].freeze
+
+    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 nil unless part
+
+          result.last[part] << token.name
+        when Attribute
+          return nil unless ATTRIBUTE_OPERATORS.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-]/
+    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 nil
+            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 nil
+            end
+
+          when :pre_operator
+            if "=*~^|$".include?(char)
+              result.last.operator = String.new(char)
+              attribute = :operator
+            elsif char != " " && char != "\t"
+              return nil
+            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 nil
+            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 nil 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 nil
+            end
+
+            result.last.name << "("
+            brackets = true
+          when "["
+            result << Attribute.new
+            attribute = :pre_key
+          else
+            return nil # 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,169 @@
+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],
+      # Gamba: 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:, 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