nokogiri 1.6.5-java → 1.6.6.1-java

data/lib/nokogiri/xml/node_set.rb

@@ -3,8 +3,9 @@ module Nokogiri
     ####
     # A NodeSet contains a list of Nokogiri::XML::Node objects.  Typically
     # a NodeSet is return as a result of searching a Document via
-    # Nokogiri::XML::Node#css or Nokogiri::XML::Node#xpath
+    # Nokogiri::XML::Searchable#css or Nokogiri::XML::Searchable#xpath
     class NodeSet
+      include Nokogiri::XML::Searchable
       include Enumerable
 
       # The Document this NodeSet is associated with
@@ -62,78 +63,33 @@ module Nokogiri
       alias :remove :unlink
 
       ###
-      # Search this document for +paths+
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
       #
-      # For more information see Nokogiri::XML::Node#css and
-      # Nokogiri::XML::Node#xpath
-      def search *paths
-        handler = ![
-          Hash, String, Symbol
-        ].include?(paths.last.class) ? paths.pop : nil
-
-        ns = paths.last.is_a?(Hash) ? paths.pop : nil
-
-        sub_set = NodeSet.new(document)
-
-        paths.each do |path|
-          sub_set += send(
-            path =~ /^(\.\/|\/|\.\.|\.$)/ ? :xpath : :css,
-            *(paths + [ns, handler]).compact
-          )
-        end
-
-        document.decorate(sub_set)
-        sub_set
-      end
-      alias :/ :search
-
-      ###
-      # Search this NodeSet for css +paths+
+      # Search this node set for CSS +rules+. +rules+ must be one or more CSS
+      # selectors. For example:
       #
-      # For more information see Nokogiri::XML::Node#css
-      def css *paths
-        handler = ![
-          Hash, String, Symbol
-        ].include?(paths.last.class) ? paths.pop : nil
-
-        ns = paths.last.is_a?(Hash) ? paths.pop : nil
-
-        sub_set = NodeSet.new(document)
+      # For more information see Nokogiri::XML::Searchable#css
+      def css *args
+        rules, handler, ns, _ = extract_params(args)
 
-        each do |node|
-          doc = node.document
-          search_ns = ns || (doc.root ? doc.root.namespaces : {})
-
-          xpaths = paths.map { |rule|
-            [
-              CSS.xpath_for(rule.to_s, :prefix => ".//", :ns => search_ns),
-              CSS.xpath_for(rule.to_s, :prefix => "self::", :ns => search_ns)
-            ].join(' | ')
-          }
-
-          sub_set += node.xpath(*(xpaths + [search_ns, handler].compact))
+        inject(NodeSet.new(document)) do |set, node|
+          set += css_internal node, rules, handler, ns
         end
-        document.decorate(sub_set)
-        sub_set
       end
 
       ###
-      # Search this NodeSet for XPath +paths+
+      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
       #
-      # For more information see Nokogiri::XML::Node#xpath
-      def xpath *paths
-        handler = ![
-          Hash, String, Symbol
-        ].include?(paths.last.class) ? paths.pop : nil
-
-        ns = paths.last.is_a?(Hash) ? paths.pop : nil
+      # Search this node set for XPath +paths+. +paths+ must be one or more XPath
+      # queries.
+      #
+      # For more information see Nokogiri::XML::Searchable#xpath
+      def xpath *args
+        paths, handler, ns, binds = extract_params(args)
 
-        sub_set = NodeSet.new(document)
-        each do |node|
-          sub_set += node.xpath(*(paths + [ns, handler].compact))
+        inject(NodeSet.new(document)) do |set, node|
+          set += node.xpath(*(paths + [ns, handler, binds].compact))
         end
-        document.decorate(sub_set)
-        sub_set
       end
 
       ###
@@ -144,31 +100,25 @@ module Nokogiri
       end
 
       ###
-      # If path is a string, search this document for +path+ returning the
-      # first Node.  Otherwise, index in to the array with +path+.
-      def at path, ns = document.root ? document.root.namespaces : {}
-        return self[path] if path.is_a?(Numeric)
-        search(path, ns).first
-      end
-      alias :% :at
-
-      ##
-      # Search this NodeSet for the first occurrence of XPath +paths+.
-      # Equivalent to <tt>xpath(paths).first</tt>
-      # See NodeSet#xpath for more information.
+      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
       #
-      def at_xpath *paths
-        xpath(*paths).first
-      end
-
-      ##
-      # Search this NodeSet for the first occurrence of CSS +rules+.
-      # Equivalent to <tt>css(rules).first</tt>
-      # See NodeSet#css for more information.
+      # Search this object for +paths+, and return only the first
+      # result. +paths+ must be one or more XPath or CSS queries.
+      #
+      # See Searchable#search for more information.
+      #
+      # Or, if passed an integer, index into the NodeSet:
+      #
+      #   node_set.at(3) # same as node_set[3]
       #
-      def at_css *rules
-        css(*rules).first
+      def at *args
+        if args.length == 1 && args.first.is_a?(Numeric)
+          return self[args.first]
+        end
+
+        super(*args)
       end
+      alias :% :at
 
       ###
       # Filter this list for nodes that match +expr+
@@ -350,6 +300,12 @@ module Nokogiri
       end
 
       alias :+ :|
+
+      private
+
+      def implied_xpath_contexts # :nodoc:
+        [".//", "self::"]
+      end
     end
   end
 end

data/lib/nokogiri/xml/searchable.rb

@@ -0,0 +1,221 @@
+module Nokogiri
+  module XML
+    #
+    #  The Searchable module declares the interface used for searching your DOM.
+    #
+    #  It implements the public methods `search`, `css`, and `xpath`,
+    #  as well as allowing specific implementations to specialize some
+    #  of the important behaviors.
+    #
+    module Searchable
+      # Regular expression used by Searchable#search to determine if a query
+      # string is CSS or XPath
+      LOOKS_LIKE_XPATH = /^(\.\/|\/|\.\.|\.$)/
+      
+      ###
+      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
+      #
+      # Search this object for +paths+. +paths+ must be one or more XPath or CSS queries:
+      #
+      #   node.search("div.employee", ".//title")
+      #
+      # A hash of namespace bindings may be appended:
+      #
+      #   node.search('.//bike:tire', {'bike' => 'http://schwinn.com/'})
+      #   node.search('bike|tire', {'bike' => 'http://schwinn.com/'})
+      #
+      # For XPath queries, a hash of variable bindings may also be
+      # appended to the namespace bindings. For example:
+      #
+      #   node.search('.//address[@domestic=$value]', nil, {:value => 'Yes'})
+      #
+      # Custom XPath functions and CSS pseudo-selectors may also be
+      # defined. To define custom functions create a class and
+      # implement the function you want to define.  The first argument
+      # to the method will be the current matching NodeSet.  Any other
+      # arguments are ones that you pass in.  Note that this class may
+      # appear anywhere in the argument list.  For example:
+      #
+      #   node.search('.//title[regex(., "\w+")]', 'div.employee:regex("[0-9]+")'
+      #     Class.new {
+      #       def regex node_set, regex
+      #         node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #       end
+      #     }.new
+      #   )
+      #
+      # See Searchable#xpath and Searchable#css for further usage help.
+      def search *args
+        paths, handler, ns, binds = extract_params(args)
+
+        xpaths = paths.map(&:to_s).map do |path|
+          (path =~ LOOKS_LIKE_XPATH) ? path : xpath_query_from_css_rule(path, ns)
+        end.flatten.uniq
+
+        xpath(*(xpaths + [ns, handler, binds].compact))
+      end
+      alias :/ :search
+
+      ###
+      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
+      #
+      # Search this object for +paths+, and return only the first
+      # result. +paths+ must be one or more XPath or CSS queries.
+      #
+      # See Searchable#search for more information.
+      def at *args
+        search(*args).first
+      end
+      alias :% :at
+
+      ###
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
+      #
+      # Search this object for CSS +rules+. +rules+ must be one or more CSS
+      # selectors. For example:
+      #
+      #   node.css('title')
+      #   node.css('body h1.bold')
+      #   node.css('div + p.green', 'div#one')
+      #
+      # A hash of namespace bindings may be appended. For example:
+      #
+      #   node.css('bike|tire', {'bike' => 'http://schwinn.com/'})
+      #
+      # Custom CSS pseudo classes may also be defined.  To define
+      # custom pseudo classes, create a class and implement the custom
+      # pseudo class you want defined.  The first argument to the
+      # method will be the current matching NodeSet.  Any other
+      # arguments are ones that you pass in.  For example:
+      #
+      #   node.css('title:regex("\w+")', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   }.new)
+      #
+      # Note that the CSS query string is case-sensitive with regards
+      # to your document type. That is, if you're looking for "H1" in
+      # an HTML document, you'll never find anything, since HTML tags
+      # will match only lowercase CSS queries. However, "H1" might be
+      # found in an XML document, where tags names are case-sensitive
+      # (e.g., "H1" is distinct from "h1").
+      #
+      def css *args
+        rules, handler, ns, _ = extract_params(args)
+
+        css_internal self, rules, handler, ns
+      end
+
+      ##
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
+      #
+      # Search this object for CSS +rules+, and return only the first
+      # match. +rules+ must be one or more CSS selectors.
+      #
+      # See Searchable#css for more information.
+      def at_css *args
+        css(*args).first
+      end
+
+      ###
+      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
+      #
+      # Search this node for XPath +paths+. +paths+ must be one or more XPath
+      # queries.
+      #
+      #   node.xpath('.//title')
+      #
+      # A hash of namespace bindings may be appended. For example:
+      #
+      #   node.xpath('.//foo:name', {'foo' => 'http://example.org/'})
+      #   node.xpath('.//xmlns:name', node.root.namespaces)
+      #
+      # A hash of variable bindings may also be appended to the namespace bindings. For example:
+      #
+      #   node.xpath('.//address[@domestic=$value]', nil, {:value => 'Yes'})
+      #
+      # Custom XPath functions may also be defined.  To define custom
+      # functions create a class and implement the function you want
+      # to define.  The first argument to the method will be the
+      # current matching NodeSet.  Any other arguments are ones that
+      # you pass in.  Note that this class may appear anywhere in the
+      # argument list.  For example:
+      #
+      #   node.xpath('.//title[regex(., "\w+")]', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   }.new)
+      #
+      def xpath *args
+        return NodeSet.new(document) unless document
+
+        paths, handler, ns, binds = extract_params(args)
+
+        sets = paths.map do |path|
+          ctx = XPathContext.new(self)
+          ctx.register_namespaces(ns)
+          path = path.gsub(/xmlns:/, ' :') unless Nokogiri.uses_libxml?
+
+          binds.each do |key,value|
+            ctx.register_variable key.to_s, value
+          end if binds
+
+          ctx.evaluate(path, handler)
+        end
+        return sets.first if sets.length == 1
+
+        NodeSet.new(document) do |combined|
+          sets.each do |set|
+            set.each do |node|
+              combined << node
+            end
+          end
+        end
+      end
+
+      ##
+      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
+      #
+      # Search this node for XPath +paths+, and return only the first
+      # match. +paths+ must be one or more XPath queries.
+      #
+      # See Searchable#xpath for more information.
+      def at_xpath *args
+        xpath(*args).first
+      end
+
+      private
+
+      def css_internal node, rules, handler, ns
+        xpaths = rules.map { |rule| xpath_query_from_css_rule(rule, ns) }
+        node.xpath(*(xpaths + [ns, handler].compact))
+      end
+
+      def xpath_query_from_css_rule rule, ns
+        implied_xpath_contexts.map do |implied_xpath_context|
+          CSS.xpath_for(rule.to_s, :prefix => implied_xpath_context, :ns => ns)
+        end.join(' | ')
+      end
+
+      def extract_params params # :nodoc:
+        handler = params.find do |param|
+          ![Hash, String, Symbol].include?(param.class)
+        end
+        params -= [handler] if handler
+
+        hashes = []
+        while Hash === params.last || params.last.nil?
+          hashes << params.pop
+          break if params.empty?
+        end
+        ns, binds = hashes.reverse
+
+        ns ||= document.root ? document.root.namespaces : {}
+
+        [params, handler, ns, binds]
+      end
+    end
+  end
+end

data/ports/patches/sort-patches-by-date

@@ -0,0 +1,25 @@
+#! /usr/bin/env ruby
+
+require "date"
+
+dir = ARGV[0] || raise("ERROR: arg1 must be dir")
+
+Dir.chdir dir
+
+files_and_times = {}
+Dir["*.patch"].sort.each do |filename|
+  dateline = `cat #{filename} | grep "Date:"`
+  datestr = dateline.split("Date:").last.strip
+  time = DateTime.parse datestr
+  files_and_times[filename] = time
+end
+
+count = 0
+files_and_times.sort_by {|k,v| v}.each do |filename, time|
+  count += 1
+  _, patch_name = filename.split("-", 2)
+  new_filename = sprintf("%4.4d-%s", count, patch_name)
+  printf "mv -f %s %s # %s\n", filename, new_filename, time
+end
+
+STDERR.print "\n**\n** REMEMBER TO UPDATE THE Manifest.txt FILE\n**\n"

data/test/css/test_nthiness.rb

@@ -79,7 +79,7 @@ EOF
       end
 
       def test_n
-        assert_result_rows (1..14).to_a, @parser.search("table/tr:nth(n)")
+        assert_result_rows((1..14).to_a, @parser.search("table/tr:nth(n)"))
       end
 
       def test_2n

data/test/html/sax/test_push_parser.rb

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+
+require "helper"
+
+module Nokogiri
+  module HTML
+    module SAX
+      class TestPushParser < Nokogiri::SAX::TestCase
+        def setup
+          super
+          @parser = HTML::SAX::PushParser.new(Doc.new)
+        end
+
+        def test_end_document_called
+          @parser.<<(<<-eoxml)
+            <p id="asdfasdf">
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          assert ! @parser.document.end_document_called
+          @parser.finish
+          assert @parser.document.end_document_called
+        end
+
+        def test_start_element
+          @parser.<<(<<-eoxml)
+            <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
+            <html><head><body><p id="asdfasdf">
+          eoxml
+
+          assert_equal [["html", []], ["head", []], ["body", []], ["p", [["id", "asdfasdf"]]]],
+            @parser.document.start_elements
+          
+          @parser.<<(<<-eoxml)
+              <!-- This is a comment -->
+              Paragraph 1
+            </p></body></html>
+          eoxml
+          assert_equal [' This is a comment '], @parser.document.comments
+          @parser.finish
+        end
+
+
+        def test_chevron_partial_html
+          @parser.<<(<<-eoxml)
+            <p id="asdfasdf">
+          eoxml
+
+          @parser.<<(<<-eoxml)
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          assert_equal [' This is a comment '], @parser.document.comments
+          @parser.finish
+        end
+
+        def test_chevron
+          @parser.<<(<<-eoxml)
+            <p id="asdfasdf">
+              <!-- This is a comment -->
+              Paragraph 1
+            </p>
+          eoxml
+          @parser.finish
+          assert_equal [' This is a comment '], @parser.document.comments
+        end
+
+        def test_default_options
+          assert_equal 0, @parser.options
+        end
+        
+        def test_broken_encoding
+          skip("ultra hard to fix for pure Java version") if Nokogiri.jruby?
+          @parser.options |= XML::ParseOptions::RECOVER
+          # This is ISO_8859-1:
+          @parser.<< "<?xml version='1.0' encoding='UTF-8'?><r>Gau\337</r>"
+          @parser.finish
+          assert(@parser.document.errors.size >= 1)
+          assert_equal "Gau\337", @parser.document.data.join
+          assert_equal [["r"], ["body"], ["html"]], @parser.document.end_elements
+        end
+      end
+    end
+  end
+end