roadie 3.0.5 → 3.1.0.rc1

data/lib/roadie.rb

@@ -16,6 +16,9 @@ require 'roadie/asset_provider'
 require 'roadie/provider_list'
 require 'roadie/filesystem_provider'
 require 'roadie/null_provider'
+require 'roadie/net_http_provider'
+require 'roadie/cached_provider'
+require 'roadie/path_rewriter_provider'
 
 require 'roadie/asset_scanner'
 require 'roadie/markup_improver'
@@ -24,5 +27,3 @@ require 'roadie/url_rewriter'
 require 'roadie/null_url_rewriter'
 require 'roadie/inliner'
 require 'roadie/document'
-
-require 'roadie/upgrade_guide'

data/lib/roadie/asset_scanner.rb

@@ -5,15 +5,18 @@ module Roadie
   # DOM tree. Referenced styles will be found using the provided asset
   # provider.
   #
-  # Any style declaration tagged with +data-roadie-ignore+ will be ignored.
+  # Any style declaration tagged with +data-roadie-ignore+ will be ignored,
+  # except for having the attribute itself removed.
   class AssetScanner
-    attr_reader :dom, :asset_provider
+    attr_reader :dom, :normal_asset_provider, :external_asset_provider
 
     # @param [Nokogiri::HTML::Document] dom
-    # @param [#find_stylesheet!] asset_provider
-    def initialize(dom, asset_provider)
+    # @param [#find_stylesheet!] normal_asset_provider
+    # @param [#find_stylesheet!] external_asset_provider
+    def initialize(dom, normal_asset_provider, external_asset_provider)
       @dom = dom
-      @asset_provider = asset_provider
+      @normal_asset_provider = normal_asset_provider
+      @external_asset_provider = external_asset_provider
     end
 
     # Looks for all non-ignored stylesheets and returns them.
@@ -38,15 +41,16 @@ module Roadie
     # @see #find_css
     # @return [Enumerable<Stylesheet>] every extracted stylesheet
     def extract_css
-      @dom.css(STYLE_ELEMENT_QUERY).map { |element|
+      stylesheets = @dom.css(STYLE_ELEMENT_QUERY).map { |element|
         stylesheet = read_stylesheet(element)
         element.remove if stylesheet
         stylesheet
       }.compact
+      remove_ignore_markers
+      stylesheets
     end
 
     private
-
     STYLE_ELEMENT_QUERY = (
       "style:not([data-roadie-ignore]), " +
       # TODO: When using Nokogiri 1.6.1 and later; we may use a double :not here
@@ -70,7 +74,7 @@ module Roadie
     def read_stylesheet(element)
       if element.name == "style"
         read_style_element element
-      else
+      elsif element.name == "link" && element['media'] != "print" && element["href"]
         read_link_element element
       end
     end
@@ -80,13 +84,29 @@ module Roadie
     end
 
     def read_link_element(element)
-      if element['media'] != "print" && element["href"] && !Utils.path_is_absolute?(element["href"])
-        asset_provider.find_stylesheet! element['href']
+      if Utils.path_is_absolute?(element["href"])
+        external_asset_provider.find_stylesheet! element['href'] if should_find_external?
+      else
+        normal_asset_provider.find_stylesheet! element['href']
       end
     end
 
     def clean_css(css)
       css.gsub(CLEANING_MATCHER, '')
     end
+
+    def should_find_external?
+      return false unless external_asset_provider
+      # If external_asset_provider is empty list; don't use it.
+      return false if external_asset_provider.respond_to?(:empty?) && external_asset_provider.empty?
+
+      true
+    end
+
+    def remove_ignore_markers
+      @dom.css("[data-roadie-ignore]").each do |node|
+        node.remove_attribute "data-roadie-ignore"
+      end
+    end
   end
 end

data/lib/roadie/cached_provider.rb

@@ -0,0 +1,77 @@
+module Roadie
+  # @api public
+  # The {CachedProvider} wraps another provider (or {ProviderList}) and caches
+  # the response from it.
+  #
+  # The default cache store is a instance-specific hash that lives for the
+  # entire duration of the instance. If you want to share hash between
+  # instances, pass your own hash-like object. Just remember to not allow this
+  # cache to grow without bounds, which a shared hash would do.
+  #
+  # Not found assets are not cached currently, but it's possible to extend this
+  # class in the future if there is a need for it. Remember this if you have
+  # providers with very slow failures.
+  #
+  # The cache store must accept {Roadie::Stylesheet} instances, and return such
+  # instances when fetched. It must respond to `#[name]` and `#[name]=` to
+  # retrieve and set entries, respectively. The `#[name]=` method also needs to
+  # return the instance again.
+  #
+  # @example Global cache
+  #   Application.asset_cache = Hash.new
+  #   slow_provider = MyDatabaseProvider.new(Application)
+  #   provider = Roadie::CachedProvider.new(slow_provider, Application.asset_cache)
+  #
+  # @example Custom cache store
+  #   class MyRoadieMemcacheStore
+  #     def initialize(memcache)
+  #       @memcache = memcache
+  #     end
+  #
+  #     def [](path)
+  #       css = memcache.read("assets/#{path}/css")
+  #       if css
+  #         name = memcache.read("assets/#{path}/name") || "cached #{path}"
+  #         Roadie::Stylesheet.new(name, css)
+  #       end
+  #     end
+  #
+  #     def []=(path, stylesheet)
+  #       memcache.write("assets/#{path}/css", stylesheet.to_s)
+  #       memcache.write("assets/#{path}/name", stylesheet.name)
+  #       stylesheet # You need to return the set Stylesheet
+  #     end
+  #   end
+  #
+  class CachedProvider
+    # The cache store used by this instance.
+    attr_reader :cache
+
+    # @param upstream [an asset provider] The wrapped asset provider
+    # @param cache [#[], #[]=] The cache store to use.
+    def initialize(upstream, cache = {})
+      @upstream = upstream
+      @cache = cache
+    end
+
+    def find_stylesheet(name)
+      cache_fetch(name) do
+        @upstream.find_stylesheet(name)
+      end
+    end
+
+    def find_stylesheet!(name)
+      cache_fetch(name) do
+        @upstream.find_stylesheet!(name)
+      end
+    end
+
+    private
+    def cache_fetch(name)
+      cache[name] || cache[name] = yield
+    rescue CssNotFound
+      cache[name] = nil
+      raise
+    end
+  end
+end

data/lib/roadie/document.rb

@@ -13,10 +13,10 @@ module Roadie
   # The internal stylesheet is used last and gets the highest priority. The
   # rest is used in the same order as browsers are supposed to use them.
   #
-  # @attr [#call] before_transformation Callback to call just before {#transform}ation is begun. Will be called with the parsed DOM tree.
-  # @attr [#call] after_transformation Callback to call just before {#transform}ation is completed. Will be called with the current DOM tree.
+  # @attr [#call] before_transformation Callback to call just before {#transform}ation begins. Will be called with the parsed DOM tree and the {Document} instance.
+  # @attr [#call] after_transformation Callback to call just before {#transform}ation is completed. Will be called with the current DOM tree and the {Document} instance.
   class Document
-    attr_reader :html, :asset_providers
+    attr_reader :html, :asset_providers, :external_asset_providers
 
     # URL options. If none are given no URL rewriting will take place.
     # @see UrlGenerator#initialize
@@ -24,10 +24,15 @@ module Roadie
 
     attr_accessor :before_transformation, :after_transformation
 
+    # Should CSS that cannot be inlined be kept in a new `<style>` element in `<head>`?
+    attr_accessor :keep_uninlinable_css
+
     # @param [String] html the input HTML
     def initialize(html)
+      @keep_uninlinable_css = true
       @html = html
       @asset_providers = ProviderList.wrap(FilesystemProvider.new)
+      @external_asset_providers = ProviderList.empty
       @css = ""
     end
 
@@ -39,9 +44,10 @@ module Roadie
 
     # Transform the input HTML and returns the processed HTML.
     #
-    # Before the transformation begins, the {#before_transformation} callback will be
-    # called with the parsed HTML tree, and after all work is complete the
-    # {#after_transformation} callback will be invoked.
+    # Before the transformation begins, the {#before_transformation} callback
+    # will be called with the parsed HTML tree and the {Document} instance, and
+    # after all work is complete the {#after_transformation} callback will be
+    # invoked in the same way.
     #
     # Most of the work is delegated to other classes. A list of them can be seen below.
     #
@@ -65,11 +71,16 @@ module Roadie
       dom.dup.to_html
     end
 
-    # Assign new asset providers. The supplied list will be wrapped in a {ProviderList} using {ProviderList.wrap}.
+    # Assign new normal asset providers. The supplied list will be wrapped in a {ProviderList} using {ProviderList.wrap}.
     def asset_providers=(list)
       @asset_providers = ProviderList.wrap(list)
     end
 
+    # Assign new external asset providers. The supplied list will be wrapped in a {ProviderList} using {ProviderList.wrap}.
+    def external_asset_providers=(list)
+      @external_asset_providers = ProviderList.wrap(list)
+    end
+
     private
     def stylesheet
       Stylesheet.new "(Document styles)", @css
@@ -80,8 +91,8 @@ module Roadie
     end
 
     def inline(dom)
-      dom_stylesheets = AssetScanner.new(dom, asset_providers).extract_css
-      Inliner.new(dom_stylesheets + [stylesheet]).inline(dom)
+      dom_stylesheets = AssetScanner.new(dom, asset_providers, external_asset_providers).extract_css
+      Inliner.new(dom_stylesheets + [stylesheet], dom).inline(keep_uninlinable_css)
     end
 
     def rewrite_urls(dom)
@@ -97,7 +108,15 @@ module Roadie
     end
 
     def callback(callable, dom)
-      callable.(dom) if callable.respond_to?(:call)
+      if callable.respond_to?(:call)
+        # Arity checking is to support the API without bumping a major version.
+        # TODO: Remove on next major version (v4.0)
+        if !callable.respond_to?(:parameters) || callable.parameters.size == 1
+          callable.(dom)
+        else
+          callable.(dom, self)
+        end
+      end
     end
   end
 end

data/lib/roadie/errors.rb

@@ -38,19 +38,61 @@ module Roadie
     # Provider used when finding
     attr_reader :provider
 
+    # Extra message
+    attr_reader :extra_message
+
     # TODO: Change signature in the next major version of Roadie.
     def initialize(css_name, extra_message = nil, provider = nil)
       @css_name = css_name
       @provider = provider
+      @extra_message = extra_message
       super build_message(extra_message)
     end
 
+    protected
+    def error_row
+      "#{provider || "Unknown provider"}: #{extra_message || message}"
+    end
+
     private
-    def build_message(extra_message)
+    # Redundant method argument is to keep API compatability without major version bump.
+    # TODO: Remove argument on version 4.0.
+    def build_message(extra_message = @extra_message)
       message = %(Could not find stylesheet "#{css_name}")
       message << ": #{extra_message}" if extra_message
       message << "\nUsed provider:\n#{provider}" if provider
       message
     end
   end
+
+  class ProvidersFailed < CssNotFound
+    attr_reader :errors
+
+    def initialize(css_name, provider_list, errors)
+      @errors = errors
+      super(css_name, "All providers failed", provider_list)
+    end
+
+    private
+    def build_message(extra_message)
+      message = %(Could not find stylesheet "#{css_name}": #{extra_message}\nUsed providers:\n)
+      each_error_row(errors) do |row|
+        message << "\t" << row << "\n"
+      end
+      message
+    end
+
+    def each_error_row(errors)
+      errors.each do |error|
+        case error
+        when ProvidersFailed
+          each_error_row(error.errors) { |row| yield row }
+        when CssNotFound
+          yield error.error_row
+        else
+          yield "Unknown provider (#{error.class}): #{error}"
+        end
+      end
+    end
+  end
 end

data/lib/roadie/filesystem_provider.rb

@@ -8,7 +8,6 @@ module Roadie
     # the base path.
     class InsecurePathError < Error; end
 
-    include AssetProvider
     attr_reader :path
 
     def initialize(path = Dir.pwd)
@@ -35,6 +34,9 @@ module Roadie
       end
     end
 
+    def to_s() inspect end
+    def inspect() "#<#{self.class} #@path>" end
+
     private
     def build_file_path(name)
       raise InsecurePathError, name if name.include?("..")

data/lib/roadie/inliner.rb

@@ -16,64 +16,94 @@ module Roadie
   #   <a href="/" style="color:red"></a>
   class Inliner
     # @param [Array<Stylesheet>] stylesheets the stylesheets to use in the inlining
-    def initialize(stylesheets)
+    # @param [Nokogiri::HTML::Document] dom
+    def initialize(stylesheets, dom)
       @stylesheets = stylesheets
+      @dom = dom
     end
 
     # Start the inlining, mutating the DOM tree.
     #
-    # @param [Nokogiri::HTML::Document] dom
+    # @param [true, false] keep_extra_blocks
     # @return [nil]
-    def inline(dom)
-      apply style_map(dom)
-      nil
-    end
+    def inline(keep_extra_blocks = true)
+      style_map, extra_blocks = consume_stylesheets
 
-    private
-    attr_reader :stylesheets
+      apply_style_map(style_map)
+      add_styles_to_head(extra_blocks) if keep_extra_blocks
 
-    def apply(style_map)
-      style_map.each_element do |element, builder|
-        apply_element_style element, builder
-      end
+      nil
     end
 
-    def style_map(dom)
+    protected
+    attr_reader :stylesheets, :dom
+
+    private
+    def consume_stylesheets
       style_map = StyleMap.new
+      extra_blocks = []
 
-      each_inlinable_block do |stylesheet, selector, properties|
-        elements = elements_matching_selector(stylesheet, selector, dom)
-        style_map.add elements, properties
+      each_style_block do |stylesheet, block|
+        if (elements = selector_elements(stylesheet, block))
+          style_map.add elements, block.properties
+        else
+          extra_blocks << block
+        end
       end
 
-      style_map
+      [style_map, extra_blocks]
     end
 
-    def each_inlinable_block
+    def each_style_block
       stylesheets.each do |stylesheet|
-        stylesheet.each_inlinable_block do |selector, properties|
-          yield stylesheet, selector, properties
+        stylesheet.blocks.each do |block|
+          yield stylesheet, block
         end
       end
     end
 
+    def selector_elements(stylesheet, block)
+      block.inlinable? && elements_matching_selector(stylesheet, block.selector)
+    end
+
+    def apply_style_map(style_map)
+      style_map.each_element { |element, builder| apply_element_style(element, builder) }
+    end
+
     def apply_element_style(element, builder)
       element["style"] = [builder.attribute_string, element["style"]].compact.join(";")
     end
 
-    def elements_matching_selector(stylesheet, selector, dom)
+    def elements_matching_selector(stylesheet, selector)
       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"
-      []
+      Utils.warn "Cannot inline #{selector.inspect} from \"#{stylesheet.name}\" stylesheet. If this is valid CSS, please report a bug."
+      nil
     rescue => error
-      warn "Roadie got error when looking for #{selector.inspect} (from \"#{stylesheet.name}\" stylesheet): #{error}"
+      Utils.warn "Got error when looking for #{selector.inspect} (from \"#{stylesheet.name}\" stylesheet): #{error}"
       raise unless error.message.include?('XPath')
-      []
+      nil
+    end
+
+    def add_styles_to_head(blocks)
+      unless blocks.empty?
+        create_style_element(blocks, find_head)
+      end
+    end
+
+    def find_head
+      dom.at_xpath('html/head')
+    end
+
+    def create_style_element(style_blocks, head)
+      return unless head
+      element = Nokogiri::XML::Node.new("style", head.document)
+      element.content = style_blocks.join("\n")
+      head.add_child(element)
     end
 
     # @api private
@@ -94,8 +124,8 @@ module Roadie
         end
       end
 
-      def each_element
-        @map.each_pair { |element, builder| yield element, builder }
+      def each_element(&block)
+        @map.each_pair(&block)
       end
     end
   end