nokogiri 1.2.3-x86-mswin32-60 → 1.4.5-x86-mswin32-60

data/lib/nokogiri/ffi/xml/text.rb

@@ -0,0 +1,18 @@
+module Nokogiri
+  module XML
+    class Text < CharacterData
+
+      def self.new(string, document, *rest) # :nodoc:
+        node_ptr = LibXML.xmlNewText(string)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct[:doc] = document.cstruct[:doc]
+
+        node = Node.wrap(node_cstruct, self)
+        node.send :initialize, string, document, *rest
+        yield node if block_given?
+        node
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Nokogiri
+  module XML
+    class XPath
+      
+      attr_accessor :cstruct # :nodoc:
+
+    end
+  end
+end

data/lib/nokogiri/ffi/xml/xpath_context.rb

@@ -0,0 +1,153 @@
+module Nokogiri
+  module XML
+    class XPathContext
+
+      attr_accessor :cstruct # :nodoc:
+
+      def register_ns(prefix, uri) # :nodoc:
+        LibXML.xmlXPathRegisterNs(cstruct, prefix, uri)
+      end
+
+      def register_variable(name, value) # :nodoc:
+        xml_value = LibXML.xmlXPathNewCString(value);
+        LibXML.xmlXPathRegisterVariable(cstruct, name, xml_value);
+      end
+
+      def evaluate(search_path, xpath_handler=nil) # :nodoc:
+        lookup = nil # to keep lambda in scope long enough to avoid a possible GC tragedy
+        query = search_path.to_s
+
+        if xpath_handler
+          lookup = lambda do |ctx, name, uri|
+            return nil unless xpath_handler.respond_to?(name)
+            ruby_funcall name, xpath_handler
+          end
+          LibXML.xmlXPathRegisterFuncLookup(cstruct, lookup, nil);
+        end
+
+        exception_handler = lambda do |ctx, error|
+          raise XPath::SyntaxError.wrap(error)
+        end
+        LibXML.xmlResetLastError()
+        LibXML.xmlSetStructuredErrorFunc(nil, exception_handler)
+
+        generic_exception_handler = lambda do |ctx, msg|
+          raise RuntimeError.new(msg) # TODO: varargs
+        end
+        LibXML.xmlSetGenericErrorFunc(nil, generic_exception_handler)
+
+        xpath_ptr = LibXML.xmlXPathEvalExpression(query, cstruct)
+
+        LibXML.xmlSetStructuredErrorFunc(nil, nil)
+        LibXML.xmlSetGenericErrorFunc(nil, nil)
+
+        if xpath_ptr.null?
+          error = LibXML.xmlGetLastError()
+          raise XPath::SyntaxError.wrap(error)
+        end
+
+        xpath = XML::XPath.new
+        xpath.cstruct = LibXML::XmlXpathObject.new(xpath_ptr)
+        xpath.document = cstruct.document.ruby_doc
+
+        case xpath.cstruct[:type]
+        when LibXML::XmlXpathObject::XPATH_NODESET
+          if xpath.cstruct[:nodesetval].null?
+            NodeSet.new(xpath.document)
+          else
+            NodeSet.wrap(xpath.cstruct[:nodesetval], xpath.document)
+          end
+        when LibXML::XmlXpathObject::XPATH_STRING
+          xpath.cstruct[:stringval]
+        when LibXML::XmlXpathObject::XPATH_NUMBER
+          xpath.cstruct[:floatval]
+        when LibXML::XmlXpathObject::XPATH_BOOLEAN
+          0 != xpath.cstruct[:boolval]
+        else
+          NodeSet.new(xpath.document)
+        end
+      end
+
+      def self.new(node) # :nodoc:
+        LibXML.xmlXPathInit()
+
+        ptr = LibXML.xmlXPathNewContext(node.cstruct[:doc])
+
+        ctx = allocate
+        ctx.cstruct = LibXML::XmlXpathContext.new(ptr)
+        ctx.cstruct[:node] = node.cstruct
+        ctx
+      end
+
+      private
+
+      #
+      #  returns a lambda that will call the handler function with marshalled parameters
+      #
+      def ruby_funcall(name, xpath_handler) # :nodoc:
+        lambda do |ctx, nargs|
+          parser_context = LibXML::XmlXpathParserContext.new(ctx)
+          context_cstruct = parser_context.context
+          document = context_cstruct.document.ruby_doc
+
+          params = []
+
+          nargs.times do |j|
+            obj = LibXML::XmlXpathObject.new(LibXML.valuePop(ctx))
+            case obj[:type]
+            when LibXML::XmlXpathObject::XPATH_STRING
+              params.unshift obj[:stringval]
+            when LibXML::XmlXpathObject::XPATH_BOOLEAN
+              params.unshift obj[:boolval] == 1
+            when LibXML::XmlXpathObject::XPATH_NUMBER
+              params.unshift obj[:floatval]
+            when LibXML::XmlXpathObject::XPATH_NODESET
+              params.unshift NodeSet.wrap(obj[:nodesetval], document)
+            else
+              char_ptr = params.unshift LibXML.xmlXPathCastToString(obj)
+              string = char_ptr.read_string
+              LibXML.xmlFree(char_ptr)
+              string
+            end
+          end
+
+          result = xpath_handler.send(name, *params)
+
+          case result.class.to_s
+          when Fixnum.to_s, Float.to_s, Bignum.to_s
+            LibXML.xmlXPathReturnNumber(ctx, result)
+          when String.to_s
+            LibXML.xmlXPathReturnString(
+              ctx,
+              LibXML.xmlXPathWrapCString(result)
+              )
+          when TrueClass.to_s
+            LibXML.xmlXPathReturnTrue(ctx)
+          when FalseClass.to_s
+            LibXML.xmlXPathReturnFalse(ctx)
+          when NilClass.to_s
+            ;
+          when Array.to_s
+            node_set = XML::NodeSet.new(document, result)
+            LibXML.xmlXPathReturnNodeSet(
+              ctx,
+              LibXML.xmlXPathNodeSetMerge(nil, node_set.cstruct)
+              )
+          else
+            if result.is_a?(XML::NodeSet)
+              LibXML.xmlXPathReturnNodeSet(
+                ctx,
+                LibXML.xmlXPathNodeSetMerge(nil, result.cstruct)
+                )
+            else
+              raise RuntimeError.new("Invalid return type #{result.class.inspect}")
+            end
+          end
+
+          nil
+        end # lambda
+      end # ruby_funcall
+
+    end
+  end
+end

data/lib/nokogiri/ffi/xslt/stylesheet.rb

@@ -0,0 +1,77 @@
+module Nokogiri
+  module XSLT
+    @modules = {}
+
+    @method_caller = lambda do |context, nargs|
+      # TODO
+    end
+
+    @init_func = lambda do |context, uri|
+      klass = @modules[uri]
+      klass.instance_methods(false).each do |method_name|
+	LibXML.xsltRegisterExtFunction(context, method_name, uri, @method_caller)
+      end
+      klass.new
+    end
+
+    @shutdown_func = lambda do |context, uri, data|
+    end
+
+    def self.register(uri, klass) # :nodoc:
+      raise NotImplementedError.new("sorry, you should implement me.")
+    end
+
+    class Stylesheet
+
+      attr_accessor :cstruct # :nodoc:
+
+      def self.parse_stylesheet_doc(document) # :nodoc:
+        LibXML.exsltRegisterAll
+
+        generic_exception_handler = lambda do |ctx, msg|
+          raise RuntimeError.new(msg) # TODO: varargs
+        end
+        LibXML.xsltSetGenericErrorFunc(nil, generic_exception_handler)
+
+        ss = LibXML.xsltParseStylesheetDoc(LibXML.xmlCopyDoc(document.cstruct, 1)) # 1 => recursive
+
+        LibXML.xsltSetGenericErrorFunc(nil, nil)
+
+        obj = allocate
+        obj.cstruct = LibXML::XsltStylesheet.new(ss)
+        obj
+      end
+
+      def serialize(document) # :nodoc:
+        buf_ptr = FFI::Buffer.new :pointer
+        buf_len = FFI::Buffer.new :int
+        LibXML.xsltSaveResultToString(buf_ptr, buf_len, document.cstruct, cstruct)
+        buf = Nokogiri::LibXML::XmlAlloc.new(buf_ptr.get_pointer(0))
+        buf.pointer.read_string(buf_len.get_int(0))
+      end
+
+      def transform(document, params=[]) # :nodoc:
+        unless document.kind_of? Nokogiri::XML::Document
+          raise ArgumentError, "argument must be a Nokogiri::XML::Document"
+        end
+
+        params = params.to_a.flatten if params.is_a?(Hash)
+        raise(TypeError) unless params.is_a?(Array)
+
+        param_arr = FFI::MemoryPointer.new(:pointer, params.length + 1, false)
+
+        # Keep the MemoryPointer instances alive until after the call
+        ptrs = params.map { |param | FFI::MemoryPointer.from_string(param.to_s) }
+        param_arr.put_array_of_pointer(0, ptrs)
+        
+        # Terminate the list with a NULL pointer
+        param_arr.put_pointer(LibXML.pointer_offset(params.length), nil)
+
+        ptr = LibXML.xsltApplyStylesheet(cstruct, document.cstruct, param_arr)
+        raise(RuntimeError, "could not perform xslt transform on document") if ptr.null?
+
+        XML::Document.wrap(ptr)
+      end
+    end
+  end
+end

data/lib/nokogiri/html.rb

@@ -1,69 +1,35 @@
 require 'nokogiri/html/entity_lookup'
 require 'nokogiri/html/document'
+require 'nokogiri/html/document_fragment'
+require 'nokogiri/html/sax/parser_context'
 require 'nokogiri/html/sax/parser'
+require 'nokogiri/html/element_description'
 
 module Nokogiri
   class << self
     ###
-    # Parse HTML.  +thing+ may be a String, or any object that
-    # responds to _read_ and _close_ such as an IO, or StringIO.
-    # +url+ is resource where this document is located.  +encoding+ is the
-    # encoding that should be used when processing the document. +options+
-    # is a number that sets options in the parser, such as
-    # Nokogiri::XML::PARSE_RECOVER.  See the constants in
-    # Nokogiri::XML.
-    def HTML thing, url = nil, encoding = nil, options = 2145
-      Nokogiri::HTML.parse(thing, url, encoding, options)
+    # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
+    def HTML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
+      Nokogiri::HTML::Document.parse(thing, url, encoding, options, &block)
     end
   end
 
   module HTML
-    # Parser options
-    PARSE_NOERROR   = 1 << 5  # No error reports
-    PARSE_NOWARNING = 1 << 6  # No warnings 
-    PARSE_PEDANTIC  = 1 << 7  # Pedantic errors
-    PARSE_NOBLANKS  = 1 << 8  # Remove blanks nodes
-    PARSE_NONET     = 1 << 11 # No network access
-
     class << self
       ###
-      # Parse HTML.  See Nokogiri.HTML.
-      def parse string_or_io, url = nil, encoding = nil, options = 2145
-        if string_or_io.respond_to?(:encoding)
-          encoding ||= string_or_io.encoding.name
-        end
-
-        if string_or_io.respond_to?(:read)
-          url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
-          return Document.read_io(string_or_io, url, encoding, options)
-        end
-
-        return Document.new if(string_or_io.length == 0)
-        Document.read_memory(string_or_io, url, encoding, options)
+      # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
+      def parse thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
+        Document.parse(thing, url, encoding, options, &block)
       end
 
       ####
       # Parse a fragment from +string+ in to a NodeSet.
-      def fragment string
-        doc = parse(string)
-        fragment = XML::DocumentFragment.new(doc)
-        finder = lambda { |c, f|
-          c.each do |child|
-            if string == child.content && child.name == 'text'
-              fragment.add_child(child)
-            end
-            fragment.add_child(child) if string =~ /<#{child.name}/
-          end
-          return fragment if fragment.children.length > 0
-
-          c.each do |child|
-            finder.call(child.children, f)
-          end
-        }
-        finder.call(doc.children, finder)
-        fragment
+      def fragment string, encoding = nil
+        HTML::DocumentFragment.parse string, encoding
       end
     end
+
+    # Instance of Nokogiri::HTML::EntityLookup
     NamedCharacters = EntityLookup.new
   end
 end

data/lib/nokogiri/html/builder.rb

@@ -1,6 +1,32 @@
 module Nokogiri
   module HTML
-    class Builder < XML::Builder
+    ###
+    # Nokogiri HTML builder is used for building HTML documents.  It is very
+    # similar to the Nokogiri::XML::Builder.  In fact, you should go read the
+    # documentation for Nokogiri::XML::Builder before reading this
+    # documentation.
+    #
+    # == Synopsis:
+    #
+    # Create an HTML document with a body that has an onload attribute, and a
+    # span tag with a class of "bold" that has content of "Hello world".
+    #
+    #   builder = Nokogiri::HTML::Builder.new do |doc|
+    #     doc.html {
+    #       doc.body(:onload => 'some_func();') {
+    #         doc.span.bold {
+    #           doc.text "Hello world"
+    #         }
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_html
+    #
+    # The HTML builder inherits from the XML builder, so make sure to read the
+    # Nokogiri::XML::Builder documentation.
+    class Builder < Nokogiri::XML::Builder
+      ###
+      # Convert the builder to HTML
       def to_html
         @doc.to_html
       end

data/lib/nokogiri/html/document.rb

@@ -1,14 +1,208 @@
 module Nokogiri
   module HTML
-    class Document < XML::Document
+    class Document < Nokogiri::XML::Document
+      ###
+      # Get the meta tag encoding for this document.  If there is no meta tag,
+      # then nil is returned.
+      def meta_encoding
+        meta = meta_content_type and
+          /charset\s*=\s*([\w-]+)/i.match(meta['content'])[1]
+      end
+
+      ###
+      # Set the meta tag encoding for this document.  If there is no meta
+      # content tag, the encoding is not set.
+      def meta_encoding= encoding
+        meta = meta_content_type and
+          meta['content'] = "text/html; charset=%s" % encoding
+      end
+
+      def meta_content_type
+        css('meta[@http-equiv]').find { |node|
+          node['http-equiv'] =~ /\AContent-Type\z/i
+        }
+      end
+      private :meta_content_type
+
+      ###
+      # Get the title string of this document.  Return nil if there is
+      # no title tag.
+      def title
+        title = at('title') and title.inner_text
+      end
+
+      ###
+      # Set the title string of this document.  If there is no head
+      # element, the title is not set.
+      def title=(text)
+        unless title = at('title')
+          head = at('head') or return nil
+          title = Nokogiri::XML::Node.new('title', self)
+          head << title
+        end
+        title.children = XML::Text.new(text, self)
+      end
+
       ####
-      # Serialize this Document with +encoding+ using +options+
-      def serialize encoding = nil, options = XML::Node::SaveOptions::FORMAT |
-        XML::Node::SaveOptions::AS_HTML |
-        XML::Node::SaveOptions::NO_DECLARATION |
-        XML::Node::SaveOptions::NO_EMPTY_TAGS
+      # Serialize Node using +options+.  Save options can also be set using a
+      # block. See SaveOptions.
+      #
+      # These two statements are equivalent:
+      #
+      #  node.serialize(:encoding => 'UTF-8', :save_with => FORMAT | AS_XML)
+      #
+      # or
+      #
+      #   node.serialize(:encoding => 'UTF-8') do |config|
+      #     config.format.as_xml
+      #   end
+      #
+      def serialize options = {}
+        options[:save_with] ||= XML::Node::SaveOptions::DEFAULT_HTML
+        super
+      end
+
+      ####
+      # Create a Nokogiri::XML::DocumentFragment from +tags+
+      def fragment tags = nil
+        DocumentFragment.new(self, tags, self.root)
+      end
+
+      class << self
+        ###
+        # Parse HTML.  +thing+ may be a String, or any object that
+        # responds to _read_ and _close_ such as an IO, or StringIO.
+        # +url+ is resource where this document is located.  +encoding+ is the
+        # encoding that should be used when processing the document. +options+
+        # is a number that sets options in the parser, such as
+        # Nokogiri::XML::ParseOptions::RECOVER.  See the constants in
+        # Nokogiri::XML::ParseOptions.
+        def parse string_or_io, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML
+
+          options = Nokogiri::XML::ParseOptions.new(options) if Fixnum === options
+          # Give the options to the user
+          yield options if block_given?
+
+          if string_or_io.respond_to?(:encoding)
+            unless string_or_io.encoding.name == "ASCII-8BIT"
+              encoding ||= string_or_io.encoding.name
+            end
+          end
+
+          if string_or_io.respond_to?(:read)
+            url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+            if !encoding
+              # Perform further encoding detection that libxml2 does
+              # not do.
+              string_or_io = EncodingReader.new(string_or_io)
+              begin
+                return read_io(string_or_io, url, encoding, options.to_i)
+              rescue EncodingFoundException => e
+                # A retry is required because libxml2 has a problem in
+                # that it cannot switch encoding well in the middle of
+                # parsing, especially if it has already seen a
+                # non-ASCII character when it finds an encoding hint.
+                encoding = e.encoding
+              end
+            end
+            return read_io(string_or_io, url, encoding, options.to_i)
+          end
+
+          # read_memory pukes on empty docs
+          return new if string_or_io.nil? or string_or_io.empty?
+
+          if !encoding
+            encoding = EncodingReader.detect_encoding(string_or_io)
+          end
+
+          read_memory(string_or_io, url, encoding, options.to_i)
+        end
+      end
+
+      class EncodingFoundException < Exception # :nodoc:
+        attr_reader :encoding
+
+        def initialize(encoding)
+          @encoding = encoding
+          super("encoding found: %s" % encoding)
+        end
+      end
+
+      class EncodingReader # :nodoc:
+        class SAXHandler < Nokogiri::XML::SAX::Document # :nodoc:
+          attr_reader :encoding
+
+          def found(encoding)
+            @encoding = encoding
+            throw :found
+          end
+
+          def not_found(encoding)
+            found nil
+          end
+
+          def start_element(name, attrs = [])
+            case name
+            when /\A(?:div|h1|img|p|br)\z/
+              not_found
+            when 'meta'
+              attr = Hash[attrs]
+              http_equiv = attr['http-equiv'] and
+                http_equiv.match(/\AContent-Type\z/i) and
+                content = attr['content'] and
+                m = content.match(/;\s*charset\s*=\s*([\w-]+)/) and
+                found m[1]
+            end
+          end
+        end
+
+        def self.detect_encoding(chunk)
+          m = chunk.match(/\A(<\?xml[ \t\r\n]+[^>]*>)/) and
+            return Nokogiri.XML(m[1]).encoding
+
+          handler = SAXHandler.new
+          parser = Nokogiri::HTML::SAX::Parser.new(handler)
+          catch(:found) {
+            parser.parse(chunk)
+          }
+          handler.encoding
+        rescue => e
+          nil
+        end
+
+        def initialize(io)
+          @io = io
+          @firstchunk = nil
+        end
+
+        def read(len)
+          # no support for a call without len
+
+          if !@firstchunk
+            @firstchunk = @io.read(len) or return nil
+
+            # This implementation expects and assumes that the first
+            # call from htmlReadIO() is made with a length long enough
+            # (~1KB) to achieve further encoding detection that
+            # libxml2 does not do.
+            if encoding = EncodingReader.detect_encoding(@firstchunk)
+              raise EncodingFoundException, encoding
+            end
+
+            # This chunk is stored for the next read in retry.
+            return @firstchunk
+          end
 
-        super(encoding, options)
+          ret = @firstchunk.slice!(0, len)
+          if (len -= ret.length) > 0
+            rest = @io.read(len) and ret << rest
+          end
+          if ret.empty?
+            nil
+          else
+            ret
+          end
+        end
       end
     end
   end