nokogiri 1.0.0 → 1.6.8.1

data/lib/nokogiri/xml/syntax_error.rb

@@ -1,21 +1,47 @@
 module Nokogiri
   module XML
-    class SyntaxError < SyntaxError
+    ###
+    # This class provides information about XML SyntaxErrors.  These
+    # exceptions are typically stored on Nokogiri::XML::Document#errors.
+    class SyntaxError < ::Nokogiri::SyntaxError
+      attr_reader :domain
+      attr_reader :code
+      attr_reader :level
+      attr_reader :file
+      attr_reader :line
+      attr_reader :str1
+      attr_reader :str2
+      attr_reader :str3
+      attr_reader :int1
+      attr_reader :column
+
+      ###
+      # return true if this is a non error
       def none?
         level == 0
       end
 
+      ###
+      # return true if this is a warning
       def warning?
         level == 1
       end
 
+      ###
+      # return true if this is an error
       def error?
         level == 2
       end
 
+      ###
+      # return true if this error is fatal
       def fatal?
         level == 3
       end
+
+      def to_s
+        super.chomp
+      end
     end
   end
 end

data/lib/nokogiri/xml/text.rb

@@ -1,6 +1,9 @@
 module Nokogiri
   module XML
-    class Text < Node
+    class Text < Nokogiri::XML::CharacterData
+      def content=(string)
+        self.native_content = string.to_s
+      end
     end
   end
 end

data/lib/nokogiri/xml/xpath/syntax_error.rb

@@ -0,0 +1,11 @@
+module Nokogiri
+  module XML
+    class XPath
+      class SyntaxError < XML::SyntaxError
+        def to_s
+          [super.chomp, str1].compact.join(': ')
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/xpath.rb

@@ -1,6 +1,10 @@
+require 'nokogiri/xml/xpath/syntax_error'
+
 module Nokogiri
   module XML
     class XPath
+      # The Nokogiri::XML::Document tied to this XPath instance
+      attr_accessor :document
     end
   end
 end

data/lib/nokogiri/xml/xpath_context.rb

@@ -2,9 +2,11 @@ module Nokogiri
   module XML
     class XPathContext
 
+      ###
+      # Register namespaces in +namespaces+
       def register_namespaces(namespaces)
         namespaces.each do |k, v|
-          k = k.gsub(/.*:/,'') # strip off 'xmlns:' or 'xml:'
+          k = k.to_s.gsub(/.*:/,'') # strip off 'xmlns:' or 'xml:'
           register_ns(k, v)
         end
       end

data/lib/nokogiri/xml.rb

@@ -1,66 +1,73 @@
+require 'nokogiri/xml/pp'
+require 'nokogiri/xml/parse_options'
 require 'nokogiri/xml/sax'
-require 'nokogiri/xml/before_handler'
-require 'nokogiri/xml/after_handler'
+require 'nokogiri/xml/searchable'
 require 'nokogiri/xml/node'
+require 'nokogiri/xml/attribute_decl'
+require 'nokogiri/xml/element_decl'
+require 'nokogiri/xml/element_content'
+require 'nokogiri/xml/character_data'
+require 'nokogiri/xml/namespace'
+require 'nokogiri/xml/attr'
 require 'nokogiri/xml/dtd'
-require 'nokogiri/xml/text'
 require 'nokogiri/xml/cdata'
+require 'nokogiri/xml/text'
 require 'nokogiri/xml/document'
+require 'nokogiri/xml/document_fragment'
+require 'nokogiri/xml/processing_instruction'
 require 'nokogiri/xml/node_set'
+require 'nokogiri/xml/syntax_error'
 require 'nokogiri/xml/xpath'
 require 'nokogiri/xml/xpath_context'
 require 'nokogiri/xml/builder'
 require 'nokogiri/xml/reader'
-require 'nokogiri/xml/syntax_error'
 require 'nokogiri/xml/notation'
-require 'nokogiri/xml/element'
-require 'nokogiri/xml/entity_declaration'
+require 'nokogiri/xml/entity_decl'
+require 'nokogiri/xml/schema'
+require 'nokogiri/xml/relax_ng'
 
 module Nokogiri
   class << self
-    def XML thing, url = nil, encoding = nil, options = 1
-      Nokogiri::XML.parse(thing, url, encoding, options)
+    ###
+    # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+    def XML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_XML, &block
+      Nokogiri::XML::Document.parse(thing, url, encoding, options, &block)
     end
   end
 
   module XML
-    # Parser options
-    PARSE_RECOVER     = 1 << 0  # Recover from errors
-    PARSE_NOENT       = 1 << 1  # Substitute entities
-    PARSE_DTDLOAD     = 1 << 2  # Load external subsets
-    PARSE_DTDATTR     = 1 << 3  # Default DTD attributes
-    PARSE_DTDVALID    = 1 << 4  # validate with the DTD
-    PARSE_NOERROR     = 1 << 5  # suppress error reports
-    PARSE_NOWARNING   = 1 << 6  # suppress warning reports
-    PARSE_PEDANTIC    = 1 << 7  # pedantic error reporting
-    PARSE_NOBLANKS    = 1 << 8  # remove blank nodes
-    PARSE_SAX1        = 1 << 9  # use the SAX1 interface internally
-    PARSE_XINCLUDE    = 1 << 10 # Implement XInclude substitition
-    PARSE_NONET       = 1 << 11 # Forbid network access
-    PARSE_NODICT      = 1 << 12 # Do not reuse the context dictionnary
-    PARSE_NSCLEAN     = 1 << 13 # remove redundant namespaces declarations
-    PARSE_NOCDATA     = 1 << 14 # merge CDATA as text nodes
-    PARSE_NOXINCNODE  = 1 << 15 # do not generate XINCLUDE START/END nodes
-
+    # Original C14N 1.0 spec canonicalization
+    XML_C14N_1_0 =       0
+    # Exclusive C14N 1.0 spec canonicalization
+    XML_C14N_EXCLUSIVE_1_0 =     1
+    # C14N 1.1 spec canonicalization
+    XML_C14N_1_1 = 2
     class << self
-      def parse string_or_io, url = nil, encoding = nil, options = 2159
-        if string_or_io.respond_to?(:read)
-          url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
-          string_or_io = string_or_io.read
-        end
+      ###
+      # Parse an XML document using the Nokogiri::XML::Reader API.  See
+      # Nokogiri::XML::Reader for mor information
+      def Reader string_or_io, url = nil, encoding = nil, options = ParseOptions::STRICT
 
-        # read_memory pukes on empty docs
-        return Document.new if string_or_io.nil? or string_or_io.empty?
+        options = Nokogiri::XML::ParseOptions.new(options) if Fixnum === options
+        # Give the options to the user
+        yield options if block_given?
 
-        Document.read_memory(string_or_io, url, encoding, options)
+        if string_or_io.respond_to? :read
+          return Reader.from_io(string_or_io, url, encoding, options.to_i)
+        end
+        Reader.from_memory(string_or_io, url, encoding, options.to_i)
       end
 
-      def substitute_entities=(value = true)
-        Document.substitute_entities = value
+      ###
+      # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+      def parse thing, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block
+        Document.parse(thing, url, encoding, options, &block)
       end
 
-      def load_external_subsets=(value = true)
-        Document.load_external_subsets = value
+      ####
+      # Parse a fragment from +string+ in to a NodeSet.
+      def fragment string
+        XML::DocumentFragment.parse(string)
       end
     end
   end

data/lib/nokogiri/xslt/stylesheet.rb

@@ -1,6 +1,25 @@
 module Nokogiri
   module XSLT
+    ###
+    # A Stylesheet represents an XSLT Stylesheet object.  Stylesheet creation
+    # is done through Nokogiri.XSLT.  Here is an example of transforming
+    # an XML::Document with a Stylesheet:
+    #
+    #   doc   = Nokogiri::XML(File.read('some_file.xml'))
+    #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
+    #
+    #   puts xslt.transform(doc)
+    #
+    # See Nokogiri::XSLT::Stylesheet#transform for more transformation
+    # information.
     class Stylesheet
+      ###
+      # Apply an XSLT stylesheet to an XML::Document.
+      # +params+ is an array of strings used as XSLT parameters.
+      # returns serialized document
+      def apply_to document, params = []
+        serialize(transform(document, params))
+      end
     end
   end
 end

data/lib/nokogiri/xslt.rb

@@ -1,10 +1,55 @@
 require 'nokogiri/xslt/stylesheet'
 
 module Nokogiri
+  class << self
+    ###
+    # Create a Nokogiri::XSLT::Stylesheet with +stylesheet+.
+    #
+    # Example:
+    #
+    #   xslt = Nokogiri::XSLT(File.read(ARGV[0]))
+    #
+    def XSLT stylesheet, modules = {}
+      XSLT.parse(stylesheet, modules)
+    end
+  end
+
+  ###
+  # See Nokogiri::XSLT::Stylesheet for creating and manipulating
+  # Stylesheet object.
   module XSLT
     class << self
-      def parse(string)
-        Stylesheet.parse_stylesheet_doc(XML.parse(string))
+      ###
+      # Parse the stylesheet in +string+, register any +modules+
+      def parse string, modules = {}
+        modules.each do |url, klass|
+          XSLT.register url, klass
+        end
+
+        if Nokogiri.jruby?
+          Stylesheet.parse_stylesheet_doc(XML.parse(string), string)
+        else
+          Stylesheet.parse_stylesheet_doc(XML.parse(string))
+        end
+      end
+
+      ###
+      # Quote parameters in +params+ for stylesheet safety
+      def quote_params params
+        parray = (params.instance_of?(Hash) ? params.to_a.flatten : params).dup
+        parray.each_with_index do |v,i|
+          if i % 2 > 0
+            parray[i]=
+              if v =~ /'/
+                "concat('#{ v.gsub(/'/, %q{', "'", '}) }')"
+              else
+                "'#{v}'";
+              end
+          else
+            parray[i] = v.to_s
+          end
+        end
+        parray.flatten
       end
     end
   end

data/lib/nokogiri.rb

@@ -1,51 +1,144 @@
+# -*- coding: utf-8 -*-
+# Modify the PATH on windows so that the external DLLs will get loaded.
+
+require 'rbconfig'
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+  # The line below caused a problem on non-GAE rack environment.
+  # unless defined?(JRuby::Rack::VERSION) || defined?(AppEngine::ApiProxy)
+  #
+  # However, simply cutting defined?(JRuby::Rack::VERSION) off resulted in
+  # an unable-to-load-nokogiri problem. Thus, now, Nokogiri checks the presense
+  # of appengine-rack.jar in $LOAD_PATH. If Nokogiri is on GAE, Nokogiri
+  # should skip loading xml jars. This is because those are in WEB-INF/lib and
+  # already set in the classpath.
+  unless $LOAD_PATH.to_s.include?("appengine-rack")
+    require 'stringio'
+    require 'isorelax.jar'
+    require 'jing.jar'
+    require 'nekohtml.jar'
+    require 'nekodtd.jar'
+    require 'xercesImpl.jar'
+    require 'serializer.jar'
+    require 'xalan.jar'
+    require 'xml-apis.jar'
+  end
+end
+
+begin
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "nokogiri/#{$1}/nokogiri"
+rescue LoadError
+  require 'nokogiri/nokogiri'
+end
 require 'nokogiri/version'
+require 'nokogiri/syntax_error'
 require 'nokogiri/xml'
 require 'nokogiri/xslt'
 require 'nokogiri/html'
-require 'nokogiri/decorators'
+require 'nokogiri/decorators/slop'
 require 'nokogiri/css'
 require 'nokogiri/html/builder'
-require 'nokogiri/hpricot'
-
-# Modify the PATH on windows so that the external DLLs will get loaded.
-ENV['PATH'] += ";" + File.expand_path(
-  File.join(File.dirname(__FILE__), "..", "ext", "nokogiri")
-) if RUBY_PLATFORM =~ /mswin/i
-
-require 'nokogiri/native'
 
+# Nokogiri parses and searches XML/HTML very quickly, and also has
+# correctly implemented CSS3 selector support as well as XPath 1.0
+# support.
+#
+# Parsing a document returns either a Nokogiri::XML::Document, or a
+# Nokogiri::HTML::Document depending on the kind of document you parse.
+#
+# Here is an example:
+#
+#   require 'nokogiri'
+#   require 'open-uri'
+#
+#   # Get a Nokogiri::HTML:Document for the page we’re interested in...
+#
+#   doc = Nokogiri::HTML(open('http://www.google.com/search?q=tenderlove'))
+#
+#   # Do funky things with it using Nokogiri::XML::Node methods...
+#
+#   ####
+#   # Search for nodes by css
+#   doc.css('h3.r a.l').each do |link|
+#     puts link.content
+#   end
+#
+# See Nokogiri::XML::Searchable#css for more information about CSS searching.
+# See Nokogiri::XML::Searchable#xpath for more information about XPath searching.
 module Nokogiri
   class << self
-    attr_accessor :error_handler
-
+    ###
+    # Parse an HTML or XML document.  +string+ contains the document.
     def parse string, url = nil, encoding = nil, options = nil
-      doc =
-        if string =~ /^\s*<[^Hh>]*html/i # Probably html
-          Nokogiri::HTML.parse(string, url, encoding, options || 2145)
-        else
-          Nokogiri::XML.parse(string, url, encoding, options || 2159)
-        end
-      yield doc if block_given?
-      doc
+      if string.respond_to?(:read) ||
+          /^\s*<(?:!DOCTYPE\s+)?html[\s>]/i === string[0, 512]
+        # Expect an HTML indicator to appear within the first 512
+        # characters of a document. (<?xml ?> + <?xml-stylesheet ?>
+        # shouldn't be that long)
+        Nokogiri.HTML(string, url, encoding,
+          options || XML::ParseOptions::DEFAULT_HTML)
+      else
+        Nokogiri.XML(string, url, encoding,
+          options || XML::ParseOptions::DEFAULT_XML)
+      end.tap { |doc|
+        yield doc if block_given?
+      }
     end
 
+    ###
+    # Create a new Nokogiri::XML::DocumentFragment
     def make input = nil, opts = {}, &blk
       if input
-        Nokogiri::XML::Node.new_from_str(input)
+        Nokogiri::HTML.fragment(input).children.first
       else
         Nokogiri(&blk)
       end
     end
+
+    ###
+    # Parse a document and add the Slop decorator.  The Slop decorator
+    # implements method_missing such that methods may be used instead of CSS
+    # or XPath.  For example:
+    #
+    #   doc = Nokogiri::Slop(<<-eohtml)
+    #     <html>
+    #       <body>
+    #         <p>first</p>
+    #         <p>second</p>
+    #       </body>
+    #     </html>
+    #   eohtml
+    #   assert_equal('second', doc.html.body.p[1].text)
+    #
+    def Slop(*args, &block)
+      Nokogiri(*args, &block).slop!
+    end
+
+    def install_default_aliases
+      # Make sure to support some popular encoding aliases not known by
+      # all iconv implementations.
+      {
+        'Windows-31J' => 'CP932',	# Windows-31J is the IANA registered name of CP932.
+      }.each { |alias_name, name|
+        EncodingHandler.alias(name, alias_name) if EncodingHandler[alias_name].nil?
+      }
+    end
   end
 
-  self.error_handler = lambda { |syntax_error| }
+  Nokogiri.install_default_aliases
 end
 
+###
+# Parser a document contained in +args+.  Nokogiri will try to guess what
+# type of document you are attempting to parse.  For more information, see
+# Nokogiri.parse
+#
+# To specify the type of document, use Nokogiri.XML or Nokogiri.HTML.
 def Nokogiri(*args, &block)
   if block_given?
-    builder = Nokogiri::HTML::Builder.new(&block)
-    return builder.doc
+    Nokogiri::HTML::Builder.new(&block).doc.root
   else
-    Nokogiri::HTML.parse(*args)
+    Nokogiri.parse(*args)
   end
 end

data/lib/xsd/xmlparser/nokogiri.rb

@@ -0,0 +1,102 @@
+require 'nokogiri'
+
+module XSD # :nodoc:
+  module XMLParser # :nodoc:
+    ###
+    # Nokogiri XML parser for soap4r.
+    #
+    # Nokogiri may be used as the XML parser in soap4r.  Simply require
+    # 'xsd/xmlparser/nokogiri' in your soap4r applications, and soap4r
+    # will use Nokogiri as it's XML parser.  No other changes should be
+    # required to use Nokogiri as the XML parser.
+    #
+    # Example (using UW ITS Web Services):
+    #
+    #   require 'rubygems'
+    #   require 'nokogiri'
+    #   gem 'soap4r'
+    #   require 'defaultDriver'
+    #   require 'xsd/xmlparser/nokogiri'
+    #
+    #   obj = AvlPortType.new
+    #   obj.getLatestByRoute(obj.getAgencies.first, 8).each do |bus|
+    #     p "#{bus.routeID}, #{bus.longitude}, #{bus.latitude}"
+    #   end
+    #
+    class Nokogiri < XSD::XMLParser::Parser
+      ###
+      # Create a new XSD parser with +host+ and +opt+
+      def initialize host, opt = {}
+        super
+        @parser = ::Nokogiri::XML::SAX::Parser.new(self, @charset || 'UTF-8')
+      end
+
+      ###
+      # Start parsing +string_or_readable+
+      def do_parse string_or_readable
+        @parser.parse(string_or_readable)
+      end
+
+      ###
+      # Handle the start_element event with +name+ and +attrs+
+      def start_element name, attrs = []
+        super(name, Hash[*attrs.flatten])
+      end
+
+      ###
+      # Handle the end_element event with +name+
+      def end_element name
+        super
+      end
+
+      ###
+      # Handle errors with message +msg+
+      def error msg
+        raise ParseError.new(msg)
+      end
+      alias :warning :error
+
+      ###
+      # Handle cdata_blocks containing +string+
+      def cdata_block string
+        characters string
+      end
+
+      ###
+      # Called at the beginning of an element
+      # +name+ is the element name
+      # +attrs+ is a list of attributes
+      # +prefix+ is the namespace prefix for the element
+      # +uri+ is the associated namespace URI
+      # +ns+ is a hash of namespace prefix:urls associated with the element
+      def start_element_namespace name, attrs = [], prefix = nil, uri = nil, ns = []
+        ###
+        # Deal with SAX v1 interface
+        name = [prefix, name].compact.join(':')
+        attributes = ns.map { |ns_prefix,ns_uri|
+          [['xmlns', ns_prefix].compact.join(':'), ns_uri]
+        } + attrs.map { |attr|
+          [[attr.prefix, attr.localname].compact.join(':'), attr.value]
+        }.flatten
+        start_element name, attributes
+      end
+
+      ###
+      # Called at the end of an element
+      # +name+ is the element's name
+      # +prefix+ is the namespace prefix associated with the element
+      # +uri+ is the associated namespace URI
+      def end_element_namespace name, prefix = nil, uri = nil
+        ###
+        # Deal with SAX v1 interface
+        end_element [prefix, name].compact.join(':')
+      end
+
+      %w{ xmldecl start_document end_document comment }.each do |name|
+        class_eval %{ def #{name}(*args); end }
+      end
+
+      add_factory(self)
+    end
+  end
+end

data/patches/sort-patches-by-date

@@ -0,0 +1,25 @@
+#! /usr/bin/env ruby
+
+require "date"
+
+dir = ARGV[0] || raise("ERROR: arg1 must be dir")
+
+Dir.chdir dir
+
+files_and_times = {}
+Dir["*.patch"].sort.each do |filename|
+  dateline = `cat #{filename} | grep "Date:"`
+  datestr = dateline.split("Date:").last.strip
+  time = DateTime.parse datestr
+  files_and_times[filename] = time
+end
+
+count = 0
+files_and_times.sort_by {|k,v| v}.each do |filename, time|
+  count += 1
+  _, patch_name = filename.split("-", 2)
+  new_filename = sprintf("%4.4d-%s", count, patch_name)
+  printf "mv -f %s %s # %s\n", filename, new_filename, time
+end
+
+STDERR.print "\n**\n** REMEMBER TO UPDATE THE Manifest.txt FILE\n**\n"

data/suppressions/README.txt

@@ -0,0 +1 @@
+This directory contains valgrind suppression files generated by the hoe-debugging gem.

data/suppressions/nokogiri_ree-1.8.7.358.supp

@@ -0,0 +1,61 @@
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Addr8
+   fun:garbage_collect
+   fun:rb_newobj
+   fun:rb_node_newnode
+   fun:ruby_yyparse
+   fun:yycompile
+   fun:load_file
+   fun:rb_load
+   fun:rb_require_safe
+   fun:rb_call0
+   fun:rb_call
+   fun:eval_fcall
+   fun:rb_eval
+   fun:rb_load
+   fun:rb_require_safe
+   fun:rb_call0
+   fun:rb_call
+   fun:eval_fcall
+   fun:rb_eval
+   fun:rb_load
+   fun:rb_require_safe
+   fun:rb_protect
+   fun:require_libraries
+   fun:proc_options
+   fun:ruby_process_options
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Addr8
+   fun:garbage_collect_0
+   fun:rb_newobj
+   fun:rb_node_newnode
+   fun:ruby_yyparse
+   fun:yycompile
+   fun:load_file
+   fun:rb_load
+   fun:rb_require_safe
+   fun:rb_call0
+   fun:rb_call
+   fun:eval_fcall
+   fun:rb_eval
+   fun:rb_load
+   fun:rb_require_safe
+   fun:rb_call0
+   fun:rb_call
+   fun:eval_fcall
+   fun:rb_eval
+   fun:rb_load
+   fun:rb_require_safe
+   fun:rb_protect
+   fun:require_libraries
+   fun:proc_options
+   fun:ruby_process_options
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Addr8
+   fun:rb_gc_wipe_stack
+}