nokogiri 1.0.0-x86-mswin32-60

data/lib/nokogiri/html/builder.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module HTML
+    class Builder < XML::Builder
+      def to_html
+        @doc.to_html
+      end
+    end
+  end
+end

data/lib/nokogiri/html/document.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module HTML
+    class Document < XML::Document
+      def to_html
+        serialize
+      end
+    end
+  end
+end

data/lib/nokogiri/html/sax/parser.rb

@@ -0,0 +1,21 @@
+module Nokogiri
+  module HTML
+    module SAX
+      class Parser < XML::SAX::Parser
+        ###
+        # Parse html stored in +data+ using +encoding+
+        def parse_memory data, encoding = 'UTF-8'
+          native_parse_memory(data, encoding)
+        end
+
+        ###
+        # Parse a file with +filename+
+        def parse_file filename, encoding = 'UTF-8'
+          raise Errno::ENOENT unless File.exists?(filename)
+          raise Errno::EISDIR if File.directory?(filename)
+          native_parse_file filename, encoding
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/version.rb

@@ -0,0 +1,3 @@
+module Nokogiri
+  VERSION = '1.0.0'
+end

data/lib/nokogiri/xml.rb

@@ -0,0 +1,67 @@
+require 'nokogiri/xml/sax'
+require 'nokogiri/xml/before_handler'
+require 'nokogiri/xml/after_handler'
+require 'nokogiri/xml/node'
+require 'nokogiri/xml/dtd'
+require 'nokogiri/xml/text'
+require 'nokogiri/xml/cdata'
+require 'nokogiri/xml/document'
+require 'nokogiri/xml/node_set'
+require 'nokogiri/xml/xpath'
+require 'nokogiri/xml/xpath_context'
+require 'nokogiri/xml/builder'
+require 'nokogiri/xml/reader'
+require 'nokogiri/xml/syntax_error'
+require 'nokogiri/xml/notation'
+require 'nokogiri/xml/element'
+require 'nokogiri/xml/entity_declaration'
+
+module Nokogiri
+  class << self
+    def XML thing, url = nil, encoding = nil, options = 1
+      Nokogiri::XML.parse(thing, url, encoding, options)
+    end
+  end
+
+  module XML
+    # Parser options
+    PARSE_RECOVER     = 1 << 0  # Recover from errors
+    PARSE_NOENT       = 1 << 1  # Substitute entities
+    PARSE_DTDLOAD     = 1 << 2  # Load external subsets
+    PARSE_DTDATTR     = 1 << 3  # Default DTD attributes
+    PARSE_DTDVALID    = 1 << 4  # validate with the DTD
+    PARSE_NOERROR     = 1 << 5  # suppress error reports
+    PARSE_NOWARNING   = 1 << 6  # suppress warning reports
+    PARSE_PEDANTIC    = 1 << 7  # pedantic error reporting
+    PARSE_NOBLANKS    = 1 << 8  # remove blank nodes
+    PARSE_SAX1        = 1 << 9  # use the SAX1 interface internally
+    PARSE_XINCLUDE    = 1 << 10 # Implement XInclude substitition
+    PARSE_NONET       = 1 << 11 # Forbid network access
+    PARSE_NODICT      = 1 << 12 # Do not reuse the context dictionnary
+    PARSE_NSCLEAN     = 1 << 13 # remove redundant namespaces declarations
+    PARSE_NOCDATA     = 1 << 14 # merge CDATA as text nodes
+    PARSE_NOXINCNODE  = 1 << 15 # do not generate XINCLUDE START/END nodes
+
+    class << self
+      def parse string_or_io, url = nil, encoding = nil, options = 2159
+        if string_or_io.respond_to?(:read)
+          url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+          string_or_io = string_or_io.read
+        end
+
+        # read_memory pukes on empty docs
+        return Document.new if string_or_io.nil? or string_or_io.empty?
+
+        Document.read_memory(string_or_io, url, encoding, options)
+      end
+
+      def substitute_entities=(value = true)
+        Document.substitute_entities = value
+      end
+
+      def load_external_subsets=(value = true)
+        Document.load_external_subsets = value
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/after_handler.rb

@@ -0,0 +1,18 @@
+module Nokogiri
+  module XML
+    class AfterHandler < BeforeHandler
+      attr_accessor :after_nodes
+
+      def initialize node, original_html
+        super
+        @after_nodes = []
+      end
+
+      def end_element name
+        return unless @original_html =~ /<#{name}/i
+        @after_nodes << @stack.last if @stack.length == 1
+        @stack.pop
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/before_handler.rb

@@ -0,0 +1,32 @@
+module Nokogiri
+  module XML
+    class BeforeHandler < Nokogiri::XML::SAX::Document # :nodoc:
+      def initialize node, original_html
+        @original_html = original_html
+        @node = node
+        @stack = []
+      end
+
+      def start_element name, attrs = []
+        return unless @original_html =~ /<#{name}/i
+        node = Node.new(name)
+        Hash[*attrs].each do |k,v|
+          node[k] = v
+        end
+        node.parent = @stack.last if @stack.length != 0
+        @stack << node
+      end
+
+      def characters string
+        node = @stack.last
+        node.content += string
+      end
+
+      def end_element name
+        return unless @original_html =~ /<#{name}/i
+        @node.add_previous_sibling @stack.last if @stack.length == 1
+        @stack.pop
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/builder.rb

@@ -0,0 +1,79 @@
+module Nokogiri
+  module XML
+    class Builder
+      attr_accessor :doc, :parent
+      def initialize(&block)
+        namespace = self.class.name.split('::')
+        namespace[-1] = 'Document'
+        @doc = eval(namespace.join('::')).new
+        @parent = @doc
+        instance_eval(&block)
+        @parent = @doc
+      end
+
+      def text(string)
+        node = Nokogiri::XML::Text.new(string)
+        insert(node)
+      end
+
+      def cdata(string)
+        node = Nokogiri::XML::CData.new(@doc, string)
+        insert(node)
+      end
+
+      def to_xml
+        @doc.to_xml
+      end
+
+      def method_missing(method, *args, &block)
+        node = Nokogiri::XML::Node.new(method.to_s) { |n|
+          if content = args.first
+            if content.is_a?(Hash)
+              content.each { |k,v| n[k.to_s] = v.to_s }
+            else
+              n.content = content
+            end
+          end
+        }
+        insert(node, &block)
+      end
+
+      private
+      def insert(node, &block)
+        node.parent = @parent
+        if block_given?
+          @parent = node
+          instance_eval(&block)
+          @parent = node.parent
+        end
+        NodeBuilder.new(node, self)
+      end
+
+      class NodeBuilder # :nodoc:
+        def initialize(node, doc_builder)
+          @node = node
+          @doc_builder = doc_builder
+        end
+
+        def method_missing(method, *args, &block)
+          case method.to_s
+          when /^(.*)!$/
+            @node['id'] = $1
+            @node.content = args.first if args.first
+          when /^(.*)=/
+            @node[$1] = args.first
+          else
+            @node['class'] = 
+              ((@node['class'] || '').split(/\s/) + [method.to_s]).join(' ')
+            @node.content = args.first if args.first
+          end
+          if block_given?
+            @doc_builder.parent = @node
+            return @doc_builder.instance_eval(&block)
+          end
+          self
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/cdata.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module XML
+    class CDATA < Text
+      def name
+        'cdata-section'
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/document.rb

@@ -0,0 +1,30 @@
+module Nokogiri
+  module XML
+    class Document < Node
+      def decorators
+        @decorators ||= Hash.new { |h,k| h[k] = [] }
+      end
+
+      def name
+        'document'
+      end
+
+      ###
+      # Apply any decorators to +node+
+      def decorate(node)
+        key = node.class.name.split('::').last.downcase
+        decorators[key].each do |klass|
+          node.extend(klass)
+        end
+      end
+
+      def to_xml
+        serialize
+      end
+
+      def namespaces
+        root ? root.collect_namespaces : {}
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/dtd.rb

@@ -0,0 +1,6 @@
+module Nokogiri
+  module XML
+    class DTD < Node
+    end
+  end
+end

data/lib/nokogiri/xml/element.rb

@@ -0,0 +1,6 @@
+module Nokogiri
+  module XML
+    class Element < Node
+    end
+  end
+end

data/lib/nokogiri/xml/entity_declaration.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module XML
+    class EntityDeclaration < Node
+      def attributes
+        nil
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/node.rb

@@ -0,0 +1,195 @@
+module Nokogiri
+  module XML
+    class Node
+      CDATA_SECTION_NODE = 4
+      COMMENT_NODE = 8
+      DOCUMENT_NODE = 9
+      HTML_DOCUMENT_NODE = 13
+      DTD_NODE = 14
+      ELEMENT_DECL = 15
+      ATTRIBUTE_DECL = 16
+      ENTITY_DECL = 17
+      NAMESPACE_DECL = 18
+      XINCLUDE_START = 19
+      XINCLUDE_END = 20
+      DOCB_DOCUMENT_NODE = 21
+
+      @@owned = {}
+
+      ###
+      # Decorate this node with the decorators set up in this node's Document
+      def decorate!
+        document.decorate(self) if document
+      end
+
+      ###
+      # Get the list of children for this node as a NodeSet
+      def children
+        list = NodeSet.new
+        list.document = document
+        document.decorate(list)
+
+        first = self.child
+        return list unless first # Empty list
+
+        list << first unless first.blank?
+        while first = first.next
+          list << first unless first.blank?
+        end
+        list
+      end
+
+      ###
+      # Search this node for +paths+.  +paths+ can be XPath or CSS, and an
+      # optional hash of namespaces may be appended.
+      # See Node#xpath and Node#css.
+      def search *paths
+        ns = paths.last.is_a?(Hash) ? paths.pop : {}
+        xpath(*(paths.map { |path|
+          path =~ /^(\.\/|\/)/ ? path : CSS::Parser.parse(path).map { |ast|
+            ast.to_xpath
+          }
+        }.flatten.uniq) + [ns])
+      end
+      alias :/ :search
+
+      def xpath *paths
+        ns = paths.last.is_a?(Hash) ? paths.pop : {}
+
+        return NodeSet.new unless document.root
+
+        sets = paths.map { |path|
+          ctx = XPathContext.new(self)
+          ctx.register_namespaces(ns)
+          set = ctx.evaluate(path).node_set
+          set.document = document
+          document.decorate(set)
+          set
+        }
+        return sets.first if sets.length == 1
+
+        NodeSet.new do |combined|
+          document.decorate(combined)
+          sets.each do |set|
+            set.each do |node|
+              combined << node
+            end
+          end
+        end
+      end
+
+      def css *rules
+        xpath(*(rules.map { |rule|
+          CSS::Parser.parse(rule).map { |ast| "." + ast.to_xpath }
+        }.flatten.uniq))
+      end
+
+      def at path, ns = {}
+        search("#{path}", ns).first
+      end
+
+      def [](property)
+        return nil unless key?(property)
+        get(property)
+      end
+
+      def next
+        next_sibling
+      end
+
+      def remove
+        unlink
+      end
+
+      ####
+      # Create nodes from +data+ and insert them before this node
+      # (as a sibling).
+      def before data
+        classes = document.class.name.split('::')
+        classes[-1] = 'SAX::Parser'
+
+        parser = eval(classes.join('::')).new(BeforeHandler.new(self, data))
+        parser.parse(data)
+      end
+
+      ####
+      # Create nodes from +data+ and insert them after this node
+      # (as a sibling).
+      def after data
+        classes = document.class.name.split('::')
+        classes[-1] = 'SAX::Parser'
+
+        handler = AfterHandler.new(self, data)
+        parser = eval(classes.join('::')).new(handler)
+        parser.parse(data)
+        handler.after_nodes.reverse.each do |sibling|
+          self.add_next_sibling sibling
+        end
+      end
+
+      def has_attribute?(property)
+        key? property
+      end
+
+      alias :get_attribute :[]
+      def set_attribute(name, value)
+        self[name] = value
+      end
+
+      def text
+        content
+      end
+      alias :inner_text :text
+
+      ####
+      # Set the content to +string+.
+      # If +encode+, encode any special characters first.
+      def content= string, encode = true
+        self.native_content = encode_special_chars(string)
+      end
+
+      def comment?
+        type == COMMENT_NODE
+      end
+
+      def cdata?
+        type == CDATA_SECTION_NODE
+      end
+
+      def xml?
+        type == DOCUMENT_NODE
+      end
+
+      def html?
+        type == HTML_DOCUMENT_NODE
+      end
+
+      def to_html
+        to_xml
+      end
+      alias :to_s :to_html
+      alias :inner_html :to_html
+
+      def css_path
+        path.split(/\//).map { |part|
+          part.length == 0 ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
+        }.compact.join(' > ')
+      end
+
+      #  recursively get all namespaces from this node and its subtree
+      def collect_namespaces
+        # TODO: print warning message if a prefix refers to more than one URI in the document?
+        ns = {}
+        traverse {|j| ns.merge!(j.namespaces)}
+        ns
+      end
+
+      ####
+      # Yields self and all children to +block+ recursively.
+      def traverse(&block)
+        children.each{|j| j.traverse(&block) }
+        block.call(self)
+      end
+    end
+  end
+end