Class: Utopia::Content::Transaction

Inherits:
Object
  • Object
show all
Defined in:
lib/utopia/content/node.rb

Overview

A single request through content middleware.

Defined Under Namespace

Classes: State

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(request, response) ⇒ Transaction

Returns a new instance of Transaction.



124
125
126
127
128
129
130
 
# File 'lib/utopia/content/node.rb', line 124

def initialize(request, response)
  @begin_tags = []
  @end_tags = []

  @request = request
  @response = response
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object 



286
287
288
289
290
291
292
293
294
 
# File 'lib/utopia/content/node.rb', line 286

def method_missing(name, *args)
  @begin_tags.reverse_each do |state|
    if state.node.respond_to? name
      return state.node.send(name, *args)
    end
  end

  super
end

Instance Attribute Details

#begin_tags ⇒ Object (readonly)

Begin tags represents a list from outer to inner most tag. At any point in parsing xml, begin_tags is a list of the inner most tag, then the next outer tag, etc. This list is used for doing dependent lookups.



147
148
149
 
# File 'lib/utopia/content/node.rb', line 147

def begin_tags
  @begin_tags
end

#end_tags ⇒ Object (readonly)

End tags represents a list of execution order. This is the order that end tags have appeared when evaluating nodes.



151
152
153
 
# File 'lib/utopia/content/node.rb', line 151

def end_tags
  @end_tags
end

#request ⇒ Object (readonly)

Returns the value of attribute request.



132
133
134
 
# File 'lib/utopia/content/node.rb', line 132

def request
  @request
end

#response ⇒ Object (readonly)

Returns the value of attribute response.



133
134
135
 
# File 'lib/utopia/content/node.rb', line 133

def response
  @response
end

Instance Method Details

#attributes ⇒ Object 



153
154
155
 
# File 'lib/utopia/content/node.rb', line 153

def attributes
  return current.attributes
end

#cdata(text) ⇒ Object 



217
218
219
 
# File 'lib/utopia/content/node.rb', line 217

def cdata(text)
  current.cdata(text)
end

#content ⇒ Object 



161
162
163
 
# File 'lib/utopia/content/node.rb', line 161

def content
  @end_tags[-1].content
end

#controller ⇒ Object

A helper method for accessing controller variables from view:



136
137
138
 
# File 'lib/utopia/content/node.rb', line 136

def controller
  @request.controller
end

#current ⇒ Object 



157
158
159
 
# File 'lib/utopia/content/node.rb', line 157

def current
  @begin_tags[-1]
end

#first ⇒ Object 



169
170
171
 
# File 'lib/utopia/content/node.rb', line 169

def first
  @begin_tags[0]
end

#lookup(tag) ⇒ Object

Takes an instance of Tag



267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/utopia/content/node.rb', line 267

def lookup(tag)
  result = tag
  node = nil

  @begin_tags.reverse_each do |state|
    result = state.lookup(result)
    
    node ||= state.node if state.node.respond_to? :lookup

    return result if Node === result
  end

  @end_tags.reverse_each do |state|
    return state.node.lookup(result) if state.node.respond_to? :lookup
  end

  return nil
end

#parent ⇒ Object 



165
166
167
 
# File 'lib/utopia/content/node.rb', line 165

def parent
  end_tags[-2]
end

#parse_xml(xml_data) ⇒ Object 



140
141
142
 
# File 'lib/utopia/content/node.rb', line 140

def parse_xml(xml_data)
  Processor.parse_xml(xml_data, self)
end

#partial(*args, &block) ⇒ Object Also known as: deferred_tag 



221
222
223
224
225
226
227
228
229
 
# File 'lib/utopia/content/node.rb', line 221

def partial(*args, &block)
  if block_given?
    current.defer(&block)
  else
    current.defer do
      tag(*args)
    end
  end
end

#render_node(node, attributes = {}) ⇒ Object 



259
260
261
262
263
264
 
# File 'lib/utopia/content/node.rb', line 259

def render_node(node, attributes = {})
  state = State.new(attributes, node)
  @begin_tags << state

  return tag_end
end

#tag(name, attributes = {}) {|node| ... } ⇒ Object

Yields:

  • (node) 


173
174
175
176
177
178
179
180
181
 
# File 'lib/utopia/content/node.rb', line 173

def tag(name, attributes = {}, &block)
  tag = Tag.new(name, attributes)

  node = tag_begin(tag)

  yield node if block_given?

  tag_end(tag)
end

#tag_begin(tag, node = nil) ⇒ Object 



198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/utopia/content/node.rb', line 198

def tag_begin(tag, node = nil)
  node ||= lookup(tag)

  if node
    state = State.new(tag, node)
    @begin_tags << state

    if node.respond_to? :tag_begin
      node.tag_begin(self, state)
    end

    return node
  end

  current.tag_begin(tag)

  return nil
end

#tag_complete(tag, node = nil) ⇒ Object 



183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/utopia/content/node.rb', line 183

def tag_complete(tag, node = nil)
  if tag.name == "content"
    current.markup(content)
  else
    node ||= lookup(tag)

    if node
      tag_begin(tag, node)
      tag_end(tag)
    else
      current.tag_complete(tag)
    end
  end
end

#tag_end(tag = nil) ⇒ Object 



233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/utopia/content/node.rb', line 233

def tag_end(tag = nil)
  top = current

  if top.tags.empty?
    if top.node.respond_to? :tag_end
      top.node.tag_end(self, top)
    end

    @end_tags << top
    buffer = top.call(self)

    @begin_tags.pop
    @end_tags.pop

    if current
      current.markup(buffer)
    end

    return buffer
  else
    current.tag_end(tag)
  end

  return nil
end