roadie 2.4.3 → 3.0.0

data/lib/roadie/filesystem_provider.rb

@@ -1,74 +1,44 @@
-require 'pathname'
-
 module Roadie
-  # A provider that looks for files on the filesystem
-  #
-  # Usage:
-  #   config.roadie.provider = FilesystemProvider.new("prefix", "path/to/stylesheets")
-  #
-  # Path specification follows certain rules thatare detailed in {#initialize}.
+  # Asset provider that looks for files on your local filesystem.
   #
-  # @see #initialize
-  class FilesystemProvider < AssetProvider
-    # @return [Pathname] Pathname representing the directory of the assets
+  # It will be locked to a specific path and it will not access files above
+  # that directory.
+  class FilesystemProvider
+    # Raised when FilesystemProvider is asked to access a file that lies above
+    # the base path.
+    class InsecurePathError < Error; end
+
+    include AssetProvider
     attr_reader :path
 
-    # Initializes a new instance of FilesystemProvider.
-    #
-    # The passed path can come in some variants:
-    # * +Pathname+ - will be used as-is
-    # * +String+ - If pointing to an absolute path, uses that path. If a relative path, relative from the +Rails.root+
-    # * +nil+ - Use the default path (equal to "public/stylesheets")
-    #
-    # @example Pointing to a directory in the project
-    #   FilesystemProvider.new(Rails.root.join("public", "assets"))
-    #   FilesystemProvider.new("public/assets")
-    #
-    # @example Pointing to external resource
-    #   FilesystemProvider.new("/home/app/stuff")
-    #
-    # @param [String] prefix The prefix (see {#prefix})
-    # @param [String, Pathname, nil] path The path to use
-    def initialize(prefix = "/stylesheets", path = nil)
-      super(prefix)
-      if path
-        @path = resolve_path(path)
-      else
-        @path = default_path
+    def initialize(path = Dir.pwd)
+      @path = path
+    end
+
+    # @return [Stylesheet, nil]
+    def find_stylesheet(name)
+      file_path = build_file_path(name)
+      if File.exist? file_path
+        Stylesheet.new file_path, File.read(file_path)
       end
     end
 
-    # Looks for the file in the tree. If the file cannot be found, and it does not end with ".css", the lookup
-    # will be retried with ".css" appended to the filename.
-    #
-    # @return [String] contents of the file
-    def find(name)
-      base = remove_prefix(name)
-      file = path.join(base)
-      if file.exist?
-        file.read.strip
+    # @raise InsecurePathError
+    # @return [Stylesheet]
+    def find_stylesheet!(name)
+      file_path = build_file_path(name)
+      if File.exist? file_path
+        Stylesheet.new file_path, File.read(file_path)
       else
-        return find("#{base}.css") if base.to_s !~ /\.css$/
-        raise CSSFileNotFound.new(name, base.to_s)
+        clean_name = File.basename file_path
+        raise CssNotFound.new(clean_name, %{#{file_path} does not exist. (Original name was "#{name}")})
       end
     end
 
     private
-      def default_path
-        resolve_path("public/stylesheets")
-      end
-
-      def resolve_path(path)
-        if path.kind_of?(Pathname)
-          @path = path
-        else
-          pathname = Pathname.new(path)
-          if pathname.absolute?
-            @path = pathname
-          else
-            @path = Roadie.app.root.join(path)
-          end
-        end
-      end
+    def build_file_path(name)
+      raise InsecurePathError, name if name.include?("..")
+      File.join(@path, name[/^([^?]+)/])
+    end
   end
 end

data/lib/roadie/inliner.rb

@@ -1,247 +1,102 @@
 require 'set'
+require 'nokogiri'
+require 'uri'
+require 'css_parser'
 
 module Roadie
-  # This class is the core of Roadie as it does all the actual work. You just give it
-  # the CSS rules, the HTML and the url_options for rewriting URLs and let it go on
-  # doing all the heavy lifting and building.
+  # @api private
+  # The Inliner inlines stylesheets to the elements of the DOM.
+  #
+  # Inlining means that {StyleBlock}s and a DOM tree are combined:
+  #   a { color: red; } # StyleBlock
+  #   <a href="/"></a>  # DOM
+  #
+  # becomes
+  #
+  #   <a href="/" style="color:red"></a>
   class Inliner
-    # Regexp matching all the url() declarations in CSS
-    #
-    # It matches without any quotes and with both single and double quotes
-    # inside the parenthesis. There's much room for improvement, of course.
-    CSS_URL_REGEXP = %r{
-      url\(
-        (
-          (?:["']|%22)?    # Optional opening quote
-        )
-        (
-          [^(]*            # Text leading up to before opening parens
-          (?:\([^)]*\))*   # Texts containing parens pairs
-          [^(]+            # Texts without parens - required
-        )
-        \1                 # Closing quote
-      \)
-    }x
-
-    # Initialize a new Inliner with the given Provider, CSS targets, HTML, and `url_options`.
-    #
-    # @param [AssetProvider] assets
-    # @param [Array] targets List of CSS files to load via the provider
-    # @param [String] html
-    # @param [Hash] url_options Supported keys: +:host+, +:port+, +:protocol+
-    # @param [lambda] after_inlining_handler A lambda that accepts one parameter or an object that responds to the +call+ method with one parameter.
-    def initialize(assets, targets, html, url_options, after_inlining_handler=nil)
-      @assets = assets
-      @css = assets.all(targets)
-      @html = html
-      @inline_css = []
-      @url_options = url_options
-      @after_inlining_handler = after_inlining_handler
-
-      if url_options and url_options[:asset_path_prefix]
-        raise ArgumentError, "The asset_path_prefix URL option is not working anymore. You need to add the following configuration to your application.rb:\n" +
-                             "    config.roadie.provider = AssetPipelineProvider.new(#{url_options[:asset_path_prefix].inspect})\n" +
-                             "Note that the prefix \"/assets\" is the default one, so you do not need to configure anything in that case."
-      end
+    # @param [Array<Stylesheet>] stylesheets the stylesheets to use in the inlining
+    def initialize(stylesheets)
+      @stylesheets = stylesheets
     end
 
-    # Start the inlining and return the final HTML output
-    # @return [String]
-    def execute
-      adjust_html do |document|
-        @document = document
-        add_missing_structure
-        extract_link_elements
-        extract_inline_style_elements
-        inline_css_rules
-        make_image_urls_absolute
-        make_style_urls_absolute
-        after_inlining_handler.call(document) if after_inlining_handler.respond_to?(:call)
-        @document = nil
-      end
+    # Start the inlining, mutating the DOM tree.
+    #
+    # @param [Nokogiri::HTML::Document] dom
+    # @return [nil]
+    def inline(dom)
+      apply style_map(dom)
+      nil
     end
 
     private
-      attr_reader :css, :html, :assets, :url_options, :document, :after_inlining_handler
+    attr_reader :stylesheets
 
-      def inline_css
-        @inline_css.join("\n")
+    def apply(style_map)
+      style_map.each_element do |element, builder|
+        apply_element_style element, builder
       end
+    end
 
-      def parsed_css
-        CssParser::Parser.new.tap do |parser|
-          parser.add_block! clean_css(css) if css
-          parser.add_block! clean_css(inline_css)
-        end
-      end
+    def style_map(dom)
+      style_map = StyleMap.new
 
-      def adjust_html
-        Nokogiri::HTML.parse(html).tap do |document|
-          yield document
-        end.dup.to_html
+      each_inlinable_block do |stylesheet, selector, properties|
+        elements = elements_matching_selector(stylesheet, selector, dom)
+        style_map.add elements, properties
       end
 
-      def add_missing_structure
-        html_node = document.at_css('html')
-        html_node['xmlns'] ||= 'http://www.w3.org/1999/xhtml'
-
-        if document.at_css('html > head').present?
-          head = document.at_css('html > head')
-        else
-          head = Nokogiri::XML::Node.new('head', document)
-          document.at_css('html').children.before(head)
-        end
-
-        # This is handled automatically by Nokogiri in Ruby 1.9, IF charset of string != utf-8
-        # We want UTF-8 to be specified as well, so we still do this.
-        unless document.at_css('html > head > meta[http-equiv=Content-Type]')
-          meta = Nokogiri::XML::Node.new('meta', document)
-          meta['http-equiv'] = 'Content-Type'
-          meta['content'] = 'text/html; charset=UTF-8'
-          head.add_child(meta)
-        end
-      end
+      style_map
+    end
 
-      def extract_link_elements
-        all_link_elements_to_be_inlined_with_url.each do |link, url|
-          asset = assets.find(url.path)
-          @inline_css << asset.to_s
-          link.remove
+    def each_inlinable_block
+      stylesheets.each do |stylesheet|
+        stylesheet.each_inlinable_block do |selector, properties|
+          yield stylesheet, selector, properties
         end
       end
+    end
 
-      def extract_inline_style_elements
-        document.css("style").each do |style|
-          next if style['media'] == 'print' or style['data-immutable']
-          @inline_css << style.content
-          style.remove
-        end
-      end
+    def apply_element_style(element, builder)
+      element["style"] = [builder.attribute_string, element["style"]].compact.join(";")
+    end
 
-      def inline_css_rules
-        elements_with_declarations.each do |element, declarations|
-          ordered_declarations = []
-          seen_properties = Set.new
-          declarations.sort.reverse_each do |declaration|
-            next if seen_properties.include?(declaration.property)
-            ordered_declarations.unshift(declaration)
-            seen_properties << declaration.property
-          end
+    def elements_matching_selector(stylesheet, selector, dom)
+      dom.css(selector.to_s)
+    # There's no way to get a list of supported pseudo selectors, so we're left
+    # with having to rescue errors.
+    # Pseudo selectors that are known to be bad are skipped automatically but
+    # this will catch the rest.
+    rescue Nokogiri::XML::XPath::SyntaxError, Nokogiri::CSS::SyntaxError => error
+      warn "Roadie cannot use #{selector.inspect} (from \"#{stylesheet.name}\" stylesheet) when inlining stylesheets"
+      []
+    rescue => error
+      warn "Roadie got error when looking for #{selector.inspect} (from \"#{stylesheet.name}\" stylesheet): #{error}"
+      raise unless error.message.include?('XPath')
+      []
+    end
 
-          rules_string = ordered_declarations.map { |declaration| declaration.to_s }.join(';')
-          element['style'] = [rules_string, element['style']].compact.join(';')
-        end
+    # @api private
+    # StyleMap is a map between a DOM element and {StyleAttributeBuilder}. Basically,
+    # it's an accumulator for properties, scoped on specific elements.
+    class StyleMap
+      def initialize
+        @map = Hash.new { |hash, key|
+          hash[key] = StyleAttributeBuilder.new
+        }
       end
 
-      def elements_with_declarations
-        Hash.new { |hash, key| hash[key] = [] }.tap do |element_declarations|
-          parsed_css.each_rule_set do |rule_set, _|
-            each_good_selector(rule_set) do |selector|
-              each_element_in_selector(selector) do |element|
-                style_declarations_in_rule_set(selector.specificity, rule_set) do |declaration|
-                  element_declarations[element] << declaration
-                end
-              end
-            end
+      def add(elements, new_properties)
+        Array(elements).each do |element|
+          new_properties.each do |property|
+            @map[element] << property
           end
         end
       end
 
-      def each_good_selector(rules)
-        rules.selectors.each do |selector_string|
-          selector = Selector.new(selector_string)
-          yield selector if selector.inlinable?
-        end
-      end
-
-      def each_element_in_selector(selector)
-        document.css(selector.to_s).each do |element|
-          yield element
-        end
-      # There's no way to get a list of supported pseudo rules, so we're left
-      # with having to rescue errors.
-      # Pseudo selectors that are known to be bad are skipped automatically but
-      # this will catch the rest.
-      rescue Nokogiri::XML::XPath::SyntaxError, Nokogiri::CSS::SyntaxError => error
-        warn "Roadie cannot use #{selector.inspect} when inlining stylesheets"
-      rescue => error
-        warn "Roadie got error when looking for #{selector.inspect}: #{error}"
-        raise unless error.message.include?('XPath')
-      end
-
-      def style_declarations_in_rule_set(specificity, rule_set)
-        rule_set.each_declaration do |property, value, important|
-          yield StyleDeclaration.new(property, value, important, specificity)
-        end
-      end
-
-      def make_image_urls_absolute
-        document.css('img').each do |img|
-          img['src'] = ensure_absolute_url(img['src']) if img['src']
-        end
-      end
-
-      def make_style_urls_absolute
-        document.css('*[style]').each do |element|
-          styling = element['style']
-          element['style'] = styling.gsub(CSS_URL_REGEXP) { "url(#{$1}#{ensure_absolute_url($2, '/stylesheets')}#{$1})" }
-        end
-      end
-
-      def ensure_absolute_url(url, base_path = nil)
-        base, uri = absolute_url_base(base_path), URI.parse(url)
-        if uri.relative? and base
-          base.merge(uri).to_s
-        else
-          uri.to_s
-        end
-      rescue URI::InvalidURIError
-        return url
-      end
-
-      def absolute_url_base(base_path)
-        return nil unless url_options
-        port = url_options[:port]
-        scheme = protocol_to_scheme url_options[:protocol]
-        URI::Generic.build({
-          :scheme => scheme,
-          :host => url_options[:host],
-          :port => (port ? port.to_i : nil),
-          :path => base_path
-        })
-      end
-
-      # Strip :// from any protocol, if present
-      def protocol_to_scheme(protocol)
-        return 'http' unless protocol
-        protocol.to_s[/^\w+/]
-      end
-
-      def all_link_elements_with_url
-        document.css("link[rel=stylesheet]").map { |link| [link, URI.parse(link['href'])] }
-      end
-
-      def all_link_elements_to_be_inlined_with_url
-        all_link_elements_with_url.reject do |link, url|
-          absolute_path_url = (url.host or url.path.nil?)
-          blacklisted_element = (link['media'] == 'print' or link['data-immutable'])
-
-          absolute_path_url or blacklisted_element
-        end
-      end
-
-      CLEANING_MATCHER = /
-        (^\s*             # Beginning-of-lines matches
-          (<!\[CDATA\[)|
-          (<!--+)
-        )|(               # End-of-line matches
-          (--+>)|
-          (\]\]>)
-        $)
-      /x.freeze
-
-      def clean_css(css)
-        css.gsub(CLEANING_MATCHER, '')
+      def each_element
+        @map.each_pair { |element, builder| yield element, builder }
       end
+    end
   end
 end

data/lib/roadie/markup_improver.rb

@@ -0,0 +1,88 @@
+module Roadie
+  # @api private
+  # Class that improves the markup of a HTML DOM tree
+  #
+  # This class will improve the following aspects of the DOM:
+  # * A HTML5 doctype will be added if missing, other doctypes will be left as-is.
+  # * Basic HTML elements will be added if missing.
+  #   * +<html>+
+  #   * +<head>+
+  #   * +<body>+
+  #   * +<meta>+ declaring charset and content-type (text/html)
+  #
+  # @note Due to a Nokogiri bug, the HTML5 doctype cannot be added under JRuby. No doctype is outputted under JRuby.
+  #   See https://github.com/sparklemotion/nokogiri/issues/984
+  class MarkupImprover
+    # The original HTML must also be passed in in order to handle the doctypes
+    # since a +Nokogiri::HTML::Document+ will always have a doctype, no matter if
+    # the original source had it or not. Reading the raw HTML is the only way to
+    # determine if we want to add a HTML5 doctype or not.
+    def initialize(dom, original_html)
+      @dom = dom
+      @html = original_html
+    end
+
+    # @return [nil] passed DOM will be mutated
+    def improve
+      ensure_doctype_present
+      head = ensure_head_element_present
+      ensure_declared_charset head
+    end
+
+    private
+    attr_reader :dom
+
+    def ensure_doctype_present
+      return if uses_buggy_jruby?
+      return if @html.include?('<!DOCTYPE ')
+      # Nokogiri adds a "default" doctype to the DOM, which we will remove
+      dom.internal_subset.remove unless dom.internal_subset.nil?
+      dom.create_internal_subset 'html', nil, nil
+    end
+
+    # JRuby up to at least 1.6.0 has a bug where the doctype of a document cannot be changed.
+    # See https://github.com/sparklemotion/nokogiri/issues/984
+    def uses_buggy_jruby?
+      # No reason to check for version yet since no existing version has a fix.
+      defined?(JRuby)
+    end
+
+    def ensure_head_element_present
+      if (head = dom.at_xpath('html/head'))
+        head
+      else
+        create_head_element dom.at_xpath('html')
+      end
+    end
+
+    def create_head_element(parent)
+      head = Nokogiri::XML::Node.new 'head', dom
+      unless parent.children.empty?
+        # Crashes when no children are present
+        parent.children.before head
+      else
+        parent << head
+      end
+      head
+    end
+
+    def ensure_declared_charset(parent)
+      if content_type_meta_element_missing?
+        parent.add_child make_content_type_element
+      end
+    end
+
+    def content_type_meta_element_missing?
+      dom.xpath('html/head/meta').none? do |meta|
+        meta['http-equiv'].to_s.downcase == 'content-type'
+      end
+    end
+
+    def make_content_type_element
+      meta = Nokogiri::XML::Node.new('meta', dom)
+      meta['http-equiv'] = 'Content-Type'
+      meta['content'] = 'text/html; charset=UTF-8'
+      meta
+    end
+  end
+end