premailer-rails-revived 1.12.0

data/spec/integration/hook_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe Premailer::Rails::Hook do
+  def run_hook(message)
+    Premailer::Rails::Hook.perform(message)
+  end
+
+  def body_content(message)
+    Nokogiri::HTML(message.html_string).at('body').content.gsub("\r\n", "\n")
+  end
+
+  class Mail::Message
+    def html_string
+      (html_part || self).body.to_s
+    end
+  end
+
+  let(:message) { Fixtures::Message.with_parts(:html) }
+  let(:processed_message) { run_hook(message) }
+
+  describe '.delivering_email' do
+    it 'is an alias to .perform' do
+      method = described_class.method(:delivering_email)
+      expected_method = described_class.method(:perform)
+
+      expect(method).to eq expected_method
+    end
+  end
+
+  describe '.previewing_email' do
+    it 'is an alias to .perform' do
+      method = described_class.method(:previewing_email)
+      expected_method = described_class.method(:perform)
+
+      expect(method).to eq expected_method
+    end
+  end
+
+  it 'inlines the CSS' do
+    expect { run_hook(message) }.to \
+      change { message.html_string.include?("<p style=") }
+  end
+
+  it 'replaces the html part with an alternative part containing text and html parts' do
+    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 '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))
+
+    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 '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)
+    expect(body_content(processed_msg)).to eq(body_content(raw_msg))
+
+    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))
+  ensure
+    Premailer::Rails.config.delete(:output_encoding)
+  end
+
+  it 'generates a text part from the html' do
+    expect { run_hook(message) }.to change(message, :text_part)
+  end
+
+  context 'when message contains no html' do
+    let(:message) { Fixtures::Message.with_parts(:text) }
+
+    it 'does not modify the message' do
+      expect { run_hook(message) }.to_not change(message, :html_string)
+    end
+  end
+
+  context 'when message also contains a text part' do
+    let(:message) { Fixtures::Message.with_parts(:html, :text) }
+
+    it 'does not generate a text part' do
+      expect { run_hook(message) }.to_not change(message, :text_part)
+    end
+
+    it 'does not replace any message part' do
+      expect { run_hook(message) }.to_not \
+        change { message.all_parts.map(&:content_type).sort }
+    end
+  end
+
+  context 'when text generation is disabled' do
+    it 'does not generate a text part' do
+      begin
+        Premailer::Rails.config[:generate_text_part] = false
+
+        expect { run_hook(message) }.to_not change(message, :text_part)
+      ensure
+        Premailer::Rails.config[:generate_text_part] = true
+      end
+    end
+  end
+
+  context 'when message also contains an attachment' do
+    let(:message) { Fixtures::Message.with_parts(:html, :attachment) }
+    it 'does not mess with it' do
+      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'
+
+      expect(processed_message.content_type).to include 'multipart/mixed'
+      expect(processed_message.parts.first.content_type).to \
+        include 'multipart/alternative'
+      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/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,16 @@
+require_relative 'boot'
+
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "action_view/railtie"
+if ENV.fetch("ASSETS_GEM", "sprockets-rails") == "sprockets-rails"
+  require "sprockets/railtie"
+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/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

@@ -0,0 +1,23 @@
+if RUBY_ENGINE == 'ruby'
+  if ENV['CI']
+    require 'coveralls'
+    Coveralls::Output.silent = true
+    Coveralls.wear! do
+      add_filter 'spec/'
+    end
+  else
+    require 'simplecov'
+    SimpleCov.start
+  end
+end
+
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+require File.expand_path("../../spec/rails_app/config/environment.rb", __FILE__)
+
+require 'support/fixtures/message'
+require 'support/fixtures/html'
+
+require 'premailer/rails'
+
+require 'nokogiri'

data/spec/support/fixtures/html.rb

@@ -0,0 +1,38 @@
+module Fixtures
+  module HTML
+    extend self
+
+    TEMPLATE = <<-HTML
+<html>
+  <head>
+%s
+  </head>
+  <body>
+    <p>
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
+      veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
+      commodo consequat.
+    </p>
+  </body>
+</html>
+    HTML
+
+    LINK = "<link rel='stylesheet' %s />\n"
+
+    def with_css_links(*files)
+      opts = files.last.is_a?(Hash) ? files.pop : {}
+      links = []
+      files.each do |file|
+        attrs = { href: "http://example.com/#{file}" }.merge(opts)
+        links << LINK % hash_to_attributes(attrs)
+      end
+
+      TEMPLATE % links.join
+    end
+
+    def hash_to_attributes(attrs)
+      attrs.map { |attr, value| "#{attr}='#{value}'" }.join(' ')
+    end
+  end
+end

data/spec/support/fixtures/message.rb

@@ -0,0 +1,182 @@
+# coding: utf-8
+
+require 'mail'
+
+module Fixtures
+  module Message
+    extend self
+
+    HTML_PART = <<-HTML
+<html>
+  <head>
+  </head>
+  <body>
+    <p>
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
+      veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
+      commodo consequat.
+    </p>
+  </body>
+</html>
+    HTML
+
+    UNICODE_STRING = '٩(-̮̮̃-̃)۶ ٩(●̮̮̃•̃)۶ ٩(͡๏̯͡๏)۶ ٩(-̮̮̃•̃).'
+
+    HTML_PART_WITH_UNICODE = <<-HTML
+<html>
+  <head>
+  </head>
+  <body>
+    <p>
+      #{UNICODE_STRING}
+    </p>
+  </body>
+</html>
+    HTML
+
+    HTML_PART_IN_GREEK = <<-HTML.encode(Encoding::ISO_8859_7)
+<html>
+  <head>
+  </head>
+  <body>
+    <p>
+      Αα Ββ Γγ Δδ Εε Ζζ Ηη Θθ Ιι Κκ Λλ Μμ Νν Ξξ Οο Ππ Ρρ Σσ Ττ Υυ Φφ Χχ Ψψ Ωω
+    </p>
+  </body>
+</html>
+    HTML
+
+    HTML_PART_WITH_DASHES = <<-HTML
+<html>
+  <head>
+  </head>
+  <body>
+    <p>
+      Hello there—yes you! What's up with – pardon the interrupion – dashes? I can also do &ndash; and &mdash;.
+    </p>
+  </body>
+</html>
+    HTML
+
+    HTML_PART_WITH_CSS = <<-HTML
+<html>
+  <head>
+    <style type="text/css">
+      p { color: red; }
+    </style>
+  </head>
+  <body>
+    <p>
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
+      veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
+      commodo consequat.
+    </p>
+  </body>
+</html>
+    HTML
+
+    TEXT_PART = <<-TEXT
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor
+incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis
+nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+    TEXT
+
+    def with_parts(*part_types)
+      if part_types.count == 1 and [:html, :text].include?(part_types.first)
+        return with_body(part_types.first)
+      end
+
+      message = base_message
+      content_part = message
+
+      if part_types.include?(:html) and part_types.include?(:text)
+        content_part = Mail::Part.new(content_type: 'multipart/alternative')
+        message.add_part(content_part)
+      end
+
+      if part_types.include? :html
+        html_part = Mail::Part.new do
+          body HTML_PART_WITH_CSS
+          content_type 'text/html; charset=UTF-8'
+        end
+        content_part.html_part = html_part
+      end
+
+      if part_types.include? :text
+        text_part = Mail::Part.new do
+          body TEXT_PART
+          content_type 'text/plain; charset=UTF-8'
+        end
+        content_part.text_part = text_part
+      end
+
+      if part_types.include? :attachment
+        message.add_file(filename: 'foo.png', content: 'foobar')
+      end
+
+      message.ready_to_send!
+
+      message
+    end
+
+    def with_body(body_type)
+      message = base_message
+
+      case body_type
+      when :html
+        message.body = HTML_PART_WITH_CSS
+        message.content_type 'text/html; charset=UTF-8'
+      when :text
+        message.body = TEXT_PART
+        message.content_type 'text/plain; charset=UTF-8'
+      end
+
+      message.ready_to_send!
+
+      message
+    end
+
+    def latin_message
+      base_message.tap do |message|
+        message.body = HTML_PART
+        message.content_type 'text/html; charset=UTF-8'
+        message.ready_to_send!
+      end
+    end
+
+    def non_latin_message
+      base_message.tap do |message|
+        message.body = HTML_PART_WITH_UNICODE
+        message.content_type 'text/html; charset=UTF-8'
+        message.ready_to_send!
+      end
+    end
+
+    def greek_message
+      base_message.tap do |message|
+        message.body = HTML_PART_IN_GREEK
+        message.content_type 'text/html; charset=ISO-8859-7'
+        message.ready_to_send!
+      end
+    end
+
+    def dash_message
+      base_message.tap do |message|
+        message.body = HTML_PART_WITH_DASHES
+        message.content_type 'text/html; charset=UTF-8'
+        message.ready_to_send!
+      end
+    end
+
+    private
+
+    def base_message
+      Mail.new do
+        to      'some@email.com'
+        subject 'testing premailer-rails'
+      end
+    end
+  end
+end

data/spec/unit/css_loaders/asset_pipeline_loader_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+if ENV.fetch("ASSETS_GEM", "sprockets") == "sprockets"
+  describe Premailer::Rails::CSSLoaders::AssetPipelineLoader 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
+
+    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 { is_expected.to eq('application.css') }
+      end
+
+      context "when asset file path contains prefix and relative_url_root is set" do
+        before do
+          allow(Rails.configuration)
+            .to receive(:relative_url_root).and_return('/foo')
+        end
+
+        let(:asset) { '/foo/assets/application.css' }
+        it { is_expected.to eq('application.css') }
+      end
+
+      context "when asset file path contains prefix and relative_url_root is set to root" do
+        before do
+          allow(Rails.configuration)
+            .to receive(:relative_url_root).and_return('/')
+        end
+
+        let(:asset) { '/assets/application.css' }
+        it { is_expected.to eq('application.css') }
+      end
+
+      context "when asset file path contains 32 chars fingerprint" do
+        let(:asset) { 'application-6776f581a4329e299531e1d52aa59832.css' }
+        it { is_expected.to eq('application.css') }
+      end
+
+      context "when asset file path contains 64 chars fingerprint" do
+        let(:asset) { 'application-02275ccb3fd0c11615bbfb11c99ea123ca2287e75045fe7b72cefafb880dad2b.css' }
+        it { is_expected.to eq('application.css') }
+      end
+
+      context "when asset file page contains numbers, but not a fingerprint" do
+        let(:asset) { 'test/20130708152545-foo-bar.css' }
+        it { is_expected.to eq("test/20130708152545-foo-bar.css") }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Premailer::Rails::CSSLoaders::NetworkLoader do
+  describe '#uri_for_url' do
+    subject { described_class.uri_for_url(url) }
+    let(:asset_host) { nil }
+
+    before do
+      action_controller = double(asset_host: asset_host)
+      config = double(action_controller: action_controller)
+      allow(Rails).to receive(:configuration).and_return(config)
+    end
+
+    context 'with a valid URL' do
+      let(:url) { 'http://example.com/test.css' }
+      it { is_expected.to eq(URI(url)) }
+    end
+
+    context 'with a protocol relative URL' do
+      let(:url) { '//example.com/test.css' }
+      it { is_expected.to eq(URI("http:#{url}")) }
+    end
+
+    context 'with a file path' do
+      let(:url) { '/assets/foo.css' }
+
+      context 'and a domain as asset host' do
+        let(:asset_host) { 'example.com' }
+        it { is_expected.to eq(URI("http://example.com#{url}")) }
+      end
+
+      context 'and a URL as asset host' do
+        let(:asset_host) { 'https://example.com' }
+        it { is_expected.to eq(URI("https://example.com/assets/foo.css")) }
+      end
+
+      context 'and a protocol relative URL as asset host' do
+        let(:asset_host) { '//example.com' }
+        it { is_expected.to eq(URI("http://example.com/assets/foo.css")) }
+      end
+
+      context 'and a callable object as asset host' do
+        let(:asset_host) { double }
+
+        it 'calls #call with the asset path as argument' do
+          expect(asset_host).to receive(:call).with(url).and_return(
+            'http://example.com')
+          expect(subject).to eq(URI('http://example.com/assets/foo.css'))
+        end
+      end
+
+      context 'without an asset host' do
+        let(:asset_host) { nil }
+        it { is_expected.not_to be }
+      end
+    end
+  end
+end