premailer-rails 1.9.5 → 1.12.0

data/spec/integration/css_helper_spec.rb

@@ -1,186 +1,319 @@
 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_url(path)
-        Premailer::Rails::CSSHelper.css_for_url(path)
+  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
+
+  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')
+    if defined?(::Sprockets)
+      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')
+        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')
+        context "when find_sources raises TypeError" do
+          let(:response) { 'content of base.css' }
+          let(:uri) { URI('http://example.com/assets/base.css') }
+
+          it "falls back to Net::HTTP" do
+            expect(Rails.application.assets_manifest).to \
+              receive(:find_sources)
+                .with('base.css')
+                .and_raise(TypeError)
+
+            allow(Net::HTTP).to \
+              receive(:get)
+                .with(uri, { 'Accept' => 'text/css' })
+                .and_return(response)
+            expect(css_for_url('http://example.com/assets/base.css')).to \
+              eq(response)
           end
         end
 
-        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'
-            )
+        context "when find_sources raises Errno::ENOENT" do
+          let(:response) { 'content of base.css' }
+          let(:uri) { URI('http://example.com/assets/base.css') }
+
+          it "falls back to Net::HTTP" do
+            expect(Rails.application.assets_manifest).to \
+              receive(:find_sources)
+                .with('base.css')
+                .and_raise(Errno::ENOENT)
 
-            expect(css_for_url('http://example.com/stylesheets/base.css')).to \
-              eq('content of base.css')
+            allow(Net::HTTP).to \
+              receive(:get)
+                .with(uri, { 'Accept' => 'text/css' })
+                .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
+        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
 
-        context 'when Rails asset pipeline is used' do
+        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
+
+        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.configuration)
-              .to receive(:assets).and_return(double(prefix: '/assets'))
-            allow(Rails.configuration)
-              .to receive(:relative_url_root).and_return(nil)
+            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)
+
+            allow(Net::HTTP).to \
+              receive(:get)
+                .with(URI(url), { 'Accept' => 'text/css' })
+                .and_return(response)
           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
+          it 'requests the file' do
+            expect(css_for_url(url)).to eq('content of base.css')
           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'))
+          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
 
-            expect(css_for_url('http://example.com/assets/base.css')).to \
-              eq('content of base.css')
-          end
+            context 'and the asset host uses protocol relative scheme' do
+              let(:asset_host) { '//assets.example.com' }
 
-          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 '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
+    elsif defined?(::Propshaft)
+      context 'when Propshaft 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
 
-            expect(css_for_url(
-              'http://example.com/assets/base-089e35bd5d84297b8d31ad552e433275.css'
-            )).to eq('content of base.css')
+        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 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' }
+        it 'returns the content of the file compiled by Propshaft' do
+          asset = double()
 
-            before do
-              allow(Rails.application.assets).to \
-                receive(:find_asset).and_return(nil)
+          expect(Rails.application.assets.load_path).to \
+            receive(:find)
+              .with('base.css')
+              .and_return(asset)
 
-              config = double(asset_host: asset_host)
-              allow(Rails.configuration).to \
-                receive(:action_controller).and_return(config)
+          expect(Rails.application.assets.compilers).to \
+            receive(:compile)
+              .with(asset)
+              .and_return('content of base.css')
 
-              uri_satisfaction = satisfy { |uri| uri.to_s == url }
-              allow(Net::HTTP).to \
-                receive(:get).with(uri_satisfaction).and_return(response)
-            end
+          expect(css_for_url('http://example.com/assets/base.css')).to \
+            eq('content of base.css')
+        end
 
-            it 'requests the file' do
-              expect(css_for_url(url)).to eq('content of base.css')
-            end
+        it 'returns same file when path contains file fingerprint' do
+          asset = double()
 
-            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
+          expect(Rails.application.assets.load_path).to \
+            receive(:find)
+              .with('base.css')
+              .and_return(asset)
+
+          expect(Rails.application.assets.compilers).to \
+            receive(:compile)
+              .with(asset)
+              .and_return('content of base.css')
+
+          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' }
+
+          before do
+            expect(Rails.application.assets.load_path).to \
+              receive(:find)
+                .with('base.css')
+                .and_return(nil)
+
+            config = double(asset_host: asset_host)
+            allow(Rails.configuration).to \
+              receive(:action_controller).and_return(config)
+
+            allow(Net::HTTP).to \
+              receive(:get)
+                .with(URI(url), { 'Accept' => 'text/css' })
+                .and_return(response)
+          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 '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
+              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
+    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

@@ -6,7 +6,7 @@ describe Premailer::Rails::Hook do
   end
 
   def body_content(message)
-    Nokogiri::HTML(message.html_string).at('body').content
+    Nokogiri::HTML(message.html_string).at('body').content.gsub("\r\n", "\n")
   end
 
   class Mail::Message
@@ -47,18 +47,31 @@ describe Premailer::Rails::Hook do
     expect(processed_message.parts).to match_array(expected_parts)
   end
 
-  describe 'when the content-transfer-encoding is set' do
-    before { message.content_transfer_encoding = 'quoted-printable' }
+  it 'does not screw up the text by maintaining the original body encoding' do
+    raw_msg = Fixtures::Message.latin_message
+    processed_msg = Fixtures::Message.latin_message
+    run_hook(processed_msg)
+    expect(body_content(processed_msg)).to eq(body_content(raw_msg))
 
-    it 'should maintain the value' do
-      expect(processed_message.parts.first.content_transfer_encoding).to \
-        eq 'quoted-printable'
-      expect(processed_message.parts.last.content_transfer_encoding).to \
-        eq 'quoted-printable'
-    end
+    raw_msg = Fixtures::Message.non_latin_message
+    processed_msg = Fixtures::Message.non_latin_message
+    run_hook(processed_msg)
+    expect(body_content(processed_msg)).to eq(body_content(raw_msg))
+
+    raw_msg = Fixtures::Message.greek_message
+    processed_msg = Fixtures::Message.greek_message
+    run_hook(processed_msg)
+    expect(body_content(processed_msg)).to eq(body_content(raw_msg))
+
+    raw_msg = Fixtures::Message.dash_message
+    processed_msg = Fixtures::Message.dash_message
+    run_hook(processed_msg)
+    expect(body_content(processed_msg)).to eq(body_content(raw_msg))
   end
 
-  it 'does not screw up the text by maintaining the original body encoding' do
+  it 'supports US-ASCII output' do
+    Premailer::Rails.config.merge!(output_encoding: 'US-ASCII')
+
     raw_msg = Fixtures::Message.latin_message
     processed_msg = Fixtures::Message.latin_message
     run_hook(processed_msg)
@@ -68,6 +81,18 @@ describe Premailer::Rails::Hook do
     processed_msg = Fixtures::Message.non_latin_message
     run_hook(processed_msg)
     expect(body_content(processed_msg)).to eq(body_content(raw_msg))
+
+    raw_msg = Fixtures::Message.greek_message
+    processed_msg = Fixtures::Message.greek_message
+    run_hook(processed_msg)
+    expect(body_content(processed_msg)).to eq(body_content(raw_msg))
+
+    raw_msg = Fixtures::Message.dash_message
+    processed_msg = Fixtures::Message.dash_message
+    run_hook(processed_msg)
+    expect(body_content(processed_msg)).to eq(body_content(raw_msg))
+  ensure
+    Premailer::Rails.config.delete(:output_encoding)
   end
 
   it 'generates a text part from the html' do
@@ -91,7 +116,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,19 @@
+require_relative 'boot'
+
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "action_view/railtie"
+
+begin
+  require "sprockets/railtie"
+rescue LoadError
+end
+
+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