vtd_xml 0.0.3-java → 0.0.6-java

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/lib/nokogiri/xml/node_set.rb

@@ -1,355 +0,0 @@
-module Nokogiri
-  module XML
-    ####
-    # 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
-    class NodeSet
-      include Enumerable
-
-      # The Document this NodeSet is associated with
-      attr_accessor :document
-
-      # Create a NodeSet with +document+ defaulting to +list+
-      def initialize document, list = []
-        @document = document
-        document.decorate(self)
-        list.each { |x| self << x }
-        yield self if block_given?
-      end
-
-      ###
-      # Get the first element of the NodeSet.
-      def first n = nil
-        return self[0] unless n
-        list = []
-        n.times { |i| list << self[i] }
-        list
-      end
-
-      ###
-      # Get the last element of the NodeSet.
-      def last
-        self[-1]
-      end
-
-      ###
-      # Is this NodeSet empty?
-      def empty?
-        length == 0
-      end
-
-      ###
-      # Returns the index of the first node in self that is == to +node+. Returns nil if no match is found.
-      def index(node)
-        each_with_index { |member, j| return j if member == node }
-        nil
-      end
-
-      ###
-      # Insert +datum+ before the first Node in this NodeSet
-      def before datum
-        first.before datum
-      end
-
-      ###
-      # Insert +datum+ after the last Node in this NodeSet
-      def after datum
-        last.after datum
-      end
-
-      alias :<< :push
-      alias :remove :unlink
-
-      ###
-      # Search this document for +paths+
-      #
-      # 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+
-      #
-      # 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)
-
-        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))
-        end
-        document.decorate(sub_set)
-        sub_set
-      end
-
-      ###
-      # Search this NodeSet for XPath +paths+
-      #
-      # 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
-
-        sub_set = NodeSet.new(document)
-        each do |node|
-          sub_set += node.xpath(*(paths + [ns, handler].compact))
-        end
-        document.decorate(sub_set)
-        sub_set
-      end
-
-      ###
-      # Search this NodeSet's nodes' immediate children using CSS selector +selector+
-      def > selector
-        ns = document.root.namespaces
-        xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
-      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.
-      #
-      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.
-      #
-      def at_css *rules
-        css(*rules).first
-      end
-
-      ###
-      # Filter this list for nodes that match +expr+
-      def filter expr
-        find_all { |node| node.matches?(expr) }
-      end
-
-      ###
-      # Append the class attribute +name+ to all Node objects in the NodeSet.
-      def add_class name
-        each do |el|
-          classes = el['class'].to_s.split(/\s+/)
-          el['class'] = classes.push(name).uniq.join " "
-        end
-        self
-      end
-
-      ###
-      # Remove the class attribute +name+ from all Node objects in the NodeSet.
-      # If +name+ is nil, remove the class attribute from all Nodes in the
-      # NodeSet.
-      def remove_class name = nil
-        each do |el|
-          if name
-            classes = el['class'].to_s.split(/\s+/)
-            if classes.empty?
-              el.delete 'class'
-            else
-              el['class'] = (classes - [name]).uniq.join " "
-            end
-          else
-            el.delete "class"
-          end
-        end
-        self
-      end
-
-      ###
-      # Set the attribute +key+ to +value+ or the return value of +blk+
-      # on all Node objects in the NodeSet.
-      def attr key, value = nil, &blk
-        unless Hash === key || key && (value || blk)
-          return first.attribute(key)
-        end
-
-        hash = key.is_a?(Hash) ? key : { key => value }
-
-        hash.each { |k,v| each { |el| el[k] = v || blk[el] } }
-
-        self
-      end
-      alias :set :attr
-      alias :attribute :attr
-
-      ###
-      # Remove the attributed named +name+ from all Node objects in the NodeSet
-      def remove_attr name
-        each { |el| el.delete name }
-        self
-      end
-
-      ###
-      # Iterate over each node, yielding  to +block+
-      def each(&block)
-        0.upto(length - 1) do |x|
-          yield self[x]
-        end
-      end
-
-      ###
-      # Get the inner text of all contained Node objects
-      def inner_text
-        collect{|j| j.inner_text}.join('')
-      end
-      alias :text :inner_text
-
-      ###
-      # Get the inner html of all contained Node objects
-      def inner_html *args
-        collect{|j| j.inner_html(*args) }.join('')
-      end
-
-      ###
-      # Wrap this NodeSet with +html+ or the results of the builder in +blk+
-      def wrap(html, &blk)
-        each do |j|
-          new_parent = document.parse(html).first
-          j.add_next_sibling(new_parent)
-          new_parent.add_child(j)
-        end
-        self
-      end
-
-      ###
-      # Convert this NodeSet to a string.
-      def to_s
-        map { |x| x.to_s }.join
-      end
-
-      ###
-      # Convert this 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
-        map { |x| x.to_html(*args) }.join
-      end
-
-      ###
-      # Convert this NodeSet to XHTML
-      def to_xhtml *args
-        map { |x| x.to_xhtml(*args) }.join
-      end
-
-      ###
-      # Convert this NodeSet to XML
-      def to_xml *args
-        map { |x| x.to_xml(*args) }.join
-      end
-
-      alias :size :length
-      alias :to_ary :to_a
-
-      ###
-      # Removes the last element from set and returns it, or +nil+ if
-      # the set is empty
-      def pop
-        return nil if length == 0
-        delete last
-      end
-
-      ###
-      # Returns the first element of the NodeSet and removes it.  Returns
-      # +nil+ if the set is empty.
-      def shift
-        return nil if length == 0
-        delete first
-      end
-
-      ###
-      # Equality -- Two NodeSets are equal if the contain the same number
-      # of elements and if each element is equal to the corresponding
-      # element in the other NodeSet
-      def == other
-        return false unless other.is_a?(Nokogiri::XML::NodeSet)
-        return false unless length == other.length
-        each_with_index do |node, i|
-          return false unless node == other[i]
-        end
-        true
-      end
-
-      ###
-      # Returns a new NodeSet containing all the children of all the nodes in
-      # the NodeSet
-      def children
-        inject(NodeSet.new(document)) { |set, node| set += node.children }
-      end
-
-      ###
-      # Returns a new NodeSet containing all the nodes in the NodeSet
-      # in reverse order
-      def reverse
-        node_set = NodeSet.new(document)
-        (length - 1).downto(0) do |x|
-          node_set.push self[x]
-        end
-        node_set
-      end
-
-      ###
-      # Return a nicely formated string representation
-      def inspect
-        "[#{map { |c| c.inspect }.join ', '}]"
-      end
-
-      alias :+ :|
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/lib/nokogiri/xml/notation.rb

@@ -1,6 +0,0 @@
-module Nokogiri
-  module XML
-    class Notation < Struct.new(:name, :public_id, :system_id)
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/lib/nokogiri/xml/parse_options.rb

@@ -1,98 +0,0 @@
-module Nokogiri
-  module XML
-    ###
-    # Parse options for passing to Nokogiri.XML or Nokogiri.HTML
-    class ParseOptions
-      # Strict parsing
-      STRICT      = 0
-      # Recover from errors
-      RECOVER     = 1 << 0
-      # Substitute entities
-      NOENT       = 1 << 1
-      # Load external subsets
-      DTDLOAD     = 1 << 2
-      # Default DTD attributes
-      DTDATTR     = 1 << 3
-      # validate with the DTD
-      DTDVALID    = 1 << 4
-      # suppress error reports
-      NOERROR     = 1 << 5
-      # suppress warning reports
-      NOWARNING   = 1 << 6
-      # pedantic error reporting
-      PEDANTIC    = 1 << 7
-      # remove blank nodes
-      NOBLANKS    = 1 << 8
-      # use the SAX1 interface internally
-      SAX1        = 1 << 9
-      # Implement XInclude substitution
-      XINCLUDE    = 1 << 10
-      # Forbid network access. Recommended for dealing with untrusted documents.
-      NONET       = 1 << 11
-      # Do not reuse the context dictionary
-      NODICT      = 1 << 12
-      # remove redundant namespaces declarations
-      NSCLEAN     = 1 << 13
-      # merge CDATA as text nodes
-      NOCDATA     = 1 << 14
-      # do not generate XINCLUDE START/END nodes
-      NOXINCNODE  = 1 << 15
-      # compact small text nodes; no modification of the tree allowed afterwards (will possibly crash if you try to modify the tree)
-      COMPACT     = 1 << 16
-      # parse using XML-1.0 before update 5
-      OLD10       = 1 << 17
-      # do not fixup XINCLUDE xml:base uris
-      NOBASEFIX   = 1 << 18
-      # relax any hardcoded limit from the parser
-      HUGE        = 1 << 19
-
-      # the default options used for parsing XML documents
-      DEFAULT_XML  = RECOVER | NONET
-      # the default options used for parsing HTML documents
-      DEFAULT_HTML = RECOVER | NOERROR | NOWARNING | NONET
-
-      attr_accessor :options
-      def initialize options = STRICT
-        @options = options
-      end
-
-      constants.each do |constant|
-        next if constant.to_sym == :STRICT
-        class_eval %{
-          def #{constant.downcase}
-            @options |= #{constant}
-            self
-          end
-
-          def no#{constant.downcase}
-            @options &= ~#{constant}
-            self
-          end
-
-          def #{constant.downcase}?
-            #{constant} & @options == #{constant}
-          end
-        }
-      end
-
-      def strict
-        @options &= ~RECOVER
-        self
-      end
-
-      def strict?
-        @options & RECOVER == STRICT
-      end
-
-      alias :to_i :options
-
-      def inspect
-        options = []
-        self.class.constants.each do |k|
-          options << k.downcase if send(:"#{k.downcase}?")
-        end
-        super.sub(/>$/, " " + options.join(', ') + ">")
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/lib/nokogiri/xml/pp/character_data.rb

@@ -1,18 +0,0 @@
-module Nokogiri
-  module XML
-    module PP
-      module CharacterData
-        def pretty_print pp # :nodoc:
-          nice_name = self.class.name.split('::').last
-          pp.group(2, "#(#{nice_name} ", ')') do
-            pp.pp text
-          end
-        end
-
-        def inspect # :nodoc:
-          "#<#{self.class.name}:#{sprintf("0x%x",object_id)} #{text.inspect}>"
-        end
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/lib/nokogiri/xml/pp/node.rb

@@ -1,56 +0,0 @@
-module Nokogiri
-  module XML
-    module PP
-      module Node
-        def inspect # :nodoc:
-          attributes = inspect_attributes.reject { |x|
-            begin
-              attribute = send x
-              !attribute || (attribute.respond_to?(:empty?) && attribute.empty?)
-            rescue NoMethodError
-              true
-            end
-          }.map { |attribute|
-            "#{attribute.to_s.sub(/_\w+/, 's')}=#{send(attribute).inspect}"
-          }.join ' '
-          "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{attributes}>"
-        end
-
-        def pretty_print pp # :nodoc:
-          nice_name = self.class.name.split('::').last
-          pp.group(2, "#(#{nice_name}:#{sprintf("0x%x", object_id)} {", '})') do
-
-            pp.breakable
-            attrs = inspect_attributes.map { |t|
-              [t, send(t)] if respond_to?(t)
-            }.compact.find_all { |x|
-              if x.last
-                if [:attribute_nodes, :children].include? x.first
-                  !x.last.empty?
-                else
-                  true
-                end
-              end
-            }
-
-            pp.seplist(attrs) do |v|
-              if [:attribute_nodes, :children].include? v.first
-                pp.group(2, "#{v.first.to_s.sub(/_\w+$/, 's')} = [", "]") do
-                  pp.breakable
-                  pp.seplist(v.last) do |item|
-                    pp.pp item
-                  end
-                end
-              else
-                pp.text "#{v.first} = "
-                pp.pp v.last
-              end
-            end
-            pp.breakable
-
-          end
-        end
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/lib/nokogiri/xml/pp.rb

@@ -1,2 +0,0 @@
-require 'nokogiri/xml/pp/node'
-require 'nokogiri/xml/pp/character_data'

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/lib/nokogiri/xml/processing_instruction.rb

@@ -1,8 +0,0 @@
-module Nokogiri
-  module XML
-    class ProcessingInstruction < Node
-      def initialize document, name, content
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/lib/nokogiri/xml/reader.rb

@@ -1,112 +0,0 @@
-module Nokogiri
-  module XML
-    ###
-    # Nokogiri::XML::Reader parses an XML document similar to the way a cursor
-    # would move.  The Reader is given an XML document, and yields nodes
-    # to an each block.
-    #
-    # Here is an example of usage:
-    #
-    #   reader = Nokogiri::XML::Reader(<<-eoxml)
-    #     <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-    #       <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    #     </x>
-    #   eoxml
-    #
-    #   reader.each do |node|
-    #
-    #     # node is an instance of Nokogiri::XML::Reader
-    #     puts node.name
-    #
-    #   end
-    #
-    # Note that Nokogiri::XML::Reader#each can only be called once!!  Once
-    # the cursor moves through the entire document, you must parse the
-    # document again.  So make sure that you capture any information you
-    # need during the first iteration.
-    #
-    # The Reader parser is good for when you need the speed of a SAX parser,
-    # but do not want to write a Document handler.
-    class Reader
-      include Enumerable
-
-      TYPE_NONE = 0
-      # Element node type
-      TYPE_ELEMENT = 1
-      # Attribute node type
-      TYPE_ATTRIBUTE = 2
-      # Text node type
-      TYPE_TEXT = 3
-      # CDATA node type
-      TYPE_CDATA = 4
-      # Entity Reference node type
-      TYPE_ENTITY_REFERENCE = 5
-      # Entity node type
-      TYPE_ENTITY = 6
-      # PI node type
-      TYPE_PROCESSING_INSTRUCTION = 7
-      # Comment node type
-      TYPE_COMMENT = 8
-      # Document node type
-      TYPE_DOCUMENT = 9
-      # Document Type node type
-      TYPE_DOCUMENT_TYPE = 10
-      # Document Fragment node type
-      TYPE_DOCUMENT_FRAGMENT = 11
-      # Notation node type
-      TYPE_NOTATION = 12
-      # Whitespace node type
-      TYPE_WHITESPACE = 13
-      # Significant Whitespace node type
-      TYPE_SIGNIFICANT_WHITESPACE = 14
-      # Element end node type
-      TYPE_END_ELEMENT = 15
-      # Entity end node type
-      TYPE_END_ENTITY = 16
-      # XML Declaration node type
-      TYPE_XML_DECLARATION = 17
-
-      # A list of errors encountered while parsing
-      attr_accessor :errors
-
-      # The encoding for the document
-      attr_reader :encoding
-
-      # The XML source
-      attr_reader :source
-
-      alias :self_closing? :empty_element?
-
-      def initialize source, url = nil, encoding = nil # :nodoc:
-        @source   = source
-        @errors   = []
-        @encoding = encoding
-      end
-      private :initialize
-
-      ###
-      # Get a list of attributes for the current node.
-      def attributes
-        Hash[attribute_nodes.map { |node|
-          [node.name, node.to_s]
-        }].merge(namespaces || {})
-      end
-
-      ###
-      # Get a list of attributes for the current node
-      def attribute_nodes
-        nodes = attr_nodes
-        nodes.each { |v| v.instance_variable_set(:@_r, self) }
-        nodes
-      end
-
-      ###
-      # Move the cursor through the document yielding the cursor to the block
-      def each
-        while cursor = self.read
-          yield cursor
-        end
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/lib/nokogiri/xml/relax_ng.rb

@@ -1,32 +0,0 @@
-module Nokogiri
-  module XML
-    class << self
-      ###
-      # Create a new Nokogiri::XML::RelaxNG document from +string_or_io+.
-      # See Nokogiri::XML::RelaxNG for an example.
-      def RelaxNG string_or_io
-        RelaxNG.new(string_or_io)
-      end
-    end
-
-    ###
-    # Nokogiri::XML::RelaxNG is used for validating XML against a
-    # RelaxNG schema.
-    #
-    # == Synopsis
-    #
-    # Validate an XML document against a RelaxNG schema.  Loop over the errors
-    # that are returned and print them out:
-    #
-    #   schema  = Nokogiri::XML::RelaxNG(File.open(ADDRESS_SCHEMA_FILE))
-    #   doc     = Nokogiri::XML(File.open(ADDRESS_XML_FILE))
-    #
-    #   schema.validate(doc).each do |error|
-    #     puts error.message
-    #   end
-    #
-    # The list of errors are Nokogiri::XML::SyntaxError objects.
-    class RelaxNG < Nokogiri::XML::Schema
-    end
-  end
-end