premailer 1.26.0 → 1.28.0

data/lib/premailer/premailer.rb

@@ -39,9 +39,9 @@ class Premailer
   CLIENT_SUPPORT_FILE = File.dirname(__FILE__) + '/../../misc/client_support.yaml'
 
   # Unmergable selectors regexp.
-  RE_UNMERGABLE_SELECTORS = /(\:(visited|active|hover|focus|after|before|selection|target|first\-(line|letter))|^\@)/i
+  RE_UNMERGABLE_SELECTORS = /(:(visited|active|hover|focus|after|before|selection|target|first-(line|letter))|^@)/i
   # Reset selectors regexp.
-  RE_RESET_SELECTORS = /^(\:\#outlook|body.*|\.ReadMsgBody|\.ExternalClass|img|\#backgroundTable)$/
+  RE_RESET_SELECTORS = /^(:\#outlook|body.*|\.ReadMsgBody|\.ExternalClass|img|\#backgroundTable)$/
 
   # list of HTMLEntities to fix
   # source: http://stackoverflow.com/questions/2812781/how-to-convert-webpage-apostrophe-8217-to-ascii-39-in-ruby-1-
@@ -57,23 +57,23 @@ class Premailer
     "–" => '-',
     "—" => '--',
     "―" => '--'
-  }
+  }.freeze
 
   # list of CSS attributes that can be rendered as HTML attributes
   #
   # @todo too much repetition
   # @todo background=""
   RELATED_ATTRIBUTES = {
-    'h1' => {'text-align' => 'align'},
-    'h2' => {'text-align' => 'align'},
-    'h3' => {'text-align' => 'align'},
-    'h4' => {'text-align' => 'align'},
-    'h5' => {'text-align' => 'align'},
-    'h6' => {'text-align' => 'align'},
-    'p' => {'text-align' => 'align'},
-    'div' => {'text-align' => 'align'},
-    'blockquote' => {'text-align' => 'align'},
-    'body' => {'background-color' => 'bgcolor'},
+    'h1' => { 'text-align' => 'align' },
+    'h2' => { 'text-align' => 'align' },
+    'h3' => { 'text-align' => 'align' },
+    'h4' => { 'text-align' => 'align' },
+    'h5' => { 'text-align' => 'align' },
+    'h6' => { 'text-align' => 'align' },
+    'p' => { 'text-align' => 'align' },
+    'div' => { 'text-align' => 'align' },
+    'blockquote' => { 'text-align' => 'align' },
+    'body' => { 'background-color' => 'bgcolor' },
     'table' => {
       '-premailer-align' => 'align',
       'background-color' => 'bgcolor',
@@ -107,7 +107,7 @@ class Premailer
       '-premailer-width' => 'width',
       '-premailer-height' => 'height'
     }
-  }
+  }.freeze
 
   # URI of the HTML file used
   attr_reader   :html_file
@@ -142,7 +142,7 @@ class Premailer
   include Warnings
 
   # Waning level names
-  WARN_LABEL = ['NONE', 'SAFE', 'POOR', 'RISKY']
+  WARN_LABEL = ['NONE', 'SAFE', 'POOR', 'RISKY'].freeze
 
   # Create a new Premailer object.
   #
@@ -182,38 +182,40 @@ class Premailer
   # @option options [Boolean] :html_fragment Handle HTML fragment without any HTML content wrappers. Default is false.
   # @option options [Boolean] :drop_unmergeable_css_rules Do not include unmergeable css rules in a <tt><style><tt> tag. Default is false.
   def initialize(html, options = {})
-    @options = {:warn_level => Warnings::SAFE,
-                :line_length => 65,
-                :link_query_string => nil,
-                :base_url => nil,
-                :rgb_to_hex_attributes => true,
-                :remove_classes => false,
-                :remove_ids => false,
-                :remove_comments => false,
-                :remove_scripts => true,
-                :reset_contenteditable => true,
-                :css => [],
-                :css_to_attributes => true,
-                :preserve_style_attribute => false,
-                :with_html_string => false,
-                :css_string => nil,
-                :preserve_styles => false,
-                :preserve_reset => true,
-                :verbose => false,
-                :debug => false,
-                :io_exceptions => false,
-                :rule_set_exceptions => true,
-                :include_link_tags => true,
-                :include_style_tags => true,
-                :input_encoding => 'ASCII-8BIT',
-                :output_encoding => nil,
-                :replace_html_entities => false,
-                :escape_url_attributes => true,
-                :unescaped_ampersand => false,
-                :create_shorthands => true,
-                :html_fragment => false,
-                :adapter => Adapter.use,
-                :drop_unmergeable_css_rules => false}.merge(options)
+    @options = {
+      :warn_level => Warnings::SAFE,
+      :line_length => 65,
+      :link_query_string => nil,
+      :base_url => nil,
+      :rgb_to_hex_attributes => true,
+      :remove_classes => false,
+      :remove_ids => false,
+      :remove_comments => false,
+      :remove_scripts => true,
+      :reset_contenteditable => true,
+      :css => [],
+      :css_to_attributes => true,
+      :preserve_style_attribute => false,
+      :with_html_string => false,
+      :css_string => nil,
+      :preserve_styles => false,
+      :preserve_reset => true,
+      :verbose => false,
+      :debug => false,
+      :io_exceptions => false,
+      :rule_set_exceptions => true,
+      :include_link_tags => true,
+      :include_style_tags => true,
+      :input_encoding => 'ASCII-8BIT',
+      :output_encoding => nil,
+      :replace_html_entities => false,
+      :escape_url_attributes => true,
+      :unescaped_ampersand => false,
+      :create_shorthands => true,
+      :html_fragment => false,
+      :adapter => Adapter.use,
+      :drop_unmergeable_css_rules => false
+    }.merge(options)
 
     @html_file = html
     @is_local_file = @options[:with_html_string] || Premailer.local_data?(html)
@@ -228,20 +230,22 @@ class Premailer
 
     if @options[:base_url]
       @base_url = Addressable::URI.parse(@options.delete(:base_url))
-    elsif not @is_local_file
+    elsif !@is_local_file
       @base_url = Addressable::URI.parse(@html_file)
     end
 
-    @css_parser = CssParser::Parser.new({
-      :absolute_paths => true,
-      :import => true,
-      :io_exceptions => @options[:io_exceptions],
-      :rule_set_exceptions => @options[:rule_set_exceptions]
-    })
+    @css_parser = CssParser::Parser.new(
+      {
+        :absolute_paths => true,
+        :import => true,
+        :io_exceptions => @options[:io_exceptions],
+        :rule_set_exceptions => @options[:rule_set_exceptions]
+      }
+    )
 
     @adapter_class = Adapter.find @options[:adapter]
 
-    self.extend(@adapter_class)
+    extend(@adapter_class)
 
     @doc = load_html(@html_file)
 
@@ -262,7 +266,8 @@ class Premailer
     @css_warnings
   end
 
-protected
+  protected
+
   def load_css_from_local_file!(path)
     css_block = +''
     path.delete_prefix!('file:')
@@ -274,13 +279,13 @@ protected
       end
 
       load_css_from_string(css_block)
-    rescue => e
+    rescue StandardError => e
       raise e if @options[:io_exceptions]
     end
   end
 
   def load_css_from_string(css_string)
-    @css_parser.add_block!(css_string, {:base_uri => @base_url, :base_dir => @base_dir, :only_media_types => [:screen, :handheld]})
+    @css_parser.add_block!(css_string, { :base_uri => @base_url, :base_dir => @base_dir, :only_media_types => [:screen, :handheld] })
   end
 
   # @private
@@ -296,20 +301,20 @@ protected
     end
   end
 
-    # Load CSS included in <tt>style</tt> and <tt>link</tt> tags from an HTML document.
+  # Load CSS included in <tt>style</tt> and <tt>link</tt> tags from an HTML document.
   def load_css_from_html! # :nodoc:
     tags = @doc.search("link[@rel='stylesheet']:not([@data-premailer='ignore']), style:not([@data-premailer='ignore'])")
     if tags
       tags.each do |tag|
-        if tag.to_s.strip =~ /^\<link/i && tag.attributes['href'] && media_type_ok?(tag.attributes['media']) && @options[:include_link_tags]
+        if tag.to_s.strip =~ /^<link/i && tag.attributes['href'] && media_type_ok?(tag.attributes['media']) && @options[:include_link_tags]
           # A user might want to <link /> to a local css file that is also mirrored on the site
           # but the local one is different (e.g. newer) than the live file, premailer will now choose the local file
 
-          if tag.attributes['href'].to_s.include? @base_url.to_s and @html_file.kind_of?(String)
-            if @options[:with_html_string]
-              link_uri = tag.attributes['href'].to_s.sub(@base_url.to_s, '')
+          if tag.attributes['href'].to_s.include?(@base_url.to_s) && @html_file.is_a?(String)
+            link_uri = if @options[:with_html_string]
+              tag.attributes['href'].to_s.sub(@base_url.to_s, '')
             else
-              link_uri = File.join(File.dirname(@html_file), tag.attributes['href'].to_s.sub!(@base_url.to_s, ''))
+              File.join(File.dirname(@html_file), tag.attributes['href'].to_s.sub!(@base_url.to_s, ''))
             end
             # if the file does not exist locally, try to grab the remote reference
             unless File.exist?(link_uri)
@@ -320,14 +325,14 @@ protected
           end
 
           if Premailer.local_data?(link_uri)
-            $stderr.puts "Loading css from local file: " + link_uri if @options[:verbose]
+            warn "Loading css from local file: " + link_uri if @options[:verbose]
             load_css_from_local_file!(link_uri)
           else
-            $stderr.puts "Loading css from uri: " + link_uri if @options[:verbose]
-            @css_parser.load_uri!(link_uri, {:only_media_types => [:screen, :handheld]})
+            warn "Loading css from uri: " + link_uri if @options[:verbose]
+            @css_parser.load_uri!(link_uri, { :only_media_types => [:screen, :handheld] })
           end
 
-        elsif tag.to_s.strip =~ /^\<style/i && @options[:include_style_tags]
+        elsif tag.to_s.strip =~ /^<style/i && @options[:include_style_tags]
           @css_parser.add_block!(tag.inner_html, :base_uri => @base_url, :base_dir => @base_dir, :only_media_types => [:screen, :handheld])
         end
       end
@@ -335,10 +340,28 @@ protected
     end
   end
 
+  # here be deprecated methods
+  public
 
+  # Free native Nokogiri/libxml2 memory held by this instance.
+  #
+  # After calling +to_inline_css+ or +to_plain_text+, the Premailer instance
+  # retains live Nokogiri documents that pin native libxml2 memory. Ruby's GC
+  # cannot see this native memory pressure, so in high-throughput scenarios
+  # (e.g. email rendering in Sidekiq workers) native memory can accumulate
+  # unboundedly. Call +cleanup!+ when you are done with the instance to
+  # release that memory immediately.
+  #
+  # After calling this method the instance is no longer usable.
+  def cleanup!
+    @processed_doc&.unlink
+    @doc&.unlink
+    @doc = nil
+    @processed_doc = nil
+    @css_parser = nil
+    @unmergable_rules = nil
+  end
 
-# here be deprecated methods
-public
   # @private
   # @deprecated
   def local_uri?(uri) # :nodoc:
@@ -346,12 +369,12 @@ public
     Premailer.local_data?(uri)
   end
 
-# here be instance methods
+  # here be instance methods
 
   # @private
   def media_type_ok?(media_types)
     media_types = media_types.to_s
-    return true if media_types.nil? or media_types.empty?
+    return true if media_types.nil? || media_types.empty?
     media_types.split(/[\s]+|,/).any? { |media_type| media_type.strip =~ /screen|handheld|all/i }
   end
 
@@ -364,32 +387,32 @@ public
 
     begin
       current_host = @base_url.host
-    rescue
+    rescue StandardError
       current_host = nil
     end
 
-    $stderr.puts "Attempting to append_query_string: #{queries}" if @options[:verbose]
+    warn "Attempting to append_query_string: #{queries}" if @options[:verbose]
 
     doc.search('a').each do |el|
       href = el.attributes['href'].to_s.strip
-      next if href.nil? or href.empty?
+      next if href.nil? || href.empty?
 
-      next if /[\#\{\[\<\%]/.match?(href[0,1]) # don't bother with anchors or special-looking links
+      next if /[\#\{\[\<\%]/.match?(href[0, 1]) # don't bother with anchors or special-looking links
 
       begin
         href = Addressable::URI.parse(href)
 
-        if current_host and !href.host.nil? and href.host != current_host
-          $stderr.puts "Skipping append_query_string for: #{href.to_s} because host is no good" if @options[:verbose]
+        if current_host && !href.host.nil? && (href.host != current_host)
+          warn "Skipping append_query_string for: #{href} because host is no good" if @options[:verbose]
           next
         end
 
-        if href.scheme and href.scheme != 'http' and href.scheme != 'https'
-          puts "Skipping append_query_string for: #{href.to_s} because scheme is no good" if @options[:verbose]
+        if href.scheme && (href.scheme != 'http') && (href.scheme != 'https')
+          puts "Skipping append_query_string for: #{href} because scheme is no good" if @options[:verbose]
           next
         end
 
-        if href.query and not href.query.empty?
+        if href.query && !href.query.empty?
           amp = @options[:unescaped_ampersand] ? '&' : '&amp;'
           href.query = href.query + amp + queries
         else
@@ -398,19 +421,18 @@ public
 
         el['href'] = href.to_s
       rescue Addressable::URI::InvalidURIError => e
-        $stderr.puts "Skipping append_query_string for: #{href.to_s} (#{e.message})" if @options[:verbose]
+        warn "Skipping append_query_string for: #{href} (#{e.message})" if @options[:verbose]
         next
       end
-
     end
     doc
   end
 
   # Check for an XHTML doctype
-  def is_xhtml?
+  def xhtml?
     intro = @doc.to_xhtml.strip.split("\n")[0..2].join(' ')
     is_xhtml = !!(intro =~ /w3c\/\/[\s]*dtd[\s]+xhtml/i)
-    $stderr.puts "Is XHTML? #{is_xhtml.inspect}\nChecked:\n#{intro}" if @options[:debug]
+    warn "Is XHTML? #{is_xhtml.inspect}\nChecked:\n#{intro}" if @options[:debug]
     is_xhtml
   end
 
@@ -423,9 +445,8 @@ public
   #
   # Returns a document.
   def convert_inline_links(doc, base_uri) # :nodoc:
-    base_uri = Addressable::URI.parse(base_uri) unless base_uri.kind_of?(Addressable::URI)
+    base_uri = Addressable::URI.parse(base_uri) unless base_uri.is_a?(Addressable::URI)
 
-    append_qs = @options[:link_query_string] || ''
     escape_attrs = @options[:escape_url_attributes]
 
     ['href', 'src', 'background'].each do |attribute|
@@ -443,23 +464,23 @@ public
         if /^http/i.match?(tag.attributes[attribute].to_s)
           begin
             merged = Addressable::URI.parse(tag.attributes[attribute])
-          rescue; next; end
+          rescue StandardError; next; end
         else
           begin
             merged = Premailer.resolve_link(tag.attributes[attribute].to_s, base_uri)
-          rescue
+          rescue StandardError
             begin
               next unless escape_attrs
               merged = Premailer.resolve_link(Addressable::URI.escape(tag.attributes[attribute].to_s), base_uri)
-            rescue; end
+            rescue StandardError; end
           end
         end
 
         # make sure 'merged' is a URI
-        merged = Addressable::URI.parse(merged.to_s) unless merged.kind_of?(Addressable::URI)
+        merged = Addressable::URI.parse(merged.to_s) unless merged.is_a?(Addressable::URI)
         tag[attribute] = merged.to_s
-      end # end of each tag
-    end # end of each attrs
+      end
+    end
 
     doc.search("*[@style]").each do |el|
       el['style'] = CssParser.convert_uris(el.attributes['style'].to_s, base_uri)
@@ -468,22 +489,21 @@ public
   end
 
   # @private
-  def self.is_media_query?(media_types)
-    media_types && media_types.any?{|mt| mt.to_s.count('()') >= 2 }
+  def self.media_query?(media_types)
+    media_types&.any? { |mt| mt.to_s.count('()') >= 2 }
   end
 
   # @private
   def self.resolve_link(path, base_path) # :nodoc:
     path = +path
     path.strip!
-    resolved = nil
     if /\A(?:(https?|ftp|file):)\/\//i.match?(path)
       resolved = path
       Premailer.canonicalize(resolved)
-    elsif base_path.kind_of?(Addressable::URI)
+    elsif base_path.is_a?(Addressable::URI)
       resolved = base_path.join(path)
       Premailer.canonicalize(resolved)
-    elsif base_path.kind_of?(String) and base_path =~ /\A(?:(?:https?|ftp|file):)\/\//i
+    elsif base_path.is_a?(String) && base_path =~ (/\A(?:(?:https?|ftp|file):)\/\//i)
       resolved = Addressable::URI.parse(base_path)
       resolved = resolved.join(path)
       Premailer.canonicalize(resolved)
@@ -496,13 +516,13 @@ public
   #
   # IO objects return true, as do strings that look like URLs.
   def self.local_data?(data)
-    return false  if data.kind_of?(String) && data =~ /\A(?:(https?|ftp):)\/\//i
+    return false if data.is_a?(String) && data =~ /\A(?:(https?|ftp):)\/\//i
     true
   end
 
   # from http://www.ruby-forum.com/topic/140101
   def self.canonicalize(uri) # :nodoc:
-    u = uri.kind_of?(Addressable::URI) ? uri : Addressable::URI.parse(uri.to_s)
+    u = uri.is_a?(Addressable::URI) ? uri : Addressable::URI.parse(uri.to_s)
     u.normalize!
     u.to_s
   end
@@ -517,7 +537,7 @@ public
 
     # Get a list off CSS properties
     @processed_doc.search("*[@style]").each do |el|
-      style_url = el.attributes['style'].to_s.gsub(/([\w\-]+)[\s]*\:/i) do |s|
+      el.attributes['style'].to_s.gsub(/([\w\-]+)[\s]*:/i) do |_s|
         properties.push($1)
       end
     end
@@ -526,30 +546,42 @@ public
 
     property_support = @client_support['css_properties']
     properties.each do |prop|
-      if property_support.include?(prop) and
-          property_support[prop].include?('support') and
-          property_support[prop]['support'] >= @options[:warn_level]
-        warnings.push({:message => "#{prop} CSS property",
+      if property_support.include?(prop) &&
+          property_support[prop].include?('support') &&
+          (property_support[prop]['support'] >= @options[:warn_level])
+        warnings.push(
+          {
+            :message => "#{prop} CSS property",
             :level => WARN_LABEL[property_support[prop]['support']],
-            :clients => property_support[prop]['unsupported_in'].join(', ')})
+            :clients => property_support[prop]['unsupported_in'].join(', ')
+          }
+        )
       end
     end
 
     @client_support['attributes'].each do |attribute, data|
       next unless data['support'] >= @options[:warn_level]
       if @doc.search("*[@#{attribute}]").length > 0
-        warnings.push({:message => "#{attribute} HTML attribute",
+        warnings.push(
+          {
+            :message => "#{attribute} HTML attribute",
             :level => WARN_LABEL[data['support']],
-            :clients => data['unsupported_in'].join(', ')})
+            :clients => data['unsupported_in'].join(', ')
+          }
+        )
       end
     end
 
     @client_support['elements'].each do |element, data|
       next unless data['support'] >= @options[:warn_level]
       if @doc.search(element).length > 0
-        warnings.push({:message => "#{element} HTML element",
+        warnings.push(
+          {
+            :message => "#{element} HTML element",
             :level => WARN_LABEL[data['support']],
-            :clients => data['unsupported_in'].join(', ')})
+            :clients => data['unsupported_in'].join(', ')
+          }
+        )
       end
     end
 

data/lib/premailer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 class Premailer
   # Premailer version.
-  VERSION = '1.26.0'
+  VERSION = '1.28.0'
 end