/instiki/svnpassword

require 'strscan'
module XHTML #:nodoc:
 class Conditions < Hash #:nodoc:
 def initialize(hash)
 super()
 hash = { :content => hash } unless Hash === hash
 hash = keys_to_symbols(hash)
 hash.each do |k,v|
 case k
 when :tag, :content then
 # keys are valid, and require no further processing
 when :attributes then
 hash[k] = keys_to_strings(v)
 when :parent, :child, :ancestor, :descendant, :sibling, :before,
 :after
 hash[k] = Conditions.new(v)
 when :children
 hash[k] = v = keys_to_symbols(v)
 v.each do |k,v2|
 case k
 when :count, :greater_than, :less_than
 # keys are valid, and require no further processing
 when :only
 v[k] = Conditions.new(v2)
 else
 raise "illegal key #{k.inspect} => #{v2.inspect}"
 end
 end
 else
 raise "illegal key #{k.inspect} => #{v.inspect}"
 end
 end
 update hash
 end
 private
 def keys_to_strings(hash)
 hash.keys.inject({}) do |h,k|
 h[k.to_s] = hash[k]
 h
 end
 end
 def keys_to_symbols(hash)
 hash.keys.inject({}) do |h,k|
 raise "illegal key #{k.inspect}" unless k.respond_to?(:to_sym)
 h[k.to_sym] = hash[k]
 h
 end
 end
 end
 # The base class of all nodes, textual and otherwise, in an HTML document.
 class Node #:nodoc:
 # The array of children of this node. Not all nodes have children.
 attr_reader :children
 # The parent node of this node. All nodes have a parent, except for the
 # root node.
 attr_reader :parent
 # The line number of the input where this node was begun
 attr_reader :line
 # The byte position in the input where this node was begun
 attr_reader :position
 # Create a new node as a child of the given parent.
 def initialize(parent, line=0, pos=0)
 @parent = parent
 @children = []
 @line, @position = line, pos
 end
 # Return a textual representation of the node.
 def to_s
 s = []
 @children.each { |child| s << child.to_s }
 s.join
 end
 # Return false (subclasses must override this to provide specific matching
 # behavior.) +conditions+ may be of any type.
 def match(conditions)
 false
 end
 # Search the children of this node for the first node for which #find
 # returns non +nil+. Returns the result of the #find call that succeeded.
 def find(conditions)
 conditions = validate_conditions(conditions)
 @children.each do |child| 
 node = child.find(conditions)
 return node if node
 end
 nil
 end
 # Search for all nodes that match the given conditions, and return them
 # as an array.
 def find_all(conditions)
 conditions = validate_conditions(conditions)
 matches = []
 matches << self if match(conditions)
 @children.each do |child|
 matches.concat child.find_all(conditions)
 end
 matches
 end
 # Returns +false+. Subclasses may override this if they define a kind of
 # tag.
 def tag?
 false
 end
 def validate_conditions(conditions)
 Conditions === conditions ? conditions : Conditions.new(conditions)
 end
 def ==(node)
 return false unless self.class == node.class && children.size == node.children.size
 equivalent = true
 children.size.times do |i|
 equivalent &&= children[i] == node.children[i]
 end
 equivalent
 end
 class <<self
 def parse(parent, line, pos, content, strict=true)
 if content !~ /^<\S/
 Text.new(parent, line, pos, content)
 else
 scanner = StringScanner.new(content)
 unless scanner.skip(/</)
 if strict
 raise "expected <"
 else
 return Text.new(parent, line, pos, content)
 end
 end
 if scanner.skip(/!\[CDATA\[/)
 unless scanner.skip_until(/\]\]>/)
 if strict
 raise "expected ]]> (got #{scanner.rest.inspect} for #{content})"
 else
 scanner.skip_until(/\Z/)
 end
 end
 return CDATA.new(parent, line, pos, scanner.pre_match.gsub(/<!\[CDATA\[/, ''))
 end
 closing = ( scanner.scan(/\//) ? :close : nil )
 return Text.new(parent, line, pos, content) unless name = scanner.scan(/[\w:-]+/)
 unless closing
 scanner.skip(/\s*/)
 attributes = {}
 while attr = scanner.scan(/[-\w:]+/)
 value = true
 if scanner.scan(/\s*=\s*/)
 if delim = scanner.scan(/['"]/)
 v = []
 while text = scanner.scan(/[^#{delim}\\]+|./)
 case text
 when "\\" then
 v << text
 v << scanner.getch
 when delim
 break
 else v << text
 end
 end
 value = v.join
 else
 value = scanner.scan(/[^\s>\/]+/)
 end
 end
 attributes[attr] = value
 scanner.skip(/\s*/)
 end
 closing = ( scanner.scan(/\/>/) ? :self : nil )
 end
 unless scanner.scan(/\s*>/)
 if strict
 raise "expected > (got #{scanner.rest.inspect} for #{content}, #{attributes.inspect})" 
 else
 # throw away all text until we find what we're looking for
 scanner.skip_until(/>/) or scanner.terminate
 end
 end
 Tag.new(parent, line, pos, name, attributes, closing)
 end
 end
 end
 end
 # A node that represents text, rather than markup.
 class Text < Node #:nodoc:
 attr_reader :content
 # Creates a new text node as a child of the given parent, with the given
 # content.
 def initialize(parent, line, pos, content)
 super(parent, line, pos)
 @content = content
 end
 # Returns the content of this node.
 def to_s
 @content
 end
 # Returns +self+ if this node meets the given conditions. Text nodes support
 # conditions of the following kinds:
 #
 # * if +conditions+ is a string, it must be a substring of the node's
 # content
 # * if +conditions+ is a regular expression, it must match the node's
 # content
 # * if +conditions+ is a hash, it must contain a <tt>:content</tt> key that
 # is either a string or a regexp, and which is interpreted as described
 # above.
 def find(conditions)
 match(conditions) && self
 end
 # Returns non-+nil+ if this node meets the given conditions, or +nil+
 # otherwise. See the discussion of #find for the valid conditions.
 def match(conditions)
 case conditions
 when String
 @content == conditions
 when Regexp
 @content =~ conditions
 when Hash
 conditions = validate_conditions(conditions)
 # Text nodes only have :content, :parent, :ancestor
 unless (conditions.keys - [:content, :parent, :ancestor]).empty?
 return false
 end
 match(conditions[:content])
 else
 nil
 end
 end
 def ==(node)
 return false unless super
 content == node.content
 end
 end
 # A CDATA node is simply a text node with a specialized way of displaying
 # itself.
 class CDATA < Text #:nodoc:
 def to_s
 "<![CDATA[#{super}]]>"
 end
 end
 # A Tag is any node that represents markup. It may be an opening tag, a
 # closing tag, or a self-closing tag. It has a name, and may have a hash of
 # attributes.
 class Tag < Node #:nodoc:
 # Either +nil+, <tt>:close</tt>, or <tt>:self</tt>
 attr_reader :closing
 # Either +nil+, or a hash of attributes for this node.
 attr_reader :attributes
 # The name of this tag.
 attr_reader :name
 # Create a new node as a child of the given parent, using the given content
 # to describe the node. It will be parsed and the node name, attributes and
 # closing status extracted.
 def initialize(parent, line, pos, name, attributes, closing)
 super(parent, line, pos)
 @name = name
 @attributes = attributes
 @closing = closing
 end
 # A convenience for obtaining an attribute of the node. Returns +nil+ if
 # the node has no attributes.
 def [](attr)
 @attributes ? @attributes[attr] : nil
 end
 # Returns non-+nil+ if this tag can contain child nodes.
 def childless?(xml = false)
 return false if xml && @closing.nil?
# !@closing.nil? ||
 @name =~ /^(img|br|hr|link|meta|area|base|basefont|
 col|frame|input|isindex|param)$/ox
 end
 # Returns a textual representation of the node
 def to_s
 if @closing == :close
 "</#{@name}>" unless self.childless?
 else
 s = ["<#{@name}"]
 @attributes.sort.each do |k,v|
 s << " #{k}"
 s << "='#{v}'" if String === v
 end
 s << "/" if (@children.empty? && @closing == :self) or self.childless?
 s << ">"
 @children.each { |child| s << child.to_s }
 s << "</#{@name}>" unless @closing == :self or self.childless? or @children.empty?
 s.join
 end
 end
 # If either the node or any of its children meet the given conditions, the
 # matching node is returned. Otherwise, +nil+ is returned. (See the
 # description of the valid conditions in the +match+ method.)
 def find(conditions)
 match(conditions) && self || super
 end
 # Returns +true+, indicating that this node represents an HTML tag.
 def tag?
 true
 end
 # Returns +true+ if the node meets any of the given conditions. The
 # +conditions+ parameter must be a hash of any of the following keys
 # (all are optional):
 #
 # * <tt>:tag</tt>: the node name must match the corresponding value
 # * <tt>:attributes</tt>: a hash. The node's values must match the
 # corresponding values in the hash.
 # * <tt>:parent</tt>: a hash. The node's parent must match the
 # corresponding hash.
 # * <tt>:child</tt>: a hash. At least one of the node's immediate children
 # must meet the criteria described by the hash.
 # * <tt>:ancestor</tt>: a hash. At least one of the node's ancestors must
 # meet the criteria described by the hash.
 # * <tt>:descendant</tt>: a hash. At least one of the node's descendants
 # must meet the criteria described by the hash.
 # * <tt>:sibling</tt>: a hash. At least one of the node's siblings must
 # meet the criteria described by the hash.
 # * <tt>:after</tt>: a hash. The node must be after any sibling meeting
 # the criteria described by the hash, and at least one sibling must match.
 # * <tt>:before</tt>: a hash. The node must be before any sibling meeting
 # the criteria described by the hash, and at least one sibling must match.
 # * <tt>:children</tt>: a hash, for counting children of a node. Accepts the
 # keys:
 # ** <tt>:count</tt>: either a number or a range which must equal (or
 # include) the number of children that match.
 # ** <tt>:less_than</tt>: the number of matching children must be less than
 # this number.
 # ** <tt>:greater_than</tt>: the number of matching children must be
 # greater than this number.
 # ** <tt>:only</tt>: another hash consisting of the keys to use
 # to match on the children, and only matching children will be
 # counted.
 #
 # Conditions are matched using the following algorithm:
 #
 # * if the condition is a string, it must be a substring of the value.
 # * if the condition is a regexp, it must match the value.
 # * if the condition is a number, the value must match number.to_s.
 # * if the condition is +true+, the value must not be +nil+.
 # * if the condition is +false+ or +nil+, the value must be +nil+.
 #
 # Usage:
 #
 # # test if the node is a "span" tag
 # node.match :tag => "span"
 #
 # # test if the node's parent is a "div"
 # node.match :parent => { :tag => "div" }
 #
 # # test if any of the node's ancestors are "table" tags
 # node.match :ancestor => { :tag => "table" }
 #
 # # test if any of the node's immediate children are "em" tags
 # node.match :child => { :tag => "em" }
 #
 # # test if any of the node's descendants are "strong" tags
 # node.match :descendant => { :tag => "strong" }
 #
 # # test if the node has between 2 and 4 span tags as immediate children
 # node.match :children => { :count => 2..4, :only => { :tag => "span" } } 
 #
 # # get funky: test to see if the node is a "div", has a "ul" ancestor
 # # and an "li" parent (with "class" = "enum"), and whether or not it has
 # # a "span" descendant that contains # text matching /hello world/:
 # node.match :tag => "div",
 # :ancestor => { :tag => "ul" },
 # :parent => { :tag => "li",
 # :attributes => { :class => "enum" } },
 # :descendant => { :tag => "span",
 # :child => /hello world/ }
 def match(conditions)
 conditions = validate_conditions(conditions)
 # check content of child nodes
 if conditions[:content]
 if children.empty?
 return false unless match_condition("", conditions[:content])
 else
 return false unless children.find { |child| child.match(conditions[:content]) }
 end
 end
 # test the name
 return false unless match_condition(@name, conditions[:tag]) if conditions[:tag]
 # test attributes
 (conditions[:attributes] || {}).each do |key, value|
 return false unless match_condition(self[key], value)
 end
 # test parent
 return false unless parent.match(conditions[:parent]) if conditions[:parent]
 # test children
 return false unless children.find { |child| child.match(conditions[:child]) } if conditions[:child]
 
 # test ancestors
 if conditions[:ancestor]
 return false unless catch :found do
 p = self
 throw :found, true if p.match(conditions[:ancestor]) while p = p.parent
 end
 end
 # test descendants
 if conditions[:descendant]
 return false unless children.find do |child|
 # test the child
 child.match(conditions[:descendant]) ||
 # test the child's descendants
 child.match(:descendant => conditions[:descendant])
 end
 end
 # count children
 if opts = conditions[:children]
 matches = children.select do |c|
 (c.kind_of?(HTML::Tag) and (c.closing == :self or ! c.childless?))
 end
 matches = matches.select { |c| c.match(opts[:only]) } if opts[:only]
 opts.each do |key, value|
 next if key == :only
 case key
 when :count
 if Integer === value
 return false if matches.length != value
 else
 return false unless value.include?(matches.length)
 end
 when :less_than
 return false unless matches.length < value
 when :greater_than
 return false unless matches.length > value
 else raise "unknown count condition #{key}"
 end
 end
 end
 # test siblings
 if conditions[:sibling] || conditions[:before] || conditions[:after]
 siblings = parent ? parent.children : []
 self_index = siblings.index(self)
 if conditions[:sibling]
 return false unless siblings.detect do |s| 
 s != self && s.match(conditions[:sibling])
 end
 end
 if conditions[:before]
 return false unless siblings[self_index+1..-1].detect do |s| 
 s != self && s.match(conditions[:before])
 end
 end
 if conditions[:after]
 return false unless siblings[0,self_index].detect do |s| 
 s != self && s.match(conditions[:after])
 end
 end
 end
 true
 end
 def ==(node)
 return false unless super
 return false unless closing == node.closing && self.name == node.name
 attributes == node.attributes
 end
 private
 # Match the given value to the given condition.
 def match_condition(value, condition)
 case condition
 when String
 value && value == condition
 when Regexp
 value && value.match(condition)
 when Numeric
 value == condition.to_s
 when true
 !value.nil?
 when false, nil
 value.nil?
 else
 false
 end
 end
 end
end