mikedamage-premailer-plus 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Mike Green
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,41 @@
+h1. premailer-plus
+
+|*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)|
+
+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 @sudo rake install@ from the project root.
+
+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
+
+Copyright (C) 2009 Mike Green. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+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 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: 0

data/bin/premailer_plus

@@ -0,0 +1,108 @@
+#!/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
+	
+	
+	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 = DATA.read.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 if your input is a local file.") {|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
+
+__END__
+Premailer Plus
+-----------------
+
+Usage:
+	FILE [options] inputfile outputfile
+	"inputfile" can be either a local file or a URL
+	
+Options:

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,396 @@
+#!/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 '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
+      Hpricot(open(uri))
+		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
+
+