Class: REXML::Light::Node

Inherits:
Object show all
Defined in:
lib/rexml/light/node.rb

Overview

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

Constant Summary collapse

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

Instance Method Summary collapse

Constructor Details

#initialize(node = nil) ⇒ Node

Create a new element.



20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/rexml/light/node.rb', line 20

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

Instance Method Details

#<<(element) ⇒ Object

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.



121
122
123
124
125
126
127
128
129
130
 
# File 'lib/rexml/light/node.rb', line 121

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) ⇒ Object 



97
98
99
 
# File 'lib/rexml/light/node.rb', line 97

def =~( path )
  XPath.match( self, path )
end

#[](reference, ns = nil) ⇒ Object 



85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/rexml/light/node.rb', line 85

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) ⇒ Object

Doesn’t handle namespaces yet



102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/rexml/light/node.rb', line 102

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 ⇒ Object 



150
151
152
 
# File 'lib/rexml/light/node.rb', line 150

def children
  self
end

#each ⇒ Object 



43
44
45
 
# File 'lib/rexml/light/node.rb', line 43

def each
  size.times { |x| yield( at(x+4) ) }
end

#has_name?(name, namespace = '') ⇒ Boolean

Returns:

  • (Boolean) 


146
147
148
 
# File 'lib/rexml/light/node.rb', line 146

def has_name?( name, namespace = '' )
  at(3) == name and namespace() == namespace
end

#local_name ⇒ Object 



61
62
63
64
 
# File 'lib/rexml/light/node.rb', line 61

def local_name
  namesplit
  @name
end

#local_name=(name_str) ⇒ Object 



66
67
68
 
# File 'lib/rexml/light/node.rb', line 66

def local_name=( name_str )
  _old_put( 1, "#@prefix:#{name_str}" )
end

#name ⇒ Object 



47
48
49
 
# File 'lib/rexml/light/node.rb', line 47

def name
  at(2)
end

#name=(name_str, ns = nil) ⇒ Object 



51
52
53
54
55
 
# File 'lib/rexml/light/node.rb', line 51

def name=( name_str, ns=nil )
  pfx = ''
  pfx = "#{prefix(ns)}:" if ns
  _old_put(2, "#{pfx}#{name_str}")
end

#namespace(prefix = prefix()) ⇒ Object 



74
75
76
 
# File 'lib/rexml/light/node.rb', line 74

def namespace( prefix=prefix() )
  namespace_of( self, prefix )
end

#namespace=(namespace) ⇒ Object 



78
79
80
81
82
83
 
# File 'lib/rexml/light/node.rb', line 78

def namespace=( namespace )
  @prefix = prefix( namespace )
  pfx = ''
  pfx = "#@prefix:" if @prefix.size > 0
  _old_put(1, "#{pfx}#@name")
end

#node_type ⇒ Object 



132
133
134
 
# File 'lib/rexml/light/node.rb', line 132

def node_type
  _old_get(0)
end

#parent ⇒ Object 



154
155
156
 
# File 'lib/rexml/light/node.rb', line 154

def parent
  at(1)
end

#parent=(node) ⇒ Object 



57
58
59
 
# File 'lib/rexml/light/node.rb', line 57

def parent=( node )
  _old_put(1,node)
end

#prefix(namespace = nil) ⇒ Object 



70
71
72
 
# File 'lib/rexml/light/node.rb', line 70

def prefix( namespace=nil )
  prefix_of( self, namespace )
end

#root ⇒ Object 



141
142
143
144
 
# File 'lib/rexml/light/node.rb', line 141

def root
  context = self
  context = context.at(1) while context.at(1)
end

#size ⇒ Object 



35
36
37
38
39
40
41
 
# File 'lib/rexml/light/node.rb', line 35

def size
  if PARENTS.include? @node[0]
    @node[-1].size
  else
    0
  end
end

#text=(foo) ⇒ Object 



136
137
138
139
 
# File 'lib/rexml/light/node.rb', line 136

def text=( foo )
  replace = at(4).kind_of?(String)? 1 : 0
  self._old_put(4,replace, normalizefoo)
end

#to_s ⇒ Object 



158
159
160
 
# File 'lib/rexml/light/node.rb', line 158

def to_s

end