premailer-rails 1.8.0 → 1.11.1

data/lib/premailer/rails/css_loaders.rb

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

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

@@ -5,21 +5,30 @@ class Premailer
         extend self
 
         def load(url)
-          if asset_pipeline_present?
-            file = file_name(url)
-            asset = ::Rails.application.assets.find_asset(file)
-            asset.to_s if asset
-          end
-        end
+          return unless asset_pipeline_present?
 
-        def asset_pipeline_present?
-          defined?(::Rails) and ::Rails.application.respond_to?(:assets)
+          file = file_name(url)
+          ::Rails.application.assets_manifest.find_sources(file).first
+        rescue Errno::ENOENT, TypeError => _error
         end
 
         def file_name(url)
+          prefix = [
+            ::Rails.configuration.relative_url_root,
+            ::Rails.configuration.assets.prefix,
+            '/'
+          ].join
           URI(url).path
-            .sub("#{::Rails.configuration.assets.prefix}/", '')
-            .sub(/-\h{32}\.css$/, '.css')
+            .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

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

@@ -5,9 +5,31 @@ class Premailer
         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
-          file_path = "public#{path}"
-          File.read(file_path) if File.exist?(file_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

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

@@ -12,19 +12,26 @@ class Premailer
         def uri_for_url(url)
           uri = URI(url)
 
-          if not valid_uri?(uri) and defined?(::Rails)
-            scheme, host =
-              ::Rails.configuration.action_controller.asset_host.split(%r{:?//})
+          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?
-            uri.scheme ||= scheme
-            uri.host ||= host
+            path = url
+            URI(File.join("#{scheme}://#{host}", path))
           end
+        end
 
-          uri if valid_uri?(uri)
+        def asset_host_present?
+          ::Rails.respond_to?(:configuration) &&
+            ::Rails.configuration.action_controller.asset_host.present?
         end
 
-        def valid_uri?(uri)
-          uri.host.present? && uri.scheme.present?
+        def asset_host(url)
+          config = ::Rails.configuration.action_controller.asset_host
+          config.respond_to?(:call) ? config.call(url) : config
         end
       end
     end

data/lib/premailer/rails/customized_premailer.rb

@@ -4,16 +4,16 @@ class 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::Adaptor handles the discovery of a
-        # suitable adaptor (Nokogiri or Hpricot). To make load_html work, an
-        # adaptor needs to be included and @options[:with_html_string] needs to
-        # be set. For further information, refer to ::Premailer#initialize.
+        # 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(html, options)
+
+        super(doc.to_s, options)
       end
     end
   end

data/lib/premailer/rails/hook.rb

@@ -42,7 +42,7 @@ class Premailer
       # 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.include?('text/html')
+        message.content_type && message.content_type.include?('text/html')
       end
 
       def generate_html_part_replacement
@@ -68,17 +68,25 @@ class Premailer
       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?
+        generate_text_part if generate_text_part?
 
-        Mail::Part.new(
-          content_type: "text/html; charset=#{html_part.charset}",
-          body: premailer.to_inline_css)
+        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 ||= Mail::Part.new(
-          content_type: "text/plain; charset=#{html_part.charset}",
-          body: premailer.to_plain_text)
+        @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

data/premailer-rails.gemspec

@@ -6,6 +6,7 @@ Gem::Specification.new do |s|
   s.name        = "premailer-rails"
   s.version     = Premailer::Rails::VERSION
   s.platform    = Gem::Platform::RUBY
+  s.license     = 'MIT'
   s.authors     = ["Philipe Fatio"]
   s.email       = ["philipe.fatio@gmail.com"]
   s.homepage    = "https://github.com/fphilipe/premailer-rails"
@@ -16,15 +17,14 @@ Gem::Specification.new do |s|
                      premailer will inline the included CSS.}
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.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', '< 5'
+  s.add_dependency 'actionmailer', '>= 3'
 
-  s.add_development_dependency 'rspec', '~> 3.0.0'
+  s.add_development_dependency 'rspec', '~> 3.3'
   s.add_development_dependency 'nokogiri'
-  s.add_development_dependency 'hpricot' unless RUBY_PLATFORM == 'java'
   s.add_development_dependency 'coveralls' if RUBY_ENGINE == 'ruby'
 end

data/spec/integration/css_helper_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Premailer::Rails::CSSHelper do
   # Reset the CSS cache:
   after do
-    Premailer::Rails::CSSHelper.send(:instance_variable_set, '@cache', {})
+    Premailer::Rails::CSSHelper.cache = {}
   end
 
-  def load_css(path)
-    Premailer::Rails::CSSHelper.send(:load_css, path)
+  def css_for_url(path)
+    Premailer::Rails::CSSHelper.css_for_url(path)
   end
 
   def css_for_doc(doc)
@@ -15,7 +15,8 @@ describe Premailer::Rails::CSSHelper do
   end
 
   def expect_file(path, content='file content')
-    allow(File).to receive(:exist?).with(path).and_return(true)
+    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
 
@@ -28,63 +29,79 @@ describe Premailer::Rails::CSSHelper do
 
       it 'returns the content of both files concatenated' do
         allow(Premailer::Rails::CSSHelper).to \
-          receive(:load_css)
+          receive(:css_for_url)
             .with('http://example.com/stylesheets/base.css')
             .and_return('content of base.css')
         allow(Premailer::Rails::CSSHelper).to \
-          receive(:load_css)
+          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 '#load_css' do
+  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')
 
-        load_css('http://example.com/stylesheets/base.css?test')
+        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')
-        load_css('/stylesheets/base.css?test')
+        css_for_url('/stylesheets/base.css?test')
       end
     end
 
-    context 'when file is cached' do
-      it 'returns the cached value' do
-        cache =
-          Premailer::Rails::CSSHelper.send(:instance_variable_get, '@cache')
-        cache['http://example.com/stylesheets/base.css'] = 'content of base.css'
+    context 'when cache is enabled' do
+      before do
+        allow(Premailer::Rails::CSSHelper).to receive(:cache_enabled?).and_return(true)
+      end
 
-        expect(load_css('http://example.com/stylesheets/base.css')).to \
-          eq('content of base.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_url('http://example.com/stylesheets/base.css')).to \
+            eq('content of base.css')
+        end
       end
     end
 
-    context 'when in development mode' do
+    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
-        cache =
-          Premailer::Rails::CSSHelper.send(:instance_variable_get, '@cache')
-        cache['http://example.com/stylesheets/base.css'] =
-          'cached content of base.css'
+        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)
-        allow(Rails.env).to receive(:development?).and_return(true)
 
-        expect(load_css('http://example.com/stylesheets/base.css')).to eq(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(: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
@@ -92,27 +109,61 @@ describe Premailer::Rails::CSSHelper do
           path = '/assets/email-digest.css'
           content = 'read from file'
           expect_file("public#{path}", content)
-          expect(load_css(path)).to eq(content)
+          expect(css_for_url(path)).to eq(content)
+        end
+      end
+
+      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).and_return(response)
+          expect(css_for_url('http://example.com/assets/base.css')).to \
+            eq(response)
+        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') }
+
+        it "falls back to Net::HTTP" do
+          expect(Rails.application.assets_manifest).to \
+            receive(:find_sources)
+              .with('base.css')
+              .and_raise(Errno::ENOENT)
+
+          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)
+        expect(Rails.application.assets_manifest).to \
+          receive(:find_sources)
             .with('base.css')
-            .and_return(double(to_s: 'content of base.css'))
+            .and_return(['content of base.css'])
 
-        expect(load_css('http://example.com/assets/base.css')).to \
+        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)
+        expect(Rails.application.assets_manifest).to \
+          receive(:find_sources)
             .with('base.css')
-            .and_return(double(to_s: 'content of base.css'))
+            .and_return(['content of base.css'])
 
-        expect(load_css(
+        expect(css_for_url(
           'http://example.com/assets/base-089e35bd5d84297b8d31ad552e433275.css'
         )).to eq('content of base.css')
       end
@@ -124,43 +175,42 @@ describe Premailer::Rails::CSSHelper do
         let(:asset_host) { 'http://assets.example.com' }
 
         before do
-          allow(Rails.application.assets).to \
-            receive(:find_asset).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)
 
-          uri_satisfaction = satisfy { |uri| uri.to_s == url }
           allow(Net::HTTP).to \
-            receive(:get).with(uri_satisfaction).and_return(response)
+            receive(:get).with(URI(url)).and_return(response)
         end
 
         it 'requests the file' do
-          expect(load_css(url)).to eq('content of base.css')
+          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(load_css(path)).to eq('content of base.css')
+            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(load_css(path)).to eq('content of base.css')
+              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 = load_css('http://example.com/stylesheets/base.css')
+        loaded_content = css_for_url('http://example.com/stylesheets/base.css')
         expect(loaded_content).to eq(content)
       end
     end