REXML::Light::Node ^(Class)

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.

Constants

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

Public Class methods

Create a new element.

# 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

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.

# 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

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

[]( reference, ns=nil )

# 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

# 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

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

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

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

has_name?( name, namespace = '' )

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

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

local_name=( name_str )

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

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

name=( name_str, ns=nil )

# 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() )

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

namespace=( namespace )

# 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

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

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

parent=( node )

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

prefix( namespace=nil )

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

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

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

# 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

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

                        end