nokogiri 1.4.3.1-java → 1.5.0-java

data/lib/nokogiri/ffi/structs/xml_document.rb

@@ -1,117 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-
-    module XmlDocumentMixin # :nodoc:
-      def self.included(base)
-        base.class_eval do
-
-          layout(
-            :_private,  :pointer,
-            :type,      :int,
-            :name,      :string,
-            :children,  :pointer,
-            :last,      :pointer,
-            :parent,    :pointer,
-            :next,      :pointer,
-            :prev,      :pointer,
-            :doc,       :pointer,
-
-            :compression,       :int,
-            :standalone,        :int,
-            :intSubset,         :pointer,
-            :extSubset,         :pointer,
-            :oldNs,             :pointer,
-            :version,           :string,
-            :encoding,          :pointer,
-            :ids,               :pointer,
-            :refs,              :pointer,
-            :URL,               :string
-            )
-
-        end
-      end
-
-      def document
-        p = self[:doc]
-        p.null? ? nil : LibXML::XmlDocumentCast.new(p)
-      end
-
-      def ruby_node_pointer
-        tuple = self[:_private]
-        tuple.null? ? 0 : tuple.get_long(0)
-      end
-
-      def ruby_node_pointer=(value)
-        self[:_private].put_long(0, value)
-      end
-
-      def ruby_doc
-        Nokogiri::WeakBucket.get_object(self)
-      end
-
-      def ruby_doc=(object)
-        Nokogiri::WeakBucket.set_object(self, object)
-      end
-
-      def unlinked_nodes
-        LibXML::XmlNodeSetCast.new(self[:_private].get_pointer(LibXML.pointer_offset(1)))
-      end
-
-      def alloc_tuple
-        self[:_private] = LibXML.calloc(LibXML::POINTER_SIZE, 2)
-        self[:_private].put_pointer(LibXML.pointer_offset(1), LibXML.xmlXPathNodeSetCreate(nil))
-      end
-    end
-
-    #
-    #  use at the point of creation, so we can be sure the document will be GCed properly
-    #
-    class XmlDocument < FFI::ManagedStruct # :nodoc:
-      include XmlDocumentMixin
-
-      def initialize(ptr)
-        super(ptr)
-        self.alloc_tuple
-      end
-
-      def self.release ptr
-        doc = LibXML::XmlDocumentCast.new(ptr)
-        func = LibXML.xmlDeregisterNodeDefault(nil)
-        begin
-          ns  = LibXML::XmlNodeSetCast.new(doc[:_private].get_pointer(LibXML.pointer_offset(1)))
-
-          ns[:nodeNr].times do |j|
-            node_cstruct = LibXML::XmlNode.new(ns[:nodeTab].get_pointer(LibXML.pointer_offset(j)))
-            case node_cstruct[:type]
-            when Nokogiri::XML::Node::ATTRIBUTE_NODE
-              LibXML.xmlFreePropList(node_cstruct)
-            when Nokogiri::XML::Node::NAMESPACE_DECL
-              LibXML.xmlFree(node_cstruct)
-            else
-              LibXML.xmlAddChild(doc, node_cstruct) if node_cstruct[:parent].null?
-            end
-          end
-          LibXML::XmlNodeSet.release(ns.pointer)
-
-          LibXML.free(doc[:_private])
-        rescue
-          puts "Nokogiri::LibXML::XmlDocument.release: exception: '#{$!}'"
-        ensure
-          LibXML.xmlFreeDoc(ptr)
-          LibXML.xmlDeregisterNodeDefault(func)
-        end
-      end
-    end
-
-    #
-    #  use when we don't want to cause the doc to be GCed
-    #
-    class XmlDocumentCast < FFI::Struct # :nodoc:
-      include XmlDocumentMixin
-    end
-
-    HtmlDocument = XmlDocument # implemented identically in libxml2.6
-    HtmlDocumentCast = XmlDocumentCast # implemented identically in libxml2.6
-  end
-
-end

data/lib/nokogiri/ffi/structs/xml_dtd.rb

@@ -1,28 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlDtd < FFI::Struct # :nodoc:
-
-      layout(
-        :_private,      :long, # actually a pointer we're casting as an integer
-        :type,          :int,
-        :name,          :string,
-        :children,      :pointer,
-        :last,          :pointer,
-        :parent,        :pointer,
-        :next,          :pointer,
-        :prev,          :pointer,
-        :doc,           :pointer,
-
-        :notations,     :pointer,
-        :elements,      :pointer,
-        :attributes,    :pointer,
-        :entities,      :pointer,
-        :external_id,   :string,
-        :system_id,     :string
-        )
-
-      include CommonNode
-
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_element.rb

@@ -1,26 +0,0 @@
-module Nokogiri
-  # :stopdoc:
-  module LibXML
-    class XmlElement < FFI::Struct
-      include CommonNode
-
-      layout(
-        :_private,      :long,
-        :type,          :int,
-        :name,          :string,
-        :children,      :pointer,
-        :last,          :pointer,
-        :parent,        :pointer,
-        :next,          :pointer,
-        :prev,          :pointer,
-        :doc,           :pointer,
-
-        :etype,         :int,
-        :content,       :pointer,
-        :properties,    :pointer,
-        :prefix,        :string
-      )
-    end
-  end
-  # :startdoc:
-end

data/lib/nokogiri/ffi/structs/xml_element_content.rb

@@ -1,17 +0,0 @@
-# :stopdoc:
-module Nokogiri
-  module LibXML
-    class XmlElementContent < FFI::Struct
-      layout(
-        :type,  :int,
-        :ocur,  :int, # This is misspelled in the header file
-        :name,  :string,
-        :c1,    :pointer,
-        :c2,    :pointer,
-        :parent,:pointer,
-        :prefix,:string
-      )
-    end
-  end
-end
-# :startdoc:

data/lib/nokogiri/ffi/structs/xml_entity.rb

@@ -1,32 +0,0 @@
-module Nokogiri
-  # :stopdoc:
-  module LibXML
-    class XmlEntity < FFI::Struct
-      include CommonNode
-
-      layout(
-        :_private,      :long,
-        :type,          :int,
-        :name,          :string,
-        :children,      :pointer,
-        :last,          :pointer,
-        :parent,        :pointer,
-        :next,          :pointer,
-        :prev,          :pointer,
-        :doc,           :pointer,
-
-        :orig,          :string,
-        :content,       :string,
-        :length,        :int,
-        :etype,         :int,
-        :external_id,   :string,
-        :system_id,     :string,
-        :nexte,         :pointer,
-        :uri,           :string,
-        :owner,         :int,
-        :checked,       :int
-      )
-    end
-  end
-  # :startdoc:
-end

data/lib/nokogiri/ffi/structs/xml_enumeration.rb

@@ -1,12 +0,0 @@
-module Nokogiri
-  # :stopdoc:
-  module LibXML
-    class XmlEnumeration < FFI::Struct
-      layout(
-        :next, :pointer,
-        :name, :string
-      )
-    end
-  end
-  # :startdoc:
-end

data/lib/nokogiri/ffi/structs/xml_node.rb

@@ -1,28 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlNode < FFI::Struct # :nodoc:
-
-      layout(
-        :_private,      :long, # actually a pointer we're casting as an integer
-        :type,          :int,
-        :name,          :string,
-        :children,      :pointer,
-        :last,          :pointer,
-        :parent,        :pointer,
-        :next,          :pointer,
-        :prev,          :pointer,
-        :doc,           :pointer,
-
-        :ns,            :pointer,
-        :content,       :string,
-        :properties,    :pointer,
-        :nsDef,         :pointer,
-        :psvi,          :pointer,
-        :line,          :short
-        )
-
-      include CommonNode
-
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_node_set.rb

@@ -1,53 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-
-    module XmlNodeSetMixin # :nodoc:
-      def self.included(base)
-        base.class_eval do
-
-          layout(
-            :nodeNr,    :int,
-            :nodeMax,   :int,
-            :nodeTab,   :pointer
-            )
-
-        end
-      end
-
-      def document
-        p = self[:doc]
-        p.null? ? nil : LibXML::XmlDocumentCast.new(p)
-      end
-
-      def nodeAt(index)
-        self[:nodeTab].get_pointer(LibXML.pointer_offset(index))
-      end
-
-      def nodeTab
-        self[:nodeTab].read_array_of_pointer(self[:nodeNr])
-      end
-
-      def nodeTab=(array)
-        # TODO: do we need to check nodeMax and allocate more memory? probably.
-        self[:nodeTab].write_array_of_pointer(array)
-      end
-    end
-
-
-    class XmlNodeSet < FFI::ManagedStruct # :nodoc:
-      include XmlNodeSetMixin
-
-      def self.release ptr
-        ns = XmlNodeSetCast.new(ptr)
-        LibXML.xmlFree ns[:nodeTab] if ns[:nodeTab]
-        LibXML.xmlFree ptr
-      end
-    end
-
-
-    class XmlNodeSetCast < FFI::Struct # :nodoc:
-      include XmlNodeSetMixin
-    end
-
-  end
-end

data/lib/nokogiri/ffi/structs/xml_notation.rb

@@ -1,11 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlNotation < FFI::Struct # :nodoc:
-      layout(
-        :name,          :string,
-        :PublicID,      :string,
-        :SystemID,      :string
-        )
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_ns.rb

@@ -1,15 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlNs < FFI::Struct # :nodoc:
-      layout(
-        :next,     :pointer,
-        :type,     :int,
-        :href,     :string,
-        :prefix,   :string,
-        :_private, :long # actually a pointer we're casting as an integer
-        )
-
-      include CommonNode
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_parser_context.rb

@@ -1,19 +0,0 @@
-module Nokogiri
-  # :stopdoc:
-  module LibXML
-    class XmlParserContext < FFI::Struct
-      layout(
-        :sax,               :pointer,
-        :userData,          :pointer,
-        :myDoc,             :pointer,
-        :wellFormed,        :int,
-        :replaceEntities,   :int,
-        :version,           :string,
-        :encoding,          :string,
-        :standalone,        :int,
-        :html,              :int
-      )
-    end
-  end
-  # :startdoc:
-end

data/lib/nokogiri/ffi/structs/xml_relax_ng.rb

@@ -1,14 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlRelaxNG < FFI::ManagedStruct # :nodoc:
-
-      layout :dummy, :int, 0 # to avoid @layout warnings
-
-      def self.release ptr
-        LibXML.xmlRelaxNGFree(ptr)
-      end
-
-    end
-  end
-end
-

data/lib/nokogiri/ffi/structs/xml_sax_handler.rb

@@ -1,51 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlSaxHandler < FFI::ManagedStruct # :nodoc:
-
-      XML_SAX2_MAGIC = 0xDEEDBEAF # see, the libxml2 authors DO have a sense of humor. i think.
-
-      layout(:internalSubset,           :pointer,
-             :isStandalone,             :pointer,
-             :hasInternalSubset,        :pointer,
-             :hasExternalSubset,        :pointer,
-             :resolveEntity,            :pointer,
-             :getEntity,                :pointer,
-             :entityDecl,               :pointer,
-             :notationDecl,             :pointer,
-             :attributeDecl,            :pointer,
-             :elementDecl,              :pointer,
-             :unparsedEntityDecl,       :pointer,
-             :setDocumentLocator,       :pointer,
-             :startDocument,            :start_document_sax_func, 
-             :endDocument,              :end_document_sax_func ,
-             :startElement,             :start_element_sax_func,
-             :endElement,               :end_element_sax_func,
-             :reference,                :pointer,
-             :characters,               :characters_sax_func,
-             :ignorableWhitespace,      :pointer,
-             :processingInstruction,    :pointer,
-             :comment,                  :comment_sax_func,
-             :warning,                  :warning_sax_func, 
-             :error,                    :error_sax_func,
-             :fatalError,               :pointer,
-             :getParameterEntity,       :pointer,
-             :cdataBlock,               :cdata_block_sax_func, 
-             :externalSubset,           :pointer,
-             :initialized,              :uint,
-             :_private,                 :pointer,
-             :startElementNs,           :start_element_ns_sax2_func,
-             :endElementNs,             :end_element_ns_sax2_func,
-             :serror,                   :syntax_error_handler
-             )
-
-      def self.allocate
-        new LibXML.calloc(1, LibXML::XmlSaxHandler.size)
-      end
-
-      def self.release ptr
-        LibXML.free(ptr)
-      end
-
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_sax_push_parser_context.rb

@@ -1,124 +0,0 @@
-module Nokogiri
-  # :stopdoc:
-  module LibXML
-    class XmlSaxPushParserContext < FFI::ManagedStruct
-
-      layout(
-        :sax,           :pointer,       # struct _xmlSAXHandler *sax;       /* The SAX handler */
-        :userData,      :pointer,       # void            *userData;        /* For SAX interface only, used by DOM build */
-        :myDoc,         :pointer,       # xmlDocPtr           myDoc;        /* the document being built */
-        :wellFormed,    :int,           # int            wellFormed;        /* is the document well formed */
-        :replaceEntities, :int,         # int       replaceEntities;        /* shall we replace entities ? */
-        :version,       :pointer,       # const xmlChar    *version;        /* the XML version string */
-        :encoding,      :pointer,       # const xmlChar   *encoding;        /* the declared encoding, if any */
-        :standalone,    :int,           # int            standalone;        /* standalone document */
-        :html,          :int,           # int                  html;        /* an HTML(1)/Docbook(2) document
-
-        :input,         :pointer,       # xmlParserInputPtr  input;         /* Current input stream */
-        :inputNr,       :int,           # int                inputNr;       /* Number of current input streams */
-        :inputMax,      :int,           # int                inputMax;      /* Max number of input streams */
-        :inputTab,      :pointer,       # xmlParserInputPtr *inputTab;      /* stack of inputs */
-
-        :node,          :pointer,       # xmlNodePtr         node;          /* Current parsed Node */
-        :nodeNr,        :int,           # int                nodeNr;        /* Depth of the parsing stack */
-        :nodeMax,       :int,           # int                nodeMax;       /* Max depth of the parsing stack */
-        :nodeTab,       :pointer,       # xmlNodePtr        *nodeTab;       /* array of nodes */
-
-        :record_info,   :int,           # int record_info;                  /* Whether node info should be kept */
-
-        # xmlParserNodeInfoSeq node_seq;    /* info about each node parsed */
-                :node_seq_maximum, :ulong,
-                :node_seq_length,  :ulong,
-                :node_seq_buffer,  :pointer,
-
-        :errNo,         :int,           # int errNo;                        /* error code */
-
-        :hasExternalSubset, :int,       # int     hasExternalSubset;        /* reference and external subset */
-        :hasPErefs,     :int,           # int             hasPErefs;        /* the internal subset has PE refs */
-        :external,      :int,           # int              external;        /* are we parsing an external entity */
-
-        :valid,         :int,           # int                 valid;        /* is the document valid */
-        :validate,      :int,           # int              validate;        /* shall we try to validate ? */
-
-        # xmlValidCtxt        vctxt;        /* The validity context */
-                :vctxt_userData,        :pointer,       # void *userData;			/* user specific data block */
-                :vctxt_error,           :pointer,       # xmlValidityErrorFunc error;		/* the callback in case of errors */
-                :vctxt_warning,         :pointer,       # xmlValidityWarningFunc warning;	/* the callback in case of warning */
-                :vctxt_node,            :pointer,       # xmlNodePtr         node;          /* Current parsed Node */
-                :vctxt_nodeNr,          :int,           # int                nodeNr;        /* Depth of the parsing stack */
-                :vctxt_nodeMax,         :int,           # int                nodeMax;       /* Max depth of the parsing stack */
-                :vctxt_nodeTab,         :pointer,       # xmlNodePtr        *nodeTab;       /* array of nodes */
-
-                :vctxt_finishDtd,       :int,           # unsigned int     finishDtd;       /* finished validating the Dtd ? */
-                :vctxt_doc,             :pointer,       # xmlDocPtr              doc;       /* the document */
-                :vctxt_valid,           :int,           # int                  valid;       /* temporary validity check result */
-                :vctxt_vstate,          :pointer,       # xmlValidState     *vstate;        /* current state */
-                :vctxt_vstatNr,         :int,           # int                vstateNr;      /* Depth of the validation stack */
-                :vctxt_vstateMax,       :int,           # int                vstateMax;     /* Max depth of the validation stack */
-                :vctxt_vstateTab,       :pointer,       # xmlValidState     *vstateTab;     /* array of validation states */
-                :vctxt_am,              :pointer,       # xmlAutomataPtr            am;     /* the automata */
-                :vctxt_state,           :pointer,       # xmlAutomataStatePtr    state;     /* used to build the automata */
-
-        :instate,       :int,           # xmlParserInputState instate;      /* current type of input */
-        :token,         :int,           # int                 token;        /* next char look-ahead */    
-
-        :directory,     :pointer,       # char           *directory;        /* the data directory */
-        :name,          :pointer,       # const xmlChar     *name;          /* Current parsed Node */
-        :nameNr,        :int,           # int                nameNr;        /* Depth of the parsing stack */
-        :nameMax,       :int,           # int                nameMax;       /* Max depth of the parsing stack */
-        :nameTab,       :pointer,       # const xmlChar *   *nameTab;       /* array of nodes */
-
-        :nbChars,       :long,          # long               nbChars;       /* number of xmlChar processed */
-        :checkIndex,    :long,          # long            checkIndex;       /* used by progressive parsing lookup */
-        :keepBlanks,    :int,           # int             keepBlanks;       /* ugly but ... */
-        :disableSAX,    :int,           # int             disableSAX;       /* SAX callbacks are disabled */
-        :inSubset,      :int,           # int               inSubset;       /* Parsing is in int 1/ext 2 subset */
-        :intSubName,    :pointer,       # const xmlChar *    intSubName;    /* name of subset */
-        :extSubURI,     :pointer,       # xmlChar *          extSubURI;     /* URI of external subset */
-        :extSubSystem,  :pointer,       # xmlChar *          extSubSystem;  /* SYSTEM ID of external subset */
-
-        :space,         :pointer,       # int *              space;         /* Should the parser preserve spaces */
-        :spaceNr,       :int,           # int                spaceNr;       /* Depth of the parsing stack */
-        :spaceMax,      :int,           # int                spaceMax;      /* Max depth of the parsing stack */
-        :spaceTab,      :pointer,       # int *              spaceTab;      /* array of space infos */
-        :depth,         :int,           # int                depth;         /* to prevent entity substitution loops */
-        :entity,        :pointer,       # xmlParserInputPtr  entity;        /* used to check entities boundaries */
-        :charset,       :int,           # int                charset;       /* encoding of the in-memory content
-        :nodelen,       :int,           # int                nodelen;       /* Those two fields are there to */
-        :nodemem,       :int,           # int                nodemem;       /* Speed up large node parsing */
-        :pedantic,      :int,           # int                pedantic;      /* signal pedantic warnings */
-        :_private,      :pointer,       # void              *_private;      /* For user data, libxml won't touch it */
-
-        :loadsubset,    :int,           # int                loadsubset;    /* should the external subset be loaded */
-        :linenumbers,   :int,           # int                linenumbers;   /* set line number in element content */
-        :catalogs,      :pointer,       # void              *catalogs;      /* document's own catalog */
-        :recovery,      :int,           # int                recovery;      /* run in recovery mode */
-        :progressive,   :int,           # int                progressive;   /* is this a progressive parsing */
-        :dict,          :pointer,       # xmlDictPtr         dict;          /* dictionnary for the parser */
-        :atts,          :pointer,       # const xmlChar *   *atts;          /* array for the attributes callbacks */
-        :maxatts,       :int,           # int                maxatts;       /* the size of the array */
-        :docdict,       :int,           # int                docdict;       /* use strings from dict to build tree */
-        :str_xml,       :pointer,       # const xmlChar *str_xml;
-        :str_xmlns,     :pointer,       # const xmlChar *str_xmlns;
-        :str_xml_ns,    :pointer,       # const xmlChar *str_xml_ns;
-
-        :sax2,          :int,           # int                sax2;          /* operating in the new SAX mode */
-        :nsNr,          :int,           # int                nsNr;          /* the number of inherited namespaces */
-        :nsMax,         :int,           # int                nsMax;         /* the size of the arrays */
-        :nsTab,         :pointer,       # const xmlChar *   *nsTab;         /* the array of prefix/namespace name */
-        :attallocs,     :pointer,       # int               *attallocs;     /* which attribute were allocated */
-        :pushTab,       :pointer,       # void *            *pushTab;       /* array of data for push */
-        :attsDefault,   :pointer,       # xmlHashTablePtr    attsDefault;   /* defaulted attributes if any */
-        :attsSpecial,   :pointer,       # xmlHashTablePtr    attsSpecial;   /* non-CDATA attributes if any */
-        :nsWellFormed,  :int,           # int                nsWellFormed;  /* is the document XML Nanespace okay */
-        :options,       :int            # int                options;       /* Extra options */
-        )
-
-      def self.release ptr
-        LibXML.xmlFreeParserCtxt(ptr)
-      end
-    end
-
-  end
-  # :startdoc:
-end

data/lib/nokogiri/ffi/structs/xml_schema.rb

@@ -1,13 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlSchema < FFI::ManagedStruct # :nodoc:
-
-      layout :dummy, :int, 0 # to avoid @layout warnings
-
-      def self.release ptr
-        LibXML.xmlSchemaFree(ptr)
-      end
-
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_syntax_error.rb

@@ -1,31 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlSyntaxError < FFI::ManagedStruct # :nodoc:
-
-      layout(
-        :domain,  :int,
-        :code,    :int,
-        :message, :pointer,
-        :level,   :int,
-        :file,    :string,
-        :line,    :int,
-        :str1,    :string,
-        :str2,    :string,
-        :str3,    :string,
-        :int1,    :int,
-        :int2,    :int,
-        :ctxt,    :pointer,
-        :node,    :pointer
-        )
-
-      def self.allocate
-        LibXML.calloc(1, LibXML::XmlSyntaxError.size)
-      end
-
-      def self.release(ptr)
-        LibXML.free(ptr)
-      end
-
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_text_reader.rb

@@ -1,12 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlTextReader < FFI::ManagedStruct # :nodoc:
-
-      layout :dummy, :int # to avoid @layout warnings
-
-      def self.release ptr
-        LibXML.xmlFreeTextReader(ptr)
-      end
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_xpath_context.rb

@@ -1,38 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    module XmlXpathContextMixin # :nodoc:
-      def self.included(base)
-        base.class_eval do
-
-          layout(
-            :doc,  :pointer,
-            :node, :pointer
-            )
-
-        end
-      end
-
-      def node
-        LibXML::XmlNode.new(self[:node])
-      end
-
-      def document
-        p = self[:doc]
-        p.null? ? nil : LibXML::XmlDocumentCast.new(p)
-      end
-    end
-
-    class XmlXpathContext < FFI::ManagedStruct # :nodoc:
-      include XmlXpathContextMixin
-
-      def self.release ptr
-        LibXML.xmlXPathFreeContext(ptr)
-      end
-    end
-
-    class XmlXpathContextCast < FFI::Struct # :nodoc:
-      include XmlXpathContextMixin
-    end
-
-  end
-end