w3c_validators 0.9.0

data/LICENSE

@@ -0,0 +1,60 @@
+= W3C Validators License
+
+W3C Validators is copyrighted free software by Alex Dunae (http://dunae.ca/).
+You can redistribute it and/or modify it under either the terms of the GPL 
+or 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 Usenet 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 distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  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

@@ -0,0 +1,116 @@
+= W3C Validators Gem README
+
+W3C Validators is a Ruby wrapper for the World Wide Web Consortium's online 
+validation services.
+
+It supports the markup validator, the feed validator and the CSS validator.
+
+=== Installation
+
+  gem install w3c_validators
+
+=== Usage
+
+There are three main validator classes available, the W3CValidators::MarkupValidator 
+(used for HTML), the W3CValidators::FeedValidator and the 
+W3CValidators::CSSValidator.
+
+Each validator has offers three different validation methods.
+
+* +validate_text+ methods take a string
+* +validate_file+ methods take a path to a file
+* +validate_uri+ methods take a published URL
+
+In addition, the W3CValidators::MarkupValidator has a validate_uri_quickly method, which 
+performs a HEAD request against the markup validation service.  The Results 
+of this call give an error count but no error details.
+
+==== Using a local validator
+
+Each of the three validators allows you to specify a custom path to the 
+validator.  You can set your own validator like this:
+
+  validator = MarkupValidator.new(:validator_uri => 'http://localhost/check')
+
+=== Examples
+
+==== Example #1: Markup validator, local file
+
+  require 'w3c_validators'
+  
+  include W3CValidators
+
+  @validator = MarkupValidator.new
+  
+  # override the DOCTYPE
+  @validator.set_doctype!(:html32)
+  
+  # turn on debugging messages
+  @validator.set_debug!(true)
+
+  file = File.dirname(__FILE__) + '/fixtures/markup.html'
+  results = @validator.validate_file(fp)
+
+  if results.errors.length > 0
+    results.errors.each do |err|
+      puts err.to_s
+    end
+  else
+    puts 'Valid!'
+  end
+  
+  puts 'Debugging messages'
+  
+  results.debug_messages.each do |key, value|
+    puts "#{key}: #{value}"
+  end
+
+
+==== Example #2: Feed validator, remote file
+
+  require 'w3c_validators'
+  
+  include W3CValidators
+
+  @validator = FeedValidator.new
+
+  results = @validator.validate_uri('http://example.com/feed.xml')
+
+  if results.errors.length > 0
+    results.errors.each do |err|
+      puts err.to_s
+    end
+  else
+    puts 'Valid!'
+  end
+
+==== Example #3: CSS validator, text fragment
+
+  require 'w3c_validators'
+  
+  include W3CValidators
+
+  @validator = CSSValidator.new
+
+  results = @validator.validate_text('body { margin: 0px; }')
+
+  if results.errors.length > 0
+    results.errors.each do |err|
+      puts err.to_s
+    end
+  else
+    puts 'Valid!'
+  end
+
+=== Tests
+
+Run unit tests using <tt>rake test</tt>.  Note that there is a one second delay 
+between each call to the W3C's validators per their request.
+
+
+=== Credits and code
+
+Documentation and the source code are available at http://code.dunae.ca/w3c_validators.
+
+Written by Alex Dunae (dunae.ca, e-mail 'code' at the same domain), 2007.
+  

data/lib/w3c_validators.rb

@@ -0,0 +1,4 @@
+require 'lib/w3c_validators/validator'
+require 'lib/w3c_validators/markup_validator'
+require 'lib/w3c_validators/feed_validator'
+require 'lib/w3c_validators/css_validator'

data/lib/w3c_validators/constants.rb

@@ -0,0 +1,79 @@
+module W3CValidators
+  CSS_PROFILES = { :css1 => 'CSS 1',
+                   :css2 => 'CSS 2.0',
+                   :css21 => 'CSS 1.0',
+                   :css3 => 'CSS 3.0',
+                   :svg => 'SVG',
+                   :svgbasic => 'SVG Basic',
+                   :svgtiny => 'SVG Tiny',
+                   :mobile => 'Mobile',
+                   :atsc_tv => 'ATSC TV',
+                   :tv => 'TV'
+                 }
+
+  DOCTYPES = { :xhtml10_strict => 'XHTML 1.0 Strict',
+               :xhtml10_transitional => 'XHTML 1.0 Transitional',
+               :xhtml10_frameset => 'XHTML 1.0 Frameset',
+               :xhtml401_strict => 'HTML 4.01 Strict',
+               :xhtml401_transitional => 'HTML 4.01 Transitional',
+               :xhtml401_framest => 'HTML 4.01 Frameset',
+               :html32 => 'HTML 3.2',
+               :html20 => 'HTML 2.0',
+               :iso_html => 'ISO/IEC 15445:2000 ("ISO HTML")',
+               :xhtml11 => 'XHTML 1.1',
+               :xhtml_basic10 => 'XHTML Basic 1.0',
+               :xhtml_print10 => 'XHTML-Print 1.0',
+               :xhtml11_plus_mathml20  => 'XHTML 1.1 plus MathML 2.0',
+               :xhtml11_plus_mathml20_plus_svg11 => 'XHTML 1.1 plus MathML 2.0 plus SVG 1.1',
+               :mathml20=> 'MathML 2.0',
+               :svg10 => 'SVG 1.0',
+               :svg11 => 'SVG 1.1',
+               :svg11tiny => 'SVG 1.1 Tiny',
+               :svg11_basic => 'SVG 1.1 Basic',
+               :smil10 => 'SMIL 1.0',
+               :smil20 => 'SMIL 2.0'
+             }
+
+  CHARSETS = {  :utf_8 => 'utf-8',
+                :utf_16 => 'utf-16',
+                :iso_8859_1 => 'iso-8859-1',
+                :iso_8859_2 => 'iso-8859-2',
+                :iso_8859_3 => 'iso-8859-3',
+                :iso_8859_4 => 'iso-8859-4',
+                :iso_8859_5 => 'iso-8859-5',
+                :iso_8859_6i => 'iso-8859-6-i',
+                :iso_8859_7 => 'iso-8859-7',
+                :iso_8859_8 => 'iso-8859-8',
+                :iso_8859_8i => 'iso-8859-8-i',
+                :iso_8859_9 => 'iso-8859-9',
+                :iso_8859_10 => 'iso-8859-10',
+                :iso_8859_11 => 'iso-8859-11',
+                :iso_8859_13 => 'iso-8859-13',
+                :iso_8859_14 => 'iso-8859-14',
+                :iso_8859_15 => 'iso-8859-15',
+                :iso_8859_16 => 'iso-8859-16',
+                :us_ascci => 'us-ascii',
+                :euc_jp => 'euc-jp',
+                :shift_jis => 'shift_jis',
+                :iso_2022_hp => 'iso-2022-jp',
+                :euc_jr => 'euc-kr',
+                :ksk_5601 => 'ksc_5601',
+                :gb_2312 => 'gb2312',
+                :gb_18030 => 'gb18030',
+                :big5 => 'big5',
+                :big5_hkscs => 'big5-HKSCS',
+                :tis_620 => 'tis-620',
+                :koi8_r => 'koi8-r',
+                :koi8_u => 'koi8-u',
+                :iso_ir_111 => 'iso-ir-111',
+                :macintosh => 'macintosh',
+                :windows_1250 => 'windows-1250',
+                :windows_1251 => 'windows-1251',
+                :windows_1252 => 'windows-1252',
+                :windows_1253 => 'windows-1253',
+                :windows_1254 => 'windows-1254',
+                :windows_1255 => 'windows-1255',
+                :windows_1256 => 'windows-1256',
+                :windows_1257 => 'windows-1257'
+              }
+end

data/lib/w3c_validators/css_validator.rb

@@ -0,0 +1,146 @@
+module W3CValidators
+  class CSSValidator < Validator
+    CSS_VALIDATOR_URI      = 'http://jigsaw.w3.org/css-validator/validator'
+
+    # Create a new instance of the CSSValidator.
+    #
+    # ==== Options
+    # You can pass in your own validator's URI (i.e. 
+    # <tt>CSSValidator.new(:validator_uri => 'http://localhost/check')</tt>).
+    def initialize(options = {})
+      if options[:validator_uri]
+        @validator_uri = URI.parse(options[:validator_uri])
+        options.delete(options[:validator_uri])
+      else
+        @validator_uri = URI.parse(CSS_VALIDATOR_URI)
+      end
+      super(options)
+    end
+    
+    # The CSS profile used for the validation.
+    #
+    # +charset+ can be a string or a symbl from the W3CValidators::CSS_PROFILES hash.
+    #
+    # ==== Example
+    #   set_profile!('css1')
+    #   set_profile!(:css1)
+    def set_profile!(profile)
+      if profile.kind_of?(Symbol)
+        if CSS_PROFILES.has_key?(profile)
+          profile = profile.to_s
+        else
+          return
+        end
+      end
+      @options[:profile] = profile
+    end
+
+    # The warning level, no for no warnings, 0 for less warnings, 1or 2 for more warnings
+    def set_warn_level!(level = 2)
+      warn_levels = ['0','1','2','no']
+      return unless warn_levels.include?(level.to_s.downcase)
+
+      @options[:warning] = level
+    end
+
+    # The language used for the response.
+    def set_language!(lang = 'en')
+      @options[:lang] = lang
+    end
+
+    # Validate the CSS of an URI.
+    #
+    # Returns W3CValidators::Results.
+    def validate_uri(uri)
+      return validate({:uri => uri})
+    end
+
+    # Validate the CSS of a string.
+    #
+    # Returns W3CValidators::Results.
+    def validate_text(text)
+      return validate({:text => text})
+    end
+    
+    # Validate the CSS of a local file.
+    #
+    # +file_path+ must be the fully-expanded path to the file.
+    #
+    # Returns W3CValidators::Results.
+    def validate_file(file_path)
+      src = read_local_file(file_path)
+      return validate_text(src)
+    end
+
+
+protected
+    def validate(options) # :nodoc:
+      options = get_request_options(options)
+      #puts options.inspect
+      response = send_request(options, :get)
+      @results = parse_soap_response(response.body)
+      #puts response.body
+      @results
+    end
+
+    # Perform sanity checks on request params
+    def get_request_options(options) # :nodoc:
+      options = @options.merge(options)
+     
+      options[:output] = SOAP_OUTPUT_PARAM
+      
+      unless options[:uri] or options[:text]
+        raise ArgumentError, "an uri or text is required."
+      end
+
+      # URI should be a string.  If it is a URI object, .to_s will
+      # be seamless; if it is not an exception will be raised.
+      if options[:uri] and not options[:uri].kind_of?(String)
+        options[:uri] = options[:uri].to_s
+      end
+
+      options
+    end
+
+
+    def parse_soap_response(response) # :nodoc:
+      doc = REXML::Document.new(response)
+
+      result_params = {}
+
+      {:uri => 'uri', :checked_by => 'checkedby', :validity => 'validity', :css_level => 'csslevel'}.each do |local_key, remote_key|        
+        if val = doc.elements["//*[local-name()='cssvalidationresponse']/*[local-name()='#{remote_key.to_s}']"]
+          result_params[local_key] = val.text
+        end
+      end
+
+      results = Results.new(result_params)
+
+      ['warninglist', 'errorlist'].each do |list_type|
+        doc.elements.each("//*[local-name()='#{list_type.to_s}']") do |message_list|        
+
+          if uri_node = message_list.elements["*[local-name()='uri']"]
+            uri = uri_node.text
+          end
+
+          [:warning, :error].each do |msg_type|
+            message_list.elements.each("*[local-name()='#{msg_type.to_s}']") do |message|
+              message_params = {}
+              message.each_element_with_text do |el|
+                message_params[el.name.to_sym] = el.text
+              end
+              message_params[:uri] = uri
+              results.add_message(msg_type, message_params)
+            end
+          end
+        end
+      end
+      return results
+
+    rescue Exception => e
+      handle_exception e
+    end
+
+  
+  end
+end

data/lib/w3c_validators/exceptions.rb

@@ -0,0 +1,4 @@
+module W3CValidators
+  class ValidatorUnavailable < StandardError; end
+  class ParsingError < StandardError; end
+end

data/lib/w3c_validators/feed_validator.rb

@@ -0,0 +1,105 @@
+module W3CValidators
+  class FeedValidator < Validator
+    FEED_VALIDATOR_URI      = 'http://validator.w3.org/feed/check.cgi'
+
+    # Create a new instance of the FeedValidator.
+    #
+    # ==== Options
+    # You can pass in your own validator's URI (i.e. 
+    # <tt>FeedValidator.new(:validator_uri => 'http://localhost/check')</tt>).
+    def initialize(options = {})
+      if options[:validator_uri]
+        @validator_uri = URI.parse(options[:validator_uri])
+        options.delete(options[:validator_uri])
+      else
+        @validator_uri = URI.parse(FEED_VALIDATOR_URI)
+      end
+      super(options)
+    end
+    
+    # Validate a feed URI using a +SOAP+ request.
+    #
+    # Returns W3CValidators::Results.
+    def validate_uri(url)
+      return validate({:url => url})
+    end
+
+    # Validate a feed from a string.
+    #
+    # Returns W3CValidators::Results.
+    def validate_text(text)
+      return validate({:rawdata => text})
+    end
+
+    # Validate a local feed file.
+    #
+    # +file_path+ must be the fully-expanded path to the file.
+    #
+    # Returns W3CValidators::Results.
+    def validate_file(file_path)
+      src = read_local_file(file_path)
+      return validate_text(src)
+    end
+
+protected
+    def validate(options) # :nodoc:
+      options = get_request_options(options)
+      response = send_request(options, :get)
+      @results = parse_soap_response(response.body)
+      @results
+    end
+
+    # Perform sanity checks on request params
+    def get_request_options(options) # :nodoc:
+      options = @options.merge(options)
+     
+      options[:output] = SOAP_OUTPUT_PARAM
+      
+      unless options[:url] or options[:rawdata]
+        raise ArgumentError, "an url or rawdata is required."
+      end
+
+      # URL should be a string.  If it is a URL object, .to_s will
+      # be seamless; if it is not an exception will be raised.
+      if options[:url] and not options[:url].kind_of?(String)
+        options[:url] = options[:url].to_s
+      end
+      
+      options
+    end
+
+    # Parse the SOAP XML response.
+    #
+    # +response+ must be a Net::HTTPResponse.
+    #
+    # Returns W3CValidators::Results.
+    def parse_soap_response(response) # :nodoc:
+      doc = REXML::Document.new(response)
+
+      result_params = {}
+
+      {:uri => 'uri', :checked_by => 'checkedby', :validity => 'validity'}.each do |local_key, remote_key|        
+        if val = doc.elements["//*[local-name()='feedvalidationresponse']/*[local-name()='#{remote_key.to_s}']"]
+          result_params[local_key] = val.text
+        end
+      end
+
+      results = Results.new(result_params)
+
+      [:warning, :error].each do |msg_type|
+        doc.elements.each("//*[local-name()='#{msg_type.to_s}']") do |message|
+          message_params = {}
+          message.each_element_with_text do |el|
+            message_params[el.name.to_sym] = el.text
+          end
+          results.add_message(msg_type, message_params)
+        end
+      end
+
+      return results
+
+    rescue Exception => e
+      handle_exception e
+    end
+  end
+end

data/lib/w3c_validators/markup_validator.rb

@@ -0,0 +1,215 @@
+module W3CValidators
+  class MarkupValidator < Validator
+    MARKUP_VALIDATOR_URI      = 'http://validator.w3.org/check'
+
+    # Create a new instance of the MarkupValidator.
+    #
+    # ==== Options
+    # The +options+ hash allows you to set request parameters (see 
+    # http://validator.w3.org/docs/api.html#requestformat) quickly. Request 
+    # parameters can also be set using set_charset!, set_debug! and set_doctype!.
+    #
+    # You can pass in your own validator's URI (i.e. 
+    # <tt>MarkupValidator.new(:validator_uri => 'http://localhost/check')</tt>).
+    def initialize(options = {})
+      if options[:validator_uri]
+        @validator_uri = URI.parse(options[:validator_uri])
+        options.delete(options[:validator_uri])
+      else
+        @validator_uri = URI.parse(MARKUP_VALIDATOR_URI)
+      end
+      super(options)
+    end
+    
+    # Specify the character encoding to use when parsing the document. 
+    #
+    # When +only_as_fallback+ is +true+, the given encoding will only be 
+    # used as a fallback value, in case the +charset+ is absent or unrecognized. 
+    #
+    # +charset+ can be a string (e.g. <tt>set_charset!('utf-8')</tt>) or 
+    # a symbol (e.g. <tt>set_charset!(:utf_8)</tt>) from the 
+    # W3CValidators::CHARSETS hash.
+    #
+    # Has no effect when using validate_uri_quickly.
+    def set_charset!(charset, only_as_fallback = false)
+      if charset.kind_of?(Symbol)
+        if CHARSETS.has_key?(charset)
+          charset = CHARSETS[charset]
+        else
+          return
+        end
+      end
+      @options[:charset] = charset
+      @options[:fbc] = only_as_fallback
+    end
+
+    # Specify the Document Type (+DOCTYPE+) to use when parsing the document. 
+    #
+    # When +only_as_fallback+ is +true+, the given document type will only be 
+    # used as a fallback value, in case the document's +DOCTYPE+ declaration 
+    # is missing or unrecognized.
+    #
+    # +doctype+ can be a string (e.g. <tt>set_doctype!('HTML 3.2')</tt>) or 
+    # a symbol (e.g. <tt>set_doctype!(:html32)</tt>) from the 
+    # W3CValidators::DOCTYPES hash.
+    #
+    # Has no effect when using validate_uri_quickly.
+    def set_doctype!(doctype, only_as_fallback = false)
+      if doctype.kind_of?(Symbol)
+        if DOCTYPES.has_key?(doctype)
+          doctype = DOCTYPES[doctype]
+        else
+          return
+        end
+      end
+      @options[:doctype] = doctype
+      @options[:fbd] = only_as_fallback
+    end
+
+    # When set the validator will output some extra debugging information on 
+    # the validated resource (such as HTTP headers) and validation process 
+    # (such as parser used, parse mode, etc.).
+    #
+    # Debugging information is stored in the Results +debug_messages+ hash. 
+    # Custom debugging messages can be set with Results#add_debug_message.
+    #
+    # Has no effect when using validate_uri_quickly.
+    def set_debug!(debug = true)
+      @options[:debug] = debug
+    end
+
+    # Validate the markup of an URI using a +SOAP+ request.
+    #
+    # Returns W3CValidators::Results.
+    def validate_uri(uri)
+      return validate({:uri => uri}, false)
+    end
+
+    # Validate the markup of an URI using a +HEAD+ request.
+    #
+    # Returns W3CValidators::Results with an error count, not full error messages.
+    def validate_uri_quickly(uri)
+      return validate({:uri => uri}, true)
+    end
+
+    # Validate the markup of a string.
+    #
+    # Returns W3CValidators::Results.
+    def validate_text(text)
+      return validate({:fragment => text}, false)
+    end
+    
+    # Validate the markup of a local file.
+    #
+    # +file_path+ must be the fully-expanded path to the file.
+    #
+    # Returns W3CValidators::Results.
+    def validate_file(file_path)
+      src = read_local_file(file_path)
+      return validate({:uploaded_file => src}, false)
+    end
+
+protected
+    def validate(options, quick = false) # :nodoc:
+      options = get_request_options(options)
+
+      if quick
+        response = send_request(options, :head)
+        @results = parse_head_response(response, options[:uri])
+      else
+        if options.has_key?(:uri) or options.has_key?(:fragment)
+          response = send_request(options, :get)
+        else
+          response = send_request(options, :post)
+        end
+
+        @results = parse_soap_response(response.body)
+      end
+      @results
+    end
+
+    # Perform sanity checks on request params
+    def get_request_options(options) # :nodoc:
+      options = @options.merge(options)
+     
+      options[:output] = SOAP_OUTPUT_PARAM
+      
+      unless options[:uri] or options[:uploaded_file] or options[:fragment]
+        raise ArgumentError, "an uri, uploaded file or fragment is required."
+      end
+
+      # URI should be a string.  If it is a URI object, .to_s will
+      # be seamless; if it is not an exception will be raised.
+      if options[:uri] and not options[:uri].kind_of?(String)
+        options[:uri] = options[:uri].to_s
+      end
+      
+      # Convert booleans to integers
+      [:fbc, :fbd, :verbose, :debug, :ss, :outline].each do |k|
+        if options.has_key?(k) and not options[k].kind_of?(Fixnum)
+          options[k] = options[k] ? 1 : 0
+        end
+      end
+
+      options
+    end
+
+
+    # Parse the SOAP XML response.
+    #
+    # +response+ must be a Net::HTTPResponse.
+    #
+    # Returns W3CValidators::Results.
+    def parse_soap_response(response) # :nodoc:
+      doc = REXML::Document.new(response)
+
+      result_params = {}
+
+      {:doctype => 'm:doctype', :uri => 'm:uri', :charset => 'm:charset', 
+       :checked_by => 'm:checkedby', :validity => 'm:validity'}.each do |local_key, remote_key|        
+        if val = doc.elements["env:Envelope/env:Body/m:markupvalidationresponse/#{remote_key}"]
+          result_params[local_key] = val.text
+        end
+      end
+
+      results = Results.new(result_params)
+
+      {:warning => 'm:warnings/m:warninglist/m:warning', :error => 'm:errors/m:errorlist/m:error'}.each do |local_type, remote_type|
+        doc.elements.each("env:Envelope/env:Body/m:markupvalidationresponse/#{remote_type}") do |message|
+          message_params = {}
+          message.each_element_with_text do |el|
+            message_params[el.name.to_sym] = el.text
+          end
+          results.add_message(local_type, message_params)
+        end
+      end
+      
+      doc.elements.each("env:Envelope/env:Body/m:markupvalidationresponse/m:debug") do |debug|
+        results.add_debug_message(debug.attribute('name').value, debug.text)
+      end
+      return results
+
+      rescue Exception => e
+        handle_exception e
+    end
+
+    # Parse the HEAD response into HTMLValidator::Results.
+    #
+    # +response+ must be a Net::HTTPResponse.
+    #
+    # Returns Results.
+    def parse_head_response(response, validated_uri = nil) # :nodoc:
+      validity = (response[HEAD_STATUS_HEADER].downcase == 'valid')
+      
+      results = Results.new(:uri => validated_uri, :validity => validity)
+
+      # Fill the results with empty error messages so we can count them
+      errors = response[HEAD_ERROR_COUNT_HEADER].to_i
+      errors.times { results.add_error }
+
+      results
+    end
+
+  
+  end
+end

data/lib/w3c_validators/message.rb

@@ -0,0 +1,82 @@
+module W3CValidators
+  class Message
+    attr_accessor :type, :line, :col, :source, :explanation, :message, :message_id
+    attr_accessor :message_count, :element, :parent, :value
+    
+    MESSAGE_TYPES = [:warning, :error]
+
+    # Due to the responses received from the W3C's validators, different data 
+    # are available for different validation types.
+    #
+    # ==== Feed validation
+    # * +line+
+    # * +col+
+    # * +message+ (originally +text+)
+    # * +message_count+
+    # * +element+
+    # * +parent+
+    # * +value+
+    # See http://validator.w3.org/feed/docs/soap.html#soap12message for full explanations.
+    #
+    # ==== Markup validation
+    # * +line+
+    # * +col+
+    # * +message+
+    # * +message_id+
+    # * +explanation+
+    # * +source+
+    # See http://validator.w3.org/docs/api.html#soap12message for full explanations.
+    #
+    # ==== CSS validation (http://jigsaw.w3.org/css-validator/api.html#soap12message)
+    # * +level+
+    # * +line+
+    # * +message+
+    # See http://jigsaw.w3.org/css-validator/api.html#soap12message for full explanations.
+    def initialize(uri, message_type, options = {})
+      @type = message_type
+      @uri = uri
+
+      # All validators
+      @line = options[:line]
+      @col = options[:col]
+      
+      # MarkupValidator
+      @source = options[:source]
+      @explanation = options[:explanation]
+      @message = options[:message]
+      @message_id = options[:messageid]
+
+      # FeedValidator
+      @message = options[:text] unless @message
+      @message_count = options[:message_count]
+      @element = options[:element]
+      @parent = options[:parent]
+      @value = options[:value]
+
+      # CSSValidator
+      @level = options[:level]
+    end
+
+    def is_warning?
+      @type == :warning
+    end
+
+    def is_error?
+      @type == :error
+    end
+
+    # Return the message as a string.
+    def to_s
+      str = @type.to_s.upcase
+      if @uri and not @uri.empty?
+        str << "; URI: #{@uri}"
+      end
+      str << "; line #{@line}"
+      if @message and not @message.empty?
+        str << ": #{@message}"
+      end
+      return str
+    end
+
+  end
+end

data/lib/w3c_validators/results.rb

@@ -0,0 +1,58 @@
+module W3CValidators
+  class Results
+    attr_reader :uri, :checked_by, :doctype, :css_level, :charset, :validity, :debug_messages
+
+    def initialize(options = {})
+      @messages       = []
+      @uri            = options[:uri]
+      @checked_by     = options[:checked_by]
+      @doctype        = options[:doctype]
+      @css_level      = options[:css_level]
+      @charset        = options[:charset]
+      @validity       = options[:validity]
+      @debug_messages = {}
+    end
+
+    def add_message(type, params = {})
+      uri = params[:uri] ||= @uri
+      @messages << Message.new(uri, type, params)
+    end    
+
+    def add_error(params = {})
+      add_message(:error, params)
+    end
+
+    def add_warning(params = {})
+      add_message(:warnings, params)
+    end
+
+    def add_debug_message(key, val)
+      @debug_messages[key] = val
+    end
+
+    # Returns either the +DOCTYPE+ or CSS level, whichever is present.
+    def checked_against
+      return @doctype if @doctype
+      return @css_level if @css_level
+      nil
+    end
+
+    def is_valid?
+      @validity.downcase.strip == 'true'
+    end
+
+    # Returns an array of Message objects.
+    def errors
+      errors = []
+      @messages.each { |msg| errors << msg if msg.is_error? }
+      errors
+    end
+
+    # Returns an array of Message objects.
+    def warnings
+      errors = []
+      @messages.each { |msg| errors << msg if msg.is_warning? }
+      errors
+    end
+  end
+end

data/lib/w3c_validators/validator.rb

@@ -0,0 +1,144 @@
+require 'cgi'
+require 'net/http'
+require 'uri'
+require 'rexml/document'
+
+require 'lib/w3c_validators/exceptions'
+require 'lib/w3c_validators/constants'
+require 'lib/w3c_validators/results'
+require 'lib/w3c_validators/message'
+
+module W3CValidators
+  # Base class for MarkupValidator and FeedValidator.
+  class Validator
+    USER_AGENT                = 'Ruby W3C Validators/0.9 (http://code.dunae.ca/w3c_validators/)'
+    VERSION                   = '0.9'
+    HEAD_STATUS_HEADER        = 'X-W3C-Validator-Status'
+    HEAD_ERROR_COUNT_HEADER   = 'X-W3C-Validator-Errors'
+    SOAP_OUTPUT_PARAM         = 'soap12'
+
+    attr_reader :results, :validator_uri
+
+    # Create a new instance of the Validator.
+    def initialize(options = {})
+      @options = options
+    end
+
+  protected
+    # Perform a validation request.
+    #
+    # +request_mode+ must be either <tt>:get</tt>, <tt>:head</tt> or <tt>:post</tt>.
+    #
+    # Returns Net::HTTPResponse.
+    def send_request(options, request_mode = :get)
+      response = nil
+      results = nil
+
+      Net::HTTP.start(@validator_uri.host, @validator_uri.port) do |http|
+        case request_mode
+          when :head
+            # perform a HEAD request
+            raise ArgumentError, "a URI must be provided for HEAD requests." unless options[:uri]
+            query = create_query_string_data(options)
+            response = http.request_head(@validator_uri.path + '?' + query)
+          when :get 
+            # send a GET request
+            query = create_query_string_data(options)          
+            response = http.get(@validator_uri.path + '?' + query)
+          when :post
+            # send a multipart form request
+            query, boundary = create_multipart_data(options)
+            response = http.post2(@validator_uri.path, query, "Content-type" => "multipart/form-data; boundary=" + boundary)
+          else
+            raise ArgumentError, "request_mode must be either :get, :head or :post"
+        end
+      end
+
+      response.value
+      return response
+
+      rescue Exception => e
+        handle_exception e
+    end
+
+    def create_multipart_data(options) # :nodoc:
+      boundary = '349832898984244898448024464570528145'
+      params = []
+      if options[:uploaded_file]
+        filename = options[:file_path] ||= 'temp.html'
+        content = options[:uploaded_file]
+        params << "Content-Disposition: form-data; name=\"uploaded_file\"; filename=\"#{filename}\"\r\n" + "Content-Type: text/html\r\n" + "\r\n" + "#{content}\r\n"
+        options.delete(:uploaded_file)
+        options.delete(:file_path)
+      end
+
+      options.each do |key, value|
+        if value
+          params << "Content-Disposition: form-data; name=\"#{CGI::escape(key.to_s)}\"\r\n" + "\r\n" + "#{value}\r\n"
+        end
+      end
+
+      multipart_query = params.collect {|p| '--' + boundary + "\r\n" + p}.join('') + "--" + boundary + "--\r\n" 
+
+      [multipart_query, boundary]
+    end
+
+    def create_query_string_data(options) # :nodoc:
+      qs = ''
+      options.each do |key, value| 
+        if value
+          qs += "#{key}=" + CGI::escape(value.to_s) + "&"
+        end
+      end
+      qs
+    end
+
+    def read_local_file(file_path) # :nodoc:
+      fh = File.new(file_path, 'r+')
+      src = fh.read
+      fh.close
+      src
+    end
+
+  private
+    #--
+    # Big thanks to ara.t.howard and Joel VanderWerf on Ruby-Talk for the exception handling help.
+    #++
+    def handle_exception(e, msg = '') # :nodoc:
+      case e      
+        when Net::HTTPServerException, SocketError
+          msg = "unable to connect to the validator at #{@validator_uri} (response was #{e.message})."
+          raise ValidatorUnavailable, msg, caller
+        when REXML::ParseException
+          msg = "unable to parse the response from the validator."
+          raise ParsingError, msg, caller
+        else
+          raise e
+      end
+
+      if e.respond_to?(:error_handler_before)
+        fcall(e, :error_handler_before, self)
+      end
+
+      if e.respond_to?(:error_handler_instead)
+        fcall(e, :error_handler_instead, self)
+      else
+        if e.respond_to? :status
+          exit_status(( e.status ))
+        end
+
+        if SystemExit === e
+          stderr.puts e.message unless(SystemExit === e and e.message.to_s == 'exit') ### avoids double message for abort('message')
+        end
+      end
+
+      if e.respond_to?(:error_handler_after)
+        fcall(e, :error_handler_after, self)
+      end
+
+      exit_status(( exit_failure )) if exit_status == exit_success
+      exit_status(( Integer(exit_status) rescue(exit_status ? 0 : 1) ))
+      exit exit_status
+    end 
+  end
+end

data/test/test_css_validator.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Test cases for the CSSValidator.
+class CSSValidatorTests < Test::Unit::TestCase
+  include W3CValidators
+  def setup
+    @v = CSSValidator.new
+
+    @invalid_fragment = <<-EOT
+    a { color: white; }
+    body { margin: blue; }
+    
+    EOT
+
+    sleep 1
+  end
+
+  def test_overriding_css_profile
+    @v.set_profile!(:svgbasic)
+    r = @v.validate_text(@invalid_fragment)
+    assert_equal 'svgbasic', r.css_level
+  end
+
+  def test_validating_file
+    file_path = File.expand_path(File.dirname(__FILE__) + '/fixtures/invalid_css.css')
+    r = @v.validate_file(file_path)
+    assert_equal 1, r.errors.length
+  end
+
+  def test_validating_uri
+    @v.set_profile!(:svgbasic)
+    r = @v.validate_text(@invalid_fragment)
+    assert_equal 1, r.errors.length
+  end
+ 
+  def test_validating_text
+    r = @v.validate_text(@invalid_fragment)
+    assert_equal 1, r.errors.length
+  end
+
+ 
+end

data/test/test_exceptions.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ExceptionTests < Test::Unit::TestCase
+  include W3CValidators
+
+  def setup
+    @valid_fragment = <<-EOV
+      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+      <title>Test</title>
+      <body>
+      <div class="example">This is a test</div>
+      </body>
+    EOV
+  end
+
+  def test_bad_validator_uri
+    ['http://noexist/', 'http://noexist.badtld/', 
+     'http://example.com/noexist'].each do |uri|
+      v = MarkupValidator.new(:validator_uri => uri)
+      assert_raise ValidatorUnavailable do
+        r = v.validate_text(@valid_fragment)
+      end
+    end
+  end
+
+  def test_bad_soap_response
+    return # need to set up a test host
+    [].each do |uri|
+      v = MarkupValidator.new(:validator_uri => uri)
+      assert_raise ParsingError do
+        r = v.validate_text(@valid_fragment)
+      end
+    end
+  end
+end

data/test/test_feed_validator.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Test cases for the FeedValidator.
+class FeedValidatorTests < Test::Unit::TestCase
+  include W3CValidators
+  def setup
+    @v = FeedValidator.new
+    sleep 1
+  end
+
+  def test_validating_uri_with_soap
+    r = @v.validate_uri('http://code.dunae.ca/w3c_validators/test/invalid_feed.xml')
+    assert_equal 1, r.errors.length
+    assert_equal 1, r.warnings.length
+  end
+ 
+  def test_validating_file
+    file_path = File.expand_path(File.dirname(__FILE__) + '/fixtures/invalid_feed.xml')
+    r = @v.validate_file(file_path)
+    assert_equal 1, r.errors.length
+  end
+ 
+  def test_validating_text
+    fragment = <<-EOT
+    <?xml version="1.0" encoding="utf-8"?>
+    <feed xmlns="http://www.w3.org/2005/Atom">
+     <title>Example Feed</title>
+     <subtitle>A subtitle.</subtitle>
+     <link href="http://example.org/feed/" rel="self"/>
+     <link href="http://example.org/"/>
+     <updated>2003-12-13T18:30:02Z</updated>
+     <author>
+       <email>johndoe@example.com</email>
+     </author>
+     <id>urn:uuid:60a76c80-d399-11d9-b91C-0003939e0af6</id>
+     <entry>
+       <title>Atom-Powered Robots Run Amok</title>
+       <link href="http://example.org/2003/12/13/atom03"/>
+       <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
+       <updated>2003-12-13T18:30:02Z</updated>
+       <summary>Some text.</summary>
+     </entry>
+    </feed>
+    EOT
+
+    r = @v.validate_text(fragment)
+    assert_equal 1, r.errors.length
+  end
+
+ 
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__), '../'))
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__), '../lib/'))
+
+require 'rubygems'
+require 'test/unit'
+require 'w3c_validators'

data/test/test_markup_validator.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Test cases for the MarkupValidator.
+class MarkupValidatorTests < Test::Unit::TestCase
+  include W3CValidators
+  def setup
+    @v = MarkupValidator.new
+    sleep 1
+  end
+
+  def test_overriding_doctype
+    @v.set_doctype!(:html32, false)
+    r = @v.validate_uri('http://code.dunae.ca/w3c_validators/test/invalid_markup.html')
+    assert_equal '-//W3C//DTD HTML 3.2 Final//EN', r.doctype
+  end
+
+  def test_overriding_doctype_for_fallback_only
+    @v.set_doctype!(:html32, true)
+    r = @v.validate_uri('http://code.dunae.ca/w3c_validators/test/invalid_markup.html')
+    assert_not_equal '-//W3C//DTD HTML 3.2 Final//EN', r.doctype
+  end
+
+  def test_overriding_charset
+    @v.set_charset!(:utf_16, false)
+    r = @v.validate_uri('http://code.dunae.ca/w3c_validators/test/invalid_markup.html')
+    assert_equal 'utf-16', r.charset
+  end
+
+  def test_overriding_charset_for_fallback_only
+    @v.set_doctype!(:utf_16, true)
+    r = @v.validate_uri('http://code.dunae.ca/w3c_validators/test/invalid_markup.html')
+    assert_not_equal 'utf-16', r.charset
+  end
+
+  def test_validating_uri_with_head_request
+    r = @v.validate_uri_quickly('http://code.dunae.ca/w3c_validators/test/invalid_markup.html')
+    assert_equal 1, r.errors.length
+    assert_equal 0, r.warnings.length
+  end
+
+  def test_validating_uri_with_soap
+    r = @v.validate_uri('http://code.dunae.ca/w3c_validators/test/invalid_markup.html')
+    assert_equal 1, r.errors.length
+    assert_equal 0, r.warnings.length
+  end
+
+  def test_debugging_uri
+    @v.set_debug!
+    r = @v.validate_uri('http://code.dunae.ca/w3c_validators/test/invalid_markup.html')
+    assert r.debug_messages.length > 0
+  end
+
+  def test_validating_file
+    file = File.dirname(__FILE__) + '/fixtures/invalid_markup.html'
+    r = @v.validate_file(file)
+    assert_equal 1, r.errors.length
+  end
+
+  def test_validating_text
+    valid_fragment = <<-EOV
+      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+      <title>Test</title>
+      <body>
+      <div class="example">This is a test</div>
+      </body>
+    EOV
+    
+    r = @v.validate_text(valid_fragment)
+    assert_equal 0, r.errors.length
+    assert_equal 0, r.warnings.length
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: w3c_validators
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+date: 2007-11-10 00:00:00 -08:00
+summary: Wrapper for the World Wide Web Consortium's online validation services.
+require_paths: 
+- lib
+email: 
+homepage: http://code.dunae.ca/w3c_validators
+rubyforge_project: 
+description: W3C Validators is a Ruby wrapper for the World Wide Web Consortium's online validation services.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Alex Dunae
+files: 
+- lib/w3c_validators
+- lib/w3c_validators/constants.rb
+- lib/w3c_validators/css_validator.rb
+- lib/w3c_validators/exceptions.rb
+- lib/w3c_validators/feed_validator.rb
+- lib/w3c_validators/markup_validator.rb
+- lib/w3c_validators/message.rb
+- lib/w3c_validators/results.rb
+- lib/w3c_validators/validator.rb
+- lib/w3c_validators.rb
+- README
+- LICENSE
+test_files: 
+- test/test_css_validator.rb
+- test/test_exceptions.rb
+- test/test_feed_validator.rb
+- test/test_helper.rb
+- test/test_markup_validator.rb
+rdoc_options: 
+- --all
+- --inline-source
+- --line-numbers
+extra_rdoc_files: 
+- README
+- LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+