premailer-plus 0.1.3

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,8 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+._*
+*~
+*.tmproj

data/LICENSE

@@ -0,0 +1,42 @@
+Premailer License
+
+Copyright (c) 2007 Alex Dunae
+
+Premailer is copyrighted free software by Alex Dunae (http://dunae.ca/).
+You can redistribute it and/or modify it under the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to the internet or an equivalent medium, or by 
+	  allowing the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may modify and include the part of the software into any other
+     software (possibly commercial) as long as clear acknowledgement and 
+     a link back to the original software (http://code.dunae.ca/premailer.web/)
+     is provided.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.textile

@@ -0,0 +1,43 @@
+h1. premailer-plus
+
+|*Misc. improvements by:*||Mike Green ("mike.is.green@gmail.com":mailto:mike.is.green@gmail.com)|
+|*Original Premailer By:*||Alex Dunae ("http://www.dunae.ca":http://www.dunae.ca)|
+
+Check out the Premailer web application at http://code.dunae.ca/premailer.web
+
+h2. Background
+
+Premailer Plus is my set of additions and corrections to Alex Dunae's excellent "Premailer":http://code.dunae.ca/premailer.web/ application. Premailer is "Preflight for HTML email", i.e. it takes your HTML code, and makes it compatible with most email clients. Email clients aren't like web browsers; their support for CSS is spotty and erratic, and they don't always render your code the way you'd expect. Premailer takes your CSS and moves it inline to each matched HTML element, and it displays warnings if you use code that's not well supported by email clients. "Campaign Monitor":http://www.campaignmonitor.com sponsors and uses Premailer to get your code ready for mass emails. It's a one of a kind, indispensible service, but I've always had a few gripes about the Premailer Rubygem, so I finally decided to fork the code and apply my fixes and improvements.
+
+h3. Problems with "Premailer Classic"
+
+I downloaded the Premailer gem so that I could rock the excellence of Premailer on my Mac instead of having to rely on an external service. There's even a TextMate bundle available that lets you Premailer you code right in the editor. But when I downloaded it, I found one glaring problem: *When you run Premailer from the command line, it throws an error when you give it a local file instead of a URL.* Kind of defeats the purpose.
+
+h3. Improvements in Premailer Plus
+
+* I fixed the command line script so that it no longer throws errors when you feed it a local file
+* New option to shorten the URLs of links in your plain text version
+** "Bit.ly":http://bit.ly
+* More to come!
+
+h2. Installation
+
+The easiest way to install Premailer Plus is to run the following code on your OS X or Linux terminal (should work on Windows too, but I'm not sure):
+
+<pre>
+	$ sudo gem install mikedamage-premailer-plus
+</pre>
+
+You can also clone this repository and run @rake build@ from the project root. Then run @sudo gem install ./pkg/premailer-plus*.gem@
+
+h2. Dependencies
+
+* "RubyGems":http://rubygems.rubyforge.org
+* "Hpricot":http://wiki.github.com/why/hpricot
+* "css-parser":http://code.dunae.ca/css_parser/
+* "text-reform":http://rubyforge.org/projects/text-format/
+* "Bitly4r":http://wiki.cantremember.com/Bitly4R/HomePage
+
+h2. Copyright
+
+Since I only improved Premailer's handling of local files and gave it the ability to shorten URL's, the copyright to this code is still held by Alex Dunae. I am only modifying and redistributing his code in compliance with the terms of Premailer's license.

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "premailer-plus"
+    gem.summary = %Q{Miscellaneous improvements and fixes to Alex Dunae's Premailer gem}
+    gem.email = "mike.is.green@gmail.com"
+    gem.homepage = "http://github.com/mikedamage/premailer-plus"
+    gem.authors = ["Mike Green"]
+
+		gem.add_dependency("hpricot", ">= 0.8.1")
+		gem.add_dependency("htmlentities", ">= 4.1.0")
+		gem.add_dependency("css_parser", ">= 0.9.0")
+		gem.add_dependency("text-reform", ">= 0.2.0")
+		
+		Jeweler::GemcutterTasks.new
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "premailer-plus #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 3

data/bin/premailer_plus

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+#
+# = Premailer Plus
+#
+# Miscellaneous improvements to Alex Dunae's Premailer gem
+
+require "optparse"
+require "optparse/time"
+require "ostruct"
+require "pathname"
+require File.join(File.dirname(__FILE__), "../lib/premailer")
+
+class PremailerApp
+	BANNER = <<-END
+Premailer Plus
+-----------------
+
+Usage:
+	FILE [options] inputfile outputfile
+	"inputfile" can be either a local file or a URL
+
+Options:
+END
+	
+	def initialize(args)
+		@args = args
+		@config = OpenStruct.new({
+			:plaintext => false,
+			:shorten_urls => false,
+			:base_url => '',
+			:infile => nil,
+			:outfile => '',
+			:querystring => '',
+			:warnings => false,
+			:verbose => true
+		})
+	end
+	
+	def run
+		if parse_options and get_arguments
+			@pm_opts = {}
+			@pm_opts.merge!({:base_url => @config.base_url}) unless @config.base_url.empty?
+			@pm_opts.merge!({:link_query_string => @config.querystring}) unless @config.querystring.empty?
+			@pm_opts.merge!({:shorten_urls => true}) if @config.shorten_urls
+			@premailer = Premailer.new(@config.infile.to_s, @pm_opts)
+			
+			write_premail_html
+			write_plain_text if @config.plaintext
+			show_warnings if @config.warnings
+		else
+			puts "Invalid options/arguments!"
+			exit 1
+		end
+	end
+	
+	private
+	def parse_options
+		opts = OptionParser.new
+		opts.banner = BANNER.gsub!(/FILE/, File.basename(__FILE__))
+		opts.on("-p", "--plaintext", "Output a plain-text version of the email in addition to HTML") { @config.plaintext = true }
+		opts.on("-s", "--shorten-urls", "Shorten URLs with Bit.ly in the plain-text version") { @config.shorten_urls = true }
+		opts.on("-b", "--baseurl URL", "Prepend this URL to links") {|url| @config.base_url = url }
+		opts.on("-q", "--querystring STRING", "Append this query string to link URLs") {|string| @config.querystring = string }
+		opts.on("-v", "--verbose", "Display status information during the pre-mailing process") { @config.verbose = true }
+		opts.on("-w", "--warnings", "Display CSS support warnings") { @config.warnings = true }
+		opts.on("-h", "--help", "Show this information") { puts opts; exit 0; }
+		true if opts.parse!(@args) rescue return false
+	end
+	
+	def get_arguments
+		if @args.nitems >= 2
+			@config.infile = Pathname.new(@args.shift)
+			@config.outfile = Pathname.new(@args.shift)
+			return true
+		else
+			return false
+		end
+	end
+	
+	def write_premail_html
+		puts "Converting HTML to inline CSS and saving as #{@config.outfile.basename.to_s}..." if @config.verbose
+		@config.outfile.open("w") do |file|
+			file.write(@premailer.to_inline_css)
+		end
+		puts "Done." if @config.verbose
+	end
+	
+	def write_plain_text
+		textfile = Pathname.new(File.join(@config.outfile.dirname.to_s, @config.outfile.basename.to_s.gsub(/\..+$/, ".txt")))
+		puts "Saving a plain-text version of your email as #{@config.outfile.basename.to_s.gsub(/\.html$/, '.txt')}..." if @config.verbose
+		puts "Shortening link URLs with Bit.ly..." if @config.verbose and @config.shorten_urls
+		textfile.open("w") do |file|
+			file.write(@premailer.to_plain_text)
+		end
+		puts "Done." if @config.verbose
+	end
+	
+	def show_warnings
+		puts "#{@premailer.warnings.nitems.to_s} warnings found:"
+		@premailer.warnings.each do |warning|
+			puts warning
+		end
+	end
+end
+
+app = PremailerApp.new(ARGV)
+app.run

data/lib/html_to_plain_text.rb

@@ -0,0 +1,61 @@
+require 'text/reform'
+require 'htmlentities'
+require 'bitly4r'
+
+# Support functions for Premailer
+module HtmlToPlainText
+
+  # Returns the text in UTF-8 format with all HTML tags removed
+  #
+  # TODO:
+  #  - add support for DL, OL
+  def convert_to_text(html, line_length, from_charset = 'UTF-8', shorten = false)
+    r = Text::Reform.new(:trim => true, 
+                         :squeeze => false, 
+                         :break => Text::Reform.break_wrap)
+		
+    txt = html
+		
+		bitly = shorten ? Bitly4R.Keyed("mikedamage", "R_abb45e99634386334b7ed6c8d081e80e") : nil
+		
+    he = HTMLEntities.new                                 # decode HTML entities
+
+    txt = he.decode(txt)
+
+    txt.gsub!(/<h([0-9]+)[^>]*>(.*)<\/h[0-9]+>/i) do |s|  # handle headings
+      hlevel = $1.to_i
+      htext = $2.gsub(/<\/?[^>]*>/i, '')                  # remove tags inside headings
+      hlength = (htext.length > line_length ? 
+                  line_length : 
+                  htext.length)
+
+      case hlevel
+        when 1                                            # H1
+          ('*' * hlength) + "\n" + htext + "\n" + ('*' * hlength) + "\n"
+        when 2                                            # H2
+          ('-' * hlength) + "\n" + htext + "\n" + ('-' * hlength) + "\n"
+        else                                              # H3-H6 are styled the same
+          htext + "\n" + ('-' * htext.length) + "\n"
+      end
+    end
+
+    txt.gsub!(/<a.*href=\"([^\"]*)\"[^>]*>(.*)<\/a>/i) do |s|   # links
+			if bitly
+				$2 + ' [' + bitly.shorten($1) + ']'
+			else
+				$2 + ' [' + $1 + ']'
+			end
+    end
+
+    txt.gsub!(/(<li[\s]+[^>]*>|<li>)/i, '  * ')           # unordered LIsts
+    txt.gsub!(/<\/p>/i, "\n\n")                           # paragraphs
+    
+    txt.gsub!(/<\/?[^>]*>/, '')                           # strip remaining tags
+    txt.gsub!(/\A[\s]+|[\s]+\Z|^[ \t]+/m, '')             # strip extra spaces
+    txt.gsub!(/[\n]{3,}/m, "\n\n")                        # tighten line breaks
+
+    txt = r.format(('[' * line_length), txt)   # wrap text
+    txt.gsub!(/^[\*][\s]/m, '  * ')                        # add spaces back to lists
+    txt
+  end
+end

data/lib/premailer.rb

@@ -0,0 +1,401 @@
+#!/usr/bin/ruby
+#
+# Premailer by Alex Dunae (dunae.ca, e-mail 'code' at the same domain), 2008
+# Version 1.5.0
+
+ENV["GEM_PATH"] = "/Library/Ruby/Gems/1.8"
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__), ''))
+
+require 'rubygems'
+require 'yaml'
+require 'open-uri'
+require 'hpricot'
+require 'css_parser'
+require 'tempfile'
+
+require 'html_to_plain_text'
+
+# Premailer processes HTML and CSS to improve e-mail deliverability.
+#
+# Premailer's main function is to render all CSS as inline <tt>style</tt> attributes using
+# the CssParser. It can also convert relative links to absolute links and check the 'safety' of 
+# CSS properties against a CSS support chart.
+#
+# = Example
+#
+#  premailer = Premailer.new(html_file, :warn_level => Premailer::Warnings::SAFE)
+#  premailer.parse!
+#  puts premailer.warnings.length.to_s + ' warnings found'
+class Premailer
+  include HtmlToPlainText
+  include CssParser
+
+  CLIENT_SUPPORT_FILE = File.dirname(__FILE__) + '/../misc/client_support.yaml'
+
+  RE_UNMERGABLE_SELECTORS = /(\:(visited|active|hover|focus|after|before|selection|target|first\-(line|letter))|^\@)/i
+  
+  # should also exclude :first-letter, etc...
+
+  # URI of the HTML file used
+  attr_reader   :html_file            
+
+  module Warnings
+    NONE = 0
+    SAFE = 1
+    POOR = 2
+    RISKY = 3
+  end
+  include Warnings
+
+  WARN_LABEL = %w(NONE SAFE POOR RISKY)
+
+  # Create a new Premailer object.
+  #
+  # +uri+ is the URL of the HTML file to process. Should be a string.
+  #
+  # ==== Options
+  # [+line_length+] Line length used by to_plain_text. Boolean, default is 65.
+  # [+warn_level+] What level of CSS compatibility warnings to show (see Warnings).
+  # [+link_query_string+] A string to append to every <a href=""> link.
+  def initialize(uri, options = {})
+    @options = {:warn_level => Warnings::SAFE, :line_length => 65, :link_query_string => nil, :base_url => nil, :shorten_urls => false}.merge(options)
+    @html_file = uri
+
+    
+    @is_local_file = true
+    if uri =~ /^(http|https|ftp)\:\/\//i
+      @is_local_file = false
+    end
+
+
+    @css_warnings = []
+
+    @css_parser = CssParser::Parser.new({:absolute_paths => true,
+                                         :import => true,
+                                         :io_exceptions => false
+                                        })
+    
+    @doc, @html_charset = load_html(@html_file)
+    
+    if @is_local_file and @options[:base_url]
+      @doc = convert_inline_links(@doc, @options[:base_url])
+    elsif not @is_local_file
+      @doc = convert_inline_links(@doc, @html_file)
+    end
+    load_css_from_html!
+  end
+
+  # Array containing a hash of CSS warnings.
+  def warnings
+    return [] if @options[:warn_level] == Warnings::NONE
+    @css_warnings = check_client_support if @css_warnings.empty?
+    @css_warnings
+  end
+
+  # Returns the original HTML as a string.
+  def to_s
+    @doc.to_html
+  end
+
+  # Returns the document with all HTML tags removed.
+  def to_plain_text
+    html_src = ''
+    begin
+      html_src = @doc.search("body").innerHTML
+    rescue
+      html_src = @doc.to_html
+    end
+		if @options[:shorten_urls]
+    	convert_to_text(html_src, @options[:line_length], @html_charset, true)
+		else
+			convert_to_text(html_src, @options[:line_length], @html_charset, false)
+		end
+  end
+
+  # Merge CSS into the HTML document.
+  #
+  # Returns a string.
+  def to_inline_css
+    doc = @doc
+    unmergable_rules = CssParser::Parser.new
+    
+    # Give all styles already in style attributes a specificity of 1000 
+    # per http://www.w3.org/TR/CSS21/cascade.html#specificity
+    doc.search("*[@style]").each do |el| 
+      el['style'] = '[SPEC=1000[' + el.attributes['style'] + ']]'
+    end
+
+    # Iterate through the rules and merge them into the HTML
+    @css_parser.each_selector(:all) do |selector, declaration, specificity|
+      # Save un-mergable rules separately
+      selector.gsub!(/:link([\s]|$)+/i, '')
+
+      # Convert element names to lower case
+      selector.gsub!(/([\s]|^)([\w]+)/) {|m| $1.to_s + $2.to_s.downcase }
+
+      if selector =~ RE_UNMERGABLE_SELECTORS
+        unmergable_rules.add_rule_set!(RuleSet.new(selector, declaration))
+      else
+        
+        doc.search(selector) do |el|
+          if el.elem?
+            # Add a style attribute or append to the existing one  
+            block = "[SPEC=#{specificity}[#{declaration}]]"
+            el['style'] = (el.attributes['style'] ||= '') + ' ' + block
+          end
+        end
+      end
+    end
+
+    # Read <style> attributes and perform folding
+    doc.search("*[@style]").each do |el|
+      style = el.attributes['style'].to_s
+      
+      declarations = []
+
+      style.scan(/\[SPEC\=([\d]+)\[(.[^\]\]]*)\]\]/).each do |declaration|
+        rs = RuleSet.new(nil, declaration[1].to_s, declaration[0].to_i)
+        declarations << rs
+      end
+
+      # Perform style folding and save
+      merged = CssParser.merge(declarations)
+
+      el['style'] = Premailer.escape_string(merged.declarations_to_s)
+    end
+
+    doc = write_unmergable_css_rules(doc, unmergable_rules)
+    
+    #doc = add_body_imposter(doc)
+    
+    doc.to_html
+  end
+
+
+protected  
+  # Load the HTML file and convert it into an Hpricot document.
+  #
+  # Returns an Hpricot document and a string with the HTML file's character set.
+  def load_html(uri)
+		if @is_local_file
+			Hpricot(File.open(uri, "r") {|f| f.read })
+		else
+			@temp_file = Tempfile.new("premailer_plus")
+			@temp_file.write(open(uri).read)
+			@temp_file.close
+			@is_local_file = true
+      Hpricot(@temp_file.open.read)
+		end
+  end
+
+  # Load CSS included in <tt>style</tt> and <tt>link</tt> tags from an HTML document.
+  def load_css_from_html!
+    if tags = @doc.search("link[@rel='stylesheet'], style")
+      tags.each do |tag|
+        if tag.to_s.strip =~ /^\<link/i and tag.attributes['href']
+          if media_type_ok?(tag.attributes['media'])
+            link_uri = Premailer.resolve_link(tag.attributes['href'].to_s, @html_file)
+            if @is_local_file
+              css_block = ''
+              File.open(link_uri, "r") do |file|
+                while line = file.gets
+                  css_block << line
+                end
+              end
+              @css_parser.add_block!(css_block, {:base_uri => @html_file})
+            else
+              @css_parser.load_uri!(link_uri)
+            end
+          end
+        elsif tag.to_s.strip =~ /^\<style/i          
+          @css_parser.add_block!(tag.innerHTML, :base_uri => URI.parse(@html_file))
+        end
+      end
+      tags.remove
+    end
+  end
+
+  def media_type_ok?(media_types)
+    return media_types.split(/[\s]+|,/).any? { |media_type| media_type.strip =~ /screen|handheld|all/i }
+  rescue
+    return true
+  end
+
+  # Create a <tt>style</tt> element with un-mergable rules (e.g. <tt>:hover</tt>) 
+  # and write it into the <tt>body</tt>.
+  #
+  # <tt>doc</tt> is an Hpricot document and <tt>unmergable_css_rules</tt> is a Css::RuleSet.
+  #
+  # Returns an Hpricot document.
+  def write_unmergable_css_rules(doc, unmergable_rules)
+    styles = ''
+    unmergable_rules.each_selector(:all, :force_important => true) do |selector, declarations, specificity|
+      styles += "#{selector} { #{declarations} }\n"
+    end    
+    unless styles.empty?
+      style_tag = "\n<style type=\"text/css\">\n#{styles}</style>\n"
+      doc.search("head").append(style_tag)
+    end
+    doc
+  end
+
+  # Convert relative links to absolute links.
+  #
+  # Processes <tt>href</tt> <tt>src</tt> and <tt>background</tt> attributes 
+  # as well as CSS <tt>url()</tt> declarations found in inline <tt>style</tt> attributes.
+  #
+  # <tt>doc</tt> is an Hpricot document and <tt>base_uri</tt> is either a string or a URI.
+  #
+  # Returns an Hpricot document.
+  def convert_inline_links(doc, base_uri)
+    base_uri = URI.parse(base_uri) unless base_uri.kind_of?(URI)
+
+    ['href', 'src', 'background'].each do |attribute|
+      
+      tags = doc.search("*[@#{attribute}]")
+      append_qs = @options[:link_query_string] ||= ''
+      unless tags.empty?
+        tags.each do |tag|
+          unless tag.attributes[attribute] =~ /^(\{|\[|<|\#)/i
+            if tag.attributes[attribute] =~ /^http/i
+              begin
+                merged = URI.parse(tag.attributes[attribute])
+              rescue
+                next
+              end
+            else
+              begin
+                merged = Premailer.resolve_link(tag.attributes[attribute].to_s, base_uri.merge)
+              rescue
+                begin
+                  merged = Premailer.resolve_link(URI.escape(tag.attributes[attribute].to_s), base_uri.merge)
+                #  merged = base_uri.merge(URI.escape(tag.attributes[attribute].to_s))
+                rescue; end
+              end
+            end # end of relative urls only
+
+            if tag.name =~ /^a$/i and not append_qs.empty?
+              if merged.query
+                merged.query = merged.query + '&' + append_qs
+              else
+                merged.query = append_qs
+              end
+            end
+            tag[attribute] = merged
+            #puts merged.inspect
+          end # end of skipping special chars
+
+
+        end # end of each tag
+      end # end of empty
+    end # end of attrs
+
+    doc.search("*[@style]").each do |el|
+      el['style'] = CssParser.convert_uris(el.attributes['style'].to_s, base_uri)
+    end
+    doc
+  end
+
+  def self.escape_string(str)
+    str.gsub(/"/, "'")
+  end
+  
+  def self.resolve_link(path, base_path)
+    if base_path.kind_of?(URI)
+      base_path.merge!(path)
+      return Premailer.canonicalize(base_path)    
+    elsif base_path.kind_of?(String) and base_path =~ /^(http[s]?|ftp):\/\//i
+      base_uri = URI.parse(base_path)
+      base_uri.merge!(path)
+      return Premailer.canonicalize(base_uri)
+    else
+
+      return File.expand_path(path, File.dirname(base_path))
+    end
+  end
+
+  # from http://www.ruby-forum.com/topic/140101
+  def self.canonicalize(uri)
+     u = uri.kind_of?(URI) ? uri : URI.parse(uri.to_s)
+     u.normalize!
+     newpath = u.path
+     while newpath.gsub!(%r{([^/]+)/\.\./?}) { |match|
+                $1 == '..' ? match : ''
+              } do end
+     newpath = newpath.gsub(%r{/\./}, '/').sub(%r{/\.\z}, '/')
+     u.path = newpath
+     u.to_s
+  end
+
+
+
+  def add_body_imposter(doc)
+    newdoc = doc
+    if body_tag = newdoc.at("body") and body_tag.attributes["style"]
+      body_html = body_tag.inner_html
+      body_tag.inner_html = "\n<div id=\"premailer_body_wrapper\">\n#{body_html}\n</div>\n"
+      if body_tag.attributes["style"]
+        newdoc.at("#premailer_body_wrapper")["style"] = body_tag.attributes["style"].to_s
+        newdoc.at("body")["style"] = "margin: 0; padding: 0;"
+      end
+      
+    end
+    return newdoc
+  rescue
+    return doc
+  end
+
+
+  # Check <tt>CLIENT_SUPPORT_FILE</tt> for any CSS warnings
+  def check_client_support
+    @client_support = @client_support ||= YAML::load(File.open(CLIENT_SUPPORT_FILE))
+
+    warnings = []
+    properties = []
+    
+    # Get a list off CSS properties
+    @doc.search("*[@style]").each do |el|
+      style_url = el.attributes['style'].gsub(/([\w\-]+)[\s]*\:/i) do |s|
+        properties.push($1)
+      end
+    end
+
+    properties.uniq!
+
+    property_support = @client_support['css_properties']
+    properties.each do |prop|
+      if property_support.include?(prop) and 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(', ')})
+      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", 
+                       :level => WARN_LABEL[property_support[prop]['support']], 
+                       :clients => property_support[prop]['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", 
+                       :level => WARN_LABEL[property_support[prop]['support']], 
+                       :clients => property_support[prop]['unsupported_in'].join(', ')})
+      end
+    end
+
+
+
+
+    
+    return warnings
+  end
+end
+
+