premailer-rails-revived 1.12.0

data/lib/premailer/rails/css_helper.rb

@@ -0,0 +1,70 @@
+class Premailer
+  module Rails
+    module CSSHelper
+      extend self
+
+      FileNotFound = Class.new(StandardError)
+
+      attr_accessor :cache
+      self.cache = {}
+
+      # Returns all linked CSS files concatenated as string.
+      def css_for_doc(doc)
+        css_urls_in_doc(doc).map { |url| css_for_url(url) }.join("\n")
+      end
+
+      def css_for_url(url)
+        if cache_enabled?
+          load_css_with_cache(url)
+        else
+          load_css(url)
+        end
+      end
+
+      private
+
+      def css_urls_in_doc(doc)
+        doc.search('link[@rel="stylesheet"]:not([@data-premailer="ignore"])').map do |link|
+          if link.respond_to?(:remove)
+            link.remove
+          else
+            link.parent.children.delete(link)
+          end
+          link.attributes['href'].to_s
+        end
+      end
+
+      def load_css_with_cache(url)
+        self.cache[url] ||= load_css(url)
+      end
+
+      def cache_enabled?
+        defined?(::Rails.env) && ::Rails.env.production?
+      end
+
+      def load_css(url)
+        Premailer::Rails.config.fetch(:strategies).each do |strategy|
+          css = find_strategy(strategy).load(url)
+          return css if css
+        end
+
+        raise FileNotFound, %{File with URL "#{url}" could not be loaded by any strategy.}
+      end
+
+      def find_strategy(key)
+        case key
+        when :filesystem
+          CSSLoaders::FileSystemLoader
+        when :asset_pipeline
+          CSSLoaders::AssetPipelineLoader
+        when :propshaft
+          CSSLoaders::PropshaftLoader
+        when :network
+          CSSLoaders::NetworkLoader
+        else
+          key
+        end
+      end
+    end
+  end
+end

data/lib/premailer/rails/css_loaders/asset_pipeline_loader.rb

@@ -0,0 +1,36 @@
+class Premailer
+  module Rails
+    module CSSLoaders
+      module AssetPipelineLoader
+        extend self
+
+        def load(url)
+          return unless asset_pipeline_present?
+
+          file = file_name(url)
+          ::Rails.application.assets_manifest.find_sources(file).first
+        rescue Errno::ENOENT, TypeError => _error
+        end
+
+        def file_name(url)
+          prefix = File.join(
+            ::Rails.configuration.relative_url_root.to_s,
+            ::Rails.configuration.assets.prefix.to_s,
+            '/'
+          )
+          URI(url).path
+            .sub(/\A#{prefix}/, '')
+            .sub(/-(\h{32}|\h{64})\.css\z/, '.css')
+        end
+
+        def asset_pipeline_present?
+          defined?(::Rails) &&
+            ::Rails.respond_to?(:application) &&
+            ::Rails.application &&
+            ::Rails.application.respond_to?(:assets_manifest) &&
+            ::Rails.application.assets_manifest
+        end
+      end
+    end
+  end
+end

data/lib/premailer/rails/css_loaders/file_system_loader.rb

@@ -0,0 +1,37 @@
+class Premailer
+  module Rails
+    module CSSLoaders
+      module FileSystemLoader
+        extend self
+
+        def load(url)
+          file = file_name(url)
+          File.read(file) if File.file?(file)
+        end
+
+        def file_name(url)
+          path = URI(url).path
+          if relative_url_root
+            path = path.sub(/\A#{relative_url_root.chomp('/')}/, '')
+          end
+          asset_filename(path)
+        end
+
+        def asset_filename(filename)
+          if defined?(::Rails) && ::Rails.respond_to?(:root)
+            File.join(::Rails.root, 'public', filename)
+          else
+            File.join('public', filename)
+          end
+        end
+
+        def relative_url_root
+          defined?(::Rails) &&
+            ::Rails.respond_to?(:configuration) &&
+            ::Rails.configuration.respond_to?(:relative_url_root) &&
+            ::Rails.configuration.relative_url_root
+        end
+      end
+    end
+  end
+end

data/lib/premailer/rails/css_loaders/network_loader.rb

@@ -0,0 +1,39 @@
+class Premailer
+  module Rails
+    module CSSLoaders
+      module NetworkLoader
+        extend self
+
+        def load(url)
+          uri = uri_for_url(url)
+          Net::HTTP.get(uri) if uri
+        end
+
+        def uri_for_url(url)
+          uri = URI(url)
+
+          if uri.host.present?
+            return uri if uri.scheme.present?
+            URI("http:#{uri}")
+          elsif asset_host_present?
+            scheme, host = asset_host(url).split(%r{:?//})
+            scheme, host = host, scheme if host.nil?
+            scheme = 'http' if scheme.blank?
+            path = url
+            URI(File.join("#{scheme}://#{host}", path))
+          end
+        end
+
+        def asset_host_present?
+          ::Rails.respond_to?(:configuration) &&
+            ::Rails.configuration.action_controller.asset_host.present?
+        end
+
+        def asset_host(url)
+          config = ::Rails.configuration.action_controller.asset_host
+          config.respond_to?(:call) ? config.call(url) : config
+        end
+      end
+    end
+  end
+end

data/lib/premailer/rails/css_loaders/propshaft_loader.rb

@@ -0,0 +1,33 @@
+class Premailer
+  module Rails
+    module CSSLoaders
+      module PropshaftLoader
+        extend self
+
+        def load(url)
+          return unless propshaft_present?
+
+          file = file_name(url)
+          asset = ::Rails.application.assets.load_path.find(file)
+          ::Rails.application.assets.compilers.compile(asset) if asset
+        end
+
+        def file_name(url)
+          prefix = File.join(
+            ::Rails.configuration.relative_url_root.to_s,
+            ::Rails.configuration.assets.prefix.to_s,
+            '/'
+          )
+          URI(url).path
+            .sub(/\A#{prefix}/, '')
+            .sub(/-(\h{40})\.css\z/, '.css')
+        end
+
+        def propshaft_present?
+          defined?(::Rails) &&
+            ::Rails.try(:application).try(:assets).class.name == "Propshaft::Assembly"
+        end
+      end
+    end
+  end
+end

data/lib/premailer/rails/css_loaders.rb

@@ -0,0 +1,6 @@
+require 'uri'
+
+require 'premailer/rails/css_loaders/file_system_loader'
+require 'premailer/rails/css_loaders/asset_pipeline_loader'
+require 'premailer/rails/css_loaders/propshaft_loader'
+require 'premailer/rails/css_loaders/network_loader'

data/lib/premailer/rails/customized_premailer.rb

@@ -0,0 +1,20 @@
+class Premailer
+  module Rails
+    class CustomizedPremailer < ::Premailer
+      def initialize(html)
+        # In order to pass the CSS as string to super it is necessary to access
+        # the parsed HTML beforehand. To do so, the adapter needs to be
+        # initialized. The ::Premailer::Adapter handles the discovery of
+        # a suitable adapter. To make load_html work, an adapter needs to be
+        # included and @options[:with_html_string] needs to be set. For further
+        # information, refer to ::Premailer#initialize.
+        @options = Rails.config.merge(with_html_string: true)
+        Premailer.send(:include, Adapter.find(Adapter.use))
+        doc = load_html(html)
+        options = @options.merge(css_string: CSSHelper.css_for_doc(doc))
+
+        super(doc.to_s, options)
+      end
+    end
+  end
+end

data/lib/premailer/rails/hook.rb

@@ -0,0 +1,140 @@
+class Premailer
+  module Rails
+    class Hook
+      attr_reader :message
+
+      class << self
+        def perform(message)
+          new(message).perform
+          message
+        end
+
+        alias_method :delivering_email, :perform
+        alias_method :previewing_email, :perform
+      end
+
+      def initialize(message)
+        @message = message
+      end
+
+      def perform
+        if skip_premailer_header_present?
+          remove_skip_premailer_header
+        elsif message_contains_html?
+          replace_html_part(generate_html_part_replacement)
+        end
+      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
+
+      # Returns true if the message itself has a content type of text/html, thus
+      # it does not contain other parts such as alternatives and attachments.
+      def pure_html_message?
+        message.content_type && message.content_type.include?('text/html')
+      end
+
+      def generate_html_part_replacement
+        if generate_text_part?
+          generate_alternative_part
+        else
+          generate_html_part
+        end
+      end
+
+      def generate_text_part?
+        Rails.config[:generate_text_part] && !message.text_part
+      end
+
+      def generate_alternative_part
+        part = Mail::Part.new(content_type: 'multipart/alternative')
+        part.add_part(generate_text_part)
+        part.add_part(generate_html_part)
+
+        part
+      end
+
+      def generate_html_part
+        # Make sure that the text part is generated first. Otherwise the text
+        # can end up containing CSS rules.
+        generate_text_part if generate_text_part?
+
+        part = html_part
+        html = premailer.to_inline_css
+        Mail::Part.new do
+          content_type "text/html; charset=#{html.encoding}"
+          body html
+        end
+      end
+
+      def generate_text_part
+        @text_part ||= begin
+          part = html_part
+          text = premailer.to_plain_text
+          Mail::Part.new do
+            content_type "text/plain; charset=#{text.encoding}"
+            body text
+          end
+        end
+      end
+
+      def premailer
+        @premailer ||= CustomizedPremailer.new(html_part.decoded)
+      end
+
+      def html_part
+        if pure_html_message?
+          message
+        else
+          message.html_part
+        end
+      end
+
+      def replace_html_part(new_part)
+        if pure_html_message?
+          replace_in_pure_html_message(new_part)
+        else
+          replace_part_in_list(message.parts, html_part, new_part)
+        end
+      end
+
+      # If the new part is a pure text/html part, the body and its content type
+      # are used for the message. If the new part is
+      def replace_in_pure_html_message(new_part)
+        if new_part.content_type.include?('text/html')
+          message.body = new_part.decoded
+          message.content_type = new_part.content_type
+        else
+          message.body = nil
+          message.content_type = new_part.content_type
+          new_part.parts.each do |part|
+            message.add_part(part)
+          end
+        end
+      end
+
+      def replace_part_in_list(parts_list, old_part, new_part)
+        if (index = parts_list.index(old_part))
+          parts_list[index] = new_part
+        else
+          parts_list.any? do |part|
+            if part.respond_to?(:parts)
+              replace_part_in_list(part.parts, old_part, new_part)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/premailer/rails/railtie.rb

@@ -0,0 +1,9 @@
+class Premailer
+  module Rails
+    class Railtie < ::Rails::Railtie
+      config.after_initialize do
+        ::Premailer::Rails.register_interceptors
+      end
+    end
+  end
+end

data/lib/premailer/rails/version.rb

@@ -0,0 +1,7 @@
+class Premailer
+  module Rails
+    VERSION = File.read(
+      File.expand_path('../../../../VERSION', __FILE__)
+    ).strip
+  end
+end

data/lib/premailer/rails.rb

@@ -0,0 +1,31 @@
+require 'premailer'
+require 'action_mailer'
+
+require 'premailer/rails/version'
+require 'premailer/rails/css_loaders'
+require 'premailer/rails/css_helper'
+require 'premailer/rails/customized_premailer'
+require 'premailer/rails/hook'
+
+class Premailer
+  module Rails
+    @config = {
+      input_encoding: 'UTF-8',
+      generate_text_part: true,
+      strategies: [:filesystem, :asset_pipeline, :propshaft, :network]
+    }
+    class << self
+      attr_accessor :config
+    end
+
+    def self.register_interceptors
+      ActionMailer::Base.register_interceptor(Premailer::Rails::Hook)
+
+      if ActionMailer::Base.respond_to?(:register_preview_interceptor)
+        ActionMailer::Base.register_preview_interceptor(Premailer::Rails::Hook)
+      end
+    end
+  end
+end
+
+require 'premailer/rails/railtie' if defined?(Rails)

data/premailer-rails.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "premailer/rails/version"
+
+Gem::Specification.new do |s|
+  s.name        = "premailer-rails-revived"
+  s.version     = Premailer::Rails::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.license     = 'MIT'
+  s.authors     = ["Adrien Siami"]
+  s.email       = ["adrien@siami.fr"]
+  s.homepage    = "https://github.com/Intrepidd/premailer-rails"
+  s.summary     = %q{Forked and revived: Easily create styled HTML emails in Rails.}
+  s.description = %q{This gem brings you the power of the premailer gem to Rails
+                     without any configuration needs. Create HTML emails,
+                     include a CSS file as you do in a normal HTML document and
+                     premailer will inline the included CSS. Forked and revived from the work of fphilipe.}
+
+  s.metadata["changelog_uri"] = "https://github.com/Intrepidd/premailer-rails/blob/v#{Premailer::Rails::VERSION}/CHANGELOG.md"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {example,spec}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'premailer', '~> 1.7', '>= 1.7.9'
+  s.add_dependency 'actionmailer', '>= 3'
+
+  s.add_development_dependency 'rspec', '~> 3.3'
+  s.add_development_dependency 'nokogiri'
+  s.add_development_dependency 'coveralls' if RUBY_ENGINE == 'ruby'
+end

data/spec/integration/css_helper_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Premailer::Rails::CSSHelper do
+  # Reset the CSS cache:
+  after do
+    Premailer::Rails::CSSHelper.cache = {}
+  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 file_loader
+    if Premailer::Rails::CSSLoaders::PropshaftLoader.propshaft_present?
+      Premailer::Rails::CSSLoaders::PropshaftLoader
+    else
+      Premailer::Rails::CSSLoaders::AssetPipelineLoader
+    end
+  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
+
+    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
+
+  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
+
+    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 cache is enabled' do
+      before do
+        allow(Premailer::Rails::CSSHelper).to receive(:cache_enabled?).and_return(true)
+      end
+
+      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_url('http://example.com/stylesheets/base.css')).to \
+            eq('content of base.css')
+        end
+      end
+    end
+
+    context 'when cache is disabled' do
+      before do
+        allow(Premailer::Rails::CSSHelper).to receive(:cache_enabled?).and_return(false)
+      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
+
+    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
+
+      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
+
+      it 'returns the content of the file compiled by Rails' do
+        expect(file_loader).to \
+          receive(:load)
+            .with('http://example.com/assets/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
+
+      it 'returns same file when path contains file fingerprint' do
+        expect(file_loader).to \
+          receive(:load)
+            .with('http://example.com/assets/base-089e35bd5d84297b8d31ad552e433275.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(file_loader).to \
+            receive(:load).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)).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' }
+
+            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
+  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