premailer-rails 1.9.5 → 1.10.3

data/spec/integration/css_helper_spec.rb

@@ -1,186 +1,217 @@
 require 'spec_helper'
 
 describe Premailer::Rails::CSSHelper do
-  [ :Nokogiri, :Hpricot ].each do |adapter|
-    next if adapter == :Hpricot and RUBY_PLATFORM == 'java'
+  # Reset the CSS cache:
+  after do
+    Premailer::Rails::CSSHelper.cache = {}
+  end
 
-    context "when adapter is #{adapter}" do
-      # Reset the CSS cache:
-      after do
-        Premailer::Rails::CSSLoaders::CacheLoader.clear!
-      end
+  def css_for_url(path)
+    Premailer::Rails::CSSHelper.css_for_url(path)
+  end
+
+  def css_for_doc(doc)
+    Premailer::Rails::CSSHelper.css_for_doc(doc)
+  end
+
+  def expect_file(path, content='file content')
+    path = "#{Rails.root}/#{path}"
+    allow(File).to receive(:file?).with(path).and_return(true)
+    expect(File).to receive(:read).with(path).and_return(content)
+  end
 
-      def css_for_url(path)
-        Premailer::Rails::CSSHelper.css_for_url(path)
+  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 'returns the content of both files concatenated' do
+        allow(Premailer::Rails::CSSHelper).to \
+          receive(:css_for_url)
+            .with('http://example.com/stylesheets/base.css')
+            .and_return('content of base.css')
+        allow(Premailer::Rails::CSSHelper).to \
+          receive(:css_for_url)
+            .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
 
-      def css_for_doc(doc)
-        Premailer::Rails::CSSHelper.css_for_doc(doc)
+    context 'when HTML contains ignored links' do
+      let(:files) { ['ignore.css', 'data-premailer' => 'ignore'] }
+
+      it 'ignores links' do
+        expect(Premailer::Rails::CSSHelper).to_not receive(:css_for_url)
+        css_for_doc(doc)
       end
+    end
+  end
 
-      def expect_file(path, content='file content')
-        allow(File).to receive(:file?).with(path).and_return(true)
-        expect(File).to receive(:read).with(path).and_return(content)
+  describe '#css_for_url' do
+    context 'when path is a url' do
+      it 'loads the CSS at the local path' do
+        expect_file('public/stylesheets/base.css')
+
+        css_for_url('http://example.com/stylesheets/base.css?test')
       end
+    end
 
-      describe '#css_for_doc' do
-        let(:html) { Fixtures::HTML.with_css_links(*files) }
-        let(:doc) { send(adapter, html) }
+    context 'when path is a relative url' do
+      it 'loads the CSS at the local path' do
+        expect_file('public/stylesheets/base.css')
+        css_for_url('/stylesheets/base.css?test')
+      end
+    end
 
-        context 'when HTML contains linked CSS files' do
-          let(:files) { %w[ stylesheets/base.css stylesheets/font.css ] }
+    context 'when cache is enabled' do
+      before do
+        allow(Premailer::Rails::CSSHelper).to receive(:cache_enabled?).and_return(true)
+      end
 
-          it 'returns the content of both files concatenated' do
-            allow(Premailer::Rails::CSSHelper).to \
-              receive(:css_for_url)
-                .with('http://example.com/stylesheets/base.css')
-                .and_return('content of base.css')
-            allow(Premailer::Rails::CSSHelper).to \
-              receive(:css_for_url)
-                .with('http://example.com/stylesheets/font.css')
-                .and_return('content of font.css')
+      context 'when file is cached' do
+        it 'returns the cached value' do
+          Premailer::Rails::CSSHelper.cache['http://example.com/stylesheets/base.css'] = 'content of base.css'
 
-            expect(css_for_doc(doc)).to eq("content of base.css\ncontent of font.css")
-          end
+          expect(css_for_url('http://example.com/stylesheets/base.css')).to \
+            eq('content of base.css')
         end
+      end
+    end
 
-        context 'when HTML contains ignored links' do
-          let(:files) { ['ignore.css', 'data-premailer' => 'ignore'] }
+    context 'when cache is disabled' do
+      before do
+        allow(Premailer::Rails::CSSHelper).to receive(:cache_enabled?).and_return(false)
+      end
 
-          it 'ignores links' do
-            expect(Premailer::Rails::CSSHelper).to_not receive(:css_for_url)
-            css_for_doc(doc)
-          end
-        end
+      it 'does not return cached values' do
+        Premailer::Rails::CSSHelper.cache['http://example.com/stylesheets/base.css'] = 'cached content'
+        content = 'new content of base.css'
+        expect_file('public/stylesheets/base.css', content)
+
+        expect(css_for_url('http://example.com/stylesheets/base.css')).to eq(content)
       end
+    end
 
-      describe '#css_for_url' do
-        context 'when path is a url' do
-          it 'loads the CSS at the local path' do
-            expect_file('public/stylesheets/base.css')
+    context 'when Rails asset pipeline is used' do
+      before do
+        allow(Rails.configuration)
+          .to receive(:assets).and_return(double(prefix: '/assets'))
+        allow(Rails.configuration)
+          .to receive(:relative_url_root).and_return(nil)
+      end
 
-            css_for_url('http://example.com/stylesheets/base.css?test')
-          end
+      context 'and a precompiled file exists' do
+        it 'returns that file' do
+          path = '/assets/email-digest.css'
+          content = 'read from file'
+          expect_file("public#{path}", content)
+          expect(css_for_url(path)).to eq(content)
         end
+      end
 
-        context 'when path is a relative url' do
-          it 'loads the CSS at the local path' do
-            expect_file('public/stylesheets/base.css')
-            css_for_url('/stylesheets/base.css?test')
-          end
-        end
+      context "when find_sources raises TypeError" do
+        let(:response) { 'content of base.css' }
+        let(:uri) { URI('http://example.com/assets/base.css') }
 
-        context 'when file is cached' do
-          it 'returns the cached value' do
-            Premailer::Rails::CSSLoaders::CacheLoader.store(
-              'http://example.com/stylesheets/base.css',
-              'content of base.css'
-            )
+        it "falls back to Net::HTTP" do
+          expect(Rails.application.assets_manifest).to \
+            receive(:find_sources)
+              .with('base.css')
+              .and_raise(TypeError)
 
-            expect(css_for_url('http://example.com/stylesheets/base.css')).to \
-              eq('content of base.css')
-          end
+          allow(Net::HTTP).to \
+            receive(:get).with(uri).and_return(response)
+          expect(css_for_url('http://example.com/assets/base.css')).to \
+            eq(response)
         end
+      end
 
-        context 'when in development mode' do
-          it 'does not return cached values' do
-            Premailer::Rails::CSSLoaders::CacheLoader.store(
-              '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(css_for_url('http://example.com/stylesheets/base.css')).to eq(content)
-          end
-        end
+      context "when find_sources raises Errno::ENOENT" do
+        let(:response) { 'content of base.css' }
+        let(:uri) { URI('http://example.com/assets/base.css') }
 
-        context 'when Rails asset pipeline is used' do
-          before do
-            allow(Rails.configuration)
-              .to receive(:assets).and_return(double(prefix: '/assets'))
-            allow(Rails.configuration)
-              .to receive(:relative_url_root).and_return(nil)
-          end
+        it "falls back to Net::HTTP" do
+          expect(Rails.application.assets_manifest).to \
+            receive(:find_sources)
+              .with('base.css')
+              .and_raise(Errno::ENOENT)
 
-          context 'and a precompiled file exists' do
-            it 'returns that file' do
-              path = '/assets/email-digest.css'
-              content = 'read from file'
-              expect_file("public#{path}", content)
-              expect(css_for_url(path)).to eq(content)
-            end
-          end
+          allow(Net::HTTP).to \
+            receive(:get).with(uri).and_return(response)
+          expect(css_for_url('http://example.com/assets/base.css')).to \
+            eq(response)
+        end
+      end
 
-          it 'returns 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'))
+      it 'returns the content of the file compiled by Rails' do
+        expect(Rails.application.assets_manifest).to \
+          receive(:find_sources)
+            .with('base.css')
+            .and_return(['content of base.css'])
 
-            expect(css_for_url('http://example.com/assets/base.css')).to \
-              eq('content of base.css')
-          end
+        expect(css_for_url('http://example.com/assets/base.css')).to \
+          eq('content of base.css')
+      end
 
-          it 'returns 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'))
+      it 'returns same file when path contains file fingerprint' do
+        expect(Rails.application.assets_manifest).to \
+          receive(:find_sources)
+            .with('base.css')
+            .and_return(['content of base.css'])
 
-            expect(css_for_url(
-              'http://example.com/assets/base-089e35bd5d84297b8d31ad552e433275.css'
-            )).to eq('content of base.css')
-          end
+        expect(css_for_url(
+          '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' }
+      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)
+        before do
+          allow(Rails.application.assets_manifest).to \
+            receive(:find_sources).and_return([])
 
-              config = double(asset_host: asset_host)
-              allow(Rails.configuration).to \
-                receive(:action_controller).and_return(config)
+          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
+          allow(Net::HTTP).to \
+            receive(:get).with(URI(url)).and_return(response)
+        end
 
-            it 'requests the file' do
-              expect(css_for_url(url)).to eq('content of base.css')
-            end
+        it 'requests the file' do
+          expect(css_for_url(url)).to eq('content of base.css')
+        end
 
-            context 'when file url does not include the host' do
-              it 'requests the file using the asset host as host' do
-                expect(css_for_url(path)).to eq('content of base.css')
-              end
+        context 'when file url does not include the host' do
+          it 'requests the file using the asset host as host' do
+            expect(css_for_url(path)).to eq('content of base.css')
+          end
 
-              context 'and the asset host uses protocol relative scheme' do
-                let(:asset_host) { '//assets.example.com' }
+          context 'and the asset host uses protocol relative scheme' do
+            let(:asset_host) { '//assets.example.com' }
 
-                it 'requests the file using http as the scheme' do
-                  expect(css_for_url(path)).to eq('content of base.css')
-                end
-              end
+            it 'requests the file using http as the scheme' do
+              expect(css_for_url(path)).to eq('content of base.css')
             end
           end
         end
+      end
+    end
 
-        context 'when static stylesheets are used' do
-          it 'returns the content of the static file' do
-            content = 'content of base.css'
-            expect_file('public/stylesheets/base.css', content)
-            loaded_content = css_for_url('http://example.com/stylesheets/base.css')
-            expect(loaded_content).to eq(content)
-          end
-        end
+    context 'when static stylesheets are used' do
+      it 'returns the content of the static file' do
+        content = 'content of base.css'
+        expect_file('public/stylesheets/base.css', content)
+        loaded_content = css_for_url('http://example.com/stylesheets/base.css')
+        expect(loaded_content).to eq(content)
       end
     end
   end

data/spec/integration/delivery_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'ActionMailer::Base delivery' do
+  it 'delivers email with inlined CSS' do
+    WelcomeMailer.welcome_email("world").deliver_now
+
+    mail = ActionMailer::Base.deliveries.last
+    expect(mail).to be_present
+    body = mail.html_part.body.to_s
+    expect(body).to be_present
+    expect(body).to include(%{<p style="font-size: 12px;">Hello world</p>})
+  end
+end

data/spec/integration/hook_spec.rb

@@ -91,7 +91,7 @@ describe Premailer::Rails::Hook do
 
     it 'does not replace any message part' do
       expect { run_hook(message) }.to_not \
-        change { message.all_parts.map(&:content_type) }
+        change { message.all_parts.map(&:content_type).sort }
     end
   end
 

data/spec/rails_app/app/assets/config/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css

data/spec/rails_app/app/assets/stylesheets/application.css

@@ -0,0 +1,3 @@
+p {
+  font-size: 12px;
+}

data/spec/rails_app/app/mailers/application_mailer.rb

@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: 'from@example.com'
+  layout 'mailer'
+end

data/spec/rails_app/app/mailers/welcome_mailer.rb

@@ -0,0 +1,6 @@
+class WelcomeMailer < ApplicationMailer
+  def welcome_email(greeting)
+    @greeting = greeting
+    mail to: "example@example.com"
+  end
+end

data/spec/rails_app/app/views/layouts/mailer.html.erb

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <link rel="stylesheet" href="/assets/application.css"/>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/spec/rails_app/app/views/welcome_mailer/welcome_email.html.erb

@@ -0,0 +1 @@
+<p>Hello <%= @greeting %></p>

data/spec/rails_app/config/application.rb

@@ -0,0 +1,13 @@
+require_relative 'boot'
+
+require "action_mailer/railtie"
+require "action_view/railtie"
+require "sprockets/railtie"
+require "rails/test_unit/railtie"
+
+Bundler.require(*Rails.groups)
+
+module Dummy
+  class Application < Rails::Application
+  end
+end

data/spec/rails_app/config/boot.rb

@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../Gemfile', __dir__)
+
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+$LOAD_PATH.unshift File.expand_path('../../../lib', __dir__)

data/spec/rails_app/config/environment.rb

@@ -0,0 +1,2 @@
+require_relative 'application'
+Rails.application.initialize!

data/spec/rails_app/config/environments/test.rb

@@ -0,0 +1,10 @@
+Rails.application.configure do
+  config.cache_classes = true
+  config.eager_load = false
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+  config.action_dispatch.show_exceptions = false
+  config.action_controller.allow_forgery_protection = false
+  config.action_mailer.delivery_method = :test
+  config.active_support.deprecation = :stderr
+end

data/spec/rails_app/config/initializers/assets.rb

@@ -0,0 +1 @@
+Rails.application.config.assets.version = '1.0'

data/spec/rails_app/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  root 'application#main'
+end

data/spec/rails_app/config.ru

@@ -0,0 +1,5 @@
+# This file is used by Rack-based servers to start the application.
+
+require_relative 'config/environment'
+
+run Rails.application

data/spec/spec_helper.rb

@@ -11,12 +11,11 @@ if RUBY_ENGINE == 'ruby'
   end
 end
 
-require 'premailer/rails'
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+require File.expand_path("../../spec/rails_app/config/environment.rb", __FILE__)
 
-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'

data/spec/unit/css_loaders/file_system_loader_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Premailer::Rails::CSSLoaders::FileSystemLoader do
+  before do
+    allow(Rails.configuration)
+      .to receive(:assets).and_return(double(prefix: '/assets'))
+    allow(Rails)
+      .to receive(:root).and_return(Pathname.new('/rails_root'))
+  end
+
+  describe '#file_name' do
+    subject { described_class.file_name(asset) }
+    let(:relative_url_root) { nil }
+
+    before do
+      config = double(relative_url_root: relative_url_root)
+      allow(Rails).to receive(:configuration).and_return(config)
+    end
+
+    context 'when relative_url_root is not set' do
+      let(:asset) { '/assets/application.css' }
+      it { is_expected.to eq(File.join(Rails.root, 'public/assets/application.css')) }
+    end
+
+    context 'when relative_url_root is set' do
+      let(:relative_url_root) { '/foo' }
+      let(:asset) { '/foo/assets/application.css' }
+      it { is_expected.to eq(File.join(Rails.root, 'public/assets/application.css')) }
+    end
+
+    context 'when relative_url_root has a trailing slash' do
+      let(:relative_url_root) { '/foo/' }
+      let(:asset) { '/foo/assets/application.css' }
+      it { is_expected.to eq(File.join(Rails.root, 'public/assets/application.css')) }
+    end
+  end
+end

data/spec/unit/css_loaders/network_loader_spec.rb

@@ -18,7 +18,7 @@ describe Premailer::Rails::CSSLoaders::NetworkLoader do
 
     context 'with a protocol relative URL' do
       let(:url) { '//example.com/test.css' }
-      it { is_expected.to eq(URI("http://#{url}")) }
+      it { is_expected.to eq(URI("http:#{url}")) }
     end
 
     context 'with a file path' do

data/spec/unit/customized_premailer_spec.rb

@@ -1,51 +1,43 @@
 require 'spec_helper'
 
 describe Premailer::Rails::CustomizedPremailer do
-  [ :nokogiri, :hpricot ].each do |adapter|
-    next if adapter == :hpricot and RUBY_PLATFORM == 'java'
+  describe '#to_plain_text' do
+    it 'includes the text from the HTML part' do
+      premailer =
+        Premailer::Rails::CustomizedPremailer
+          .new(Fixtures::Message::HTML_PART)
+      expect(premailer.to_plain_text.gsub(/\s/, ' ').strip).to \
+        eq(Fixtures::Message::TEXT_PART.gsub(/\s/, ' ').strip)
+    end
+  end
 
-    context "when adapter is #{adapter}" do
-      before { allow(Premailer::Adapter).to receive(:use).and_return(adapter) }
+  describe '#to_inline_css' do
+    let(:regex) { %r{<p style=("|')color: ?red;?\1>} }
 
-      describe '#to_plain_text' do
-        it 'includes the text from the HTML part' do
-          premailer =
-            Premailer::Rails::CustomizedPremailer
-              .new(Fixtures::Message::HTML_PART)
-          expect(premailer.to_plain_text.gsub(/\s/, ' ').strip).to \
-            eq(Fixtures::Message::TEXT_PART.gsub(/\s/, ' ').strip)
-        end
+    context 'when inline CSS block present' do
+      it 'returns the HTML with the CSS inlined' do
+        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)
+        expect(premailer.to_inline_css).to match(regex)
       end
+    end
 
-      describe '#to_inline_css' do
-        let(:regex) { %r{<p style=("|')color: ?red;?\1>} }
-
-        context 'when inline CSS block present' do
-          it 'returns the HTML with the CSS inlined' do
-            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)
-            expect(premailer.to_inline_css).to match(regex)
-          end
-        end
-
-        context 'when CSS is loaded externally' do
-          it 'returns the HTML with the CSS inlined' do
-            html = Fixtures::Message::HTML_PART_WITH_CSS
-            premailer = Premailer::Rails::CustomizedPremailer.new(html)
-            expect(premailer.to_inline_css).to match(regex)
-          end
-        end
+    context 'when CSS is loaded externally' do
+      it 'returns the HTML with the CSS inlined' do
+        html = Fixtures::Message::HTML_PART_WITH_CSS
+        premailer = Premailer::Rails::CustomizedPremailer.new(html)
+        expect(premailer.to_inline_css).to match(regex)
+      end
+    end
 
-        context 'when HTML contains unicode' do
-          it 'does not mess those up' do
-            html = Fixtures::Message::HTML_PART_WITH_UNICODE
-            premailer = Premailer::Rails::CustomizedPremailer.new(html)
-            expect(premailer.to_inline_css).to \
-              include(Fixtures::Message::UNICODE_STRING)
-          end
-        end
+    context 'when HTML contains unicode' do
+      it 'does not mess those up' do
+        html = Fixtures::Message::HTML_PART_WITH_UNICODE
+        premailer = Premailer::Rails::CustomizedPremailer.new(html)
+        expect(premailer.to_inline_css).to \
+          include(Fixtures::Message::UNICODE_STRING)
       end
     end
   end