Class: Utopia::Content::Document

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

Overview

A single request through content middleware. We use a struct to hide instance varibles since we instance_exec within this context.

Defined Under Namespace

Classes: State

Instance Attribute Summary collapse

Attributes inherited from Response

#body, #headers, #status

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Response

#cache!, #content_type=, #do_not_cache!, #lookup, #to_a

Constructor Details

#initialize(request, attributes = {}) ⇒ Document

Returns a new instance of Document



44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/utopia/content/document.rb', line 44

def initialize(request, attributes = {})
	@request = request
	
	@attributes = attributes
	
	@first = nil
	@current = nil
	@end_tags = []
	
	super()
end

Instance Attribute Details

#attributes ⇒ Object (readonly)

Per-document global attributes.



87
88
89
 
# File 'lib/utopia/content/document.rb', line 87

def attributes
  @attributes
end

#current ⇒ Object (readonly)

The current state, represents a list from outer to inner most tag by traversing Utopia::Content::Document::State#parent. At any point in parsing markup, this is a list of the inner most tag, then the next outer tag, etc.



92
93
94
 
# File 'lib/utopia/content/document.rb', line 92

def current
  @current
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.



100
101
102
 
# File 'lib/utopia/content/document.rb', line 100

def end_tags
  @end_tags
end

#first ⇒ Object (readonly)

The first State generated by rendering this document. It contains useful information regarding the node and uri used to access the resource.



96
97
98
 
# File 'lib/utopia/content/document.rb', line 96

def first
  @first
end

#request ⇒ Object (readonly)

The Rack::Request for this document.



84
85
86
 
# File 'lib/utopia/content/document.rb', line 84

def request
  @request
end

Class Method Details

.render(node, request, attributes) ⇒ Object 



40
41
42
 
# File 'lib/utopia/content/document.rb', line 40

def self.render(node, request, attributes)
	self.new(request, attributes).render!(node, attributes)
end

Instance Method Details

#[](key) ⇒ Object 



56
57
58
 
# File 'lib/utopia/content/document.rb', line 56

def [] key
	@attributes[key]
end

#[]=(key, value) ⇒ Object 



60
61
62
 
# File 'lib/utopia/content/document.rb', line 60

def []= key, value
	@attributes[key] = value
end

#content ⇒ Object

The content of the node



215
216
217
 
# File 'lib/utopia/content/document.rb', line 215

def content
	@end_tags.last.content
end

#controller ⇒ Object

A helper method for accessing controller variables from view:



71
72
73
 
# File 'lib/utopia/content/document.rb', line 71

def controller
	@controller ||= Utopia::Controller[request]
end

#localization ⇒ Object 



75
76
77
 
# File 'lib/utopia/content/document.rb', line 75

def localization
	@localization ||= Utopia::Localization[request]
end

#lookup_node(path) ⇒ Node

Lookup a node with the given path relative to the current node.

Returns:

  • (Node) —

    The node if could be found.



210
211
212
 
# File 'lib/utopia/content/document.rb', line 210

def lookup_node(path)
	@current.node.lookup_node(path)
end

#lookup_tag(tag) ⇒ Node

Maps a tag to a node instance by asking the current node to lookup the tag name. This function is called for each tag and thus heavily affects performance.

Returns:

  • (Node) —

    The node for the given tag.



190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'lib/utopia/content/document.rb', line 190

def lookup_tag(tag)
	# result = tag
	# 
	# # This loop works from inner to outer tags, and updates the tag we are currently searching for based on any overrides:
	# @begin_tags.reverse_each do |state|
	# 	result = state.lookup(result)
	# 	
	# 	return result if result.is_a?(Node)
	# end
	
	# This loop looks up a tag by asking the most embedded node to look it up based on tag name. This almost always only evaluates the top state:
	@end_tags.reverse_each do |state|
		return state.node.lookup_tag(tag) if state.node.respond_to?(:lookup_tag)
	end
	
	return nil
end

#parent ⇒ Object 



219
220
221
 
# File 'lib/utopia/content/document.rb', line 219

def parent
	@end_tags[-2]
end

#parse_markup(markup) ⇒ Object 



79
80
81
 
# File 'lib/utopia/content/document.rb', line 79

def parse_markup(markup)
	MarkupParser.parse(markup, self)
end

#render!(node, attributes) ⇒ Object 



64
65
66
67
68
 
# File 'lib/utopia/content/document.rb', line 64

def render!(node, attributes)
	@body << render_node(node, attributes)
	
	return self
end

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



178
179
180
181
182
183
184
185
186
 
# File 'lib/utopia/content/document.rb', line 178

def render_node(node, attributes = {})
	@current = State.new(@current, nil, node, attributes)
	
	# We keep track of the first thing rendered by this document.
	@first ||= @current
	
	# This returns the content of rendering the tag:
	return tag_end
end

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



102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/utopia/content/document.rb', line 102

def tag(name, attributes = {})
	# If we provide a block which can give inner data, we are not self-closing.
	tag = Tag.new(name, !block_given?, attributes)

	if block_given?
		node = tag_begin(tag)
		yield node
		tag_end(tag)
	else
		tag_complete(tag, node)
	end
end

#tag_begin(tag, node = nil) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/utopia/content/document.rb', line 126

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

	if node
		@current = State.new(@current, tag, node)

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

		return node
	end

	# raise ArgumentError.new("tag_begin: #{tag} is tag.self_closed?") if tag.self_closed?

	@current.tag_begin(tag)

	return nil
end

#tag_complete(tag, node = nil) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
 
# File 'lib/utopia/content/document.rb', line 115

def tag_complete(tag, node = nil)
	node ||= lookup_tag(tag)

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

#tag_end(tag = nil) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/utopia/content/document.rb', line 154

def tag_end(tag = nil)
	# Determine if the current state contains tags that need to be completed, or if the state itself is finished.
	if @current.empty?
		if node = @current.node
			node.tag_end(self, @current) if node.respond_to?(:tag_end)
		end

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

		@current = @current.parent
		@end_tags.pop

		@current.write(buffer) if @current

		return buffer
	else
		# raise ArgumentError.new("tag_begin: #{tag} is tag.self_closed?") if tag.self_closed?
		@current.tag_end(tag)
	end

	return nil
end

#text(string) ⇒ Object 



150
151
152
 
# File 'lib/utopia/content/document.rb', line 150

def text(string)
	@current.text(string)
end

#write(string) ⇒ Object Also known as: cdata 



144
145
146
 
# File 'lib/utopia/content/document.rb', line 144

def write(string)
	@current.write(string)
end