Class: HTML::Tag

Inherits:
Node show all
Defined in:
actionpack/lib/action_controller/vendor/html-scanner/html/node.rb,
actionpack/lib/action_controller/vendor/html-scanner/html/selector.rb

Overview

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.

Instance Attribute Summary (collapse)

Attributes inherited from Node

#children, #line, #parent, #position

Instance Method Summary (collapse)

Methods inherited from Node

#find_all, parse, #validate_conditions

Constructor Details

- (Tag) initialize(parent, line, pos, name, attributes, closing)

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.



297
298
299
300
301
302
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 297

def initialize(parent, line, pos, name, attributes, closing)
  super(parent, line, pos)
  @name = name
  @attributes = attributes
  @closing = closing
end

Instance Attribute Details

- (Object) attributes (readonly)

Either nil, or a hash of attributes for this node.



289
290
291
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 289

def attributes
  @attributes
end

- (Object) closing (readonly)

Either nil, :close, or :self



286
287
288
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 286

def closing
  @closing
end

- (Object) name (readonly)

The name of this tag.



292
293
294
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 292

def name
  @name
end

Instance Method Details

- (Object) ==(node)



513
514
515
516
517
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 513

def ==(node)
  return false unless super
  return false unless closing == node.closing && self.name == node.name
  attributes == node.attributes
end

- (Object) [](attr)

A convenience for obtaining an attribute of the node. Returns nil if the node has no attributes.



306
307
308
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 306

def [](attr)
  @attributes ? @attributes[attr] : nil
end

- (Boolean) childless?(xml = false)

Returns non-nil if this tag can contain child nodes.



311
312
313
314
315
316
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 311

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

- (Object) find(conditions)

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.)



339
340
341
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 339

def find(conditions)
  match(conditions) && self || super
end

- (Object) match(conditions)

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):

  • :tag: the node name must match the corresponding value

  • :attributes: a hash. The node's values must match the corresponding values in the hash.

  • :parent: a hash. The node's parent must match the corresponding hash.

  • :child: a hash. At least one of the node's immediate children must meet the criteria described by the hash.

  • :ancestor: a hash. At least one of the node's ancestors must meet the criteria described by the hash.

  • :descendant: a hash. At least one of the node's descendants must meet the criteria described by the hash.

  • :sibling: a hash. At least one of the node's siblings must meet the criteria described by the hash.

  • :after: a hash. The node must be after any sibling meeting the criteria described by the hash, and at least one sibling must match.

  • :before: a hash. The node must be before any sibling meeting the criteria described by the hash, and at least one sibling must match.

  • :children: a hash, for counting children of a node. Accepts the keys:

** :count: either a number or a range which must equal (or

include) the number of children that match.

** :less_than: the number of matching children must be less than

this number.

** :greater_than: the number of matching children must be

greater than this number.

** :only: 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/ }


418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 418

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

- (Object) select(selector, *values)



821
822
823
824
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/selector.rb', line 821

def select(selector, *values)
  selector = HTML::Selector.new(selector, values)
  selector.select(self)
end

- (Boolean) tag?

Returns true, indicating that this node represents an HTML tag.



344
345
346
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 344

def tag?
  true
end

- (Object) to_s

Returns a textual representation of the node



319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
# File 'actionpack/lib/action_controller/vendor/html-scanner/html/node.rb', line 319

def to_s
  if @closing == :close
    "</#{@name}>"
  else
    s = "<#{@name}"
    @attributes.each do |k,v|
      s << " #{k}"
      s << "=\"#{v}\"" if String === v
    end
    s << " /" if @closing == :self
    s << ">"
    @children.each { |child| s << child.to_s }
    s << "</#{@name}>" if @closing != :self && !@children.empty?
    s
  end
end