md-roadie 2.4.2.md.1

data/lib/roadie.rb

@@ -0,0 +1,79 @@
+module Roadie
+  class << self
+    # Shortcut for inlining CSS using {Inliner}
+    # @see Inliner
+    def inline_css(*args)
+      Roadie::Inliner.new(*args).execute
+    end
+
+    # Shortcut to Rails.application
+    def app
+      Rails.application
+    end
+
+    # Returns all available providers
+    def providers
+      [AssetPipelineProvider, FilesystemProvider]
+    end
+
+    # Returns the value of +config.roadie.enabled+.
+    #
+    # Roadie will disable all processing if this config is set to +false+. If
+    # you just want to disable CSS inlining without disabling the rest of
+    # Roadie, pass +css: nil+ to the +defaults+ method inside your mailers.
+    def enabled?
+      config.roadie.enabled
+    end
+
+    # Returns the active provider
+    #
+    # If no provider has been configured a new provider will be instantiated
+    # depending on if the asset pipeline is enabled or not.
+    #
+    # If +config.assets.enabled+ is +true+, the {AssetPipelineProvider} will be used
+    # while {FilesystemProvider} will be used if it is set to +false+.
+    #
+    # @see AssetPipelineProvider
+    # @see FilesystemProvider
+    def current_provider
+      return config.roadie.provider if config.roadie.provider
+
+      if assets_enabled?
+        AssetPipelineProvider.new
+      else
+        FilesystemProvider.new
+      end
+    end
+
+    # Returns the value of +config.roadie.after_inlining+
+    #
+    def after_inlining_handler
+      config.roadie.after_inlining
+    end
+
+    private
+      def config
+        Roadie.app.config
+      end
+
+      def assets_enabled?
+        # In Rails 4.0, config.assets.enabled is nil by default, so we need to
+        # explicitly make sure it's not false rather than checking for a
+        # truthy value.
+        config.respond_to?(:assets) and config.assets and config.assets.enabled != false
+      end
+  end
+end
+
+require 'roadie/version'
+require 'roadie/css_file_not_found'
+require 'roadie/selector'
+require 'roadie/style_declaration'
+
+require 'roadie/asset_provider'
+require 'roadie/asset_pipeline_provider'
+require 'roadie/filesystem_provider'
+
+require 'roadie/inliner'
+
+require 'roadie/railtie' if defined?(Rails)

data/lib/roadie/action_mailer_extensions.rb

@@ -0,0 +1,95 @@
+require 'uri'
+require 'nokogiri'
+require 'css_parser'
+
+module Roadie
+  # This module adds the Roadie functionality to ActionMailer 3 when included in ActionMailer::Base.
+  #
+  # If you want to add Roadie to any other mail framework, take a look at how this module is implemented.
+  module ActionMailerExtensions
+    def self.included(base)
+      base.class_eval do
+        if base.method_defined?(:collect_responses)
+          alias_method_chain :collect_responses, :inline_styles
+        else
+          alias_method_chain :collect_responses_and_parts_order, :inline_styles
+        end
+        alias_method_chain :mail, :inline_styles
+      end
+    end
+
+    protected
+      def mail_with_inline_styles(headers = {}, &block)
+        if headers.has_key?(:css)
+          @targets = headers[:css]
+        else
+          @targets = default_css_targets
+        end
+
+        if headers.has_key?(:after_inlining)
+          @after_inlining_handler = headers[:after_inlining]
+        else
+          @after_inlining_handler = default_after_inlining || Roadie.after_inlining_handler 
+        end
+
+        mail_without_inline_styles(headers, &block).tap do |email|
+          email.header.fields.delete_if { |field| %w(css after_inlining).include?(field.name) }
+        end
+      end
+
+      # Rails 4
+      def collect_responses_with_inline_styles(headers, &block)
+        responses = collect_responses_without_inline_styles(headers, &block)
+        if Roadie.enabled?
+          responses.map { |response| inline_style_response(response) }
+        else
+          responses
+        end
+      end
+
+      # Rails 3
+      def collect_responses_and_parts_order_with_inline_styles(headers, &block)
+        responses, order = collect_responses_and_parts_order_without_inline_styles(headers, &block)
+        if Roadie.enabled?
+          [responses.map { |response| inline_style_response(response) }, order]
+        else
+          [responses, order]
+        end
+      end
+
+    private
+      def default_css_targets
+        self.class.default[:css]
+      end
+
+      def default_after_inlining
+        self.class.default[:after_inlining]
+      end
+
+      def after_inlining_handler 
+        @after_inlining_handler 
+      end
+
+      def inline_style_response(response)
+        if response[:content_type] == 'text/html'
+          response.merge :body => Roadie.inline_css(Roadie.current_provider, css_targets, response[:body], url_options, after_inlining_handler)
+        else
+          response
+        end
+      end
+
+      def css_targets
+        Array.wrap(@targets || []).map { |target| resolve_target(target) }.compact.map(&:to_s)
+      end
+
+      def resolve_target(target)
+        if target.kind_of? Proc
+          instance_exec(&target)
+        elsif target.respond_to? :call
+          target.call
+        else
+          target
+        end
+      end
+  end
+end

data/lib/roadie/asset_pipeline_provider.rb

@@ -0,0 +1,28 @@
+module Roadie
+  # A provider that hooks into Rail's Asset Pipeline.
+  #
+  # Usage:
+  #   config.roadie.provider = AssetPipelineProvider.new('prefix')
+  #
+  # @see http://guides.rubyonrails.org/asset_pipeline.html
+  class AssetPipelineProvider < AssetProvider
+    # Looks up the file with the given name in the asset pipeline
+    #
+    # @return [String] contents of the file
+    def find(name)
+      asset_file(name).to_s.strip
+    end
+
+    private
+      def assets
+        Roadie.app.assets
+      end
+
+      def asset_file(name)
+        basename = remove_prefix(name)
+        assets[basename].tap do |file|
+          raise CSSFileNotFound.new(basename) unless file
+        end
+      end
+  end
+end

data/lib/roadie/asset_provider.rb

@@ -0,0 +1,62 @@
+module Roadie
+  # @abstract Subclass to create your own providers
+  class AssetProvider
+    # The prefix is whatever is prepended to your stylesheets when referenced inside markup.
+    #
+    # The prefix is stripped away from any URLs before they are looked up in {#find}:
+    #   find("/assets/posts/comment.css")
+    #   # Same as: (if prefix == "/assets"
+    #   find("posts/comment.css")
+    attr_reader :prefix
+
+    # @param [String] prefix Prefix of assets as seen from the browser
+    # @see #prefix
+    def initialize(prefix = "/assets")
+      @prefix = prefix
+      @quoted_prefix = prepare_prefix(prefix)
+    end
+
+    # Iterates all the passed elements and calls {#find} on them, joining the results with a newline.
+    #
+    # @example
+    #   MyProvider.all("first", "second.css", :third)
+    #
+    # @param [Array] files The target files to be loaded together
+    # @raise [CSSFileNotFound] In case any of the elements is not found
+    # @see #find
+    def all(files)
+      files.map { |file| find(file) }.join("\n")
+    end
+
+    # @abstract Implement in your own subclass
+    #
+    # Return the CSS contents of the file specified. A provider should not care about
+    # the +.css+ extension; it can, however, behave differently if it's passed or not.
+    #
+    # If the asset cannot be found, the method should raise {CSSFileNotFound}.
+    #
+    # @example
+    #   MyProvider.find("mystyle")
+    #   MyProvider.find("mystyle.css")
+    #   MyProvider.find(:mystyle)
+    #
+    # @param [String] name Name of the file requested
+    # @raise [CSSFileNotFound] In case any of the elements is not found
+    def find(name)
+      raise "Not implemented"
+    end
+
+    private
+      def prepare_prefix(prefix)
+        if prefix =~ /^\//
+          "/?#{Regexp.quote(prefix[1, prefix.size])}"
+        else
+          Regexp.quote(prefix)
+        end
+      end
+
+      def remove_prefix(name)
+        name.sub(/^#{@quoted_prefix}\/?/, '').sub(%r{^/}, '').gsub(%r{//+}, '/')
+      end
+  end
+end

data/lib/roadie/css_file_not_found.rb

@@ -0,0 +1,22 @@
+module Roadie
+  # Raised when a stylesheet specified for inlining is not present.
+  # You can access the target filename via #filename.
+  class CSSFileNotFound < StandardError
+    attr_reader :filename, :guess
+
+    def initialize(filename, guess = nil)
+      @filename = filename
+      @guess = guess
+      super(build_message)
+    end
+
+    private
+      def build_message
+        if guess
+          "Could not find #{filename} (guessed from #{guess.inspect})"
+        else
+          "Could not find #{filename}"
+        end
+      end
+  end
+end

data/lib/roadie/filesystem_provider.rb

@@ -0,0 +1,74 @@
+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}.
+  #
+  # @see #initialize
+  class FilesystemProvider < AssetProvider
+    # @return [Pathname] Pathname representing the directory of the assets
+    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
+      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
+      else
+        return find("#{base}.css") if base.to_s !~ /\.css$/
+        raise CSSFileNotFound.new(name, base.to_s)
+      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
+  end
+end

data/lib/roadie/inliner.rb

@@ -0,0 +1,251 @@
+require 'set'
+
+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.
+  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, document_options={})
+      @assets = assets
+      @css = assets.all(targets)
+      @html = html
+      @inline_css = []
+      @url_options = url_options
+      @after_inlining_handler = after_inlining_handler
+      @document_options = document_options
+
+      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
+    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
+    end
+
+    private
+      attr_reader :css, :html, :assets, :url_options, :document, :after_inlining_handler
+
+      def inline_css
+        @inline_css.join("\n")
+      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 adjust_html
+        parse_method = @document_options.key?(:fragment) ? :fragment : :parse
+
+        Nokogiri::HTML.__send__(parse_method, html).tap do |document|
+          yield document
+        end.dup.to_html
+      end
+
+      def add_missing_structure
+        html_node = document.at_css('html')
+        return unless html_node
+        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
+
+      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
+        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 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
+
+          rules_string = ordered_declarations.map { |declaration| declaration.to_s }.join(';')
+          element['style'] = [rules_string, element['style']].compact.join(';')
+        end
+      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
+          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, '')
+      end
+  end
+end