rubyjedi-nokogiri_java 1.4.0.20100513161003-java

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

@@ -0,0 +1,135 @@
+module Nokogiri
+  module XML
+    module SAX
+      class Parser
+        # :stopdoc:
+
+        attr_accessor :cstruct
+
+        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
+
+        def setup_lambdas
+          @closures = {} # we need to keep references to the closures to avoid GC
+
+          [ :startDocument, :endDocument, :startElement, :endElement, :characters,
+            :comment, :warning, :error, :cdataBlock, :startElementNs, :endElementNs ].each do |sym|
+            @closures[sym] = lambda { |*args| send("__internal__#{sym}", *args) } # "i'm your private dancer", etc.
+          end
+
+          @closures.each { |k,v| cstruct[k] = v }
+
+          cstruct[:initialized] = Nokogiri::LibXML::XmlSaxHandler::XML_SAX2_MAGIC
+        end
+
+        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(_)
+          @document.end_document
+        end
+
+        def __internal__startElement(_, name, attributes)
+          attrs = attributes.null? ? [] : attributes.get_array_of_string(0)
+          @document.start_element name, attrs
+        end
+
+        def __internal__endElement(_, name)
+          @document.end_element name
+        end
+
+        def __internal__characters(_, data, data_length)
+          @document.characters data.slice(0, data_length)
+        end
+
+        def __internal__comment(_, data)
+          @document.comment data
+        end
+
+        def __internal__warning(_, msg)
+          # TODO: vasprintf here
+          @document.warning(msg)
+        end
+
+        def __internal__error(_, msg)
+          # TODO: vasprintf here
+          @document.error(msg)
+        end
+
+        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)
+          localname = localname.null? ? nil : localname.read_string
+          prefix    = prefix   .null? ? nil : prefix   .read_string
+          uri       = uri      .null? ? nil : uri      .read_string
+
+          attr_list = []
+          ns_list   = []
+
+          if ! attributes.null?
+            # Each attribute is an array of [localname, prefix, URI, value, end]
+            (0..(nb_attributes-1)*5).step(5) do |j|
+              key          = attributes.get_pointer(LibXML.pointer_offset(j)).read_string
+              attr_prefix = attributes.get_pointer(LibXML.pointer_offset(j + 1))
+              attr_prefix = attr_prefix.null? ? nil : attr_prefix.read_string
+              attr_uri = attributes.get_pointer(LibXML.pointer_offset(j + 2))
+              attr_uri = attr_uri.null? ? nil : attr_uri.read_string
+              value_length = attributes.get_pointer(LibXML.pointer_offset(j+4)).address \
+                           - attributes.get_pointer(LibXML.pointer_offset(j+3)).address
+              value        = attributes.get_pointer(LibXML.pointer_offset(j+3)).get_string(0, value_length)
+              attr_list << Attribute.new(key, attr_prefix, attr_uri, value)
+            end
+          end
+
+          if ! namespaces.null?
+            (0..(nb_namespaces-1)*2).step(2) do |j|
+              key   = namespaces.get_pointer(LibXML.pointer_offset(j))
+              key   = key.null?   ? nil : key.read_string
+              value = namespaces.get_pointer(LibXML.pointer_offset(j+1))
+              value = value.null? ? nil : value.read_string
+              ns_list << [key, value]
+            end
+          end
+
+          @document.start_element_namespace(
+            localname,
+            attr_list,
+            prefix,
+            uri,
+            ns_list
+          )
+        end
+
+        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
+
+        # :startdoc:
+      end
+    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

@@ -0,0 +1,55 @@
+module Nokogiri
+  module XML
+    module SAX
+      class PushParser
+
+        attr_accessor :cstruct # :nodoc:
+
+        def options
+          cstruct[:options]
+        end
+
+        def options=(user_options)
+          if LibXML.xmlCtxtUseOptions(cstruct, user_options) != 0
+            raise RuntimeError, "Cannot set XML parser context options"
+          end
+          nil
+        end
+
+        protected
+
+        # Move this out of private block because it's used in Nokogiri::XML::SAX::PushParser
+        def initialize_native(sax, filename) # :nodoc:
+          filename = filename.to_s unless filename.nil?
+          ctx_ptr = LibXML.xmlCreatePushParserCtxt(
+            sax.cstruct, nil, nil, 0, filename
+            )
+          raise(RuntimeError, "Could not create a parser context") if ctx_ptr.null?
+          self.cstruct = LibXML::XmlSaxPushParserContext.new(ctx_ptr) ;
+          self
+        end
+
+        private
+
+        def native_write(chunk, last_chunk) # :nodoc:
+          size = 0
+          unless chunk.nil?
+            chunk = chunk.to_s
+            size = chunk.length
+          end
+
+          if LibXML.xmlParseChunk(cstruct, chunk, size, last_chunk ? 1 : 0) != 0
+            if (cstruct[:options] & XML::ParseOptions::RECOVER) == 0
+              error = LibXML.xmlCtxtGetLastError(cstruct)
+              raise Nokogiri::XML::SyntaxError.wrap(error)
+            end
+          end
+
+          self
+        end
+
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Nokogiri
+  module XML
+    class Schema
+      # :stopdoc:
+
+      attr_accessor :cstruct
+
+      def validate_document document
+        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
+        content_copy = FFI::MemoryPointer.from_string(content)
+        ctx = LibXML.xmlSchemaNewMemParserCtxt(content_copy, 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
+
+      def self.from_document document
+        ctx = LibXML.xmlSchemaNewDocParserCtxt(document.document.cstruct)
+
+        errors = []
+
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(errors))
+        unless Nokogiri.is_2_6_16?
+          LibXML.xmlSchemaSetParserStructuredErrors(
+            ctx,
+            SyntaxError.error_array_pusher(errors),
+            nil
+          )
+        end
+
+        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
+
+      # :startdoc:
+    end
+  end
+end
+

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

@@ -0,0 +1,98 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    class SyntaxError < ::Nokogiri::SyntaxError
+
+      attr_accessor :cstruct
+
+      def initialize(message)
+        self.cstruct = LibXML::XmlSyntaxError.new(LibXML::XmlSyntaxError.allocate())
+        self.cstruct[:message] = LibXML.xmlStrdup(message)
+      end
+
+      def domain
+        cstruct[:domain]
+      end
+
+      def code
+        cstruct[:code]
+      end
+
+      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 message=(string)
+        unless cstruct[:message].null?
+          LibXML.xmlFree(cstruct[:message])
+        end
+        cstruct[:message] = LibXML.xmlStrdup(string)
+        string
+      end
+
+      def initialize_copy(other)
+        raise ArgumentError, "node must be a Nokogiri::XML::SyntaxError" unless other.is_a?(Nokogiri::XML::SyntaxError)
+        LibXML.xmlCopyError(other.cstruct, cstruct)
+        self
+      end
+
+      def level
+        cstruct[:level]
+      end
+
+      def file
+        cstruct[:file].null? ? nil : cstruct[:file]
+      end
+
+      def line
+        cstruct[:line]
+      end
+
+      def str1
+        cstruct[:str1].null? ? nil : cstruct[:str1]
+      end
+
+      def str2
+        cstruct[:str].null? ? nil : cstruct[:str]
+      end
+
+      def str3
+        cstruct[:str3].null? ? nil : cstruct[:str3]
+      end
+
+      def int1
+        cstruct[:int1]
+      end
+
+      def column
+        cstruct[:int2]
+      end
+      alias_method :int2, :column
+
+      class << self
+        def error_array_pusher(array)
+          Proc.new do |_ignored_, error|
+            array << wrap(error) if array
+          end
+        end
+
+        def wrap(error_ptr)
+          error_struct = LibXML::XmlSyntaxError.allocate
+          LibXML.xmlCopyError(error_ptr, error_struct)
+          error_cstruct = LibXML::XmlSyntaxError.new(error_struct)
+          error = self.allocate # will generate XML::XPath::SyntaxError or XML::SyntaxError
+          error.cstruct = error_cstruct
+          error
+        end
+      end
+
+    end
+  end
+
+end
+# :startdoc: