RubyGems - htmltools - Versions diffs - 1.10 - Mend

htmltools 1.10

Files changed (20) hide show

@@ -0,0 +1,323 @@
+# This module is a mix-in that provides parent/child behavior to real
+# Element classes. Because it defines <tt>each()</tt> and includes Enumerable,
+# you can iterate through a tree using the usual Enumerable methods.
+#
+# Copyright::   Copyright (C) 2003, Johannes Brodwall <johannes@brodwall.com>,
+#               Copyright (C) 2002, Ned Konz <ned@bike-nomad.com>
+# License::     Same as Ruby's
+# CVS ID:       $Id: element.rb,v 1.4 2004/09/24 23:28:55 jhannes Exp $
+require 'html/tags'
+module HTMLTree
+  module TreeElement
+    include Enumerable
+    protected
+    def initialize_tree_element(parent_or_nil = nil, contents_or_nil = nil)
+      @_content, @_parent = contents_or_nil, parent_or_nil
+      if parent_or_nil
+        parent_or_nil.add_child(self)
+      end
+    end
+    attr_accessor :_parent
+    public
+    # Add one or more children to this node.
+    def add_child(*children_to_add)
+      if can_have_children?
+        children_to_add.each do |child|
+          @_content << child
+          child._parent = self
+        end
+      else
+        raise(ArgumentError.exception('node cannot have children'))
+      end
+    end
+    alias_method :add_children, :add_child
+    # Remove one or more children from this node.
+    def remove_child(*children_to_remove)
+      if can_have_children?
+        children_to_remove.each do |child|
+          child._parent = nil if @_content.delete(child)
+        end
+      else
+        raise(ArgumentError.exception('node cannot have children'))
+      end
+    end
+    alias_method :remove_children, :remove_child
+    # Change my parent. Disconnects from prior parent, if any.
+    def parent=(parent_or_nil)
+      @_parent.remove_child(self) if @_parent
+      parent_or_nil.add_child(self) if parent_or_nil
+    end
+    # Return true if my content is a collection of Elements
+    # rather than actual data.
+    def can_have_children?
+      @_content.kind_of?(Array)
+    end
+    # Return a collection of my children. Returns an empty Array if I am a
+    # data element, just to keep other methods simple.
+    def children
+      can_have_children? ? @_content : []
+    end
+    # Return my content; either my children or my data.
+    def content
+      @_content
+    end
+    # Return my parent element.
+    def parent
+      @_parent
+    end
+    def path
+      "/"
+    end
+    # Return the ultimate parent.
+    def root
+      @_parent ? self : @_parent.root
+    end
+    # Return true if I have any children.
+    def has_children?
+      children.size > 0
+    end
+    # Breadth-first iterator, required by Enumerable.
+    def each(&block)
+      block.call(self)
+      children.each { |ch| ch.each(&block) }
+    end
+    # Print out to $stdout (or given IO or String)
+    # a formatted dump of my structure.
+    def dump(indent=0, io=$stdout)
+      io << "  " * indent
+      io << self.to_s
+      io << "\n"
+      children.each { |ea| ea.dump(indent+1, io) }
+    end
+  end
+  # This is a Element that represents the whole document (and makes a
+  # scope for the DTD declaration)
+  class Document
+    include TreeElement
+    def initialize
+      initialize_tree_element(nil, [])
+    end
+    def to_s
+      ''
+    end
+    def each(&block)
+      children.each { |ch| ch.each(&block) }
+    end
+    def write(io)
+      children.each { |t| t.write(io) }
+    end
+    def tag
+      ''
+    end
+    # Return my child <html> node, if any.
+    def html_node
+      children.detect { |ea| ea.tag == 'html' }
+    end
+  end
+  # This is a TreeElement that represents tagged items in an HTML
+  # document.
+  class Element
+    include TreeElement
+    protected
+    # parent_or_nil::   TreeElement or nil
+    # tag_name::        String
+    def initialize(parent_or_nil = nil, tag_name = nil)
+      initialize_tree_element(parent_or_nil, [])
+      @_tag = tag_name
+      @_attributes = {}
+      @_attribute_order = []
+    end
+    public
+    def can_have_children?; true; end
+    # Return true if I'm data instead of a tag
+    def data?; false; end
+    def to_s
+      a = [ "<", tag ]
+      @_attribute_order.each { |k|
+        v = @_attributes[k]
+        a << " #{k.to_s}=\"#{v.to_s}\""
+      }
+      a << ">"
+      a.join('')
+    end
+    # Append an attribute. <tt>values</tt> are first flattened into an Array,
+    # then converted into strings.
+    #
+    # If there is a single attribute value, it will appear as a String,
+    # otherwise it will be an Array of Strings.
+    #
+    # Example:
+    #   element.add_attribute("width", "123")
+    #   element.add_attribute("value", [ "a", "b" ])
+    def add_attribute(name, *values)
+      values = values.flatten.collect { |ea| ea.to_s.strip }
+      name = name.downcase
+      if @_attributes.include?(name)
+        @_attributes[name] = @_attributes[name].to_a + values
+      else
+        @_attributes[name] = values.size > 1 ? values : values[0]
+      end
+      @_attribute_order << name
+      self
+    end
+    # Return my tag (should be a String)
+    def tag; @_tag; end
+    # Return an HTML::Tag for further information, or nil if this is an
+    # unknown tag.
+    def tag_info
+      begin
+        HTML::Tag.named(@_tag)
+      rescue NoSuchHTMLTagError
+        nil
+      end
+    end
+    # Return the path to this element from the root
+    def path
+      path = []
+      node = self
+      while node do
+        path.unshift node.tag
+        node = node.parent
+      end
+      path.join(".")
+    end
+    def show_structure(indent = 0)
+      puts(' ' * indent) + path
+      elements.each { |node| node.show_structure(indent + 2) }
+      nil
+    end
+    # Return the children of this node that are elements (not data)
+    def elements
+      children.select { |node| node.is_a? Element }
+    end
+    # Return my attributes Hash.
+    def attributes; @_attributes; end
+    # Return the order of my attributes
+    def attribute_order; @_attribute_order; end
+    # Return the value of a single attribute (a String or Array).
+    def attribute(name); @_attributes[name]; end
+    # Return the value of a single attribute (a String or Array).
+    def [](name); attribute(name); end
+    # Replace an attribute.
+    def []=(name, *values)
+      @_attributes[name] = values.size > 1 ? values : values[0]
+      @_attribute_order.delete(name)
+      self
+    end
+    # Print me (and my descendents) on the given IO stream.
+    def write(io)
+      io << self
+      children.each { |t| t.write(io) }
+      unless tag_info.is_empty_element
+        io.puts( "</#{tag()}>" )
+      end
+    end
+  end
+  # This is a TreeElement that represents leaf data nodes (CDATA, scripts,
+  # comments, processing directives). It forwards unknown messages to the
+  # content element, so it otherwise behaves like a String.
+  class Data
+    include TreeElement
+    protected
+    # parent_or_nil:: parent, TreeElement or nil
+    # str:: contents, String
+    def initialize(parent_or_nil = nil, str = '')
+      initialize_tree_element(parent_or_nil, str)
+    end
+    public
+    # Return true because I am a data Element.
+    def data?; true; end
+    # Return false because I have no children.
+    def can_have_children?; false; end
+    # Return an empty collection because I have no children.
+    def children; []; end
+    # Return my (empty) tag String.
+    def tag; ''; end
+    # Return my (empty) attributes Hash.
+    def attributes; {}; end
+    def to_s
+      @_content
+    end
+    # Print me on the given IO stream.
+    def write(io)
+      io << self
+    end
+    # Forward all other methods to my content, so I can otherwise behave
+    # like a String.
+    def method_missing(sym, *args)
+      @_content.method(sym).call(*args)
+    end
+  end
+  class Comment < Data
+    def to_s
+      '<!--' + @_content + '-->'
+    end
+  end
+  class Special < Data
+    def to_s
+      '<' + @_content + '>'
+    end
+  end
+end

data/lib/html/rexml-nodepath.rb ADDED

@@ -0,0 +1,49 @@
+# This module adds method 'full_path' to REXML hierarchy
+# This method will print out the path to the given node, for example
+#  /html/body/p[0]/@text
+#
+# Copyright::   Copyright (C) 2004, Johannes Brodwall <johannes@brodwall.com>
+# License::     Same as Ruby's
+# CVS ID:       $Id: rexml-nodepath.rb,v 1.5 2005/05/25 17:38:45 jhannes Exp $
+module REXML
+  class Child
+    def parent_path
+        parent ? parent.full_path : ''
+    end
+  end
+  class Document
+    def full_path
+      ''
+    end
+  end
+  class Element
+    def child_index
+      return "" unless parent
+      siblings = parent.to_a.select do |node|
+        node.kind_of? Element and node.expanded_name == self.expanded_name
+      end
+      return "" if siblings.size < 2
+      "[" + (siblings.index(self)+1).to_s + "]"
+    end
+    def full_path
+      parent_path + '/' + expanded_name + child_index
+    end
+  end
+  class Text
+    def full_path
+      parent_path + '/text()' + " " + expanded_name
+    end
+  end
+  class Attribute
+    def full_path
+      element.full_path + '/@' + name
+    end
+  end
+end

data/lib/html/sgml-parser.rb ADDED

@@ -0,0 +1,372 @@
+# A parser for SGML, using the derived class as static DTD.
+#
+# Taken from http://raa.ruby-lang.org/list.rhtml?name=html-parser-2
+# This file seems to be included in the current install of Ruby,
+# but with a bug related to attributes quoted with '"', so I have
+# included in in the HTML package of this distribution
+#
+# Copyright::   Copyright (C) 2003, Johannes Brodwall <johannes@brodwall.com>,
+#               Copyright (C) 2002, Ned Konz <ned@bike-nomad.com>
+# License::     Same as Ruby's
+# CVS ID:       $Id: sgml-parser.rb,v 1.4 2004/09/24 23:28:55 jhannes Exp $
+module HTML
+   class SGMLParser
+     attr_reader :src_range
+     # Regular expressions used for parsing:
+     Interesting = /[&<]/
+     Incomplete = Regexp.compile('&([a-zA-Z][a-zA-Z0-9]*|#[0-9]*)?|' +
+                                 '<([a-zA-Z][^<>]*|/([a-zA-Z][^<>]*)?|' +
+                                 '![^<>]*)?')
+     Entityref = /&([a-zA-Z][-.a-zA-Z0-9]*)[^-.a-zA-Z0-9]/
+     Charref = /&#([0-9]+)[^0-9]/
+     Starttagopen = /<[>a-zA-Z]/
+     Endtagopen = /<\/[<>a-zA-Z]/
+     Endbracket = /[<>]/
+     Special = /<![^<>]*>/
+     Commentopen = /<!--/
+     Commentclose = /--[ \t\n]*>/
+     Tagfind = /[a-zA-Z][a-zA-Z0-9.-]*/
+     Attrfind = Regexp.compile('[\s,]*([a-zA-Z_][a-zA-Z_0-9.-]*)' +
+                               '(\s*=\s*' +
+                               "('[^']*'" +
+                               '|"[^"]*"' +
+                               '|[-~a-zA-Z0-9,./:+*%?!()_#=]*))?')
+     Endtagfind = /\s*\/\s*>/
+     Entitydefs =
+       {'lt'=>'<', 'gt'=>'>', 'amp'=>'&', 'quot'=>'"', 'apos'=>'\''}
+     def initialize(verbose=false)
+       @verbose = verbose
+       reset
+     end
+     def reset
+       @rawdata = ''
+       @stack = []
+       @lasttag = '???'
+       @nomoretags = false
+       @literal = false
+       @offset = 0
+       @ranges = []
+     end
+     def get_source(range)
+       start = range.first
+       end_index = range.end
+       exclusive = range.exclude_end?
+       offset_range = Range.new(start-@offset, end_index-@offset, exclusive)
+       return @rawdata[offset_range]
+     end
+     def set_range(start, end_index)
+       @src_range = Range.new(start+@offset, end_index+@offset, exclusive = true)
+       #puts "setting range #{@src_range}, text = \"#{get_source(src_range)}\""
+     end
+     def has_context(gi)
+       @stack.include? gi
+     end
+     def setnomoretags
+       @nomoretags = true
+       @literal = true
+     end
+     def setliteral(*args)
+       @literal = true
+     end
+     def feed(data)
+       @rawdata << data
+       goahead(false)
+     end
+     def close
+       goahead(true)
+     end
+     def handle_data_range(rawdata, start, end_index)
+       if end_index > start
+         set_range(start, end_index)
+         handle_data(rawdata[start...end_index])
+       end
+       return end_index
+     end
+     def goahead(_end)
+       rawdata = @rawdata
+       i = 0
+       n = rawdata.length
+       while i < n
+         if @nomoretags
+           i = handle_data_range(rawdata, i, n)
+           break
+         end
+         j = rawdata.index(Interesting, i)
+         j = n unless j
+         i = handle_data_range(rawdata, i, j)
+         break if (i == n)
+         if rawdata[i] == ?< #
+           if rawdata.index(Starttagopen, i) == i
+             if @literal
+               i = handle_data_range(rawdata, i, i+1)
+               next
+             end
+             k = parse_starttag(i)
+             break unless k
+             i = k
+             next
+           end
+           if rawdata.index(Endtagopen, i) == i
+             k = parse_endtag(i)
+             break unless k
+             i = k
+             @literal = false
+             next
+           end
+           if rawdata.index(Commentopen, i) == i
+             if @literal
+               i = handle_data_range(rawdata, i, i+1)
+               next
+             end
+             k = parse_comment(i)
+             break unless k
+             i += k
+             next
+           end
+           if rawdata.index(Special, i) == i
+             if @literal
+               i = handle_data_range(rawdata, i, i+1)
+               next
+             end
+             k = parse_special(i)
+             break unless k
+             i += k
+             next
+           end
+         elsif rawdata[i] == ?& #
+           if rawdata.index(Charref, i) == i
+             end_index = i + $&.length
+             end_index -= 1 unless rawdata[end_index-1] == ?;
+             set_range(i, end_index)
+             handle_charref($1)
+             i = end_index
+             next
+           end
+           if rawdata.index(Entityref, i) == i
+             end_index = i + $&.length
+             end_index -= 1 unless rawdata[end_index-1] == ?;
+             set_range(i, end_index)
+             handle_entityref($1)
+             i = end_index
+             next
+           end
+         else
+           raise RuntimeError, 'neither < nor & ??'
+         end
+         # We get here only if incomplete matches but
+         # nothing else
+         match = rawdata.index(Incomplete, i)
+         unless match == i
+           i = handle_data_range(rawdata, i, i+1)
+           next
+         end
+         j = match + $&.length
+         break if j == n # Really incomplete
+         i = handle_data_range(rawdata, i, j)
+       end
+       # end while
+       if _end and i < n
+         i = handle_data_range(rawdata, i, n)
+       end
+       @rawdata = rawdata[i..-1]
+       @offset += i
+     end
+     def parse_comment(i)
+       rawdata = @rawdata
+       if rawdata[i, 4] != '<!--'
+         raise RuntimeError, 'unexpected call to handle_comment'
+       end
+       match = rawdata.index(Commentclose, i)
+       return nil unless match
+       matched_length = $&.length
+       j = match
+       src_length = match + matched_length - i
+       set_range(i, i + src_length)
+       handle_comment(rawdata[i+4..(j-1)])
+       return src_length
+     end
+     def parse_starttag(i)
+       rawdata = @rawdata
+       j = rawdata.index(Endbracket, i + 1)
+       return nil unless j
+       attrs = []
+       if rawdata[i+1] == ?> #
+         # SGML shorthand: <> == <last open tag seen>
+         k = j
+         tag = @lasttag
+       else
+         match = rawdata.index(Tagfind, i + 1)
+         unless match
+           raise RuntimeError, 'unexpected call to parse_starttag'
+         end
+         k = i + 1 + ($&.length)
+         tag = $&.downcase
+         @lasttag = tag
+       end
+       while k < j
+         break if rawdata.index(Endtagfind, k)
+         break unless rawdata.index(Attrfind, k)
+         matched_length = $&.length
+         attrname, rest, attrvalue = $1, $2, $3
+         if not rest
+           attrvalue = '' # was: = attrname
+         elsif (attrvalue[0] == ?' && attrvalue[-1] == ?') or
+             (attrvalue[0] == ?" && attrvalue[-1] == ?")
+           attrvalue = attrvalue[1..-2]
+         end
+         attrs << [attrname.downcase, attrvalue]
+         k += matched_length
+       end
+       if rawdata[j] == ?> #
+         j += 1
+       end
+       set_range(i, j)
+       finish_starttag(tag, attrs)
+       return j
+     end
+     def parse_endtag(i)
+       rawdata = @rawdata
+       j = rawdata.index(Endbracket, i + 1)
+       return nil unless j
+       tag = (rawdata[i+2..j-1].strip).downcase
+       if rawdata[j] == ?> #
+         j += 1
+       end
+       set_range(i, j)
+       finish_endtag(tag)
+       return j
+     end
+     def finish_starttag(tag, attrs)
+       method = 'start_' + tag
+       if self.respond_to?(method)
+         @stack << tag
+         handle_starttag(tag, method, attrs)
+         return 1
+       else
+         method = 'do_' + tag
+         if self.respond_to?(method)
+           handle_starttag(tag, method, attrs)
+           return 0
+         else
+           unknown_starttag(tag, attrs)
+           return -1
+         end
+       end
+     end
+     def finish_endtag(tag)
+       if tag == ''
+         found = @stack.length - 1
+         if found < 0
+           unknown_endtag(tag)
+           return
+         end
+       else
+         unless @stack.include? tag
+           method = 'end_' + tag
+           unless self.respond_to?(method)
+             unknown_endtag(tag)
+           end
+           return
+         end
+         found = @stack.index(tag) #or @stack.length
+       end
+       while @stack.length > found
+         tag = @stack[-1]
+         method = 'end_' + tag
+         if respond_to?(method)
+           handle_endtag(tag, method)
+         else
+           unknown_endtag(tag)
+         end
+         @stack.pop
+       end
+     end
+     def parse_special(i)
+       rawdata = @rawdata
+       match = rawdata.index(Endbracket, i+1)
+       return nil unless match
+       matched_length = $&.length
+       src_length = match - i + matched_length
+       set_range(i, i + src_length)
+       handle_special(rawdata[i+1..(match-1)])
+       return src_length
+     end
+     def handle_starttag(tag, method, attrs)
+       self.send(method, attrs)
+     end
+     def handle_endtag(tag, method)
+       self.send(method)
+     end
+     def report_unbalanced(tag)
+       if @verbose
+         print '*** Unbalanced </' + tag + '>', "\n"
+         print '*** Stack:', self.stack, "\n"
+       end
+     end
+     def handle_charref(name)
+       n = Integer(name)
+       if !(0 <= n && n <= 255)
+         unknown_charref(name)
+         return
+       end
+       handle_data(n.chr)
+     end
+     def handle_entityref(name)
+       table = Entitydefs
+       if table.include?(name)
+         handle_data(table[name])
+       else
+         unknown_entityref(name)
+         return
+       end
+     end
+     def handle_data(data)
+     end
+     def handle_comment(data)
+     end
+     def handle_special(data)
+     end
+     def unknown_starttag(tag, attrs)
+     end
+     def unknown_endtag(tag)
+     end
+     def unknown_charref(ref)
+     end
+     def unknown_entityref(ref)
+     end
+   end
+end