alexdunae-w3c_validators 1.0.0

data/lib/w3c_validators/feed_validator.rb

@@ -0,0 +1,110 @@
+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+ may be either the fully-expanded path to the file or
+    # an IO object (like File).
+    #
+    # Returns W3CValidators::Results.
+    def validate_file(file_path)
+      if file_path.respond_to? :read
+        src = file_path.read
+      else
+        src = read_local_file(file_path)
+      end
+      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,227 @@
+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+ may be either the fully-expanded path to the file or
+    # an IO object (like File).
+    #
+    # Returns W3CValidators::Results.
+    def validate_file(file_path)
+      if file_path.respond_to? :read
+        src = file_path.read
+      else
+        src = read_local_file(file_path)
+      end 
+
+      return validate({:uploaded_file => src, :file_path => file_path}, 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/env:Fault/env:Reason") do |message|
+        message.elements.each("env:Text") do |m|
+          results.add_message(:error, {:mesage => m.text})
+        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/nu_validator.rb

@@ -0,0 +1,144 @@
+require 'json'
+
+module W3CValidators
+  class NuValidator < Validator
+    MARKUP_VALIDATOR_URI      = 'http://validator.nu/'
+
+    # Create a new instance of the NuValidator.
+    #
+    # ==== Options
+    # The +options+ hash allows you to set request parameters (see 
+    # http://wiki.whatwg.org/wiki/Validator.nu_Common_Input_Parameters) quickly. Request 
+    # parameters can also be set using set_charset! and set_doctype!.
+    #
+    # You can pass in your own validator's URI (i.e. 
+    # <tt>NuValidator.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
+
+
+    # Validate the markup of an URI.
+    #
+    # Returns W3CValidators::Results.
+    def validate_uri(uri)
+      return validate({:doc => uri})
+    end
+
+
+    # Validate the markup of a string.
+    #
+    # Returns W3CValidators::Results.
+    def validate_text(text)
+      return validate({:content => text})
+    end
+    
+    # Validate the markup of a local file.
+    #
+    # +file_path+ may be either the fully-expanded path to the file or
+    # an IO object (like File).
+    #
+    # Returns W3CValidators::Results.
+    def validate_file(file)
+      if file.respond_to? :read
+        src = file.read
+        file_path = file.path ||= nil
+      else
+        src = read_local_file(file)
+        file_path = file
+      end 
+
+      return validate({:file => src, :file_path => file_path})
+    end
+
+protected
+    def validate(options) # :nodoc:
+      options = get_request_options(options)
+
+      if options.has_key?(:doc)
+        response = send_request(options, :get)
+      else
+        response = send_request(options, :post)
+      end
+
+      @results = parse_json_response(response.body)
+      @results
+    end
+
+    # Perform sanity checks on request params
+    def get_request_options(options) # :nodoc:
+      options = @options.merge(options)
+     
+      options[:out] = 'json'
+
+      # only option that is currently supported
+      options[:showsource] = 'yes'
+
+      unless options[:doc] or options[:file] or options[:content]
+        raise ArgumentError, "an uri, file or block of 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[:doc] and not options[:doc].kind_of?(String)
+        options[:doc] = options[:doc].to_s
+      end
+      options
+    end
+
+
+    # Parse the JSON response.
+    #
+    # +response+ must be a Net::HTTPResponse.
+    #
+    # Returns W3CValidators::Results.
+    def parse_json_response(response) # :nodoc:
+      doc = JSON.parse(response)
+
+      result_params = {
+        :doctype => :html5,
+        :checked_by => MARKUP_VALIDATOR_URI
+        }
+
+      result_params[:uri] = doc['url'] ||= nil
+      if doc['source']
+        result_params[:charset] = doc['source']['encoding'] ||= nil
+      end
+
+      result_params[:validity] = !doc['messages'].any? { |msg| msg['type'] =~ /^error$/i }
+
+      results = Results.new(result_params)
+
+      doc['messages'].each do |msg|
+        if msg['type'] =~ /^error$/i
+          msg_type = :error
+        elsif msg['subType'] =~ /^warning$/
+          msg_type = :warning
+        else
+          next
+          # TODO: should throw exceptions here
+        end
+
+        message_params = {
+          :line => msg['firstLine'],
+          :col => msg['firstColumn'],
+          :message => msg['message'],
+          :source => msg['extract']
+        }
+
+        results.add_message(msg_type, message_params)
+      end
+
+      return results
+
+      rescue Exception => e
+        handle_exception e
+    end
+  end
+end