romanbsd-tarantula 0.1.8

data/vendor/w3c_validators/README

@@ -0,0 +1,120 @@
+= 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 or an IO object
+* +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.
+
+Thanks to Ryan King (http://theryanking.com/) for creating the 0.9.2 update.
+
+Thanks to Ryan King (http://theryanking.com/), Jonathan Julian (http://jonathanjulian.org/)
+and Sylvain LaFleur for creating the 0.9.3 update.

data/vendor/w3c_validators/README.svn

@@ -0,0 +1,4 @@
+Based on rev 26, patched by Roman Shterenzon <romanbsd@yahoo.com>
+in order to use POST instead of GET in order to avoid forming URIs that
+are too long. The read_local_file method was changed so the file doesn't have
+to be writeable (it was a bug).

data/vendor/w3c_validators/lib/w3c_validators/constants.rb

@@ -0,0 +1,80 @@
+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',
+               :html5 => 'HTML 5',
+               :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/vendor/w3c_validators/lib/w3c_validators/css_validator.rb

@@ -0,0 +1,149 @@
+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+ 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[: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/vendor/w3c_validators/lib/w3c_validators/exceptions.rb

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

data/vendor/w3c_validators/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/vendor/w3c_validators/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