nokogiri 1.3.0-x86-mingw32

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

@@ -0,0 +1,62 @@
+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::Document.parse(string)
+        add_decorators(doc)
+      end
+
+      # HTML proxy
+      def HTML(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)
+        ns << XML::Text.new(string, doc)
+        ns
+      end
+
+      # Add compatibility decorators
+      def add_decorators(doc)
+        doc.decorators(XML::Node) << Decorators::Hpricot::Node
+        doc.decorators(XML::NodeSet) << Decorators::Hpricot::NodeSet
+        doc.decorate!
+        doc
+      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)
+        Nokogiri::Hpricot.add_decorators(builder.doc)
+      else
+        doc = Nokogiri.parse(*args)
+        Nokogiri::Hpricot.add_decorators(doc)
+      end
+    end
+  end
+end

data/lib/nokogiri/html.rb

@@ -0,0 +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.  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
+    class << self
+      ###
+      # 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
+        HTML::DocumentFragment.parse(string)
+      end
+    end
+
+    # Instance of Nokogiri::HTML::EntityLookup
+    NamedCharacters = EntityLookup.new
+  end
+end