nokogiri 1.4.7-x86-mingw32 → 1.5.0-x86-mingw32

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

@@ -1,143 +0,0 @@
-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 = []
-          offset = 0
-          if ! attributes.null?
-            while ! attributes.get_pointer(LibXML.pointer_offset(offset)).null? do
-              cons = attributes.get_array_of_string(LibXML.pointer_offset(offset), 2)
-              attrs << cons
-              offset += 2
-            end
-          end
-          @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

@@ -1,79 +0,0 @@
-# :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 line
-          return nil if cstruct[:input].null?
-          input = LibXML::XmlParserInput.new cstruct[:input]
-          input[:line]
-        end
-
-        def column
-          return nil if cstruct[:input].null?
-          input = LibXML::XmlParserInput.new cstruct[:input]
-          input[:col]
-        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

@@ -1,51 +0,0 @@
-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
-
-        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
-
-        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
-
-      end
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-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 validate_file filename
-        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.xmlSchemaValidateFile(ctx, filename, 0)
-
-        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

@@ -1,98 +0,0 @@
-# :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.chomp
-      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]
-      end
-
-      def str2
-        cstruct[:str]
-      end
-
-      def str3
-        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: