This repository was archived by the owner on Aug 15, 2022. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 605
Expand file tree
/
Copy pathgraphlet.coffee
More file actions
executable file
·241 lines (203 loc) · 6.85 KB
/
Copy pathgraphlet.coffee
File metadata and controls
executable file
·241 lines (203 loc) · 6.85 KB
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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
fetchRootTraverse = require 'traverse'
{ Base, Model, Inflector, future, sequence, race, dash } = require 'bongo'
{ extend } = require 'underscore'
{ slice } = []
Relationship = require './relationship'
LazyNode = require './lazynode'
module.exports = future class Graphlet
constructor:(options = {}) ->
@[option]? value for option, value of options
lasso: ->
@abstractly 'lasso', arguments
abstractly: future (pipeline, method, arg, next) ->
last = pipeline.last()
nodes = last.nodes or last.edges
unless nodes?
throw new Error 'abstractly needs nodes or edges'
if nodes
callAbstractly = race (node, next) ->
abstractly = node.abstractly
if 'function' is typeof abstractly
abstractly.call node, method, arg, next
else
next()
, next
callAbstractly node for node in nodes
this
reverse: do ->
reverse = (arr) ->
for own _, collection of arr
collection.reverse?()
future (pipeline, isDeep, next) ->
[next, isDeep] = [isDeep, next] unless next
if isDeep is true
for stage in pipeline
reverse stage
else
reverse pipeline.last()
next()
#
#
# fetch: future (pipeline, name, rest..., next) ->
# @invoke 'fetch', name, rest..., next
#
# assure: future (pipeline, rest..., next) ->
# @[@getInterfaceName(name)] 'assure', rest..., next
#
# add: future (pipeline, rest..., next) ->
# @[@getInterfaceName(name)] 'add', rest..., next
#
# remove: future (pipeline, rest..., next) ->
# @[@getInterfaceName(name)] 'fetch', rest..., next
#
#
edgesOfEach:do ->
selectorCallback = (callback, err, relationships) ->
return callback err if err
@push relationships...
callback null
selectFromNode = (node, sharedOptions, acc, callback) ->
{ selector, query, limit, sort, skip, hint } = sharedOptions
selector = extend {}, selector ? query, { sourceId: node.getId() }
options = { limit, sort, skip, hint }
Relationship.some selector, options, selectorCallback.bind acc, callback
selectFromEdge = (edge, sharedOptions, acc, callback) ->
{ selector, query, limit, sort, skip, hint } = sharedOptions
selector = extend {}, selector ? query, { sourceId: edge.targetId }
options = { limit, sort, skip, hint }
Relationship.some selector, options, selectorCallback.bind acc, callback
future (pipeline, options, next) ->
last = pipeline.last()
{ andNext } = pipeline
delete pipeline.andNext
[next, options] = [options, next] unless next
options or= {}
acc = if andNext then last.nodes ? last.edges else []
queue =
if last.nodes
last.nodes.map (node) -> ->
selectFromNode node, options, acc, (err) ->
if err then next err
else queue.fin()
else if last.edges
last.edges.map (edge) -> ->
selectFromEdge edge, options, acc, (err) ->
if err then next err
else queue.fin()
dash queue, ->
pipeline.push { edges: acc }
next()
edges: future (pipeline, options, next) ->
last = pipeline.last()
{ andNext } = pipeline
delete pipeline.andNext
[next, options] = [options, next] unless next
options or= {}
{ selector, query, limit, sort, skip, hint } = options
selector or= query or= {}
if last.nodes
extend selector, { sourceId: { $in: (node.getId() for node in last.nodes) } }
else if last.edges
extend selector, { sourceId: { $in: (edge.targetId for edge in last.edges) } }
Relationship.some selector, options, (err, relationships) ->
if err
next err
else
if andNext
last.edges.push relationships...
delete last.nodes
else
pipeline.push { edges: relationships }
next()
this
nodes: future (pipeline, options, next) ->
last = pipeline.last()
[next, options] = [options, next] unless next
options or= {}
if last?.nodes
throw new Error \
"Can't traverse to nodes from nodes. You need to select some edges."
if Array.isArray options
pipeline.push { nodes: options }
next()
else
nodes = { nodes: [] }
pipeline.push nodes
collectNodes = race (i, constructor, pipeline, selector, options, fin) ->
root = pipeline.root()
constructor.some selector, options, (err, instances) ->
if err
next err
else
nodes.nodes.push instances...
fin()
, next
{ selector, query, limit, sort, skip, hint } = options
selector or= query or= {}
if last.edges
targets = {}
for edge in last.edges
targets[edge.targetName] or= []
targets[edge.targetName].push edge.targetId
unless Object.keys(targets).length then next()
else for own targetName, targetIds of targets
constructor = Base.constructors[targetName]
collectNodes constructor, pipeline, (extend {}, selector, { _id:
if targetIds.length > 1
{ $in: targetIds }
else
targetIds[0]
}
), { limit, sort, skip, hint }
else
throw new Error 'this is a strange condition'
this
and: future (pipeline, next) ->
last = pipeline.last()
type = \
if last.nodes then 'edges'
else if last.edges then 'nodes'
last[type] = pipeline[pipeline.length - 2][type]
pipeline.andNext = yes
next()
tap: future (pipeline, callback, next) ->
callback pipeline
next()
endGraphlet: future (pipeline, next) ->
nodes = {}
graphlet = []
for stage, i in pipeline when stage.nodes?
for node in stage.nodes
constructorName = node.constructor.name
node = nodes[node.getId()] = node.get()
node.bongo_ = { constructorName }
graphlet.push node if i is 0
for stage in pipeline when stage.edges?
for edge in stage.edges
sourceNode = nodes[edge.sourceId] or= new LazyNode edge.sourceName, edge.sourceId
targetNode = nodes[edge.targetId] or= new LazyNode edge.targetName, edge.targetId
targetCollection = sourceNode[Inflector.pluralize edge.as] or= []
targetCollection.push targetNode
pipeline.push { graphlet }
next()
fetchGraphlet:(callback) ->
@then (err, pipeline) ->
if err
callback err
else
{ graphlet } = pipeline.last()
callback null, graphlet
fetchRoot:(index, callback) ->
[callback, index] = [index, callback] unless callback
index or= 0
@fetchGraphlet (err, graphlet) ->
if err
callback err
else
callback null, graphlet[index]
traverse:(callback) ->
@then (err, obj) ->
if err
callback err
else
callback null, new Traverse obj