RubyGems - htmltools - Versions diffs - 1.10 - Mend

htmltools 1.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

data/lib/html/element.rb ADDED

@@ -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