roadie 1.0.0.pre1

data/README.textile

@@ -0,0 +1,108 @@
+h1. Roadie
+
+Roadie tries to make sending HTML emails a little less painful in Rails 3 by inlining stylesheets and rewrite relative URLs for you.
+
+If you want to have this in Rails 2, please see "MailStyle":https://www.github.com/purify/mail_style.
+
+h2. How does it work?
+
+Email clients have bad support for stylesheets, and some of them blocks stylesheets from downloading. The easiest way to handle this is to work with all styles inline, but that is error prone and hard to work with as you cannot use classes and/or reuse styling.
+
+This gem helps making this easier by automatically inlining stylesheet rules into the document before sending it. You just give it a list of stylesheets and it will go though all of the selectors assigning the styles to the maching elements. Careful attention has been put into rules being applied in the correct order, so it should behave just like in the browser[1].
+
+Roadie also rewrites all relative URLs in the email to a absolute counterpart, making images you insert and those referenced in your stylesheets work. No more headaches about how to write the stylesheets while still having them work with emails from your acceptance environments.
+
+fn1. Of course, rules like @:hover@ will not work by definition. Only static styles can be added.
+
+h2. Features
+
+* Writes CSS styles inline
+** Respects @!important@ styles
+** Does not overwrite styles already present in the @style@ attribute of tags
+** Supports the same CSS selectors as "Nokogiri":http://nokogiri.org/ (use CSS3 selectors in your emails!)
+* Makes image urls absolute
+** Hostname and port configurable on a per-environment basis
+* Makes link <code>href</code>s absolute
+* Automatically adds proper html skeleton when missing (you don't have to create a layout for emails)[2]
+
+fn2. This might be removed in a future version, though. You really ought to create a good layout and not let Roadie guess how you want to have it structured
+
+h3. What about Sass / Less?
+
+Sass is supported "by accident" as long as the stylesheets are generated and stored in the stylesheets directory. This is the default behavior from Sass. You are recommended to add a deploy task that generates the stylesheets to make sure that they are present at all times.
+
+h2. Install
+
+Add the gem to Rails' Gemfile
+<pre><code>gem 'roadie'</code></pre>
+
+h2. Usage
+
+Simply specify the <code>:css</code> option to mailer:
+
+<pre><code>class Notifier < ActionMailer::Base
+  default :css => :email, :from => 'support@mycompany.com'
+  def registration_mail
+    mail(:subject => 'Welcome Aboard', :to => 'someone@example.com')
+  end
+
+  def newsletter
+    mail(:subject => 'Newsletter', :to => 'someone@example.com', :css => [:email, :newsletter])
+  end
+end</code></pre>
+(you could also use the @defaults@ method in ActionMailer)
+
+This will look for a css file called @email.css@ in your @public/stylesheets@ folder. The @css@ method can take either a string, a symbol or an array of both. You should pass the CSS filename without the ".css" extension.
+
+h3. Image URL Correcting
+
+If you have @default_url_options[:host]@ set in your mailer, then Roadie will do it's best to make the urls of images and in stylesheets absolute.
+
+In @application.rb@:
+<pre><code>class Application
+  config.action_mailer.default_url_options = {:host => 'example.com'}
+end</code></pre>
+
+If you want to to be different depending on your environment, just set it in your environment's configuration instead.
+
+h3. Ignoring stylesheets
+
+By default, @style@ elements in the email document's @head@ are processed along with the stylesheets and removed from the @head@.
+
+You can set a special <code>data-immutable="true"</code> attribute on @style@ tags you do not want to be processed and removed from the document's @head@. This is the place to put things like @:hover@ selectors that you want to have for email clients allowing them.
+
+Style elements with <code>media="print"</code> are always ignored.
+
+h2. Bugs / TODO
+
+* Improve overall performance
+* Clean up stylesheet assignment code
+
+h2. History and contributors
+
+This gem was originally developed for Rails 2 use on "Purify":http://purifyapp.com under the name "MailStyle":https://www.github.com/purify/mail_style. However, the author stopped maintaining it and a fork took place to make it Rails 3 compatible.
+
+The following people have contributed to the orignal gem:
+
+* "Jim Neath":http://jimneath.org (Original author)
+* "Lars Klevans":http://tastybyte.blogspot.com/
+* "Jonas Grimfelt":http://github.com/grimen
+* "Ben Johnson":http://www.binarylogic.com
+* "Istvan Hoka":http://istvanhoka.com/
+* "Voraz":http://blog.voraz.com.br
+
+h2. License
+
+(The MIT License)
+
+Copyright &copy; 2009-2011
+
+* "Jim Neath":http://jimneath.org
+* Magnus Bergmark <magnus.bergmark@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,60 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+require 'jeweler'
+
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+
+NAME = "roadie"
+EXTRA_RDOC_FILES = %w[README.textile]
+Jeweler::Tasks.new do |t|
+  t.name = NAME
+  t.summary = %{Making HTML emails comfortable for the Rails rockstars}
+  t.email = "magnus.bergmark@gmail.com"
+  t.homepage = "http://github.com/Mange/roadie"
+  t.description = %{Roadie tries to make sending HTML emails a little less painful in Rails 3 by inlining stylesheets and rewrite relative URLs for you.}
+  t.author = "Magnus Bergmark"
+
+  t.require_path = 'lib'
+  t.files = %w(Rakefile) + EXTRA_RDOC_FILES + Dir.glob(File.join(*%w[{lib,spec} ** *]).to_s)
+  t.extra_rdoc_files = EXTRA_RDOC_FILES
+
+  # dependencies defined in Gemfile
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+desc "Generate documentation for the #{NAME} plugin."
+Rake::RDocTask.new(:rdoc) do |t|
+  t.rdoc_dir = 'rdoc'
+  t.title    = NAME
+  t.options << '--line-numbers' << '--inline-source'
+  t.rdoc_files.include(EXTRA_RDOC_FILES)
+  t.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Run plugin specs for #{NAME}."
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = ["-c"]
+end
+
+desc "Run plugin specs for #{NAME} with specdoc formatting and colors"
+RSpec::Core::RakeTask.new('specdoc') do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = ["--format specdoc", "-c"]
+end
+
+desc "Default: Run specs."
+task :default => :spec

data/lib/roadie.rb

@@ -0,0 +1,28 @@
+module Roadie
+  class CSSFileNotFound < StandardError; end
+
+  def self.inline_css(*args);
+    Roadie::Inliner.new(*args).execute
+  end
+
+  def self.load_css(root, targets)
+    loaded_css = []
+    stylesheets = root.join('public', 'stylesheets')
+
+    targets.map { |target| stylesheets.join("#{target}.css") }.each do |target_file|
+      if target_file.exist?
+        loaded_css << target_file.read
+      else
+        raise CSSFileNotFound, "Could not find #{target_file}"
+      end
+    end
+    loaded_css.join("\n")
+  end
+end
+
+require 'roadie/inliner'
+
+require 'action_mailer'
+require 'roadie/action_mailer_extensions'
+
+ActionMailer::Base.send :include, Roadie::ActionMailerExtensions

data/lib/roadie/action_mailer_extensions.rb

@@ -0,0 +1,49 @@
+require 'uri'
+require 'nokogiri'
+require 'css_parser'
+
+module Roadie
+  module ActionMailerExtensions
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :collect_responses_and_parts_order, :inline_styles
+        alias_method_chain :mail, :inline_styles
+      end
+    end
+
+    protected
+      def mail_with_inline_styles(headers = {}, &block)
+        @inline_style_css_targets = headers[:css]
+        mail_without_inline_styles(headers.except(:css), &block).tap do |email|
+          email[:css] = nil
+        end
+      end
+
+      def collect_responses_and_parts_order_with_inline_styles(headers, &block)
+        responses, order = collect_responses_and_parts_order_without_inline_styles(headers, &block)
+        new_responses = []
+        responses.each do |response|
+          new_responses << inline_style_response(response)
+        end
+        [new_responses, order]
+      end
+
+    private
+      def inline_style_response(response)
+        if response[:content_type] == 'text/html'
+          response.merge :body => Roadie.inline_css(css_rules, response[:body], Rails.application.config.action_mailer.default_url_options)
+        else
+          response
+        end
+      end
+
+      def css_targets
+        return nil if @inline_style_css_targets == false
+        Array(@inline_style_css_targets || self.class.default[:css] || []).map { |target| target.to_s }
+      end
+
+      def css_rules
+        @css_rules ||= Roadie.load_css(Rails.root, css_targets) if css_targets.present?
+      end
+  end
+end

data/lib/roadie/inliner.rb

@@ -0,0 +1,145 @@
+module Roadie
+  class Inliner
+    CSS_URL_REGEXP = %r{
+      url\(
+        (["']?)
+        (
+          [^(]*            # Text leading up to before opening parens
+          (?:\([^)]*\))*   # Texts containing parens pairs
+          [^(]+            # Texts without parens - required
+        )
+        \1
+      \)
+    }x
+
+    attr_reader :css, :html, :url_options
+
+    def initialize(css, html, url_options)
+      @css = css
+      @inline_css = []
+      @html = html
+      @url_options = url_options
+    end
+
+    def execute
+      adjust_html do |document|
+        add_missing_structure(document)
+        extract_inline_style_elements(document)
+        inline_css_rules(document)
+        make_image_urls_absolute(document)
+        make_style_urls_absolute(document)
+      end
+    end
+
+    private
+      def inline_css
+        @inline_css.join("\n")
+      end
+
+      def parsed_css
+        CssParser::Parser.new.tap do |parser|
+          parser.add_block!(css) if css
+          parser.add_block!(inline_css)
+        end
+      end
+
+      def adjust_html
+        Nokogiri::HTML.parse(html).tap do |document|
+          yield document
+        end.to_html
+      end
+
+      def add_missing_structure(document)
+        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
+
+        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_inline_style_elements(document)
+        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(document)
+        matched_elements = {}
+        assign_rules_to_elements(document, matched_elements)
+
+        matched_elements.each do |element, rules|
+          rules_string = rules.map { |property, rule| [property, rule[:value]].join(':')  }.join('; ')
+          element['style'] = [rules_string, element['style']].compact.join('; ')
+        end
+      end
+
+      def assign_rules_to_elements(document, matched_elements)
+        parsed_css.each_rule_set do |rules|
+          rules.selectors.reject { |selector| selector.include?(':') }.each do |selector|
+            document.css(selector.strip).each do |element|
+              register_rules_for_element(matched_elements, element, selector, rules)
+            end
+          end
+        end
+      end
+
+      def register_rules_for_element(store, element, selector, rules)
+        specificity = CssParser.calculate_specificity(selector)
+        element_rules = (store[element] ||= {})
+        rules.each_declaration do |property, value, important|
+          stored = (element_rules[property] ||= {:specificity => -1})
+          more_specific = (stored[:specificity] <= specificity)
+          if (important and not stored[:important]) or (important and stored[:important] and more_specific) or (more_specific and not stored[:important])
+            stored.merge!(:value => value, :specificity => specificity, :important => important)
+          end
+        end
+      end
+
+      def make_image_urls_absolute(document)
+        document.css('img').each do |img|
+          img['src'] = ensure_absolute_url(img['src']) if img['src']
+        end
+      end
+
+      def make_style_urls_absolute(document)
+        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
+        URI::Generic.build({
+          :scheme => url_options[:protocol] || 'http',
+          :host => url_options[:host],
+          :port => url_options[:port],
+          :path => base_path
+        })
+      end
+  end
+end

data/spec/fixtures/public/stylesheets/bar.css

@@ -0,0 +1 @@
+contents of bar

data/spec/fixtures/public/stylesheets/foo.css

@@ -0,0 +1 @@
+contents of foo

data/spec/fixtures/public/stylesheets/integration.css

@@ -0,0 +1,4 @@
+body { background: url(../images/dots.png) repeat-x; }
+#message { background-color: #fff; margin: 0 auto; width: 75%; }
+
+h1 { color: #eee; }

data/spec/fixtures/views/integration_mailer/notification.html.erb

@@ -0,0 +1,8 @@
+<div id="message">
+  <h1>Dear person</1>
+
+  <p>I have to inform you that <strong><%= @reason %></strong>.</p>
+
+  <p>Thank you,<br />
+  The app</p>
+</div>

data/spec/fixtures/views/integration_mailer/notification.text.erb

@@ -0,0 +1,6 @@
+= Dear person =
+
+I have to inform you that <%= @reason %>.
+
+Thank you,
+The app

data/spec/integration_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe "roadie integration" do
+  class TestApplication
+    def config
+      OpenStruct.new(:action_mailer => OpenStruct.new(:default_url_options => {:host => "example.app.org"}))
+    end
+  end
+
+  class IntegrationMailer < ActionMailer::Base
+    default :css => :integration, :from => 'john@example.com'
+    append_view_path Pathname.new(__FILE__).dirname.join('fixtures').join('views')
+
+    def notification(to, reason)
+      @reason = reason
+      mail(:subject => 'Notification for you', :to => to) { |format| format.html; format.text }
+    end
+  end
+
+  before(:each) do
+    Rails.stub!(:root => Pathname.new(__FILE__).dirname.join('fixtures'), :application => TestApplication.new)
+    IntegrationMailer.delivery_method = :test
+  end
+
+  it "should inline styles for an email" do
+    email = IntegrationMailer.notification('doe@example.com', 'your quota limit has been reached')
+
+    email.to.should == ['doe@example.com']
+    email.from.should == ['john@example.com']
+    email.should have(2).parts
+
+    email.parts.find { |part| part.mime_type == 'text/html' }.tap do |html_part|
+      document = Nokogiri::HTML.parse(html_part.body.decoded)
+      document.should have_selector('html > head + body')
+      document.should have_selector('body #message h1')
+      document.should have_styling('background' => 'url(http://example.app.org/images/dots.png) repeat-x').at_selector('body')
+      document.should have_selector('strong[contains("quota")]')
+    end
+
+    email.parts.find { |part| part.mime_type == 'text/plain' }.tap do |plain_part|
+      plain_part.body.decoded.should_not match(/<.*>/)
+    end
+
+    email.deliver
+  end
+end

data/spec/lib/roadie/action_mailer_extensions_spec.rb

@@ -0,0 +1,112 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Roadie::ActionMailerExtensions, "inlining styles" do
+  class InliningMailer < ActionMailer::Base
+    default :css => :simple
+
+    def multipart
+      mail(:subject => "Multipart email") do |format|
+        format.html { render :text => 'Hello HTML' }
+        format.text { render :text => 'Hello Text' }
+      end
+    end
+
+    # Not sure how to implement this one.
+    # TODO: Either remove or implement
+    def nested_multipart_mixed(css_file = nil)
+      raise "Nested multipart mixed is not implemented"
+      content_type "multipart/mixed"
+      part :content_type => "multipart/alternative", :content_disposition => "inline" do |p|
+        p.part :content_type => 'text/html', :body => 'Hello HTML'
+        p.part :content_type => 'text/plain', :body => 'Hello Text'
+      end
+    end
+
+    def singlepart_html
+      mail(:subject => "HTML email") do |format|
+        format.html { render :text => 'Hello HTML' }
+      end
+    end
+
+    def singlepart_plain
+      mail(:subject => "Text email") do |format|
+        format.text { render :text => 'Hello Text' }
+      end
+    end
+  end
+
+  before(:each) do
+    Roadie.stub!(:load_css => 'loaded css')
+    Roadie.stub!(:inline_css => 'unexpected value') # Make sure a implementation problem doesn't hurt these examples
+  end
+
+  describe "for singlepart text/plain" do
+    it "should not touch the email body" do
+      Roadie.should_not_receive(:inline_css)
+      InliningMailer.singlepart_plain
+    end
+  end
+
+  describe "for singlepart text/html" do
+    it "should inline css to the email body" do
+      Roadie.should_receive(:inline_css).with(anything, 'Hello HTML', anything).and_return('html')
+      InliningMailer.singlepart_html.body.decoded.should == 'html'
+    end
+  end
+
+  describe "for multipart" do
+    it "should keep both parts" do
+      InliningMailer.multipart.should have(2).parts
+    end
+
+    it "should inline css to the email's html part" do
+      Roadie.should_receive(:inline_css).with(anything, 'Hello HTML', anything).and_return('html')
+      email = InliningMailer.multipart
+      email.parts.find { |part| part.mime_type == 'text/html' }.body.decoded.should == 'html'
+      email.parts.find { |part| part.mime_type == 'text/plain' }.body.decoded.should == 'Hello Text'
+    end
+  end
+end
+
+describe Roadie::ActionMailerExtensions, "loading css files" do
+  class CssLoadingMailer < ActionMailer::Base
+    default :css => :default_value
+    def use_default
+      mail &with_empty_html_response
+    end
+
+    def override(target)
+      mail :css => target, &with_empty_html_response
+    end
+
+    protected
+      def with_empty_html_response
+        Proc.new { |format| format.html { render :text => '' } }
+      end
+  end
+
+  before(:each) do
+    Roadie.stub!(:inline_css => 'html')
+  end
+
+  it "should load the css specified in the default mailer settings" do
+    Roadie.should_receive(:load_css).with(Rails.root, ['default_value']).and_return('')
+    CssLoadingMailer.use_default
+  end
+
+  it "should load the css specified in the specific mailer action instead of the default choice" do
+    Roadie.should_receive(:load_css).with(Rails.root, ['specific']).and_return('')
+    CssLoadingMailer.override(:specific)
+  end
+
+  it "should load no css when specifying false in the mailer action" do
+    Roadie.should_not_receive(:load_css)
+    CssLoadingMailer.override(false)
+  end
+
+  it "should load multiple css files when given an array" do
+    Roadie.should_receive(:load_css).with(Rails.root, ['specific', 'other']).and_return('')
+    CssLoadingMailer.override([:specific, :other])
+  end
+end

data/spec/lib/roadie/inliner_spec.rb

@@ -0,0 +1,221 @@
+require 'spec_helper'
+
+describe Roadie::Inliner do
+  def use_css(css); @css = css; end
+  def rendering(html, options = {})
+    Nokogiri::HTML.parse Roadie::Inliner.new(@css, html, options.fetch(:url_options, {:host => 'example.com'})).execute
+  end
+
+  describe "inlining styles" do
+    before(:each) do
+      # Make sure to have some css even when we don't specify any
+      # We have specific tests for when this is nil
+      use_css ''
+    end
+
+    it "should inline simple attributes" do
+      use_css 'p { color: green }'
+      rendering('<p></p>').should have_styling('color' => 'green').at_selector('p')
+    end
+
+    it "should combine multiple selectors into one" do
+      use_css "p { color: green; }
+              .tip { float: right; }"
+      rendering('<p class="tip"></p>').should have_styling('color' => 'green', 'float' => 'right').at_selector('p')
+    end
+
+    it "should use the ones attributes with the highest specificality when conflicts arises" do
+      use_css "p { color: red; }
+              .safe { color: green; border: 1px solid black; }"
+      rendering('<p class="safe"></p>').should have_styling('color' => 'green', 'border' => '1px solid black').at_selector('p')
+    end
+
+    it "should support multiple selectors for the same rules" do
+      use_css 'p, a { color: green; }'
+      rendering('<p></p><a></a>').tap do |document|
+        document.should have_styling('color' => 'green').at_selector('p')
+        document.should have_styling('color' => 'green').at_selector('a')
+      end
+    end
+
+    it "should respect !important properties" do
+      use_css "a { text-decoration: underline !important; }
+               a.hard-to-spot { text-decoration: none; }"
+      rendering('<a class="hard-to-spot"></a>').should have_styling('text-decoration' => 'underline').at_selector('a')
+    end
+
+    it "should combine with already present inline styles" do
+      use_css "p { color: green }"
+      rendering('<p style="font-size: 1.1em"></p>').should have_styling('color' => 'green', 'font-size' => '1.1em').at_selector('p')
+    end
+
+    it "should not overwrite already present inline styles" do
+      use_css "p { color: red }"
+      rendering('<p style="color: green"></p>').should have_styling('color' => 'green').at_selector('p')
+    end
+
+    it "should ignore selectors with :psuedo-classes" do
+      use_css 'p:hover { color: red }'
+      rendering('<p></p>').should_not have_styling('color' => 'red').at_selector('p')
+    end
+
+    describe "inline <style> elements" do
+      it "should be used for inlined styles" do
+        rendering(<<-HTML).should have_styling('color' => 'green', 'font-size' => '1.1em').at_selector('p')
+          <html>
+            <head>
+              <style type="text/css">p { color: green; }</style>
+            </head>
+            <body>
+              <p>Hello World</p>
+              <style type="text/css">p { font-size: 1.1em; }</style>
+            </body>
+          </html>
+        HTML
+      end
+
+      it "should be removed" do
+        rendering(<<-HTML).should_not have_selector('style')
+          <html>
+            <head>
+              <style type="text/css">p { color: green; }</style>
+            </head>
+            <body>
+              <style type="text/css">p { font-size: 1.1em; }</style>
+            </body>
+          </html>
+        HTML
+      end
+
+      it "should not be touched when data-immutable=true" do
+        document = rendering <<-HTML
+          <style type="text/css" data-immutable="true">p { color: red; }</style>
+          <p></p>
+        HTML
+        document.should have_selector('style[data-immutable=true]')
+        document.should_not have_styling('color' => 'red').at_selector('p')
+      end
+
+      it "should not be touched when media=print" do
+        document = rendering <<-HTML
+          <style type="text/css" media="print">p { color: red; }</style>
+          <p></p>
+        HTML
+        document.should have_selector('style[media=print]')
+        document.should_not have_styling('color' => 'red').at_selector('p')
+      end
+
+      it "should still be inlined when no external css rules are defined" do
+        use_css nil
+        rendering(<<-HTML).should have_styling('color' => 'green').at_selector('p')
+          <style type="text/css">p { color: green; }</style>
+          <p>Hello World</p>
+        HTML
+      end
+    end
+  end
+
+  describe "making urls absolute" do
+    it "should work on image sources" do
+      rendering('<img src="/images/foo.jpg" />').should have_attribute('src' => 'http://example.com/images/foo.jpg').at_selector('img')
+      rendering('<img src="../images/foo.jpg" />').should have_attribute('src' => 'http://example.com/images/foo.jpg').at_selector('img')
+      rendering('<img src="foo.jpg" />').should have_attribute('src' => 'http://example.com/foo.jpg').at_selector('img')
+    end
+
+    it "should not touch image sources that are already absolute" do
+      rendering('<img src="http://other.example.org/images/foo.jpg" />').should have_attribute('src' => 'http://other.example.org/images/foo.jpg').at_selector('img')
+    end
+
+    it "should work on inlined style attributes" do
+      rendering('<p style="background: url(/paper.png)"></p>').should have_styling('background' => 'url(http://example.com/paper.png)').at_selector('p')
+      rendering('<p style="background: url(&quot;/paper.png&quot;)"></p>').should have_styling('background' => 'url("http://example.com/paper.png")').at_selector('p')
+    end
+
+    it "should work on external style declarations" do
+      use_css "p { background-image: url(/paper.png); }
+               table { background-image: url('/paper.png'); }
+               div { background-image: url(\"/paper.png\"); }"
+      rendering('<p></p>').should have_styling('background-image' => 'url(http://example.com/paper.png)').at_selector('p')
+      rendering('<table></table>').should have_styling('background-image' => "url('http://example.com/paper.png')").at_selector('table')
+      rendering('<div></div>').should have_styling('background-image' => 'url("http://example.com/paper.png")').at_selector('div')
+    end
+
+    it "should not touch style urls that are already absolute" do
+      external_url = 'url(http://other.example.org/paper.png)'
+      use_css "p { background-image: #{external_url}; }"
+      rendering('<p></p>').should have_styling('background-image' => external_url).at_selector('p')
+      rendering(%(<div style="background-image: #{external_url}"></div>)).should have_styling('background-image' => external_url).at_selector('div')
+    end
+
+    it "should not touch the urls when no url options are defined" do
+      use_css "img { background: url(/a.jpg); }"
+      rendering('<img src="/b.jpg" />', :url_options => nil).tap do |document|
+        document.should have_attribute('src' => '/b.jpg').at_selector('img')
+        document.should have_styling('background' => 'url(/a.jpg)').at_selector('img')
+      end
+    end
+
+    it "should support port and protocol settings" do
+      use_css "img { background: url(/a.jpg); }"
+      rendering('<img src="/b.jpg" />', :url_options => {:host => 'example.com', :protocol => 'https', :port => '8080'}).tap do |document|
+        document.should have_attribute('src' => 'https://example.com:8080/b.jpg').at_selector('img')
+        document.should have_styling('background' => 'url(https://example.com:8080/a.jpg)').at_selector('img')
+      end
+    end
+
+    it "should not touch data: URIs" do
+      use_css "div { background: url(data:abcdef); }"
+      rendering('<div></div>').should have_styling('background' => 'url(data:abcdef)').at_selector('div')
+    end
+  end
+
+  describe "inserting tags" do
+    it "should insert a doctype if not present" do
+      rendering('<html><body></body></html>').to_xml.should include('<!DOCTYPE ')
+      rendering('<!DOCTYPE html><html><body></body></html>').to_xml.should_not match(/(DOCTYPE.*?){2}/)
+    end
+
+    it "should set xmlns of <html> to that of XHTML" do
+      rendering('<html><body></body></html>').should have_selector('html[xmlns="http://www.w3.org/1999/xhtml"]')
+    end
+
+    it "should insert basic html structure if not present" do
+      rendering('<h1>Hey!</h1>').should have_selector('html > head + body > h1')
+    end
+
+    it "should insert <head> if not present" do
+      rendering('<html><body></body></html>').should have_selector('html > head + body')
+    end
+
+    it "should insert meta tag describing content-type" do
+      rendering('<html><head></head><body></body></html>').should have_selector('head meta[http-equiv="Content-Type"][content="text/html; charset=utf-8"]')
+    end
+
+    it "should not insert duplicate meta tags describing content-type" do
+      rendering(<<-HTML).to_html.scan('meta').should have(1).item
+      <html>
+        <head>
+          <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+        </head>
+      </html>
+      HTML
+    end
+  end
+
+  describe "css url regex" do
+    it "should parse css urls" do
+      {
+        'url(/foo.jpg)' => '/foo.jpg',
+        'url("/foo.jpg")' => '/foo.jpg',
+        "url('/foo.jpg')" => '/foo.jpg',
+        'url(http://localhost/foo.jpg)' => 'http://localhost/foo.jpg',
+        'url("http://localhost/foo.jpg")' => 'http://localhost/foo.jpg',
+        "url('http://localhost/foo.jpg')" => 'http://localhost/foo.jpg',
+        'url(/andromeda_(galaxy).jpg)' => '/andromeda_(galaxy).jpg',
+      }.each do |raw, expected|
+        raw =~ Roadie::Inliner::CSS_URL_REGEXP
+        $2.should == expected
+      end
+    end
+  end
+end

data/spec/lib/roadie_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Roadie do
+  describe ".inline_css" do
+    it "should create an instance of Roadie::Inliner and execute it" do
+      Roadie::Inliner.should_receive(:new).with('attri', 'butes').and_return(double('inliner', :execute => 'html'))
+      Roadie.inline_css('attri', 'butes').should == 'html'
+    end
+  end
+
+  describe ".load_css(root, targets)" do
+    let(:fixtures_root) { Pathname.new(__FILE__).dirname.join('..', 'fixtures') }
+
+    it "should load files matching the target names under root/public/stylesheets" do
+      Roadie.load_css(fixtures_root, ['foo']).should == 'contents of foo'
+    end
+
+    it "should load files in order and join them with a newline" do
+      Roadie.load_css(fixtures_root, %w[foo bar]).should == "contents of foo\ncontents of bar"
+      Roadie.load_css(fixtures_root, %w[bar foo]).should == "contents of bar\ncontents of foo"
+    end
+
+    it "should raise a Roadie::CSSFileNotFound error when a css file could not be found" do
+      expect { Roadie.load_css(fixtures_root, ['not_here']) }.to raise_error(Roadie::CSSFileNotFound, /not_here/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,101 @@
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'ostruct'
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rspec'
+require 'action_mailer'
+require 'roadie'
+
+class TestApplication
+  def config
+    OpenStruct.new(:action_mailer => OpenStruct.new(:default_url_options => {:host => "example.com"}))
+  end
+end
+
+if defined?(Rails)
+  Rails.stub!(:root => Pathname.new('/path/to'), :application => TestApplication.new)
+else
+  class Rails
+    def self.root; Pathname.new('/path/to'); end
+    def self.application; TestApplication.new; end
+  end
+end
+
+RSpec::Matchers.define :have_styling do |rules|
+  chain :at_selector do |selector|
+    @selector = selector
+  end
+
+  match do |document|
+    styles = parsed_styles(document)
+    if rules.nil?
+      styles.blank?
+    else
+      rules.stringify_keys.should == parsed_styles(document)
+    end
+  end
+
+  describe { "have styles #{rules.inspect} at selector #{@selector.inspect}" }
+  failure_message_for_should { |document| "expected styles at #{@selector.inspect} to be #{rules.inspect} but was #{parsed_styles(document).inspect}" }
+  failure_message_for_should_not { "expected styles at #{@selector.inspect} to not be #{rules.inspect}" }
+
+  def element_styles(document)
+    node = document.css(@selector).first
+    node && node['style']
+  end
+
+  def parsed_styles(document)
+    return @parsed_styles if defined?(@parsed_styles)
+    if (styles = element_styles(document)).present?
+      @parsed_styles = styles.split(';').inject({}) do |styles, item|
+        attribute, value = item.split(':', 2)
+        styles.merge!(attribute.strip => value.strip)
+      end
+    else
+      @parsed_styles = nil
+    end
+  end
+end
+
+RSpec::Matchers.define :have_attribute do |attribute|
+  chain :at_selector do |selector|
+    @selector = selector
+  end
+
+  match do |document|
+    name, expected = attribute.first
+    expected == attribute(document, name)
+  end
+
+  describe { "have attribute #{attribute.inspect} at selector #{@selector.inspect}" }
+  failure_message_for_should do |document|
+    name, expected = attribute.first
+    "expected #{name} attribute at #{@selector.inspect} to be #{expected.inspect} but was #{attribute(document, name).inspect}"
+  end
+  failure_message_for_should_not do |document|
+    name, expected = attribute.first
+    "expected #{name} attribute at #{@selector.inspect} to not be #{expected.inspect}"
+  end
+
+  def attribute(document, attribute_name)
+    node = document.css(@selector).first
+    node && node[attribute_name]
+  end
+end
+
+RSpec::Matchers.define :have_selector do |selector|
+  match { |document| document.css(selector).present? }
+  failure_message_for_should { "expected document to #{name_to_sentence}#{expected_to_sentence}"}
+  failure_message_for_should_not { "expected document to not #{name_to_sentence}#{expected_to_sentence}"}
+end
+

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification 
+name: roadie
+version: !ruby/object:Gem::Version 
+  hash: 270495472
+  prerelease: true
+  segments: 
+  - 1
+  - 0
+  - 0
+  - pre1
+  version: 1.0.0.pre1
+platform: ruby
+authors: 
+- Magnus Bergmark
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-06 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: nokogiri
+  requirement: *id001
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: css_parser
+  requirement: *id002
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  name: actionmailer
+  requirement: *id003
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rake
+  requirement: *id004
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 270495428
+        segments: 
+        - 1
+        - 5
+        - 0
+        - pre5
+        version: 1.5.0.pre5
+  name: jeweler
+  requirement: *id005
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  name: rspec-rails
+  requirement: *id006
+  type: :development
+description: Roadie tries to make sending HTML emails a little less painful in Rails 3 by inlining stylesheets and rewrite relative URLs for you.
+email: magnus.bergmark@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- README.textile
+- Rakefile
+- lib/roadie.rb
+- lib/roadie/action_mailer_extensions.rb
+- lib/roadie/inliner.rb
+- spec/fixtures/public/stylesheets/bar.css
+- spec/fixtures/public/stylesheets/foo.css
+- spec/fixtures/public/stylesheets/integration.css
+- spec/fixtures/views/integration_mailer/notification.html.erb
+- spec/fixtures/views/integration_mailer/notification.text.erb
+- spec/integration_spec.rb
+- spec/lib/roadie/action_mailer_extensions_spec.rb
+- spec/lib/roadie/inliner_spec.rb
+- spec/lib/roadie_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/Mange/roadie
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Making HTML emails comfortable for the Rails rockstars
+test_files: 
+- spec/integration_spec.rb
+- spec/lib/roadie/action_mailer_extensions_spec.rb
+- spec/lib/roadie/inliner_spec.rb
+- spec/lib/roadie_spec.rb
+- spec/spec_helper.rb