premailer-rails 1.5.1 → 1.6.0

data/lib/premailer/rails/hook.rb

@@ -5,6 +5,7 @@ class Premailer
 
       def self.delivering_email(message)
         self.new(message).perform
+        message
       end
 
       def initialize(message)
@@ -12,15 +13,23 @@ class Premailer
       end
 
       def perform
-        if message_contains_html?
+        if skip_premailer_header_present?
+          remove_skip_premailer_header
+        elsif message_contains_html?
           replace_html_part(generate_html_part_replacement)
         end
-
-        message
       end
 
       private
 
+      def skip_premailer_header_present?
+        message.header[:skip_premailer]
+      end
+
+      def remove_skip_premailer_header
+        message.header[:skip_premailer] = nil
+      end
+
       def message_contains_html?
         html_part.present?
       end

data/premailer-rails.gemspec

@@ -20,13 +20,11 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'premailer', '~> 1.7'
-  s.add_dependency 'rails', '>= 3'
+  s.add_dependency 'premailer', '~> 1.7', '>= 1.7.9'
+  s.add_dependency 'actionmailer', '>= 3', '< 5'
 
-  s.add_development_dependency 'rspec-core'
-  s.add_development_dependency 'rspec-expectations'
-  s.add_development_dependency 'mocha'
-  s.add_development_dependency 'mail'
+  s.add_development_dependency 'rspec', '>= 3.0.0.beta1'
   s.add_development_dependency 'nokogiri'
   s.add_development_dependency 'hpricot' unless RUBY_PLATFORM == 'java'
+  s.add_development_dependency 'coveralls'
 end

data/spec/integration/css_helper_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Premailer::Rails::CSSHelper do
+  # Reset the CSS cache:
+  after do
+    Premailer::Rails::CSSHelper.send(:instance_variable_set, '@cache', {})
+  end
+
+  def load_css(path)
+    Premailer::Rails::CSSHelper.send(:load_css, path)
+  end
+
+  def css_for_doc(doc)
+    Premailer::Rails::CSSHelper.css_for_doc(doc)
+  end
+
+  def expect_file(path, content='file content')
+    allow(File).to receive(:exist?).with(path).and_return(true)
+    expect(File).to receive(:read).with(path).and_return(content)
+  end
+
+  describe '#css_for_doc' do
+    let(:html) { Fixtures::HTML.with_css_links(*files) }
+    let(:doc) { Nokogiri(html) }
+
+    context 'when HTML contains linked CSS files' do
+      let(:files) { %w[ stylesheets/base.css stylesheets/font.css ] }
+
+      it 'should return the content of both files concatenated' do
+        allow(Premailer::Rails::CSSHelper).to \
+          receive(:load_css)
+            .with('http://example.com/stylesheets/base.css')
+            .and_return('content of base.css')
+        allow(Premailer::Rails::CSSHelper).to \
+          receive(:load_css)
+            .with('http://example.com/stylesheets/font.css')
+            .and_return('content of font.css')
+
+        expect(css_for_doc(doc)).to eq("content of base.css\ncontent of font.css")
+      end
+    end
+  end
+
+  describe '#load_css' do
+    context 'when path is a url' do
+      it 'should load the CSS at the local path' do
+        expect_file('public/stylesheets/base.css')
+
+        load_css('http://example.com/stylesheets/base.css?test')
+      end
+    end
+
+    context 'when path is a relative url' do
+      it 'should load the CSS at the local path' do
+        expect_file('public/stylesheets/base.css')
+        load_css('/stylesheets/base.css?test')
+      end
+    end
+
+    context 'when file is cached' do
+      it 'should return the cached value' do
+        cache =
+          Premailer::Rails::CSSHelper.send(:instance_variable_get, '@cache')
+        cache['http://example.com/stylesheets/base.css'] = 'content of base.css'
+
+        expect(load_css('http://example.com/stylesheets/base.css')).to \
+          eq('content of base.css')
+      end
+    end
+
+    context 'when in development mode' do
+      it 'should not return cached values' do
+        cache =
+          Premailer::Rails::CSSHelper.send(:instance_variable_get, '@cache')
+        cache['http://example.com/stylesheets/base.css'] =
+          'cached content of base.css'
+        content = 'new content of base.css'
+        expect_file('public/stylesheets/base.css', content)
+        allow(Rails.env).to receive(:development?).and_return(true)
+
+        expect(load_css('http://example.com/stylesheets/base.css')).to eq(content)
+      end
+    end
+
+    context 'when Rails asset pipeline is used' do
+      before do
+        allow(Rails.configuration).to receive(:assets).and_return(double(prefix: '/assets'))
+      end
+
+      context 'and a precompiled file exists' do
+        it 'should return that file' do
+          path = '/assets/email-digest.css'
+          content = 'read from file'
+          expect_file("public#{path}", content)
+          expect(load_css(path)).to eq(content)
+        end
+      end
+
+      it 'should return the content of the file compiled by Rails' do
+        expect(Rails.application.assets).to \
+          receive(:find_asset)
+            .with('base.css')
+            .and_return(double(to_s: 'content of base.css'))
+
+        expect(load_css('http://example.com/assets/base.css')).to \
+          eq('content of base.css')
+      end
+
+      it 'should return same file when path contains file fingerprint' do
+        expect(Rails.application.assets).to \
+          receive(:find_asset)
+            .with('base.css')
+            .and_return(double(to_s: 'content of base.css'))
+
+        expect(load_css(
+          'http://example.com/assets/base-089e35bd5d84297b8d31ad552e433275.css'
+        )).to eq('content of base.css')
+      end
+
+      context 'when asset can not be found' do
+        let(:response) { 'content of base.css' }
+        let(:path) { '/assets/base-089e35bd5d84297b8d31ad552e433275.css' }
+        let(:url) { "http://assets.example.com#{path}" }
+        let(:asset_host) { 'http://assets.example.com' }
+
+        before do
+          allow(Rails.application.assets).to \
+            receive(:find_asset).and_return(nil)
+
+          config = double(asset_host: asset_host)
+          allow(Rails.configuration).to \
+            receive(:action_controller).and_return(config)
+
+          uri_satisfaction = satisfy { |uri| uri.to_s == url }
+          allow(Net::HTTP).to \
+            receive(:get).with(uri_satisfaction).and_return(response)
+        end
+
+        it 'should request the file' do
+          expect(load_css(url)).to eq('content of base.css')
+        end
+
+        context 'when file url does not include the host' do
+          it 'should request the file using the asset host as host' do
+            expect(load_css(path)).to eq('content of base.css')
+          end
+
+          context 'and the asset host uses protocol relative scheme' do
+            let(:asset_host) { '//assets.example.com' }
+
+            it 'should request the file using http as the scheme' do
+              expect(load_css(path)).to eq('content of base.css')
+            end
+          end
+        end
+     end
+    end
+
+    context 'when static stylesheets are used' do
+      it 'should return the content of the static file' do
+        content = 'content of base.css'
+        expect_file('public/stylesheets/base.css', content)
+        loaded_content = load_css('http://example.com/stylesheets/base.css')
+        expect(loaded_content).to eq(content)
+      end
+    end
+  end
+end

data/spec/{lib → integration}/hook_registration_spec.rb

@@ -2,9 +2,8 @@ require 'spec_helper'
 
 describe 'ActionMailer::Base.register_interceptor' do
   it 'should register interceptor Premailer::Rails::Hook' do
-    ActionMailer::Base
-      .expects(:register_interceptor)
-      .with(Premailer::Rails::Hook)
+    expect(ActionMailer::Base).to \
+      receive(:register_interceptor).with(Premailer::Rails::Hook)
     load 'premailer/rails.rb'
   end
 end

data/spec/{lib → integration}/hook_spec.rb

@@ -11,7 +11,7 @@ describe Premailer::Rails::Hook do
     end
   end
 
-  let(:message) { Fixtures::Message.with_body(:html) }
+  let(:message) { Fixtures::Message.with_parts(:html) }
   let(:processed_message) { run_hook(message) }
 
   it 'inlines the CSS' do
@@ -20,8 +20,9 @@ describe Premailer::Rails::Hook do
   end
 
   it 'replaces the html part with an alternative part containing text and html parts' do
-    processed_message.content_type.should include 'multipart/alternative'
-    processed_message.parts.should =~ [message.html_part, message.text_part]
+    expect(processed_message.content_type).to include('multipart/alternative')
+    expected_parts = [message.html_part, message.text_part]
+    expect(processed_message.parts).to match_array(expected_parts)
   end
 
   it 'generates a text part from the html' do
@@ -29,7 +30,7 @@ describe Premailer::Rails::Hook do
   end
 
   context 'when message contains no html' do
-    let(:message) { Fixtures::Message.with_body(:text) }
+    let(:message) { Fixtures::Message.with_parts(:text) }
 
     it 'does not modify the message' do
       expect { run_hook(message) }.to_not change(message, :html_string)
@@ -64,14 +65,29 @@ describe Premailer::Rails::Hook do
   context 'when message also contains an attachment' do
     let(:message) { Fixtures::Message.with_parts(:html, :attachment) }
     it 'does not mess with it' do
-      message.content_type.should include 'multipart/mixed'
-      message.parts.first.content_type.should include 'text/html'
-      message.parts.last.content_type.should include 'image/png'
+      expect(message.content_type).to include 'multipart/mixed'
+      expect(message.parts.first.content_type).to include 'text/html'
+      expect(message.parts.last.content_type).to include 'image/png'
 
-      processed_message.content_type.should include 'multipart/mixed'
-      processed_message.parts.first.content_type.should \
+      expect(processed_message.content_type).to include 'multipart/mixed'
+      expect(processed_message.parts.first.content_type).to \
         include 'multipart/alternative'
-      processed_message.parts.last.content_type.should include 'image/png'
+      expect(processed_message.parts.last.content_type).to include 'image/png'
+    end
+  end
+
+  context 'when message has a skip premailer header' do
+    before do
+      message.header[:skip_premailer] = true
+    end
+
+    it 'does not change the message body' do
+      expect { run_hook(message) }.to_not change(message, :body)
+    end
+
+    it 'removes that header' do
+      expect { run_hook(message) }.to \
+        change { message.header[:skip_premailer].nil? }.to(true)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,13 +1,25 @@
+if ENV['CI']
+  require 'coveralls'
+  Coveralls::Output.silent = true
+  Coveralls.wear! do
+    add_filter 'spec/'
+  end
+else
+  require 'simplecov'
+  SimpleCov.start
+end
+
 require 'premailer/rails'
 
-require 'stubs/action_mailer'
-require 'stubs/rails'
-require 'fixtures/message'
-require 'fixtures/html'
+require 'support/stubs/action_mailer'
+require 'support/stubs/rails'
+require 'support/fixtures/message'
+require 'support/fixtures/html'
 
 require 'hpricot' unless RUBY_PLATFORM == 'java'
 require 'nokogiri'
 
 RSpec.configure do |config|
-  config.mock_with :mocha
+  config.raise_errors_for_deprecations!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
 end

data/spec/{fixtures → support/fixtures}/html.rb

@@ -30,13 +30,5 @@ module Fixtures
 
       TEMPLATE % links.join
     end
-
-    def with_no_css_link
-      with_css_links
-    end
-
-    def with_style_block
-      TEMPLATE % '<style type="text/css">p { color: red; }</style>'
-    end
   end
 end

data/spec/{stubs → support/stubs}/rails.rb

@@ -1,26 +1,8 @@
-require 'stubs/dummy'
-
-class Logger
-  def self.try(*args); end
-end
-
 module Rails
   extend self
 
   module Configuration
     extend self
-
-    module Middleware
-      extend self
-
-      def include?(what)
-        false
-      end
-    end
-
-    def middleware
-      Middleware
-    end
   end
 
   module Env
@@ -51,14 +33,6 @@ module Rails
     Configuration
   end
 
-  def logger
-    Logger
-  end
-
-  def root
-    'RAILS_ROOT'
-  end
-
   def application
     Application
   end

data/spec/unit/css_loaders/asset_pipeline_loader_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Premailer::Rails::CSSLoaders::AssetPipelineLoader do
+  before do
+    assets = double(prefix: '/assets')
+    config = double(assets: assets)
+    allow(Rails).to receive(:configuration).and_return(config)
+  end
+
+  describe ".file_name" do
+    subject do
+      Premailer::Rails::CSSLoaders::AssetPipelineLoader.file_name(asset)
+    end
+
+    context "when asset file path contains prefix" do
+      let(:asset) { '/assets/application.css' }
+      it { should == 'application.css' }
+    end
+
+    context "when asset file path contains fingerprint" do
+      let(:asset) { 'application-6776f581a4329e299531e1d52aa59832.css' }
+      it { should == 'application.css' }
+    end
+
+    context "when asset file page contains numbers, but not a fingerprint" do
+      let(:asset) { 'test/20130708152545-foo-bar.css' }
+      it { should == "test/20130708152545-foo-bar.css" }
+    end
+  end
+end

data/spec/{lib → unit}/customized_premailer_spec.rb

@@ -1,5 +1,3 @@
-# coding: UTF-8
-
 require 'spec_helper'
 
 describe Premailer::Rails::CustomizedPremailer do
@@ -7,27 +5,28 @@ describe Premailer::Rails::CustomizedPremailer do
     next if adapter == :hpricot and RUBY_PLATFORM == 'java'
 
     context "when adapter is #{adapter}" do
-      before { Premailer::Adapter.stubs(:use).returns(adapter) }
+      before { allow(Premailer::Adapter).to receive(:use).and_return(adapter) }
 
       describe '#to_plain_text' do
         it 'should include the text from the HTML part' do
           premailer =
             Premailer::Rails::CustomizedPremailer
               .new(Fixtures::Message::HTML_PART)
-          premailer.to_plain_text.gsub(/\s/, ' ').strip
-            .should == Fixtures::Message::TEXT_PART.gsub(/\s/, ' ').strip
+          expect(premailer.to_plain_text.gsub(/\s/, ' ').strip).to \
+            eq(Fixtures::Message::TEXT_PART.gsub(/\s/, ' ').strip)
         end
       end
 
       describe '#to_inline_css' do
+        let(:regex) { %r{<p style=("|')color: ?red;?\1>} }
+
         context 'when inline CSS block present' do
           it 'should return the HTML with the CSS inlined' do
-            Premailer::Rails::CSSHelper
-              .stubs(:css_for_doc)
-              .returns('p { color: red; }')
+            allow(Premailer::Rails::CSSHelper).to \
+              receive(:css_for_doc).and_return('p { color: red; }')
             html = Fixtures::Message::HTML_PART
             premailer = Premailer::Rails::CustomizedPremailer.new(html)
-            premailer.to_inline_css.should =~ /<p style=("|')color: ?red;?\1>/
+            expect(premailer.to_inline_css).to match(regex)
           end
         end
 
@@ -35,7 +34,7 @@ describe Premailer::Rails::CustomizedPremailer do
           it 'should return the HTML with the CSS inlined' do
             html = Fixtures::Message::HTML_PART_WITH_CSS
             premailer = Premailer::Rails::CustomizedPremailer.new(html)
-            premailer.to_inline_css.should =~ /<p style=("|')color: ?red;?\1>/
+            expect(premailer.to_inline_css).to match(regex)
           end
         end
       end
@@ -44,21 +43,21 @@ describe Premailer::Rails::CustomizedPremailer do
 
   describe '.new' do
     it 'should extract the CSS' do
-      Premailer::Rails::CSSHelper.expects(:css_for_doc)
+      expect(Premailer::Rails::CSSHelper).to receive(:css_for_doc)
       Premailer::Rails::CustomizedPremailer.new('some html')
     end
 
     it 'should pass on the configs' do
       Premailer::Rails.config = { foo: :bar }
       premailer = Premailer::Rails::CustomizedPremailer.new('some html')
-      premailer.instance_variable_get(:'@options')[:foo].should == :bar
+      expect(premailer.instance_variable_get(:'@options')[:foo]).to eq(:bar)
     end
 
     it 'should not allow to override with_html_string' do
       Premailer::Rails.config = { with_html_string: false }
       premailer = Premailer::Rails::CustomizedPremailer.new('some html')
       options = premailer.instance_variable_get(:'@options')
-      options[:with_html_string].should == true
+      expect(options[:with_html_string]).to eq(true)
     end
   end
 end