Class: REXML::Light::Node

Class | REXML::Light::Node
In: | rexml/light/node.rb
Parent: | Object

Represents a tagged XML element. Elements are characterized by having children, attributes, and names, and can themselves be children.

### Methods

<< =~ [] []= children each has_name? local_name local_name= name name= namespace namespace= new node_type parent parent= prefix root size text= to_s

### Constants

NAMESPLIT | = | /^(?:(#{XMLTokens::NCNAME_STR}):)?(#{XMLTokens::NCNAME_STR})/u
PARENTS | = | [ :element, :document, :doctype ]

### Public Class methods

new(node=nil)

Create a new element.

[Source]

    # File rexml/light/node.rb, line 21
                            def initialize node=nil
                                    @node = node
                                    if node.kind_of? String
                                            node = [ :text, node ]
                                    elsif node.nil?
                                            node = [ :document, nil, nil ]
                                    elsif node[0] == :start_element
                                            node[0] = :element
                                    elsif node[0] == :start_doctype
                                            node[0] = :doctype
                                    elsif node[0] == :start_document
                                            node[0] = :document
                                    end
                            end

### Public Instance methods

<<(element)

Append a child to this element, optionally under a provided namespace. The namespace argument is ignored if the element argument is an Element object. Otherwise, the element argument is a string, the namespace (if provided) is the namespace the element is created in.

[Source]

    # File rexml/light/node.rb, line 122
                            def << element
                                    if node_type() == :text
                                            at(-1) << element
                                    else
                                            newnode = Node.new( element )
                                            newnode.parent = self
                                            self.push( newnode )
                                    end
                                    at(-1)
                            end

=~( path )

[Source]

    # File rexml/light/node.rb, line 98
                            def =~( path )
                                    XPath.match( self, path )
                            end

[]( reference, ns=nil )

[Source]

    # File rexml/light/node.rb, line 86
                            def []( reference, ns=nil )
                                    if reference.kind_of? String
                                            pfx = ''
                                            pfx = "#{prefix(ns)}:" if ns
                                            at(3)["#{pfx}#{reference}"]
                                    elsif reference.kind_of? Range
                                            _old_get( Range.new(4+reference.begin, reference.end, reference.exclude_end?) )
                                    else
                                            _old_get( 4+reference )
                                    end
                            end

[]=( reference, ns, value=nil )

Doesn‘t handle namespaces yet

[Source]

    # File rexml/light/node.rb, line 103
                            def []=( reference, ns, value=nil )
                                    if reference.kind_of? String
                                            value = ns unless value
                                            at( 3 )[reference] = value
                                    elsif reference.kind_of? Range
                                            _old_put( Range.new(3+reference.begin, reference.end, reference.exclude_end?), ns )
                                    else
                                            if value
                                                    _old_put( 4+reference, ns, value )
                                            else
                                                    _old_put( 4+reference, ns )
                                            end
                                    end
                            end

children()

[Source]

    # File rexml/light/node.rb, line 151
                            def children
                                    self
                            end

each( ) {|at(x+4 )| ...}

[Source]

    # File rexml/light/node.rb, line 44
                            def each( &block )
                                    size.times { |x| yield( at(x+4) ) }
                            end

has_name?( name, namespace = '' )

[Source]

    # File rexml/light/node.rb, line 147
                            def has_name?( name, namespace = '' )
                                    at(3) == name and namespace() == namespace
                            end

local_name()

[Source]

    # File rexml/light/node.rb, line 62
                            def local_name
                                    namesplit
                                    @name
                            end

local_name=( name_str )

[Source]

    # File rexml/light/node.rb, line 67
                            def local_name=( name_str )
                                    _old_put( 1, "#@prefix:#{name_str}" )
                            end

name()

[Source]

    # File rexml/light/node.rb, line 48
                            def name
                                    at(2)
                            end

name=( name_str, ns=nil )

[Source]

    # File rexml/light/node.rb, line 52
                            def name=( name_str, ns=nil )
                                    pfx = ''
                                    pfx = "#{prefix(ns)}:" if ns
                                    _old_put(2, "#{pfx}#{name_str}")
                            end

namespace( prefix=prefix() )

[Source]

    # File rexml/light/node.rb, line 75
                            def namespace( prefix=prefix() )
                                    namespace_of( self, prefix )
                            end

namespace=( namespace )

[Source]

    # File rexml/light/node.rb, line 79
                            def namespace=( namespace )
                                    @prefix = prefix( namespace )
                                    pfx = ''
                                    pfx = "#@prefix:" if @prefix.size > 0
                                    _old_put(1, "#{pfx}#@name")
                            end

node_type()

[Source]

    # File rexml/light/node.rb, line 133
                            def node_type
                                    _old_get(0)
                            end

parent()

[Source]

    # File rexml/light/node.rb, line 155
                            def parent
                                    at(1)
                            end

parent=( node )

[Source]

    # File rexml/light/node.rb, line 58
                            def parent=( node )
                                    _old_put(1,node)
                            end

prefix( namespace=nil )

[Source]

    # File rexml/light/node.rb, line 71
                            def prefix( namespace=nil )
                                    prefix_of( self, namespace )
                            end

root()

[Source]

    # File rexml/light/node.rb, line 142
                            def root
                                    context = self
                                    context = context.at(1) while context.at(1)
                            end

size()

[Source]

    # File rexml/light/node.rb, line 36
                            def size
                                    if PARENTS.include? @node[0]
                                            @node[-1].size
                                    else
                                            0
                                    end
                            end

text=( foo )

[Source]

    # File rexml/light/node.rb, line 137
                            def text=( foo )
                                    replace = at(4).kind_of?(String)? 1 : 0
                                    self._old_put(4,replace, normalizefoo)
                            end

to_s()

[Source]

    # File rexml/light/node.rb, line 159
                            def to_s

                            end

[Validate]