nokogiri 1.3.3-java → 1.4.0-java

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

@@ -19,7 +19,7 @@ module Nokogiri
         self
       end
 
-      def +(node_set) # :nodoc:
+      def |(node_set) # :nodoc:
         raise(ArgumentError, "node_set must be a Nokogiri::XML::NodeSet") unless node_set.is_a?(XML::NodeSet)
         new_set_ptr = LibXML::xmlXPathNodeSetMerge(nil, self.cstruct)
         new_set_ptr = LibXML::xmlXPathNodeSetMerge(new_set_ptr, node_set.cstruct)

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

@@ -1,19 +1,20 @@
+# :stopdoc:
 module Nokogiri
   module XML
     class Reader
 
-      attr_accessor :cstruct # :nodoc:
-      attr_accessor :reader_callback # :nodoc:
+      attr_accessor :cstruct
+      attr_accessor :reader_callback
 
-      def default? # :nodoc:
+      def default?
         LibXML.xmlTextReaderIsDefault(cstruct) == 1
       end
 
-      def value? # :nodoc:
+      def value?
         LibXML.xmlTextReaderHasValue(cstruct) == 1
       end
 
-      def attributes? # :nodoc:
+      def attributes?
         #  this implementation of xmlTextReaderHasAttributes explicitly includes
         #  namespaces and properties, because some earlier versions ignore
         #  namespaces.
@@ -23,7 +24,7 @@ module Nokogiri
         node[:type] == Node::ELEMENT_NODE && (!node[:properties].null? || !node[:nsDef].null?)
       end
 
-      def namespaces # :nodoc:
+      def namespaces
         return {} unless attributes?
 
         ptr = LibXML.xmlTextReaderExpand(cstruct)
@@ -32,7 +33,7 @@ module Nokogiri
         Reader.node_namespaces(ptr)
       end
 
-      def attribute_nodes # :nodoc:
+      def attr_nodes
         return {} unless attributes?
 
         ptr = LibXML.xmlTextReaderExpand(cstruct)
@@ -42,7 +43,7 @@ module Nokogiri
         Node.node_properties node_struct
       end
 
-      def attribute_at(index) # :nodoc:
+      def attribute_at(index)
         return nil if index.nil?
         index = index.to_i
         attr_ptr = LibXML.xmlTextReaderGetAttributeNo(cstruct, index)
@@ -53,7 +54,7 @@ module Nokogiri
         attr
       end
 
-      def attribute(name) # :nodoc:
+      def attribute(name)
         return nil if name.nil?
         attr_ptr = LibXML.xmlTextReaderGetAttribute(cstruct, name.to_s)
         if attr_ptr.null?
@@ -81,56 +82,56 @@ module Nokogiri
         attr
       end
 
-      def attribute_count # :nodoc:
+      def attribute_count
         count = LibXML.xmlTextReaderAttributeCount(cstruct)
         count == -1 ? nil : count
       end
 
-      def depth # :nodoc:
+      def depth
         val = LibXML.xmlTextReaderDepth(cstruct)
         val == -1 ? nil : val
       end
 
-      def xml_version # :nodoc:
+      def xml_version
         val = LibXML.xmlTextReaderConstXmlVersion(cstruct)
         val.null? ? nil : val.read_string
       end
 
-      def lang # :nodoc:
+      def lang
         val = LibXML.xmlTextReaderConstXmlLang(cstruct)
         val.null? ? nil : val.read_string
       end
 
-      def value # :nodoc:
+      def value
         val = LibXML.xmlTextReaderConstValue(cstruct)
         val.null? ? nil : val.read_string
       end
 
-      def prefix # :nodoc:
+      def prefix
         val = LibXML.xmlTextReaderConstPrefix(cstruct)
         val.null? ? nil : val.read_string
       end
 
-      def namespace_uri # :nodoc:
+      def namespace_uri
         val = LibXML.xmlTextReaderConstNamespaceUri(cstruct)
         val.null? ? nil : val.read_string
       end
 
-      def local_name # :nodoc:
+      def local_name
         val = LibXML.xmlTextReaderConstLocalName(cstruct)
         val.null? ? nil : val.read_string
       end
 
-      def name # :nodoc:
+      def name
         val = LibXML.xmlTextReaderConstName(cstruct)
         val.null? ? nil : val.read_string
       end
 
-      def state # :nodoc:
+      def state
         LibXML.xmlTextReaderReadState(cstruct)
       end
 
-      def read # :nodoc:
+      def read
         error_list = self.errors
 
         LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(error_list))
@@ -150,7 +151,27 @@ module Nokogiri
         nil
       end
 
-      def self.from_memory(buffer, url=nil, encoding=nil, options=0) # :nodoc:
+      def inner_xml
+        string_ptr = LibXML.xmlTextReaderReadInnerXml(cstruct)
+        return nil if string_ptr.null?
+        string = string_ptr.read_string
+        LibXML.xmlFree(string_ptr)
+        string
+      end
+
+      def outer_xml
+        string_ptr = LibXML.xmlTextReaderReadOuterXml(cstruct)
+        return nil if string_ptr.null?
+        string = string_ptr.read_string
+        LibXML.xmlFree(string_ptr)
+        string
+      end
+
+      def node_type
+        LibXML.xmlTextReaderNodeType(cstruct)
+      end
+
+      def self.from_memory(buffer, url=nil, encoding=nil, options=0)
         raise(ArgumentError, "string cannot be nil") if buffer.nil?
 
         memory = FFI::MemoryPointer.new(buffer.length) # we need to manage native memory lifecycle
@@ -164,7 +185,7 @@ module Nokogiri
         reader
       end
 
-      def self.from_io(io, url=nil, encoding=nil, options=0) # :nodoc:
+      def self.from_io(io, url=nil, encoding=nil, options=0)
         raise(ArgumentError, "io cannot be nil") if io.nil?
 
         cb = IoCallbacks.reader(io) # we will keep a reference to prevent it from being GC'd
@@ -181,7 +202,7 @@ module Nokogiri
       private
 
       class << self
-        def node_namespaces(ptr) # :nodoc:
+        def node_namespaces(ptr)
           cstruct = LibXML::XmlNode.new(ptr)
           ahash = {}
           return ahash unless cstruct[:type] == Node::ELEMENT_NODE
@@ -200,7 +221,7 @@ module Nokogiri
           ahash
         end
       end
-      
     end
   end
 end
+# :startdoc:

data/lib/nokogiri/ffi/xml/sax/parser.rb

@@ -2,38 +2,23 @@ module Nokogiri
   module XML
     module SAX
       class Parser
+        # :stopdoc:
 
-        attr_accessor :cstruct # :nodoc:
+        attr_accessor :cstruct
 
-        def parse_memory(data) # :nodoc:
-          raise(ArgumentError, 'data cannot be nil') if data.nil?
-          LibXML.xmlSAXUserParseMemory(cstruct, nil, data, data.length)
-          data
-        end
-
-        def native_parse_io(io, encoding) # :nodoc:
-          sax_ctx = LibXML.xmlCreateIOParserCtxt(cstruct, nil, IoCallbacks.reader(io), nil, nil, encoding)
-          LibXML.xmlParseDocument(sax_ctx)
-          LibXML.xmlFreeParserCtxt(sax_ctx)
-          io
-        end
-
-        def native_parse_file(data) # :nodoc:
-          LibXML.xmlSAXUserParseFile(cstruct, nil, data)
-        end
-
-        def self.new(doc = XML::SAX::Document.new, encoding = 'ASCII') # :nodoc:
+        def self.new(doc = XML::SAX::Document.new, encoding = 'UTF-8')
           parser = allocate
           parser.document = doc
           parser.encoding = encoding
           parser.cstruct = LibXML::XmlSaxHandler.allocate
           parser.send(:setup_lambdas)
+          parser.instance_variable_set(:@ctxt, nil)
           parser
         end
 
-      private
+        private
 
-        def setup_lambdas # :nodoc:
+        def setup_lambdas
           @closures = {} # we need to keep references to the closures to avoid GC
 
           [ :startDocument, :endDocument, :startElement, :endElement, :characters,
@@ -46,15 +31,23 @@ module Nokogiri
           cstruct[:initialized] = Nokogiri::LibXML::XmlSaxHandler::XML_SAX2_MAGIC
         end
 
-        def __internal__startDocument(_) # :nodoc:
+        def __internal__startDocument(_)
+          if @ctxt && @ctxt[:html] == 0 && @ctxt[:standalone] != -1
+            standalone = {
+              0 => 'no',
+              1 => 'yes',
+            }[@ctxt[:standalone]]
+
+            @document.xmldecl @ctxt[:version], @ctxt[:encoding], standalone
+          end
           @document.start_document
         end
 
-        def __internal__endDocument(_) # :nodoc:
+        def __internal__endDocument(_)
           @document.end_document
         end
 
-        def __internal__startElement(_, name, attributes) # :nodoc:
+        def __internal__startElement(_, name, attributes)
           attrs = []
           unless attributes.null?
             j = 0
@@ -66,33 +59,33 @@ module Nokogiri
           @document.start_element name, attrs
         end
 
-        def __internal__endElement(_, name) # :nodoc:
+        def __internal__endElement(_, name)
           @document.end_element name
         end
 
-        def __internal__characters(_, data, data_length) # :nodoc:
+        def __internal__characters(_, data, data_length)
           @document.characters data.slice(0, data_length)
         end
 
-        def __internal__comment(_, data) # :nodoc:
+        def __internal__comment(_, data)
           @document.comment data
         end
 
-        def __internal__warning(_, msg) # :nodoc:
+        def __internal__warning(_, msg)
           # TODO: vasprintf here
           @document.warning(msg)
         end
 
-        def __internal__error(_, msg) # :nodoc:
+        def __internal__error(_, msg)
           # TODO: vasprintf here
           @document.error(msg)
         end
 
-        def __internal__cdataBlock(_, data, data_length) # :nodoc:
+        def __internal__cdataBlock(_, data, data_length)
           @document.cdata_block data.slice(0, data_length)
         end
 
-        def __internal__startElementNs(_, localname, prefix, uri, nb_namespaces, namespaces, nb_attributes, nb_defaulted, attributes) # :nodoc:
+        def __internal__startElementNs(_, localname, prefix, uri, nb_namespaces, namespaces, nb_attributes, nb_defaulted, attributes)
           localname = localname.null? ? nil : localname.read_string
           prefix    = prefix   .null? ? nil : prefix   .read_string
           uri       = uri      .null? ? nil : uri      .read_string
@@ -132,17 +125,17 @@ module Nokogiri
             uri,
             ns_list
           )
-          start_element_namespace(localname, attr_list, prefix, uri, ns_list)
         end
 
-        def __internal__endElementNs(_, localname, prefix, uri) # :nodoc:
+        def __internal__endElementNs(_, localname, prefix, uri)
           localname = localname.null? ? nil : localname.read_string
           prefix    = prefix   .null? ? nil : prefix   .read_string
           uri       = uri      .null? ? nil : uri      .read_string
 
           @document.end_element_namespace(localname, prefix, uri)
-          end_element_namespace(localname, prefix, uri)
         end
+
+        # :startdoc:
       end
     end
   end

data/lib/nokogiri/ffi/xml/sax/parser_context.rb

@@ -0,0 +1,67 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    module SAX
+      class ParserContext
+        attr_accessor :cstruct
+        attr_accessor :reader_callback
+
+        def self.memory data
+          raise(ArgumentError, 'data cannot be nil') if data.nil?
+          raise('data cannot be empty') if data.length == 0
+          ctx = LibXML::XmlParserContext.new(
+            LibXML.xmlCreateMemoryParserCtxt data, data.length
+          )
+          pc = allocate
+          pc.cstruct = ctx
+          pc
+        end
+
+        def self.io io, encoding
+          reader_callback = IoCallbacks.reader(io) # keep a reference to prevent it from being GC'd
+          sax_ctx = LibXML.xmlCreateIOParserCtxt(
+            nil,
+            nil,
+            reader_callback,
+            nil,
+            nil,
+            encoding
+          )
+          pc = allocate
+          pc.cstruct = LibXML::XmlParserContext.new sax_ctx
+          pc.reader_callback = reader_callback
+          pc
+        end
+
+        def self.file filename
+          ctx = LibXML.xmlCreateFileParserCtxt filename
+          pc = allocate
+          pc.cstruct = LibXML::XmlParserContext.new ctx
+          pc
+        end
+
+        def parse_with sax_handler, type = :xml
+          raise ArgumentError unless XML::SAX::Parser === sax_handler
+          sax = sax_handler.cstruct
+          cstruct[:sax] = sax
+
+          sax_handler.instance_variable_set(:@ctxt, cstruct)
+
+          LibXML.send(:"#{type}ParseDocument", cstruct)
+
+          cstruct[:sax] = nil
+          LibXML.xmlFreeDoc cstruct[:myDoc] unless cstruct[:myDoc].null?
+        end
+
+        def replace_entities=(value)
+          self.cstruct[:replaceEntities] = value ? 1 : 0
+        end
+
+        def replace_entities
+          self.cstruct[:replaceEntities] == 0 ? false : true
+        end
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/nokogiri/ffi/xml/sax/push_parser.rb

@@ -14,10 +14,11 @@ module Nokogiri
             size = chunk.length
           end
 
-          last_chunk = last_chunk ? 1 : 0
-
-          rcode = LibXML.xmlParseChunk(cstruct, chunk, size, last_chunk)
-          raise RuntimeError, "Couldn't parse chunk" if 0 != rcode
+          rcode = LibXML.xmlParseChunk(cstruct, chunk, size, last_chunk ? 1 : 0)
+          if rcode != 0
+            error = LibXML.xmlCtxtGetLastError(cstruct)
+            raise Nokogiri::XML::SyntaxError.wrap(error)
+          end
 
           self
         end

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

@@ -1,70 +1,84 @@
+# :stopdoc:
 module Nokogiri
   module XML
     class SyntaxError < ::Nokogiri::SyntaxError
 
-      attr_accessor :cstruct # :nodoc:
+      attr_accessor :cstruct
 
-      def domain # :nodoc:
+      def initialize(message)
+        self.cstruct = LibXML::XmlSyntaxError.new(LibXML::XmlSyntaxError.allocate())
+        self.cstruct[:message] = FFI::MemoryPointer.from_string(message)
+      end
+
+      def domain
         cstruct[:domain]
       end
 
-      def code # :nodoc:
+      def code
         cstruct[:code]
       end
 
-      def message # :nodoc:
-        cstruct[:message]
+      def message
+        val = cstruct[:message]
+        val.null? ? nil : val.read_string
       end
       undef_method :inspect
       alias_method :inspect, :message
       undef_method :to_s
       alias_method :to_s, :message
 
-      def level # :nodoc:
+      def message=(string)
+        unless cstruct[:message].null?
+          LibXML.xmlFree(cstruct[:message])
+        end
+        cstruct[:message] = string
+      end
+
+      def level
         cstruct[:level]
       end
 
-      def file # :nodoc:
+      def file
         cstruct[:file].null? ? nil : cstruct[:file]
       end
 
-      def line # :nodoc:
+      def line
         cstruct[:line]
       end
 
-      def str1 # :nodoc:
+      def str1
         cstruct[:str1].null? ? nil : cstruct[:str1]
       end
 
-      def str2 # :nodoc:
+      def str2
         cstruct[:str].null? ? nil : cstruct[:str]
       end
 
-      def str3 # :nodoc:
+      def str3
         cstruct[:str3].null? ? nil : cstruct[:str3]
       end
 
-      def int1 # :nodoc:
+      def int1
         cstruct[:int1]
       end
 
-      def column # :nodoc:
+      def column
         cstruct[:int2]
       end
       alias_method :int2, :column
 
       class << self
-        def error_array_pusher(array) # :nodoc:
+        def error_array_pusher(array)
           Proc.new do |_ignored_, error|
             array << wrap(error) if array
           end
         end
 
-        def wrap(error_ptr) # :nodoc:
+        def wrap(error_ptr)
           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 = self.allocate # will generate XML::XPath::SyntaxError or XML::SyntaxError
           error.cstruct = error_cstruct
           error
         end
@@ -74,3 +88,4 @@ module Nokogiri
   end
 
 end
+# :startdoc: