nokogiri 1.2.3-java → 1.3.0-java

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

@@ -0,0 +1,55 @@
+module Nokogiri
+  module XML
+    class Schema
+
+      attr_accessor :cstruct # :nodoc:
+
+      def validate_document(document) # :nodoc:
+        errors = []
+
+        ctx = LibXML.xmlSchemaNewValidCtxt(cstruct)
+        raise RuntimeError.new("Could not create a validation context") if ctx.null?
+
+        LibXML.xmlSchemaSetValidStructuredErrors(ctx,
+          SyntaxError.error_array_pusher(errors), nil) unless Nokogiri.is_2_6_16?
+
+        LibXML.xmlSchemaValidateDoc(ctx, document.cstruct)
+
+        LibXML.xmlSchemaFreeValidCtxt(ctx)
+
+        errors
+      end
+      private :validate_document
+
+      def self.read_memory(content) # :nodoc:
+        ctx = LibXML.xmlSchemaNewMemParserCtxt(content, content.length)
+
+        errors = []
+
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(errors))
+        LibXML.xmlSchemaSetParserStructuredErrors(ctx, SyntaxError.error_array_pusher(errors), nil) unless Nokogiri.is_2_6_16?
+
+        schema_ptr = LibXML.xmlSchemaParse(ctx)
+
+        LibXML.xmlSetStructuredErrorFunc(nil, nil)
+        LibXML.xmlSchemaFreeParserCtxt(ctx)
+
+        if schema_ptr.null?
+          error = LibXML.xmlGetLastError
+          if error
+            raise SyntaxError.wrap(error)
+          else
+            raise RuntimeError, "Could not parse document"
+          end
+        end
+
+        schema = allocate
+        schema.cstruct = LibXML::XmlSchema.new schema_ptr
+        schema.errors = errors
+        schema
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,76 @@
+module Nokogiri
+  module XML
+    class SyntaxError < ::Nokogiri::SyntaxError
+
+      attr_accessor :cstruct # :nodoc:
+
+      def domain # :nodoc:
+        cstruct[:domain]
+      end
+
+      def code # :nodoc:
+        cstruct[:code]
+      end
+
+      def message # :nodoc:
+        cstruct[:message]
+      end
+      undef_method :inspect
+      alias_method :inspect, :message
+      undef_method :to_s
+      alias_method :to_s, :message
+
+      def level # :nodoc:
+        cstruct[:level]
+      end
+
+      def file # :nodoc:
+        cstruct[:file].null? ? nil : cstruct[:file]
+      end
+
+      def line # :nodoc:
+        cstruct[:line]
+      end
+
+      def str1 # :nodoc:
+        cstruct[:str1].null? ? nil : cstruct[:str1]
+      end
+
+      def str2 # :nodoc:
+        cstruct[:str].null? ? nil : cstruct[:str]
+      end
+
+      def str3 # :nodoc:
+        cstruct[:str3].null? ? nil : cstruct[:str3]
+      end
+
+      def int1 # :nodoc:
+        cstruct[:int1]
+      end
+
+      def column # :nodoc:
+        cstruct[:int2]
+      end
+      alias_method :int2, :column
+
+      class << self
+        def error_array_pusher(array) # :nodoc:
+          Proc.new do |_ignored_, error|
+            array << wrap(error) if array
+          end
+        end
+
+        def wrap(error_ptr) # :nodoc:
+          error_struct = LibXML::XmlSyntaxError.allocate
+          LibXML.xmlCopyError(error_ptr, error_struct)
+          error_cstruct = LibXML::XmlSyntaxError.new(error_struct)
+          error = self.new # will generate XML::XPath::SyntaxError or XML::SyntaxError
+          error.cstruct = error_cstruct
+          error
+        end
+      end
+
+    end
+  end
+
+end

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

@@ -0,0 +1,18 @@
+module Nokogiri
+  module XML
+    class Text < Node
+
+      def self.new(string, document, *rest) # :nodoc:
+        node_ptr = LibXML.xmlNewText(string)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct[:doc] = document.cstruct
+
+        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,19 @@
+module Nokogiri
+  module XML
+    class XPath
+      
+      attr_accessor :cstruct # :nodoc:
+
+      def node_set # :nodoc:
+        ptr = cstruct[:nodesetval] if cstruct[:nodesetval]
+        ptr = LibXML.xmlXPathNodeSetCreate(nil) if ptr.null?
+
+        set = XML::NodeSet.new(@document)
+        set.cstruct = LibXML::XmlNodeSet.new(ptr)
+        set.document = @document
+        set
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+module Nokogiri
+  module XML
+    class XPathContext
+
+      attr_accessor :cstruct # :nodoc:
+
+      def register_ns(prefix, uri) # :nodoc:
+        LibXML.xmlXPathRegisterNs(cstruct, prefix, uri)
+      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[:doc]
+        xpath
+      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 = parser_context.context
+          doc = context.doc.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
+              ns_ptr = LibXML::XmlNodeSet.new(obj[:nodesetval])
+              set = NodeSet.allocate
+              set.cstruct = ns_ptr
+              params.unshift set
+            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(doc, 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,47 @@
+module Nokogiri
+  module XSLT
+    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::MemoryPointer.new :pointer
+        buf_len = FFI::MemoryPointer.new :int
+        LibXML.xsltSaveResultToString(buf_ptr, buf_len, document.cstruct, cstruct)
+        buf = Nokogiri::LibXML::XmlAlloc.new(buf_ptr.read_pointer)
+        buf.pointer.read_string(buf_len.read_int)
+      end
+
+      def transform(document, params=[]) # :nodoc:
+        param_arr = FFI::MemoryPointer.new(:pointer, params.length + 1)
+        params.each_with_index do |param, j|
+          param_arr[j].put_pointer(0, FFI::MemoryPointer.from_string(param.to_s))
+        end
+        param_arr[params.length].put_pointer(0,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/hpricot.rb

@@ -2,25 +2,32 @@ require 'nokogiri'
 
 module Nokogiri
   module Hpricot
+    # STag compatibility proxy
     STag = String
+    # Elem compatibility proxy
     Elem = XML::Node
+    # NamedCharacters compatibility proxy
     NamedCharacters = Nokogiri::HTML::NamedCharacters
     class << self
+      # parse proxy
       def parse(*args)
         doc = Nokogiri.parse(*args)
         add_decorators(doc)
       end
 
+      # XML proxy
       def XML(string)
-        doc = Nokogiri::XML.parse(string)
+        doc = Nokogiri::XML::Document.parse(string)
         add_decorators(doc)
       end
 
+      # HTML proxy
       def HTML(string)
-        doc = Nokogiri::HTML.parse(string)
+        doc = Nokogiri::HTML::Document.parse(string)
         add_decorators(doc)
       end
 
+      # make proxy
       def make string
         doc = XML::Document.new
         ns = XML::NodeSet.new(doc)
@@ -28,6 +35,7 @@ module Nokogiri
         ns
       end
 
+      # Add compatibility decorators
       def add_decorators(doc)
         doc.decorators(XML::Node) << Decorators::Hpricot::Node
         doc.decorators(XML::NodeSet) << Decorators::Hpricot::NodeSet
@@ -36,8 +44,11 @@ module Nokogiri
       end
     end
   end
-  
+
   class << self
+    ###
+    # Parse a document and apply the Hpricot decorators for Hpricot
+    # compatibility mode.
     def Hpricot(*args, &block)
       if block_given?
         builder = Nokogiri::HTML::Builder.new(&block)

data/lib/nokogiri/html.rb

@@ -1,69 +1,34 @@
 require 'nokogiri/html/entity_lookup'
 require 'nokogiri/html/document'
+require 'nokogiri/html/document_fragment'
 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 = 2145, &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 = 2145, &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
+        HTML::DocumentFragment.parse(string)
       end
     end
+
+    # Instance of Nokogiri::HTML::EntityLookup
     NamedCharacters = EntityLookup.new
   end
 end