nokogiri 1.4.7-x86-mswin32-60 → 1.5.0-x86-mswin32-60

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

@@ -1,18 +0,0 @@
-module Nokogiri
-  module XML
-    class Text < CharacterData
-
-      def self.new(string, document, *rest) # :nodoc:
-        node_ptr = LibXML.xmlNewText(string)
-        node_cstruct = LibXML::XmlNode.new(node_ptr)
-        node_cstruct[:doc] = document.cstruct[:doc]
-
-        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

@@ -1,9 +0,0 @@
-module Nokogiri
-  module XML
-    class XPath
-      
-      attr_accessor :cstruct # :nodoc:
-
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-module Nokogiri
-  module XML
-    class XPathContext
-
-      attr_accessor :cstruct # :nodoc:
-
-      def register_ns(prefix, uri) # :nodoc:
-        LibXML.xmlXPathRegisterNs(cstruct, prefix, uri)
-      end
-
-      def register_variable(name, value) # :nodoc:
-        xml_value = LibXML.xmlXPathNewCString(value);
-        LibXML.xmlXPathRegisterVariable(cstruct, name, xml_value);
-      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.document.ruby_doc
-
-        case xpath.cstruct[:type]
-        when LibXML::XmlXpathObject::XPATH_NODESET
-          if xpath.cstruct[:nodesetval].null?
-            NodeSet.new(xpath.document)
-          else
-            NodeSet.wrap(xpath.cstruct[:nodesetval], xpath.document)
-          end
-        when LibXML::XmlXpathObject::XPATH_STRING
-          xpath.cstruct[:stringval]
-        when LibXML::XmlXpathObject::XPATH_NUMBER
-          xpath.cstruct[:floatval]
-        when LibXML::XmlXpathObject::XPATH_BOOLEAN
-          0 != xpath.cstruct[:boolval]
-        else
-          NodeSet.new(xpath.document)
-        end
-      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_cstruct = parser_context.context
-          document = context_cstruct.document.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
-              params.unshift NodeSet.wrap(obj[:nodesetval], document)
-            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(document, 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

@@ -1,77 +0,0 @@
-module Nokogiri
-  module XSLT
-    @modules = {}
-
-    @method_caller = lambda do |context, nargs|
-      # TODO
-    end
-
-    @init_func = lambda do |context, uri|
-      klass = @modules[uri]
-      klass.instance_methods(false).each do |method_name|
-	LibXML.xsltRegisterExtFunction(context, method_name, uri, @method_caller)
-      end
-      klass.new
-    end
-
-    @shutdown_func = lambda do |context, uri, data|
-    end
-
-    def self.register(uri, klass) # :nodoc:
-      raise NotImplementedError.new("sorry, you should implement me.")
-    end
-
-    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::Buffer.new :pointer
-        buf_len = FFI::Buffer.new :int
-        LibXML.xsltSaveResultToString(buf_ptr, buf_len, document.cstruct, cstruct)
-        buf = Nokogiri::LibXML::XmlAlloc.new(buf_ptr.get_pointer(0))
-        buf.pointer.read_string(buf_len.get_int(0))
-      end
-
-      def transform(document, params=[]) # :nodoc:
-        unless document.kind_of? Nokogiri::XML::Document
-          raise ArgumentError, "argument must be a Nokogiri::XML::Document"
-        end
-
-        params = params.to_a.flatten if params.is_a?(Hash)
-        raise(TypeError) unless params.is_a?(Array)
-
-        param_arr = FFI::MemoryPointer.new(:pointer, params.length + 1, false)
-
-        # Keep the MemoryPointer instances alive until after the call
-        ptrs = params.map { |param | FFI::MemoryPointer.from_string(param.to_s) }
-        param_arr.put_array_of_pointer(0, ptrs)
-        
-        # Terminate the list with a NULL pointer
-        param_arr.put_pointer(LibXML.pointer_offset(params.length), 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/version_warning.rb

@@ -1,14 +0,0 @@
-module Nokogiri
-  if self.is_2_6_16?
-    VERSION_INFO['warnings'] << "libxml 2.6.16 is old and buggy."
-    if !defined?(I_KNOW_I_AM_USING_AN_OLD_AND_BUGGY_VERSION_OF_LIBXML2)
-      warn <<-eom
-HI.  You're using libxml2 version 2.6.16 which is over 4 years old and has
-plenty of bugs.  We suggest that for maximum HTML/XML parsing pleasure, you
-upgrade your version of libxml2 and re-install nokogiri.  If you like using
-libxml2 version 2.6.16, but don't like this warning, please define the constant
-I_KNOW_I_AM_USING_AN_OLD_AND_BUGGY_VERSION_OF_LIBXML2 before requring nokogiri.
-      eom
-    end
-  end
-end

data/test/ffi/test_document.rb

@@ -1,35 +0,0 @@
-require "helper"
-
-if defined?(Nokogiri::LibXML)
-
-  class FFI::TestDocument < Nokogiri::TestCase
-
-    def test_ruby_doc_reflection
-      doc = Nokogiri::XML("<root><foo>foo</foo></root>")
-      assert_equal doc, doc.cstruct.ruby_doc
-    end
-
-    def test_ruby_doc_setter
-      doc = Nokogiri::XML("<root><foo>foo</foo></root>")
-      foo = "foobar"
-      doc.cstruct.ruby_doc = foo
-      assert_equal foo, doc.cstruct.ruby_doc
-    end
-
-    def test_unlinked_nodes
-      doc = Nokogiri::XML("<root><foo>foo</foo></root>")
-      assert_instance_of Nokogiri::LibXML::XmlNodeSetCast, doc.cstruct.unlinked_nodes
-    end
-
-    def test_unlinked_nodes_contains_unlinked_nodes
-      doc = Nokogiri::XML("<root><foo>foo</foo></root>")
-      node = doc.xpath('//foo').first
-      assert_equal 0, doc.cstruct.unlinked_nodes[:nodeNr]
-      node.unlink
-      assert_equal 1, doc.cstruct.unlinked_nodes[:nodeNr]
-      assert_equal node.cstruct.pointer, doc.cstruct.unlinked_nodes[:nodeTab].get_pointer(0)
-    end
-
-  end
-
-end