tenderlove-nokogiri 0.0.0.20081001111445

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/document.rb

@@ -0,0 +1,22 @@
+module Nokogiri
+  module XML
+    class Document < Node
+      def decorators
+        @decorators ||= Hash.new { |h,k| h[k] = [] }
+      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
+    end
+  end
+end

data/lib/nokogiri/xml/node.rb

@@ -0,0 +1,162 @@
+module Nokogiri
+  module XML
+    class Node
+      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
+
+      def decorate!
+        document.decorate(self) if document
+      end
+
+      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
+
+      def find(*paths)
+        find_by_xpath(*(paths.map { |path|
+          path =~ /^(\.\/|\/)/ ? path : CSS::Parser.parse(path).map { |ast|
+            ast.to_xpath
+          }
+        }.flatten.uniq))
+      end
+      alias :search :find
+      alias :/ :find
+
+      def find_by_xpath *paths
+        sets = paths.map { |path|
+          set = XPathContext.new(self).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 find_by_css *rules
+        find_by_xpath(*(rules.map { |rule|
+          CSS::Parser.parse(rule).map { |ast| ast.to_xpath }
+        }.flatten.uniq))
+      end
+
+      def at path
+        search("#{path}").first
+      end
+
+      def [](property)
+        return nil unless key?(property)
+        get(property)
+      end
+
+      def next
+        next_sibling
+      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 remove_attribute name
+        remove(name)
+      end
+
+      def inner_text
+        content
+      end
+
+      ####
+      # 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 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
+
+      def xpath
+        path
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/node_set.rb

@@ -0,0 +1,136 @@
+module Nokogiri
+  module XML
+    class NodeSet
+      include Enumerable
+
+      attr_accessor :document
+
+      def initialize
+        yield self if block_given?
+      end
+
+      def first
+        self[0]
+      end
+
+      def last
+        self[length - 1]
+      end
+
+      def before datum
+        first.before datum
+      end
+
+      def after datum
+        last.after datum
+      end
+
+      def << node
+        push(node)
+      end
+
+      def search path
+        sub_set = NodeSet.new
+        document.decorate(sub_set)
+        each do |node|
+          node.search(path).each do |sub_node|
+            sub_set << sub_node
+          end
+        end
+        sub_set.document = document
+        sub_set
+      end
+      alias :/ :search
+
+      def at path
+        search(path).first
+      end
+
+      def add_class name
+        each do |el|
+          next unless el.respond_to? :get_attribute
+          classes = el.get_attribute('class').to_s.split(" ")
+          el.set_attribute('class', classes.push(name).uniq.join(" "))
+        end
+        self
+      end
+
+      def remove_class name = nil
+        each do |el|
+          next unless el.respond_to? :get_attribute
+          if name
+            classes = el.get_attribute('class').to_s.split(" ")
+            el.set_attribute('class', (classes - [name]).uniq.join(" "))
+          else
+            el.remove_attribute("class")
+          end
+        end
+        self
+      end
+
+      def attr key, value = nil, &blk
+        if value or blk
+          each do |el|
+            el.set_attribute(key, value || blk[el])
+          end
+          return self      
+        end    
+        if key.is_a? Hash
+          key.each { |k,v| self.attr(k,v) }
+          return self
+        else
+          return self[0].get_attribute(key)
+        end
+      end
+      alias_method :set, :attr
+
+      def remove_attr name
+        each do |el|
+          next unless el.respond_to? :remove_attribute
+          el.remove_attribute(name)
+        end
+        self      
+      end
+
+      ###
+      # Iterate over each node, yielding  to +block+
+      def each(&block)
+        x = 0
+        while x < length
+          yield self[x]
+          x += 1
+        end
+      end
+
+      def inner_text
+        collect{|j| j.inner_text}.join('')
+      end
+      alias :text :inner_text
+
+      def wrap(html, &blk)
+        each do |j|
+          new_parent = Nokogiri.make(html, &blk)
+          j.replace(new_parent)
+          nest = new_parent
+          if nest.child
+            nest = nest.child until nest.child.nil?
+          end
+          j.parent = nest
+        end
+        self
+      end
+
+      def to_s
+        map { |x| x.to_s }.join
+      end
+
+      def to_html
+        map { |x| x.to_html }.join('')
+      end
+
+      def size
+        length
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/reader.rb

@@ -0,0 +1,14 @@
+module Nokogiri
+  module XML
+    class Reader
+      include Enumerable
+
+      def each(&block)
+        while node = self.read
+          block.call(node)
+        end
+      end
+      private :initialize
+    end
+  end
+end