ccls-html_test 0.3.5

data/lib/url_checker.rb

@@ -0,0 +1,147 @@
+module Html
+	module Test
+		class InvalidUrl < RuntimeError; end
+
+		class UrlChecker
+			attr_accessor :request, :response, :params
+			
+			include Html::Test::UrlSelector		
+			
+			def initialize(controller)
+				self.request = controller.request
+				self.response = controller.response
+				self.params = controller.params
+			end
+			
+			def check_urls_resolve
+				urls_to_check.each do |url|
+					check_url_resolves(url)
+				end
+			end
+
+			def check_redirects_resolve				
+				redirect_url = response.headers['Location']
+				if response.status =~ /302/ && redirect_url.present?
+					check_url_resolves(redirect_url)
+				end
+			end
+
+			private
+			def urls_to_check
+				anchor_urls + image_urls + form_urls
+			end
+
+			def check_url_resolves(url)
+				return if skip_url?(url, root_url) || external_http?(url, root_url)
+				url = strip_anchor(remove_query(make_absolute(url)))
+				return if public_file_exists?(url)
+				check_action_exists(url)
+			end
+
+			def root_url
+				request.protocol + request.host_with_port
+			end
+
+			def public_file_exists?(url)
+				public_path = File.join(rails_public_path, url)
+				File.exists?(public_path) || File.exists?(public_path + ".html")
+			end
+
+			def rails_public_path
+				File.join(Rails.root, "public")
+			end
+
+			# Make URLs absolute paths, i.e. relative to the site root
+			def make_absolute(url)
+				url = remove_host(url) if has_protocol?(url)
+				return url if url =~ %r{^/}
+				current_url = request.url || url_from_params
+				current_url = File.dirname(current_url) if current_url !~ %r{/$}
+				url = File.join(current_url, url) 
+			end
+
+			def remove_host(url)
+				url_no_host = url[%r{^[a-z]+://[^/]+(/.+)$}, 1]
+				url_no_host.blank? ? "/" : url_no_host
+			end
+
+			def remove_query(url)
+				url =~ /\?/ ? url[/^(.+?)\?/, 1] : url
+			end
+
+			def strip_anchor(url)
+				url =~ /\#/ ? url[/^(.+?)\#/, 1] : url
+			end
+
+			# Each URL is required to have at least one HTTP method for which there is a route with an action
+			def check_action_exists(url)
+				unless routes_from_url(url).any? { |route| route_has_action?(route) }
+					raise_invalid_url(url, "No action or template")
+				end
+			end
+
+			def route_has_action?(route)
+				controller = "#{route[:controller].camelize}Controller".constantize
+				controller.public_instance_methods.include?(route[:action]) || template_file_exists?(route, controller)				
+			end
+
+			def template_file_exists?(route, controller)
+				# Workaround for Rails 1.2 that doesn't have the view_paths method
+				template_dirs = controller.respond_to?(:view_paths) ?
+					controller.view_paths : [controller.view_root]
+				template_dirs.each do |template_dir|
+					template_file = File.join(template_dir, controller.controller_path, "#{route[:action]}.*")
+					return true if !Dir.glob(template_file).empty?
+				end
+				false
+			end
+
+			# This is a special case where on my site I had a catch all route for 404s. If you have
+			# such a route, you can override this method and check for it, i.e. you could do something
+			# like this:
+			#
+			#	 if params[:action] == "rescue_404"
+			#		 raise Html::Test::InvalidUrl.new("Action rescue_404 invoked for url '#{url}'")
+			#	 end
+			def check_not_404(url, params)
+				# This method is unimplemented by default
+			end
+
+			def routes_from_url(url)
+				routes = [:get, :post, :put, :delete].map do |method|
+					begin
+						# Need to specify the method here for RESTful resource routes to work, i.e.
+						# for /posts/1 to be recognized as the show action etc.
+
+
+#	ActionController::Routing::Routes does not exist in Rails 3!
+#	fortunately, I don't use "check_urls" so not an issue right now.
+
+						params = ::ActionController::Routing::Routes.recognize_path(url, {:method => method})
+						check_not_404(url, params)
+						params
+					rescue
+						# Could not find a route with that method
+						nil
+					end
+				end.compact
+				routes.present? ? routes : raise_invalid_url(url, "Cannot find a route")
+			end
+
+			def url_from_params(options = params)
+				return "/" if params.empty?
+				options[:controller] ||= params[:controller]
+				::ActionController::Routing::Routes.generate_extras(symbolize_hash(options))[0]
+			end
+
+			# Convert all keys in the hash to symbols. Not sure why this is needed.
+			def symbolize_hash(hash)
+				hash.keys.inject({}) { |h, k| h[k.to_sym] = hash[k]; h }
+			end
+			
+			def raise_invalid_url(url, message)
+				raise(Html::Test::InvalidUrl.new("#{message} for url '#{url}' request_uri='#{request.url}' body='#{response.body}'"))
+			end
+		end
+	end
+end

data/lib/url_selector.rb

@@ -0,0 +1,57 @@
+module Html
+  module Test
+    module UrlSelector
+      def skip_url?(url, root_url = nil)
+        if url.blank? || unsupported_protocol?(url) || special_url?(url)
+          true
+        else
+          false
+        end
+      end
+
+      def special_url?(url)
+        [/^javascript:/, /^mailto:/, /^\#$/].any? { |pattern| url =~ pattern }
+      end
+
+      def external_http?(url, root_url = nil)
+        if root_url
+          http_protocol?(url) && !url.starts_with?(root_url)
+        else
+          http_protocol?(url)
+        end
+      end
+
+      def http_protocol?(url)
+        url =~ %r{^http(?:s)?://} ? true : false
+      end
+
+      def has_protocol?(url)
+        url =~ %r{^[a-z]+://} ? true : false
+      end
+
+      def unsupported_protocol?(url)
+        has_protocol?(url) && !http_protocol?(url)
+      end
+
+      def anchor_urls
+        select("a").map { |l| l.attributes['href'] }
+      end
+
+      def image_urls
+        select("img").map { |i| i.attributes['src'] }
+      end
+
+      def form_urls
+        select("form").map { |i| i.attributes['action'] }        
+      end
+      
+      def response_body
+        self.respond_to?(:response) ? response.body : @response.body
+      end
+
+      def select(pattern)
+        HTML::Selector.new(pattern).select(HTML::Document.new(response_body).root)
+      end      
+    end
+  end
+end

data/lib/validate_filter.rb

@@ -0,0 +1,62 @@
+module Html
+	module Test
+		class ValidateFilter
+			attr_accessor :request, :response, :params, :validators
+			
+			include ::Test::Unit::Assertions
+			include ::Html::Test::Assertions
+
+			def initialize(controller)
+				self.request = controller.request
+				self.response = controller.response
+				self.params = controller.params
+				self.validators = controller.class.validators
+			end
+
+			def validate_page
+#				url = request.request_uri
+#	no more request_uri in Rails 3
+				url = request.url
+				return if (!should_validate? || ValidateFilter.already_validated?(url))
+#				assert_validates(validators, response.body.strip, url, :verbose => true)
+				assert_validates(validators, response.body.strip, url )
+				ValidateFilter.mark_url_validated(url)
+			end
+
+			def self.already_validated?(url)
+				if Html::Test::Validator.revalidate_all
+					false
+				else
+					validated_urls[url]
+				end
+			end
+
+			def self.mark_url_validated(url)
+				validated_urls[url] = true				
+			end
+
+			def self.validated_urls
+				@validated_urls ||= {}
+			end
+
+			# Override this method if you only want to validate a subset of pages
+			def should_validate?
+#				response.status =~ /200/ &&
+#         (response.headers['Content-Type'] =~ /text\/html/i || response.body =~ /<html/)
+#	In rails 3, 
+#		response.status is a Fixnum which would return nil in this match
+#		and response.headers['Content-Type'] is blank
+				response.status.to_s =~ /200/ &&
+					(response.content_type =~ /text\/html/i || response.body =~ /<html/)
+			end			
+
+			#	Used in testing (of html_test_extension plugin)
+			#	to remove the validated_urls hash
+			#	so can test with the same url.
+			def self.clear_validated_urls
+				@validated_urls = {}
+			end
+
+		end
+	end
+end

data/lib/validator.rb

@@ -0,0 +1,127 @@
+require 'tempfile'
+require 'net/http'
+require 'fileutils'
+
+module Html
+	module Test
+		class Validator
+
+			# verbose = true shows "validating ..."
+			# verbose = false shows NOTHING
+			@@verbose = true
+			cattr_accessor :verbose
+			#
+			#	revalidate_all = true will validate every call to a url
+			#	revalidate_all = false will only validate the first call to a url
+			@@revalidate_all = true
+			cattr_accessor :revalidate_all
+
+			@@tidy_ignore_list = []
+			cattr_accessor :tidy_ignore_list
+
+			# For local validation you might change this to http://localhost/validator/htdocs/check
+			DEFAULT_W3C_URL = "http://validator.w3.org/check"
+			@@w3c_url = DEFAULT_W3C_URL
+			cattr_accessor :w3c_url
+			
+			# Whether the W3C validator should show the HTML document being validated in
+			# its response. Set to 0 to disable.
+			@@w3c_show_source = "1"
+			cattr_accessor :w3c_show_source
+
+			DEFAULT_DTD = File.join(File.dirname(__FILE__), 'DTD', 'xhtml1-strict.dtd')
+
+			# Path to DTD file that the xmllint validator uses
+			def self.dtd(document)
+				DEFAULT_DTD
+			end
+			
+			# Validate an HTML document string using tidy.
+			# Code excerpted from the rails_tidy plugin
+			def self.tidy_errors(body)
+				tidy = RailsTidy.tidy_factory
+				tidy.clean(body)
+				errors = tidy.errors.empty? ? nil :
+					tidy.errors.delete_if { |e| tidy_ignore_list.select { |p| e =~ p }.size > 0 }.join("\n")
+				tidy.release
+				errors.blank? ? nil : errors
+			end
+
+			# Validate an HTML document string by going to the online W3C validator.
+			# Credit for the original code goes to Scott Baron (htonl)
+			def self.w3c_errors(body)
+				response = Net::HTTP.post_form(URI.parse(w3c_url),
+															{'ss'=>w3c_show_source, 'fragment'=>body})
+				status = response['x-w3c-validator-status']
+				if status != 'Valid'
+					# Reference in the stylesheets
+					response.body.sub!(%r{@import "./base.css"}, %Q{@import "#{File.dirname(w3c_url)}/base.css"})
+					response_file = find_unique_path(File.join(tmp_dir, "w3c_response.html"))
+
+					#	open(response_file, "w" ) { |f| f.puts(response.body) }
+					#	I was getting many errors like ...  (in ruby 1.9.3 and rails 3)
+					#	Encoding::UndefinedConversionError: "\xE2" from ASCII-8BIT to UTF-8
+					#	adding force_encoding('UTF-8') seems to fix this.
+					open(response_file, "w" ) { |f| f.puts(response.body.force_encoding('UTF-8')) }
+
+					"W3C status #{status}. Response from W3C was written to the file #{response_file}"
+				else
+					nil
+				end
+			end
+
+			# Validate an HTML document string using the xmllint command line validator tool.
+			# Returns nil if validation passes and an error message otherwise.
+			# Original code taken from the book "Enterprise Integration with Ruby"
+			def self.xmllint_errors(body)
+				error_file = create_tmp_file("xmllint_error")
+				doc_file = command = nil
+				if dtd(body) =~ /^doctype$/i
+					# Use the DOCTYPE declaration
+					doc_file = create_tmp_file("xmllint", body)
+					command = "xmllint --noout --valid #{doc_file} &> #{error_file}"
+				else
+					# Override the DOCTYPE declaration
+					doc_file = create_tmp_file("xmllint", body.sub(/<!DOCTYPE[^>]+>/m, ""))
+					command = "xmllint --noout --dtdvalid #{dtd(body)} #{doc_file} &> #{error_file}"
+				end
+				system(command)
+				status = $?.exitstatus
+				if status == 0
+					return nil
+				else
+					failure_doc = File.join(tmp_dir, "xmllint_last_response.html")
+					FileUtils.cp doc_file, failure_doc
+					return ("command='#{command}'. HTML document at '#{failure_doc}'. " +
+						IO.read(error_file))
+				end
+			end
+			
+			private
+			def self.find_unique_path(path)
+				filename = File.basename(path)
+				ext = File.extname(filename)
+				size_no_ext = filename.size - ext.size
+				filename_no_ext = filename[0, size_no_ext]
+				counter = 2
+				while File.exists?(path)
+					new_filename = [filename_no_ext, "-", counter, ext].join
+					path = File.join(File.dirname(path), new_filename)
+					counter += 1
+				end
+				path
+			end
+			
+			def self.create_tmp_file(name, contents = "")
+				tmp_file = Tempfile.new(name)
+				tmp_file.puts(contents)
+				tmp_file.close
+				tmp_file.path
+			end
+			
+			def self.tmp_dir
+				Dir::tmpdir
+			end
+		end
+	end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'ccls-html_test' if RAILS_ENV == 'test'

data/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/script/validate

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# == Synopsis
+# This script validates an HTML page via HTTP and checks for broken
+# links and images. Links are followed one step away from the start page.
+# HTML validation is also done for pages linked internally from the start page
+# (i.e. relative URLs).
+#
+# == Usage
+# vendor/plugins/html_test/script/validate http://my.url.com [options]
+#
+# Options:
+#
+# --no-follow::                 Don't follow any anchor or images URLs on
+#                               the start page (i.e. only one page is requested).
+#
+# --validators validator_list:: A comma separated list of validators to use
+#                               for HTML validation. Supported validators:
+#                               tidy, xmllint, w3c. Default validator is
+#                               tidy if it is installed, otherwise w3c.
+#
+# --dtd dtd_path::              Path to the DTD file to use for xmllint
+#                               validation. By default xmllint will use
+#                               the XHTML 1.0 strict DTD. Set dtd_path
+#                               to "doctype" to make xmllint use the
+#                               DTD specified in the DOCTYPE tag
+#                               (can be slow).
+#
+# --skip skip_patterns::        A comma separated list of regexp patterns for
+#                               URLs to not visit. Using the pattern '.*'
+#                               is equivalent to the --no-follow option.
+#
+# --only only_pattern::         Only visit URLs matching given regexp pattern
+#
+# --no-external::               Do not visit external URLs, i.e. URLs with
+#                               different domain than the start page.
+#
+# --quiet::                     Don't output anything unless there is a failure.
+
+require 'optparse'
+require 'rdoc/usage'
+require 'uri'
+
+require File.join(File.dirname(__FILE__), "..", "..", "..", "..", "test", "test_helper")
+require File.join(File.dirname(__FILE__), "..", "lib", "html_test")
+
+options = Html::Test::LinkValidator.parse_command_line(ARGV) rescue RDoc::usage
+Html::Test::LinkValidator.new(ARGV[0], options)