html_validation 0.0.1

data/.document

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

data/.gitignore

@@ -0,0 +1,4 @@
+/pkg
+.redcar/*
+spec/.validation/*
+.rspec

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,23 @@
+source "http://rubygems.org"
+
+gemspec
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec"
+  gem "bundler"  
+end
+
+gem 'rdoc'
+gem 'thor'
+
+# Unix Rubies (OSX, Linux)  
+platform :ruby do
+  
+end
+
+# Windows Rubies (RubyInstaller)  
+platforms :mswin, :mingw do
+  
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    html_validation (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    json (1.7.7)
+    rdoc (4.0.0)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+    thor (0.17.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  html_validation!
+  rdoc
+  rspec
+  thor

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 - 2013 Eric Beland
+
+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.rdoc

@@ -0,0 +1,113 @@
+= HTML Validation
+
+html_validation helps you validate, track, and fix or accept HTML validation
+issues without depending on an external web service. 
+The idea is to take an HTML markup string associated 
+with a particular resource (file or URL) and validate it locally. 
+No web connection or dependency on a 3rd party web service is involved--just an 
+install of HTML Tidy, which is supported by the W3C. An RSPec matcher is included.
+
+HTML Validation is intended to be used in acceptance tests, test suites or rake 
+tasks to alert you to changes in your html's validity so you can fix them, or 
+barring that, review and accept any errors and warnings. 
+
+== HTML 5
+
+The current (as of March 2013) default version of Tidy doesn't support HTML 5.
+To get HTML 5 support, install this fork of tidy:  https://github.com/w3c/tidy-html5 
+Download the repo as a zip file and extract somewhere, then follow the instructions 
+given on the page (using sudo for make commands if on Linux).
+
+Be sure to get rid of the old tidy first if you have it already.
+
+Redhat/Fedora:    sudo yum erase tidy
+Ubuntu:           sudo apt-get remove tidy
+OS X:             sudo port uninstall tidy
+
+On linux/OS X machines, confirm the right installation path shows up with:  which tidy
+
+== RSpec Setup / Usage:
+    Add to spec/spec_helper.rb:  
+ 
+    require 'html_validation'
+    include PageValidations
+
+    Now, within your Integration Tests, you can do this: 
+
+    page.should have_valid_html
+
+    It can be convenient to see the html printed in the RSpec failure messages.
+    To enable this feature:
+
+    HaveValidHTML.show_html_in_failures = true
+
+== Non-RSpec Usage:
+
+    require 'html_validation'
+
+
+    h = HTMLValidation.new
+    v = h.validation("<html>foo</html>", 'http://somesite.com/index.html')
+    
+    # Note: The second argument (resource) just serves as an identifier used to 
+    # name our results files, and no data is actually retrieved for you from on the URL!
+
+    v.valid?
+    -> false
+    
+    v.exceptions
+    ->  line 1 column 1 - Warning: missing <!DOCTYPE> declaration
+    ->  line 1 column 9 - Warning: plain text isn't allowed in <head> elements
+    ->  line 1 column 9 - Warning: inserting missing 'title' element
+  
+    v.accept!
+    
+    v.valid?
+    -> true
+	
+  # Note: after the exceptions string has been accepted, the exceptions 
+  # are still available in v.exceptions even though valid? will return true.
+
+  # The exception string is treated and matched as a whole. The current 
+  # implementation does not allow partial acceptance of individual
+  # results in a result string. 
+    
+== Accepting Errors
+    
+    The HTML Validation gem stores failure data per-resource. The results are stored
+    in the data_folder. Typically this is the default folder: spec/.validation.
+    After a validation fails, run the thor task to accept or reject validation exceptions.
+
+    From your project's root folder, run:    thor validation:review 
+    
+    Note, if you configure an alternate data_folder, you may pass it as an option
+    to the Thor task.
+
+   
+== NOTES
+    
+    This is untested on Windows as I don't have access to a Windows machine at the moment. 
+    It is written so it could (probably) work on Windows. Pull requests in this area would
+    be welcomed.  
+                                   
+== Requirements
+
+    HTML Tidy needs to be either installed at /usr/bin/tidy or on the PATH.
+
+
+== Contributing to html_validation
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.   
+
+
+=== Running the tests
+
+    After tidy has been installed, in the gem folder, run:  rspec spec
+
+Copyright (c) 2012 Eric Beland. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/html_validation.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/html_validation/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Eric Beland"]
+  gem.email         = ["ebeland@gmail.com"]
+  gem.description   = %q{HTML Validation lets you validate html locally. Lets you build html validation into your test suite, but break the rules if you must.}
+  gem.summary       = %q{Local HTML validation for tests and RSpec. }
+  gem.homepage      = "https://github.com/ericbeland/html_validation"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "html_validation"
+  gem.require_paths = ["lib"]
+  gem.version       = PageValidations::HTML_VALIDATOR_VERSION
+end

data/lib/html_validation/have_valid_html.rb

@@ -0,0 +1,44 @@
+require 'html_validation'
+
+# This is a sample matcher for use with Rspec and Capybara. 
+# https://github.com/jnicklas/capybara 
+# keep this in spec/support/matchers
+module PageValidations
+  
+  class HaveValidHTML
+ 
+    # This is the matching method called by RSpec
+    # The response is passed in as an argument when you do this:
+    # page.should have_valid_html
+  
+    @@show_html_in_failures = false
+ 
+    def self.show_html_in_failures=(val)
+      @@show_html_in_failures = val
+    end
+  
+    def matches?(page)
+      h  = HTMLValidation.new
+      @v = h.validation(page.body, page.current_url)
+      @v.valid?
+    end
+  
+    def description
+      "Have valid html"
+    end
+
+    def failure_message_for_should
+      "#{@v.resource} Invalid html (fix or run rake html_validation task to add exceptions)\n#{@v.resource} exceptions:\n #{@v.exceptions}\n\n #{@v.html if @@show_html_in_failures}"
+    end
+  
+    def failure_message_for_should_not
+      "#{@v.resource} Expected valid? to fail but didn't. Did you accidentally accept these html validation errors?  \n#{@v.resource} exceptions:\n #{@v.exceptions}\n\n #{@v.html if @@show_html_in_failures}"
+    end  
+  
+  end
+
+  def have_valid_html
+    HaveValidHTML.new
+  end
+
+end

data/lib/html_validation/html_validation_matcher.rb

@@ -0,0 +1,21 @@
+# the item to include to get the RSPec matcher(s)
+
+require File.expand_path(File.join(File.dirname(__FILE__),  'have_valid_html'))
+
+module HTMLValidationMatcher
+  @@data_path = nil  
+  
+  def self.included(base)
+    # get path of including file, which should be in the /spec folder
+    @@data_path, = File.expand_path(File.dirname(caller[0].partition(":")[0]))      
+  end
+
+  def self.data_path
+    @@data_path
+  end    
+  
+  def self.data_path=(path)
+    @@data_path = path
+  end
+  
+end

data/lib/html_validation/html_validation_result.rb

@@ -0,0 +1,93 @@
+require 'open3'
+
+class HTMLValidationResult
+  attr_accessor :resource, :html, :exceptions
+    
+  include PageValidations
+  # valid options[:tidy_opts]
+  def initialize(resource, html, datapath, options={})
+    @resource           = resource
+    @html               = html
+    @exceptions         = ''
+    @datapath           = datapath
+    @tidyopts           = options[:tidy_opts] || "-qi"
+	  @ignore_proprietary = options[:ignore_proprietary] 
+    valid?
+  end
+
+  # takes a .url and loads the data into this object
+  def self.load_from_files(filepath)
+    resource  = File.open("#{filepath}.resource.txt", 'r').read
+    html      = File.open("#{filepath}.html.txt", 'r').read
+	  HTMLValidationResult.new(resource, html, filepath)
+  end
+  
+  # Validates an html string using html tidy. If there are no warnings or exceptions, or 
+  # there is a previously accepted exception string that matches exactly, valid? returns true
+  # Line numbers of exceptions are likely to change with any edit, so our validation 
+  # compares the exception strings with the lines and columns removed. Name can be a filename,
+  # file system path, or url, so long it is uniquely associated with the passed in html.
+  def valid?
+    @exceptions = validate    
+    File.delete(data_path("accepted")) if File.exists?(data_path("accepted")) if @exceptions == ''     
+    valid = (filter(@exceptions) == '' or accepted?(@exceptions))   
+    save_html_and_exceptions    
+    valid
+  end
+
+  # Saves the exception string for the given url or file path. When next run, if the exception
+  # string is identical, valid? will return true. Note that #exceptions will still list the 
+  # exception string, though, even if it is an accepted exception string.
+  def accept!    
+    File.open(data_path("accepted"), 'w') {|f| f.write(@exceptions) }
+  end
+  
+  private
+  # We specifically prefer /usr/bin/tidy by default on *nix as there is another "tidy" programs
+  # that could end up earlier on the path.  On snow leopard, tidy was installed at this location 
+  # for me by default.
+  def tidy_command
+    is_windows = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+    bin = (is_windows or !File.exists?("/usr/bin/tidy")) ? 'tidy' : '/usr/bin/tidy'
+    "#{bin} #{@tidyopts}"
+  end
+    
+  # get the filename for storing a type of data
+  def data_path(filetype)
+    "#{@datapath}.#{filetype}.txt"
+  end
+
+  def save_html_and_exceptions
+    File.open(data_path("html"), 'w')       {|f| f.write(@html) }
+    File.open(data_path("resource"), 'w')   {|f| f.write(@resource) } 
+    File.open(data_path("exceptions"), 'w') {|f| f.write(@exceptions) }       
+  end     
+
+    # have we previously accepted this exact string for this path?
+  def accepted?(exception_str)
+    exception_str = filter(exception_str)
+    File.exists?(data_path('accepted')) ? filter(File.open(data_path('accepted'),"r").read) == exception_str : false
+  end
+  
+  # Line numbers of exceptions are likely to change with any minor edit, so our validation 
+  # compares the result strings with the lines and columns removed. This means that 
+  # if the errors change position in the file (up or down b/c you add or remove code), 
+  # accepted exception strings will remain valid.
+  def filter(str)
+	  str.gsub!(/^line.*trimming empty.*\n/, '')  # the messages about empty are overzealous, and not invalid
+	  str.gsub!(/^line.*proprietary.*\n/, '') if @ignore_proprietary # if you use IE only attributes like wrap, or spellcheck or things not in standard	  
+    str.gsub(/line [0-9]+ column [0-9]+ -/, '')	
+   # /line [0-9]+ column [0-9]+ - / +  =~ "line 1 column 1 - Warning: missing <!DOCTYPE> declaration"
+  end
+      
+  def validate
+    stdin, stdout, stderr = Open3.popen3(tidy_command)
+    stdin.puts @html
+    stdin.close
+    stdout.close
+    result = stderr.read
+    stderr.close
+    result
+  end
+  
+end

data/lib/html_validation/version.rb

@@ -0,0 +1,3 @@
+module PageValidations
+  HTML_VALIDATOR_VERSION = "0.0.1"
+end

data/lib/html_validation.rb

@@ -0,0 +1,82 @@
+# == HTML Validation
+# HTLM Acceptance helps you watch and come to terms with your HTML's validity, or lack thereof.  
+# The idea is to take an html markup string associated with a particular path (file or URL),
+# and validate it. It is intended to be used in acceptance tests, test suites or a rake task
+# to alert you to changes in your html's validity so you can fix them, or barring that, review and accept
+# errors and warnings. 
+
+# ==Resource paths
+# When calling the validation routine, a path, or URL is passed. This is used internally to name 
+# the resulting validation output files.
+
+# NOTE: HTMLValidation never retreives html or reads in files *for* you. It doesn't read files, or call 
+# passed URL's. The purpose of passing a resource path is to give the test a name which saved exceptions 
+# can be stored against and compared to. In theory, the resource could be any distinct string, meaningful or not.
+
+# If the resource (URL or file) has a saved exception string and it matches, the validation passes. 
+# The user can use a rake task can run this manually and upd  ate the accepted exception string.
+
+require 'rbconfig'
+
+require File.expand_path(File.join(File.dirname(__FILE__),  'html_validation/html_validation_result'))
+require File.expand_path(File.join(File.dirname(__FILE__),  'html_validation/html_validation_matcher'))
+
+module PageValidations
+  
+  class HTMLValidation
+    
+    # The data_folder is where we store our output. options[:tidyopts], which defaults to "-qi"
+    # can be used to override the command line options to html tidy.  On *nix, man tidy to see
+    # what else you might use for this string instead of "-qi", however "-qi" is probably what 
+    # you want 95% of the time.
+  
+    # You may also pass :ignore_proprietary => true as an option to suppress messages like: 
+    #  line 1 column 176 - Warning: <textarea> proprietary attribute "wrap"
+    #  line 1 column 176 - Warning: <textarea> proprietary attribute "spellcheck"
+  
+    # It may be useful to pass a subfolder in your project as the data_folder, so your
+    # HTML Validation status and validation results are stored along with your source. 
+    def initialize(folder_for_data = nil, options = {})
+      self.data_folder = folder_for_data || default_result_file_path
+      @options         = options
+    end
+
+    # For each stored exception, yield an HTMLValidationResult object to allow the user to 
+    # call .accept! on the exception if it is OK.  
+    def each_exception
+      Dir.chdir(@data_folder)
+      Dir.glob("*.exceptions.txt").each do |file|
+        if File.open(File.join(@data_folder, file), 'r').read != ''
+          yield HTMLValidationResult.load_from_files(file.gsub('.exceptions.txt',''))
+        end
+      end
+    end
+  
+    def validation(html, resource)
+      resource_data_path = File.join(@data_folder, filenameize(resource))
+      HTMLValidationResult.new(resource, html, resource_data_path, @options)
+    end
+  
+    def data_folder=(path)
+      FileUtils.mkdir_p(path)   
+      @data_folder = path                          
+    end
+  
+    def default_result_file_path
+      posix = RbConfig::CONFIG['host_os'] =~ /(darwin|linux)/
+      rootpath = Rails.root if defined?(Rails)
+      rootpath ||= HTMLValidationMatcher.data_path if HTMLValidationMatcher.data_path    
+      rootpath ||= posix ? '/tmp/' : "c:\\tmp\\"
+      File.join(rootpath, '.validation')
+    end
+  
+    private
+  
+    # Takes a url or filepath qne trims and sanitizes it for use as a filename.
+    def filenameize(path)
+      path.gsub!(/www.|^(http:\/\/|\/|C:\\)/, '')
+      path.gsub(/[^0-9A-Za-z.]/, '_')  
+    end
+  
+  end
+end

data/lib/tasks/validation.thor

@@ -0,0 +1,27 @@
+#!/usr/bin/env thor
+require  File.expand_path(File.join(File.dirname(__FILE__), '..', 'html_validation'))
+
+class Validation < Thor
+  include PageValidations
+  desc "review", "Review and Accept (or fix and rerun) HTML Validation errors"
+  
+  method_option :data_path, :aliases => "-d", :desc => "Optional custom data path (if not default of /spec/.validate)"
+  def review
+    data_path = options[:data_path] || File.join(Dir.getwd, 'spec', '.validation')
+    $stdout.puts "Reviewing validation results in: #{data_path}"
+  
+    HTMLValidation.new(data_path).each_exception do |result|
+      $stdout.puts "Validation exceptions for: #{result.resource}:\n#{result.exceptions}" 
+      $stdout.puts "Accept (y)es (n)o or (q)uit"
+      sin = $stdin.gets
+      if sin[0].downcase == 'y'
+        result.accept! 
+        $stdout.puts "Accepted!"
+      else
+        $stdout.puts "Rejected!"
+      end
+      exit if sin.downcase == 'exit' or sin.downcase == 'quit' or sin.downcase == 'q'
+    end
+    $stdout.puts "HTML Validation Acceptance completed"
+  end
+end

data/spec/html_validator_matcher_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'html_validation/have_valid_html'
+
+describe "HTMLValidationRSpecMatcher" do
+    
+  before(:each) do
+     @page = double("page")
+  end
+
+  it "should check page object with the matcher for valid HTML and pass valid html" do
+    @page.stub :html => good_html
+    @page.stub :body => good_html
+    @page.stub :current_url => 'http://www.fake.com/good_page'
+    @page.should have_valid_html
+  end
+  
+   it "should check page object with the matcher for valid HTML and fail bad HTML" do
+    @page.stub :html => bad_html
+    @page.stub :body => bad_html
+    @page.stub :current_url => 'http://www.fake.com/bad_page'
+    @page.should_not have_valid_html
+  end
+  
+  
+  private
+
+  def bad_html
+    '<html><title>the title<title></head><body><p>blah blah</body></html>'
+  end
+  
+  def good_html
+    '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html><title>the title</title></head><body><p>a paragraph</p></body></html>'
+  end
+    
+  def tmp_path
+    is_windows = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+    is_windows ? 'c:\temp\validation' : '/tmp/validation'
+  end
+  
+  # clean our temp dir without killing it
+  def clean_dir(dir)
+    Dir.chdir(dir)
+    Dir.glob('*').each {|f| FileUtils.rm f }
+  end
+  
+end

data/spec/html_validator_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+  
+describe "HTMLValidation" do
+  
+  before(:each) do
+    FileUtils.mkdir tmp_path if !File.exists?('/tmp/validation')
+    @h = HTMLValidation.new('/tmp/validation')    
+  end
+  
+  it "should return false for invalid xml" do
+    result = @h.validation(bad_html, "http://myothersite.com").valid?.should be_false
+  end
+  
+  it "should return true for valid html" do
+    result = @h.validation(good_html, "http://mysite.com").valid?.should be_true
+  end
+  
+  it "should have an exception string for invalid xml" do
+    result = @h.validation(bad_html, "http://myfavoritesite.com")
+    (result.exceptions.empty?).should be_false
+  end
+  
+  it "should return true for valid? if exceptions are accepted" do
+    result = @h.validation(bad_html, "http://mynewsite.com")
+    result.accept!
+    result = @h.validation(bad_html, "http://mynewsite.com").valid?.should be_true
+  end
+  
+  it "should show no exceptions for a truly valid file" do
+    result = @h.validation(good_html, "http://mybestsite.com")
+    (result.exceptions == '').should be_true
+  end
+  
+  it "should still show exceptions when returning valid for an accepted exception string" do
+    result = @h.validation(bad_html, "http://myworstsite.com")
+    result.accept!
+    result = @h.validation(bad_html, "http://myworstsite.com")
+    result.valid?.should be_true
+    (result.exceptions.length == 0).should be_false
+  end
+  
+  it "should reset exceptions after each call to valid?" do
+    result = @h.validation(bad_html, "http://myuglysite.com")
+    result = @h.validation(good_html, "http://myuglysite.com")
+    (result.exceptions.length == 0).should be_true
+    result.valid?.should be_true
+  end
+  
+  it "should reset accepted exceptions string after seeing valid html for a path" do
+    result = @h.validation(bad_html, "http://notmysite.com")
+    result.accept!
+    result = @h.validation(bad_html, "http://notmysite.com").valid?.should be_true
+    # now we see valid, so we should reset
+    result = @h.validation(good_html, "http://notmysite.com").valid?.should be_true
+    result = @h.validation(bad_html, "http://notmysite.com").valid?.should be_false
+  end
+  
+  it "should not pass a different non-accepted exception" do
+    result = @h.validation(bad_html, "http://mycoolsite.com")
+    result.accept!
+    result = @h.validation("<html></body></html>", "http://mycoolsite.com").valid?.should be_false    
+  end
+  
+  it "should ignore proprietary tags when ignore_proprietary is passed" do
+	  html_with_proprietary=good_html.gsub('<body>','<body><textarea wrap="true" spellcheck="true">hi</textarea>')	
+	  result = @h.validation(html_with_proprietary, "http://mycrosoft.com")
+	  result.valid?.should be_false		
+	  @h = HTMLValidation.new('/tmp/validation', :ignore_proprietary=>true)
+	  result = @h.validation(html_with_proprietary, "http://mycrosoft.com")
+	  result.valid?.should be_true
+  end
+  
+  it "should work without a data path being manually set" do
+     h = HTMLValidation.new()    
+     result = h.validation(good_html, "http://mybestsite.com")
+    (result.exceptions == '').should be_true        
+  end
+  
+  
+  describe "when launching HTML Tidy" do
+    
+    it "should let me pass different Tidy command line options" do
+      @h = HTMLValidation.new('/tmp/validation', :tidy_opts=>"-e")
+      result = @h.validation("<html>foo", 'c:\mycoolapp\somesite.html')
+      result.exceptions.include?("were found!").should be_true
+      @h = HTMLValidation.new('/tmp/validation')
+      result = @h.validation("<html>foo", 'c:\mycoolapp\somesite.html')
+      result.exceptions.include?("were found!").should be_false  
+	  end
+    
+  end
+  
+  describe "when walking exception results" do
+  
+    it "should yield loaded exception results" do	
+      @h = HTMLValidation.new('/tmp/validation')
+      result = @h.validation("<html>foo", 'c:\evencooler.com\somesite.html')  
+      had_exceptions = false
+      @h.each_exception do |e|
+        had_exceptions = true
+          e.is_a?(HTMLValidationResult).should be_true
+          (e.resource.length > 0).should be_true
+          (e.html.length > 0).should be_true
+        end	
+      had_exceptions.should be_true
+	  end
+ 
+  end
+  
+  
+  private
+  
+  def bad_html
+    '<html><title>the title<title></head><body><p>blah blah</body></html>'
+  end
+  
+  def good_html
+    '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html><title>the title</title></head><body><p>a paragraph</p></body></html>'
+  end
+    
+  def tmp_path
+    is_windows = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+    is_windows ? 'c:\temp\validation' : '/tmp/validation'
+  end
+  
+  # clean our temp dir without killing it
+  def clean_dir(dir)
+    Dir.chdir(dir)
+    Dir.glob('*').each {|f| FileUtils.rm f }
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'html_validation'
+
+include PageValidations
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: html_validation
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Eric Beland
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-16 00:00:00.000000000 Z
+dependencies: []
+description: HTML Validation lets you validate html locally. Lets you build html validation
+  into your test suite, but break the rules if you must.
+email:
+- ebeland@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- html_validation.gemspec
+- lib/html_validation.rb
+- lib/html_validation/have_valid_html.rb
+- lib/html_validation/html_validation_matcher.rb
+- lib/html_validation/html_validation_result.rb
+- lib/html_validation/version.rb
+- lib/tasks/validation.thor
+- spec/html_validator_matcher_spec.rb
+- spec/html_validator_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ericbeland/html_validation
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Local HTML validation for tests and RSpec.
+test_files:
+- spec/html_validator_matcher_spec.rb
+- spec/html_validator_spec.rb
+- spec/spec_helper.rb