-
Notifications
You must be signed in to change notification settings - Fork 30
/
element_wrapper.rb
204 lines (177 loc) · 4.92 KB
/
element_wrapper.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
module Pacer::Wrappers
class ElementWrapper
include Pacer::Element
extend Forwardable
include Comparable
include Pacer::Routes::RouteOperations
include Pacer::Core::Graph::ElementRoute
class << self
attr_accessor :caches
def base_vertex_wrapper
VertexWrapper
end
def base_edge_wrapper
EdgeWrapper
end
def wrap(element, exts)
wrapper_for(exts).new(element.graph, element.element)
end
def extensions
@extensions ||= []
end
def add_extensions(exts)
wrapper_for(extensions + exts.to_a)
end
def clear_cache
VertexWrapper.clear_cache
EdgeWrapper.clear_cache
caches.each { |c| c.clear_cache } if caches
end
def route_conditions(graph)
return @route_conditions if defined? @route_conditions
@route_conditions = extensions.inject({}) do |h, ext|
if ext.respond_to? :route_conditions
h.merge! ext.route_conditions(graph)
else
h
end
end
@route_conditions
end
def lookup(graph)
return @lookup if defined? @lookup
@lookup = extensions.inject({}) do |h, ext|
if ext.respond_to? :lookup
h.merge! ext.lookup(graph)
else
h
end
end
@lookup
end
protected
def build_extension_wrapper(exts, mod_names, superclass)
sc_name = superclass.to_s.split(/::/).last
exts = exts.uniq unless exts.is_a? Set
Class.new(superclass) do
exts.each do |obj|
if obj.is_a? Module or obj.is_a? Class
mod_names.each do |mod_name|
if obj.const_defined? mod_name
include obj.const_get(mod_name)
extensions << obj unless extensions.include? obj
end
end
end
end
end
end
end
# For internal use only.
#
# The graph the element belongs to.
#
# Used to help prevent objects from different graphs from being
# accidentally associated, as well as to get graph-specific data for
# the element.
#
# @return [PacerGraph]
attr_reader :graph
attr_reader :element
def initialize(graph, element)
@graph = graph
if element.is_a? ElementWrapper
@element = element.element
else
@element = element
end
after_initialize
end
def chain_route(args_hash)
Pacer::RouteBuilder.current.chain self, args_hash
end
# Convenience method to retrieve a property by name.
#
# @param [#to_s] key the property name
# @return [Object]
def [](key)
if key.is_a? Array
key.map { |k| self[k] }
else
value = element.getProperty(key.to_s)
graph.decode_property(value)
end
end
# Convenience method to set a property by name to the given value.
# @param [#to_s] key the property name
# @param [Object] value the value to set the property to
def []=(key, value)
begin
value = graph.encode_property(value)
rescue Exception => e
throw Pacer::ClientError.new "Unable to serialize #{ key }: #{ value.class }"
end
key = key.to_s
if value.nil?
element.removeProperty(key)
else
element.setProperty(key, value)
end
end
# Specialize result to return self for elements.
# @return [ElementWrapper] self
def result(name = nil)
self
end
# Query whether the current node belongs to the given graph.
#
# @param [Object] g the object to compare to {#graph}
def from_graph?(g)
g.blueprints_graph.equal? graph.blueprints_graph
end
# Returns a hash of property values by name.
#
# @return [Hash]
def properties
Hash[element.getPropertyKeys.map { |name| [name, graph.decode_property(element.getProperty(name))] }]
end
# Replace the element's properties with the given hash
#
# @param [Hash] props the element's new properties
def properties=(props)
(element.getPropertyKeys - props.keys.collect { |k| k.to_s }).each do |key|
element.removeProperty key
end
props.each do |key, value|
self[key] = value
end
end
def property_keys
getPropertyKeys
end
# The id of the current element
# @return [Object] element id (type varies by graph implementation.
def element_id
element.getId
end
# Sort objects semi arbitrarily based on {#display_name}.
# @param other
#
# @return [Fixnum]
def <=>(other)
display_name.to_s <=> other.display_name.to_s
end
def element_payload
element.payload if element.is_a? Pacer::Payload::Element
end
def reload
if element.respond_to? :reload
element.reload
end
self
end
protected
def after_initialize
end
end
end