premailer-rails 1.3.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7fe7ad5147d3f2fc55adfb214b582cf36cb6e8d
-  data.tar.gz: c89ed93ba60d97da47d9052a4021ec9464ca6f61
+  metadata.gz: 41073202cdcfc614302e4ebd78983e637bca0509
+  data.tar.gz: e6cffc67a632087c4403ae5ae3bc315f6949bcee
 SHA512:
-  metadata.gz: 51cfbedc2689258c5bf481d573365b25c7116ebccdad4be79115d68e10515cfe5651c77e9d34fd31f70c5b0170f7e86b0b02c3fa5a887627be81157bf9c8f479
-  data.tar.gz: f39cd91e3c94347be787f47a2aa6487a27c046d007981a164ad30d394924d0f64b38743bd708e2b5d56c3f14dce07de3bd5caefc06a4a3d41ec993fd0019bceb
+  metadata.gz: af6af666d40e0d924d3a8982fd240d407d9b5f01e8295d03c7aaa411285876ef23c03dc54aad10e0c4e0e28caa0c5132f7d0230c74edf0828e79664e1b30bf37
+  data.tar.gz: e1b3fa698a622be4fe6fd1bd18d9407dbac7823417fc0bf251adda5af9f096dec35fdbbca0f055dc5754fe7de763db3e541cfd84edbf0180d44a8d81012ffcbd

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -1,3 +1,4 @@
 *.gem
 doc/
 Gemfile.lock
+coverage/

data/Gemfile

@@ -1,6 +1,5 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
-# Specify your gem's dependencies in premailer-rails3.gemspec
 gemspec
 
 platforms :jruby do

data/README.md

@@ -4,14 +4,12 @@
 [![Gem Version](https://badge.fury.io/rb/premailer-rails.png)](http://badge.fury.io/rb/premailer-rails)
 [![Dependency Status](https://gemnasium.com/fphilipe/premailer-rails.png)](https://gemnasium.com/fphilipe/premailer-rails)
 [![Code Climate](https://codeclimate.com/github/fphilipe/premailer-rails.png)](https://codeclimate.com/github/fphilipe/premailer-rails)
+[![Coverage Status](https://coveralls.io/repos/fphilipe/premailer-rails/badge.png?branch=master)](https://coveralls.io/r/fphilipe/premailer-rails)
 
-This gem is a no config solution for the wonderful
-[Premailer gem](https://github.com/alexdunae/premailer) to be used with Rails.
-It uses interceptors which were introduced in Rails 3 and tweaks all mails which
-are `deliver`ed and adds a plain text part to them and inlines all CSS rules
-into the HTML part.
+This gem is a no config solution for the wonderful [Premailer gem](https://github.com/alexdunae/premailer) to be used with Rails.
+It uses interceptors which were introduced in Rails 3 and tweaks all mails which are `deliver`ed and adds a plain text part to them and inlines all CSS rules into the HTML part.
 
-By default it inlines all the CSS files that are linked to in the HTML:
+By default it inlines all inline `<style>` declarations and all the CSS files that are linked to in the HTML:
 
 ```html
 <link type='text/css' ... />
@@ -19,7 +17,6 @@ By default it inlines all the CSS files that are linked to in the HTML:
 
 Don't worry about the host in the CSS URL since this will be ignored.
 
-Every CSS file is loaded from within the app.
 The retrieval of the file depends on your assets configuration:
 
 * Rails 3.1 asset pipeline: It will load the compiled version of the CSS asset
@@ -30,18 +27,13 @@ The retrieval of the file depends on your assets configuration:
 * Classic static assets: It will try to load the CSS file located in
   `public/stylesheets/`
 
-* [Hassle](https://github.com/pedro/hassle): It will try to load the
-  compiled CSS file located in the default Hassle location
-  `tmp/hassle/stylesheets/`
-
 ## Installation
 
 Simply add the gem to your Gemfile in your Rails project:
 
     gem 'premailer-rails'
 
-premailer-rails requires either nokogiri or hpricot. It doesn't list them as a
-dependency so you can choose which one to use.
+premailer-rails requires either nokogiri or hpricot. It doesn't list them as a dependency so you can choose which one to use.
 
     gem 'nokogiri'
     # or
@@ -74,13 +66,10 @@ The default configs are:
 }
 ```
 
-The input encoding option [changed](https://github.com/alexdunae/premailer/commit/5f5cbb4ac181299a7e73d3eca11f3cf546585364)
-at some point. To make sure this option works regardless of the premailer
-version, the old and new setting is specified. If you want to use another
-encoding make sure to specify the right one or both.
+The input encoding option [changed](https://github.com/alexdunae/premailer/commit/5f5cbb4ac181299a7e73d3eca11f3cf546585364) at some point.
+To make sure this option works regardless of the premailer version, the old and new setting is specified.
+If you want to use another encoding make sure to specify the right one or both.
 
-If you don't want to generate a text part from the html part, set the config
-`:generate_text_part` to false.
+If you don't want to automatically generate a text part from the html part, set the config `:generate_text_part` to false.
 
-Note that the options `:with_html_string` and `:css_string` are used to make
-this gem work and will thus be overridden.
+Note that the options `:with_html_string` and `:css_string` are used internally and thus will be overridden.

data/VERSION

@@ -1 +1 @@
-1.3.2
+1.4.0

data/lib/premailer/rails.rb

@@ -1,6 +1,7 @@
 require 'premailer'
 require 'action_mailer'
 
+require 'premailer/rails/version'
 require 'premailer/rails/css_loaders'
 require 'premailer/rails/css_helper'
 require 'premailer/rails/customized_premailer'

data/lib/premailer/rails/css_helper.rb

@@ -29,10 +29,6 @@ class Premailer
         end
       end
 
-      def has_inline_css?(doc)
-        not doc.search('style[@type="text/css"]').empty?
-      end
-
       def load_css(url)
         path = extract_path(url)
 

data/lib/premailer/rails/hook.rb

@@ -1,42 +1,115 @@
 class Premailer
   module Rails
     class Hook
+      attr_reader :message
+
       def self.delivering_email(message)
-        # If the mail only has one part, it may be stored in message.body. In that
-        # case, if the mail content type is text/html, the body part will be the
-        # html body.
-        if message.html_part
-          html_body       = message.html_part.body.to_s
-          needs_multipart = true
-          message.parts.delete(message.html_part)
-        elsif message.content_type =~ /text\/html/
-          html_body       = message.body.to_s
-          message.body    = nil
-          needs_multipart = Rails.config[:generate_text_part]
+        self.new(message).perform
+      end
+
+      def initialize(message)
+        @message = message
+      end
+
+      def perform
+        if message_contains_html?
+          replace_html_part(generate_html_part_replacement)
         end
 
-        if html_body
-          premailer = CustomizedPremailer.new(html_body)
-          charset   = message.charset
-
-          if needs_multipart
-            # IMPORTANT: Plain text part must be generated before CSS is inlined.
-            # Not doing so results in CSS declarations visible in the plain text
-            # part.
-            if Rails.config[:generate_text_part] \
-            and not message.text_part
-              message.text_part do
-                content_type "text/plain; charset=#{charset}"
-                body premailer.to_plain_text
-              end
-            end
+        message
+      end
+
+      private
+
+      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.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_html_part)
+        part.add_part(generate_text_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?
+
+        Mail::Part.new(
+          :content_type => "text/html; charset=#{html_part.charset}",
+          :body => premailer.to_inline_css)
+      end
+
+      def generate_text_part
+        @text_part ||= Mail::Part.new(
+          :content_type => "text/plain; charset=#{html_part.charset}",
+          :body => premailer.to_plain_text)
+      end
+
+      def premailer
+        @premailer ||= CustomizedPremailer.new(html_part.body.to_s)
+      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.body.to_s
+          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
 
-            message.html_part do
-              content_type "text/html; charset=#{charset}"
-              body premailer.to_inline_css
+      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
-          else
-            message.body = premailer.to_inline_css
           end
         end
       end

data/lib/premailer/rails/nokogiri_fix.rb

@@ -7,7 +7,9 @@ Premailer::Adapter::Nokogiri.module_eval do
       html = html.force_encoding('UTF-8').encode!
       ::Nokogiri::HTML(html) {|c| c.recover }
     else
+      # :nocov:
       ::Nokogiri::HTML(html, nil, 'UTF-8') {|c| c.recover }
+      # :nocov:
     end
   end
 end

data/premailer-rails.gemspec

@@ -29,4 +29,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'mail'
   s.add_development_dependency 'nokogiri'
   s.add_development_dependency 'hpricot'
+  s.add_development_dependency 'coveralls'
 end

data/spec/fixtures/message.rb

@@ -44,17 +44,39 @@ 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
 
-      message.html_part do
-        body HTML_PART
-        content_type 'text/html; charset=UTF-8'
-      end if part_types.include? :html
+      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
 
-      message.text_part do
-        body TEXT_PART
-        content_type 'text/plain; charset=UTF-8'
-      end if part_types.include? :text
+      if part_types.include? :attachment
+        message.add_file(:filename => 'foo.png', :content => 'foobar')
+      end
+
+      message.ready_to_send!
 
       message
     end
@@ -64,13 +86,15 @@ nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
 
       case body_type
       when :html
-        message.body = HTML_PART
+        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
 
@@ -79,7 +103,7 @@ nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
     def base_message
       Mail.new do
         to      'some@email.com'
-        subject 'testing premailer-rails3'
+        subject 'testing premailer-rails'
       end
     end
   end

data/spec/lib/hook_registration_spec.rb

@@ -5,6 +5,6 @@ describe 'ActionMailer::Base.register_interceptor' do
     ActionMailer::Base \
       .expects(:register_interceptor) \
       .with(Premailer::Rails::Hook)
-    load 'premailer/rails3.rb'
+    load 'premailer/rails.rb'
   end
 end

data/spec/lib/hook_spec.rb

@@ -1,105 +1,77 @@
 require 'spec_helper'
 
 describe Premailer::Rails::Hook do
-  describe '.delivering_email' do
-    before { File.stubs(:read).returns('') }
-    def run_hook(message)
-      Premailer::Rails::Hook.delivering_email(message)
-    end
+  def run_hook(message)
+    Premailer::Rails::Hook.delivering_email(message)
+  end
 
-    context 'when message contains html part' do
-      let(:message) { Fixtures::Message.with_parts :html }
+  class Mail::Message
+    def html_string
+      (html_part || self).body.to_s
+    end
+  end
 
-      it 'should create a text part from the html part' do
-        Premailer::Rails::CustomizedPremailer \
-          .any_instance.expects(:to_plain_text)
-        run_hook(message)
-        message.text_part.should be_a Mail::Part
-      end
+  let(:message) { Fixtures::Message.with_body(:html) }
+  let(:processed_message) { run_hook(message) }
 
-      it 'should inline the css in the html part' do
-        Premailer::Rails::CustomizedPremailer \
-          .any_instance.expects(:to_inline_css)
-        run_hook(message)
-      end
+  it 'inlines the CSS' do
+    expect { run_hook(message) }.to \
+      change { message.html_string.include?("<p style=") }
+  end
 
-      it 'should not create a text part if disabled' do
-        Premailer::Rails::CustomizedPremailer \
-          .any_instance.expects(:to_plain_text).never
-        Premailer::Rails.config[:generate_text_part] = false
-        run_hook(message)
-        Premailer::Rails.config[:generate_text_part] = true
-        message.text_part.should be_nil
-        message.html_part.should be_a Mail::Part
-      end
+  it 'replaces the html part with an alternative part containing text and html parts' do
+    processed_message.content_type.should include 'multipart/alternative'
+    processed_message.parts.should =~ [message.html_part, message.text_part]
+  end
 
-      it 'should not create an additional html part' do
-        run_hook(message)
-        message.parts.count { |i| i.content_type =~ /text\/html/ }.should == 1
-      end
-    end
+  it 'generates a text part from the html' do
+    expect { run_hook(message) }.to change(message, :text_part)
+  end
 
-    context 'when message contains text part' do
-      let(:message) { Fixtures::Message.with_parts :text }
+  context 'when message contains no html' do
+    let(:message) { Fixtures::Message.with_body(:text) }
 
-      it 'should not modify the message' do
-        Premailer.expects(:new).never
-        run_hook(message)
-      end
+    it 'does not modify the message' do
+      expect { run_hook(message) }.to_not change(message, :html_string)
     end
+  end
 
-    context 'when message contains html and text part' do
-      let(:message) { Fixtures::Message.with_parts :html, :text }
-
-      it 'should not create a text part from the html part' do
-        Premailer::Rails::CustomizedPremailer \
-          .any_instance.expects(:to_plain_text).never
-        run_hook(message)
-        message.text_part.should be_a Mail::Part
-      end
+  context 'when message also contains a text part' do
+    let(:message) { Fixtures::Message.with_parts(:html, :text) }
 
-      it 'should inline the css in the html part' do
-        Premailer::Rails::CustomizedPremailer \
-          .any_instance.expects(:to_inline_css)
-        run_hook(message)
-      end
+    it 'does not generate a text part' do
+      expect { run_hook(message) }.to_not change(message, :text_part)
     end
 
-    context 'when message contains html body' do
-      let(:message) { Fixtures::Message.with_body :html }
-
-      it 'should create a text part from the html part' do
-        Premailer::Rails::CustomizedPremailer \
-          .any_instance.expects(:to_plain_text)
-        run_hook(message)
-      end
-
-      it 'should create a html part and inline the css' do
-        Premailer::Rails::CustomizedPremailer \
-          .any_instance.expects(:to_inline_css)
-        run_hook(message)
-        message.html_part.should be_a Mail::Part
-      end
+    it 'does not replace any message part' do
+      expect { run_hook(message) }.to_not \
+        change { message.all_parts.map(&:content_type) }
+    end
+  end
 
-      it 'should not create a text part if disabled' do
-        Premailer::Rails::CustomizedPremailer \
-          .any_instance.expects(:to_plain_text).never
+  context 'when text generation is disabled' do
+    it 'does not generate a text part' do
+      begin
         Premailer::Rails.config[:generate_text_part] = false
-        run_hook(message)
+
+        expect { run_hook(message) }.to_not change(message, :text_part)
+      ensure
         Premailer::Rails.config[:generate_text_part] = true
-        message.text_part.should be_nil
-        message.html_part.should be_nil
-        message.body.should_not be_empty
       end
     end
+  end
 
-    context 'when message contains text body' do
-      let(:message) { Fixtures::Message.with_body :text }
-
-      it 'should not modify the message' do
-        Premailer.expects(:new).never
-        run_hook(message)
-      end
+  context 'when message also contains an attachment' do
+    let(:message) { Fixtures::Message.with_parts(:html, :attachment) }
+    it 'does not mess with it' do
+      message.content_type.should include 'multipart/mixed'
+      message.parts.first.content_type.should include 'text/html'
+      message.parts.last.content_type.should include 'image/png'
+
+      processed_message.content_type.should include 'multipart/mixed'
+      processed_message.parts.first.content_type.should \
+        include 'multipart/alternative'
+      processed_message.parts.last.content_type.should include 'image/png'
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,10 @@
+if RUBY_VERSION >= '1.9'
+  require 'coveralls'
+  Coveralls.wear! do
+    add_filter 'spec/'
+  end
+end
+
 require 'premailer/rails'
 
 require 'stubs/action_mailer'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: premailer-rails
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.4.0
 platform: ruby
 authors:
 - Philipe Fatio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-12 00:00:00.000000000 Z
+date: 2013-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: premailer
@@ -122,6 +122,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |-
   This gem brings you the power of the premailer gem to Rails
                        without any configuration needs. Create HTML emails,
@@ -133,6 +147,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .coveralls.yml
 - .gitignore
 - .rspec
 - .travis.yml
@@ -148,9 +163,7 @@ files:
 - lib/premailer/rails/customized_premailer.rb
 - lib/premailer/rails/hook.rb
 - lib/premailer/rails/nokogiri_fix.rb
-- lib/premailer/rails/premailer.rb
 - lib/premailer/rails/version.rb
-- lib/premailer/rails3.rb
 - premailer-rails.gemspec
 - spec/fixtures/html.rb
 - spec/fixtures/message.rb

data/lib/premailer/rails/premailer.rb

@@ -1,20 +0,0 @@
-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::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.
-        @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)
-      end
-    end
-  end
-end

data/lib/premailer/rails3.rb

@@ -1,23 +0,0 @@
-require 'premailer'
-require 'action_mailer'
-
-require 'premailer/rails/css_loaders'
-require 'premailer/rails/css_helper'
-require 'premailer/rails/customized_premailer'
-require 'premailer/rails/hook'
-require 'premailer/rails/nokogiri_fix'
-
-class Premailer
-  module Rails
-    @config = {
-      :input_encoding     => 'UTF-8',
-      :inputencoding      => 'UTF-8',
-      :generate_text_part => true
-    }
-    class << self
-      attr_accessor :config
-    end
-  end
-end
-
-ActionMailer::Base.register_interceptor(Premailer::Rails::Hook)