prawn-svg 0.27.1 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 78e98b74bfb10e36c2de7a051662546c98ddcfa5
-  data.tar.gz: 9fe692aebb49298a976f9436141c9bf9f4e3b750
+  metadata.gz: 5f5f1b932d2ff278ac37b5957a18b57d51013345
+  data.tar.gz: 7502fc93ebe947b1955d478292bf71c7b5dd40c0
 SHA512:
-  metadata.gz: bca8bd9a84bb372434d0a6aac7911c13e097fbdc30e788c9dad883a922237b384cc6f9786a3992193bd46ee47e562274bbe5e7f39a7ad6eba0a9311422e40c24
-  data.tar.gz: 67af84522eb27d03b18afa2d9f6309b4a2588f411ddf123681dd69bf34992a85c2aab62946d87ab025bb12c66df3e2189b3543c5eba4e79c4de691003206696b
+  metadata.gz: 770335f6cd4fbff5a30d6d6ff965ff2148e66543342de66a320583f4f24ec040d341054749c619c7a9ef1491e1e0155158ba63ea407b440406791dec60fc57f2
+  data.tar.gz: 8e1d9b9a00984309065c1ffc93b7695aafb97d4fbc91c3b6b76d7cc9ee4fe106365b23672f7a87fe0edc97e2612a7d7d3adfe557d5aaa1af4a0c90fb15652717

data/README.md

@@ -81,7 +81,7 @@ prawn-svg supports most but not all of the full SVG 1.1 specification.  It curre
  - `<switch>` and `<foreignObject>`, although prawn-svg cannot handle any data that is not SVG so `<foreignObject>`
    tags are always ignored.
 
- - properties: `clip-path`, `color`, `display`, `fill-opacity`, `fill`, `opacity`, `overflow`, `stroke`, `stroke-dasharray`, `stroke-linecap`, `stroke-opacity`, `stroke-width`
+ - properties: `clip-path`, `color`, `display`, `fill`, `fill-opacity`, `fill-rule`, `opacity`, `overflow`, `stroke`, `stroke-dasharray`, `stroke-linecap`, `stroke-opacity`, `stroke-width`
 
  - properties on lines, polylines, polygons and paths: `marker-end`, `marker-mid`, `marker-start`
 
@@ -101,12 +101,21 @@ prawn-svg supports most but not all of the full SVG 1.1 specification.  It curre
 
 ## CSS
 
-prawn-svg uses the css_parser gem to parse CSS <tt>&lt;style&gt;</tt> blocks.  It only handles simple tag, class or id selectors; attribute and other advanced selectors are not supported by the gem.
+prawn-svg supports CSS, both in `<style>` blocks and `style` attributes.
+
+In CSS selectors you can use element names, IDs, classes, attributes (existence, `=`, `^=`, `$=`, `*=`, `~=`, `|=`)
+and all combinators (` `, `>`, `+`, `~`).
+The pseudo-classes `:first-child`, `:last-child` and `:nth-child(n)` (where n is a number) also work.
+
+Pseudo-elements and the other pseudo-classes are not supported.  Specificity ordering is
+implemented, but `!important` is not.
 
 ## Not supported
 
 prawn-svg does not support radial gradients, patterns or filters.
 
+It does not support text in the clip area, but you can clip shapes and text by any shape.
+
 ## Configuration
 
 ### Fonts

data/lib/prawn-svg.rb

@@ -21,7 +21,9 @@ require 'prawn/svg/pathable'
 require 'prawn/svg/elements'
 require 'prawn/svg/extension'
 require 'prawn/svg/interface'
-require 'prawn/svg/css'
+require 'prawn/svg/css/font_family_parser'
+require 'prawn/svg/css/selector_parser'
+require 'prawn/svg/css/stylesheets'
 require 'prawn/svg/ttf'
 require 'prawn/svg/font'
 require 'prawn/svg/document'

data/lib/prawn/svg/{css.rb → css/font_family_parser.rb}

@@ -1,6 +1,6 @@
-class Prawn::SVG::CSS
-  class << self
-    def parse_font_family_string(string)
+module Prawn::SVG::CSS
+  class FontFamilyParser
+    def self.parse(string)
       in_quote = nil
       in_escape = false
       current = nil
@@ -37,4 +37,3 @@ class Prawn::SVG::CSS
     end
   end
 end
-

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

@@ -0,0 +1,174 @@
+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
+
+    private
+
+    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 = 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 = char
+              attribute = :operator
+            elsif char == " " || char == "\t"
+              attribute = :pre_operator
+            else
+              return
+            end
+
+          when :pre_operator
+            if "=*~^|$".include?(char)
+              result.last.operator = char
+              attribute = :operator
+            elsif char != " " && char != "\t"
+              return
+            end
+
+          when :operator
+            if "=*~^|$".include?(char)
+              result.last.operator << char
+            elsif char == " " || char == "\t"
+              attribute = :pre_value
+            elsif char == '"' || char == "'"
+              result.last.value = ''
+              attribute = char
+            else
+              result.last.value = char
+              attribute = :value
+            end
+
+          when :pre_value
+            if char == '"' || char == "'"
+              result.last.value = ''
+              attribute = char
+            elsif char != " " && char != "\t"
+              result.last.value = char
+              attribute = :value
+            end
+
+          when :value
+            if char == "]"
+              result.last.value = 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) if !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)
+            return unless result.last.is_a?(Identifier) && result[-2] && result[-2].is_a?(Modifier) && result[-2].type == :pseudo_class
+            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,125 @@
+module Prawn::SVG::CSS
+  class Stylesheets
+    attr_reader :css_parser, :root, :media
+
+    def initialize(css_parser, root, media = :all)
+      @css_parser = css_parser
+      @root = root
+      @media = media
+    end
+
+    def load
+      load_style_elements
+      xpath_styles = gather_xpath_styles
+      associate_xpath_styles_with_elements(xpath_styles)
+    end
+
+    private
+
+    def load_style_elements
+      REXML::XPath.match(root, '//style').each do |source|
+        data = source.texts.map(&:value).join
+        css_parser.add_block!(data)
+      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|
+          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
+
+    def css_selector_to_xpath(selector)
+      selector.map do |element|
+        pseudo_classes = Set.new(element[:pseudo_class])
+
+        result = case element[:combinator]
+                 when :child
+                   '/'
+                 when :adjacent
+                   pseudo_classes << 'first-child'
+                   '/following-sibling::'
+                 when :siblings
+                   '/following-sibling::'
+                 else
+                   '//'
+                 end
+
+        result << element[:name] if element[:name]
+        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
+
+        pseudo_classes.each do |pc|
+          case pc
+          when "first-child" then result << "[1]"
+          when "last-child"  then result << "[last()]"
+          when /^nth-child\((\d+)\)$/ then result << "[#{$1}]"
+          end
+        end
+
+        result
+      end.join
+    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/document.rb

@@ -12,7 +12,8 @@ class Prawn::SVG::Document
     :fallback_font_name,
     :font_registry,
     :url_loader,
-    :css_parser, :elements_by_id, :gradients
+    :elements_by_id, :gradients,
+    :element_styles
 
   def initialize(data, bounds, options, font_registry: nil, css_parser: CssParser::Parser.new)
     @root = REXML::Document.new(data).root
@@ -31,7 +32,6 @@ class Prawn::SVG::Document
     @gradients = {}
     @fallback_font_name = options.fetch(:fallback_font_name, DEFAULT_FALLBACK_FONT_NAME)
     @font_registry = font_registry
-    @css_parser = css_parser
 
     @url_loader = Prawn::SVG::UrlLoader.new(
       enable_cache:          options[:cache_images],
@@ -42,7 +42,7 @@ class Prawn::SVG::Document
     @sizing = Prawn::SVG::Calculators::DocumentSizing.new(bounds, @root.attributes)
     calculate_sizing(requested_width: options[:width], requested_height: options[:height])
 
-    parse_style_elements
+    @element_styles = Prawn::SVG::CSS::Stylesheets.new(css_parser, root).load
 
     yield self if block_given?
   end
@@ -52,16 +52,4 @@ class Prawn::SVG::Document
     sizing.requested_height = requested_height
     sizing.calculate
   end
-
-  private
-
-  # <style> elements specified anywhere in the document apply to the entire
-  # document.  Because of this, we load all <style> elements before parsing
-  # the rest of the document.
-  def parse_style_elements
-    REXML::XPath.match(root, '//style').each do |source|
-      data = source.texts.map(&:value).join
-      css_parser.add_block!(data)
-    end
-  end
 end

data/lib/prawn/svg/elements.rb

@@ -4,7 +4,7 @@ end
 
 require 'prawn/svg/elements/call_duplicator'
 
-%w(base depth_first_base root container viewport text text_component line polyline polygon circle ellipse rect path use image gradient marker ignored).each do |filename|
+%w(base depth_first_base root container clip_path viewport text text_component line polyline polygon circle ellipse rect path use image gradient marker ignored).each do |filename|
   require "prawn/svg/elements/#{filename}"
 end
 
@@ -13,7 +13,7 @@ module Prawn::SVG::Elements
     g: Prawn::SVG::Elements::Container,
     symbol: Prawn::SVG::Elements::Container,
     defs: Prawn::SVG::Elements::Container,
-    clipPath: Prawn::SVG::Elements::Container,
+    clipPath: Prawn::SVG::Elements::ClipPath,
     switch: Prawn::SVG::Elements::Container,
     svg: Prawn::SVG::Elements::Viewport,
     text: Prawn::SVG::Elements::Text,

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

@@ -157,14 +157,23 @@ class Prawn::SVG::Elements::Base
   end
 
   def apply_drawing_call
-    if !state.disable_drawing && drawable?
-      draw_types = PAINT_TYPES.select { |property| computed_properties.send(property) != 'none' }
+    return if state.disable_drawing || !drawable?
 
-      if draw_types.empty?
-        add_call_and_enter("end_path")
+    fill   = computed_properties.fill != 'none'
+    stroke = computed_properties.stroke != 'none'
+
+    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(draw_types.join("_and_"))
+        add_call_and_enter(command)
       end
+    elsif stroke
+      add_call_and_enter('stroke')
+    else
+      add_call_and_enter('end_path')
     end
   end
 
@@ -207,32 +216,20 @@ class Prawn::SVG::Elements::Base
   end
 
   def extract_attributes_and_properties
-    if @document && @document.css_parser
-      tag_style = @document.css_parser.find_by_selector(source.name)
-      id_style = @document.css_parser.find_by_selector("##{source.attributes["id"]}") if source.attributes["id"]
-
-      if classes = source.attributes["class"]
-        class_styles = classes.split(' ').collect do |class_name|
-          @document.css_parser.find_by_selector(".#{class_name}")
-        end
+    if styles = document.element_styles[source]
+      # TODO : implement !important, at the moment it's just ignored
+      styles.each do |name, value, _important|
+        @properties.set(name, value)
       end
-
-      element_style = source.attributes['style']
-
-      style = [tag_style, class_styles, id_style, element_style].flatten.collect do |s|
-        s.nil? || s.strip == "" ? "" : "#{s}#{";" unless s.match(/;\s*\z/)}"
-      end.join
-    else
-      style = source.attributes['style'] || ""
     end
 
+    @properties.load_hash(parse_css_declarations(source.attributes['style'] || ''))
+
     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
 
-    @properties.load_hash(parse_css_declarations(style))
-
     state.computed_properties.compute_properties(@properties)
   end