nokogiri 1.11.0.rc1-x86-linux

data/lib/nokogiri/xml/cdata.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Nokogiri
+  module XML
+    class CDATA < Nokogiri::XML::Text
+      ###
+      # Get the name of this CDATA node
+      def name
+        '#cdata-section'
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/character_data.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Nokogiri
+  module XML
+    class CharacterData < Nokogiri::XML::Node
+      include Nokogiri::XML::PP::CharacterData
+    end
+  end
+end

data/lib/nokogiri/xml/document.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+module Nokogiri
+  module XML
+    ##
+    # Nokogiri::XML::Document is the main entry point for dealing with
+    # XML documents.  The Document is created by parsing an XML document.
+    # See Nokogiri::XML::Document.parse() for more information on parsing.
+    #
+    # For searching a Document, see Nokogiri::XML::Searchable#css and
+    # Nokogiri::XML::Searchable#xpath
+    #
+    class Document < Nokogiri::XML::Node
+      # I'm ignoring unicode characters here.
+      # See http://www.w3.org/TR/REC-xml-names/#ns-decl for more details.
+      NCNAME_START_CHAR = "A-Za-z_"
+      NCNAME_CHAR       = NCNAME_START_CHAR + "\\-.0-9"
+      NCNAME_RE         = /^xmlns(:[#{NCNAME_START_CHAR}][#{NCNAME_CHAR}]*)?$/
+
+      ##
+      # Parse an XML file.
+      #
+      # +string_or_io+ may be a String, or any object that responds to
+      # _read_ and _close_ such as an IO, or StringIO.
+      #
+      # +url+ (optional) is the URI where this document is located.
+      #
+      # +encoding+ (optional) is the encoding that should be used when processing
+      # the document.
+      #
+      # +options+ (optional) is a configuration object that sets options during
+      # parsing, such as Nokogiri::XML::ParseOptions::RECOVER. See the
+      # Nokogiri::XML::ParseOptions for more information.
+      #
+      # +block+ (optional) is passed a configuration object on which
+      # parse options may be set.
+      #
+      # By default, Nokogiri treats documents as untrusted, and so
+      # does not attempt to load DTDs or access the network. See
+      # Nokogiri::XML::ParseOptions for a complete list of options;
+      # and that module's DEFAULT_XML constant for what's set (and not
+      # set) by default.
+      #
+      # Nokogiri.XML() is a convenience method which will call this method.
+      #
+      def self.parse string_or_io, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML
+        options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
+        # Give the options to the user
+        yield options if block_given?
+
+        if empty_doc?(string_or_io)
+          if options.strict?
+            raise Nokogiri::XML::SyntaxError.new("Empty document")
+          else
+            return encoding ? new.tap { |i| i.encoding = encoding } : new
+          end
+        end
+
+        doc = if string_or_io.respond_to?(:read)
+          url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+          read_io(string_or_io, url, encoding, options.to_i)
+        else
+          # read_memory pukes on empty docs
+          read_memory(string_or_io, url, encoding, options.to_i)
+        end
+
+        # do xinclude processing
+        doc.do_xinclude(options) if options.xinclude?
+
+        return doc
+      end
+
+      # A list of Nokogiri::XML::SyntaxError found when parsing a document
+      attr_accessor :errors
+
+      def initialize *args # :nodoc:
+        @errors     = []
+        @decorators = nil
+      end
+
+      ##
+      # Create an element with +name+, and optionally setting the content and attributes.
+      #
+      #   doc.create_element "div" # <div></div>
+      #   doc.create_element "div", :class => "container" # <div class='container'></div>
+      #   doc.create_element "div", "contents" # <div>contents</div>
+      #   doc.create_element "div", "contents", :class => "container" # <div class='container'>contents</div>
+      #   doc.create_element "div" { |node| node['class'] = "container" } # <div class='container'></div>
+      #
+      def create_element name, *args, &block
+        elm = Nokogiri::XML::Element.new(name, self, &block)
+        args.each do |arg|
+          case arg
+          when Hash
+            arg.each { |k,v|
+              key = k.to_s
+              if key =~ NCNAME_RE
+                ns_name = key.split(":", 2)[1]
+                elm.add_namespace_definition ns_name, v
+              else
+                elm[k.to_s] = v.to_s
+              end
+            }
+          else
+            elm.content = arg
+          end
+        end
+        if ns = elm.namespace_definitions.find { |n| n.prefix.nil? or n.prefix == '' }
+          elm.namespace = ns
+        end
+        elm
+      end
+
+      # Create a Text Node with +string+
+      def create_text_node string, &block
+        Nokogiri::XML::Text.new string.to_s, self, &block
+      end
+
+      # Create a CDATA Node containing +string+
+      def create_cdata string, &block
+        Nokogiri::XML::CDATA.new self, string.to_s, &block
+      end
+
+      # Create a Comment Node containing +string+
+      def create_comment string, &block
+        Nokogiri::XML::Comment.new self, string.to_s, &block
+      end
+
+      # The name of this document.  Always returns "document"
+      def name
+        'document'
+      end
+
+      # A reference to +self+
+      def document
+        self
+      end
+
+      ##
+      # Recursively get all namespaces from this node and its subtree and
+      # return them as a hash.
+      #
+      # For example, given this document:
+      #
+      #   <root xmlns:foo="bar">
+      #     <bar xmlns:hello="world" />
+      #   </root>
+      #
+      # This method will return:
+      #
+      #   { 'xmlns:foo' => 'bar', 'xmlns:hello' => 'world' }
+      #
+      # WARNING: this method will clobber duplicate names in the keys.
+      # For example, given this document:
+      #
+      #   <root xmlns:foo="bar">
+      #     <bar xmlns:foo="baz" />
+      #   </root>
+      #
+      # The hash returned will look like this: { 'xmlns:foo' => 'bar' }
+      #
+      # Non-prefixed default namespaces (as in "xmlns=") are not included
+      # in the hash.
+      #
+      # Note that this method does an xpath lookup for nodes with
+      # namespaces, and as a result the order may be dependent on the
+      # implementation of the underlying XML library.
+      #
+      def collect_namespaces
+        xpath("//namespace::*").inject({}) do |hash, ns|
+          hash[["xmlns",ns.prefix].compact.join(":")] = ns.href if ns.prefix != "xml"
+          hash
+        end
+      end
+
+      # Get the list of decorators given +key+
+      def decorators key
+        @decorators ||= Hash.new
+        @decorators[key] ||= []
+      end
+
+      ##
+      # Validate this Document against it's DTD.  Returns a list of errors on
+      # the document or +nil+ when there is no DTD.
+      def validate
+        return nil unless internal_subset
+        internal_subset.validate self
+      end
+
+      ##
+      # Explore a document with shortcut methods. See Nokogiri::Slop for details.
+      #
+      # Note that any nodes that have been instantiated before #slop!
+      # is called will not be decorated with sloppy behavior. So, if you're in
+      # irb, the preferred idiom is:
+      #
+      #   irb> doc = Nokogiri::Slop my_markup
+      #
+      # and not
+      #
+      #   irb> doc = Nokogiri::HTML my_markup
+      #   ... followed by irb's implicit inspect (and therefore instantiation of every node) ...
+      #   irb> doc.slop!
+      #   ... which does absolutely nothing.
+      #
+      def slop!
+        unless decorators(XML::Node).include? Nokogiri::Decorators::Slop
+          decorators(XML::Node) << Nokogiri::Decorators::Slop
+          decorate!
+        end
+
+        self
+      end
+
+      ##
+      # Apply any decorators to +node+
+      def decorate node
+        return unless @decorators
+        @decorators.each { |klass,list|
+          next unless node.is_a?(klass)
+          list.each { |moodule| node.extend(moodule) }
+        }
+      end
+
+      alias :to_xml :serialize
+      alias :clone :dup
+
+      # Get the hash of namespaces on the root Nokogiri::XML::Node
+      def namespaces
+        root ? root.namespaces : {}
+      end
+
+      ##
+      # Create a Nokogiri::XML::DocumentFragment from +tags+
+      # Returns an empty fragment if +tags+ is nil.
+      def fragment tags = nil
+        DocumentFragment.new(self, tags, self.root)
+      end
+
+      undef_method :swap, :parent, :namespace, :default_namespace=
+      undef_method :add_namespace_definition, :attributes
+      undef_method :namespace_definitions, :line, :add_namespace
+
+      def add_child node_or_tags
+        raise "A document may not have multiple root nodes." if (root && root.name != 'nokogiri_text_wrapper') && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
+        node_or_tags = coerce(node_or_tags)
+        if node_or_tags.is_a?(XML::NodeSet)
+          raise "A document may not have multiple root nodes." if node_or_tags.size > 1
+          super(node_or_tags.first)
+        else
+          super
+        end
+      end
+      alias :<< :add_child
+
+      ##
+      # +JRuby+
+      # Wraps Java's org.w3c.dom.document and returns Nokogiri::XML::Document
+      def self.wrap(document) end if false # native-ext provides Document.wrap
+
+      ##
+      # +JRuby+
+      # Returns Java's org.w3c.dom.document of this Document.
+      def to_java; end if false # JRuby provides #to_java
+
+      private
+      def self.empty_doc? string_or_io
+        string_or_io.nil? ||
+          (string_or_io.respond_to?(:empty?) && string_or_io.empty?) ||
+          (string_or_io.respond_to?(:eof?) && string_or_io.eof?)
+      end
+
+      # @private
+      IMPLIED_XPATH_CONTEXTS = [ '//'.freeze ].freeze # :nodoc:
+
+      def inspect_attributes
+        [:name, :children]
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/document_fragment.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+module Nokogiri
+  module XML
+    class DocumentFragment < Nokogiri::XML::Node
+      ##
+      #  Create a new DocumentFragment from +tags+.
+      #
+      #  If +ctx+ is present, it is used as a context node for the
+      #  subtree created, e.g., namespaces will be resolved relative
+      #  to +ctx+.
+      def initialize document, tags = nil, ctx = nil
+        return self unless tags
+
+        children = if ctx
+                     # Fix for issue#490
+                     if Nokogiri.jruby?
+                       # fix for issue #770
+                       ctx.parse("<root #{namespace_declarations(ctx)}>#{tags}</root>").children
+                     else
+                       ctx.parse(tags)
+                     end
+                   else
+                     XML::Document.parse("<root>#{tags}</root>") \
+                       .xpath("/root/node()")
+                   end
+        children.each { |child| child.parent = self }
+      end
+
+      if Nokogiri.uses_libxml?
+        def dup
+          new_document = document.dup
+          new_fragment = self.class.new(new_document)
+          children.each do |child|
+            child.dup(1, new_document).parent = new_fragment
+          end
+          new_fragment
+        end
+      end
+
+      ###
+      # return the name for DocumentFragment
+      def name
+        '#document-fragment'
+      end
+
+      ###
+      # Convert this DocumentFragment to a string
+      def to_s
+        children.to_s
+      end
+
+      ###
+      # Convert this DocumentFragment to html
+      # See Nokogiri::XML::NodeSet#to_html
+      def to_html *args
+        if Nokogiri.jruby?
+          options = args.first.is_a?(Hash) ? args.shift : {}
+          if !options[:save_with]
+            options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_HTML
+          end
+          args.insert(0, options)
+        end
+        children.to_html(*args)
+      end
+
+      ###
+      # Convert this DocumentFragment to xhtml
+      # See Nokogiri::XML::NodeSet#to_xhtml
+      def to_xhtml *args
+        if Nokogiri.jruby?
+          options = args.first.is_a?(Hash) ? args.shift : {}
+          if !options[:save_with]
+            options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_XHTML
+          end
+          args.insert(0, options)
+        end
+        children.to_xhtml(*args)
+      end
+
+      ###
+      # Convert this DocumentFragment to xml
+      # See Nokogiri::XML::NodeSet#to_xml
+      def to_xml *args
+        children.to_xml(*args)
+      end
+
+      ###
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
+      #
+      # Search this fragment for CSS +rules+. +rules+ must be one or more CSS
+      # selectors. For example:
+      #
+      # For more information see Nokogiri::XML::Searchable#css
+      def css *args
+        if children.any?
+          children.css(*args) # 'children' is a smell here
+        else
+          NodeSet.new(document)
+        end
+      end
+
+      #
+      #  NOTE that we don't delegate #xpath to children ... another smell.
+      #  def xpath ; end
+      #
+
+      ###
+      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
+      #
+      # Search this fragment for +paths+. +paths+ must be one or more XPath or CSS queries.
+      #
+      # For more information see Nokogiri::XML::Searchable#search
+      def search *rules
+        rules, handler, ns, binds = extract_params(rules)
+
+        rules.inject(NodeSet.new(document)) do |set, rule|
+          set += if rule =~ Searchable::LOOKS_LIKE_XPATH
+                   xpath(*([rule, ns, handler, binds].compact))
+                 else
+                   children.css(*([rule, ns, handler].compact)) # 'children' is a smell here
+                 end
+        end
+      end
+
+      alias :serialize :to_s
+
+      class << self
+        ####
+        # Create a Nokogiri::XML::DocumentFragment from +tags+
+        def parse tags
+          self.new(XML::Document.new, tags)
+        end
+      end
+
+      # A list of Nokogiri::XML::SyntaxError found when parsing a document
+      def errors
+        document.errors
+      end
+
+      def errors= things # :nodoc:
+        document.errors = things
+      end
+
+      private
+
+      # fix for issue 770
+      def namespace_declarations ctx
+        ctx.namespace_scopes.map do |namespace|
+          prefix = namespace.prefix.nil? ? "" : ":#{namespace.prefix}"
+          %Q{xmlns#{prefix}="#{namespace.href}"}
+        end.join ' '
+      end
+
+      def coerce data
+        return super unless String === data
+
+        document.fragment(data).children
+      end
+    end
+  end
+end