-
Notifications
You must be signed in to change notification settings - Fork 0
/
scaffolder.py
161 lines (115 loc) · 5.52 KB
/
scaffolder.py
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
import os
from string import Template
outputPath = os.path.join(os.getcwd(), 'riffle/src/main/java/com/exis/riffle/')
# OI-- does this need generic information too?
# public Deferred then(Handler.Zero handler) {
# return _then (Cumin.cuminicate(handler));
# }
callDeferredTemplate = '''
public $genericList CallDeferred then($genericClassList $handlerType handler) {
return _then(Cumin.cuminicate($classVars handler), Cumin.representation($inputGenerics));
}
'''
# public static <A> Wrapped cuminicate(Class<A> a, Handler.One<A> fn) {
# return (q) -> { fn.run(convert(a, q[0])); return null; };
# }
cuminTemplate = '''
public static $genericList Wrapped cuminicate($genericClassList, $handler fn) {
return (q) -> { fn.run($converters); return null; };
}
'''
cuminReturnTemplate = '''
public static $genericList Wrapped cuminicate($genericClassList, $handler fn) {
return (q) -> { return fn.run($converters); };
}
'''
# public <A> Deferred register(String endpoint, Class<A> a, Handler.One<A> handler) {
# return _register(endpoint, Cumin.cuminicate(a, handler));
# }
handlerTemplate = '''
public $genericList Deferred $name(String endpoint, $genericClassList $handler handler) {
return _$name(endpoint, Cumin.cuminicate($cuminicateArgs), Cumin.representation($inputGenerics));
}
'''
# interface Two<A, B> { void run(A a, B b); }
# interface Three<A, B, C> { void run(A a, B b, C c); }
interfaceTemplate = '''
interface $name$genericList { $ret run($paramList); }
'''
allGenerics = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
returns = ['R']
handlerNames = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven']
def generateBasics(i, j):
genericList = allGenerics[:i] + returns[:j]
classList = ', '.join(["Class<%s> %s" % (x, x.lower()) for x in genericList])
generics = "" if len(genericList) == 0 else "<%s>" % ', '.join(genericList)
handler = "Handler.%s%s" % (handlerNames[i] + handlerNames[j], generics)
return generics, genericList, classList, handler
def renderDeferred(i, j):
generics, genericList, classList, handler = generateBasics(i, j)
classList = classList + ', ' if len(classList) > 0 else classList
handler = "Handler.%s%s" % (handlerNames[i] + handlerNames[j], generics)
classVars = ', '.join([x.lower() for x in genericList])
inputClasses = ', '.join([x.lower() for x in genericList])
classVars = classVars + ', ' if len(classVars) > 0 else classVars
classes = ', '.join(["convert(%s, q[%s])" % (x.lower(), i) for i, x in enumerate(genericList)])
return Template(callDeferredTemplate).substitute(genericList=generics, handlerType=handler, genericClassList=classList, classVars=classVars, inputGenerics=inputClasses)
def renderCumin(i, j):
generics, genericList, classList, handler = generateBasics(i, j)
converters = ', '.join(["convert(%s, q[%s])" % (x.lower(), i) for i, x in enumerate(allGenerics[:i])])
template = cuminTemplate if j == 0 else cuminReturnTemplate
return Template(template).substitute(genericList=generics, genericClassList=classList, handler=handler, converters=converters)
def renderHandler(i, j, name):
generics, genericList, classList, handler = generateBasics(i, j)
cuminicateArgs = [x.lower() for x in genericList]
inputClasses = cuminicateArgs[:i]
cuminicateArgs.append('handler')
cuminicateArgs = ", ".join(cuminicateArgs)
classList = classList + ', ' if len(classList) > 0 else classList
inputClasses = ', '.join(inputClasses)
return Template(handlerTemplate).substitute(genericList=generics, name=name, genericClassList=classList, handler=handler, cuminicateArgs=cuminicateArgs, inputGenerics=inputClasses)
def renderInterface(i, j):
generics, genericList, classList, handler = generateBasics(i, j)
paramList = ", ".join("%s %s" % (x, x.lower()) for x in allGenerics[:i])
ret = "void" if j == 0 else "R"
return Template(interfaceTemplate).substitute(genericList=generics, name=(handlerNames[i] + handlerNames[j]), paramList=paramList, ret=ret)
# Replaces the exising lines with these new lines
def foldLines(f, addition):
start_marker = '// Start Generic Shotgun'
end_marker = '// End Generic Shotgun'
ret = []
with open(f) as inf:
ignoreLines = False
written = False
for line in inf:
if end_marker in line:
ignoreLines = False
if ignoreLines:
if not written:
written = True
[ret.append(x) for x in addition]
else:
ret.append(line)
if start_marker in line:
ignoreLines = True
return ret
def foldAndWrite(fileName, lines):
fileName = os.path.join(outputPath, fileName)
lines = foldLines(fileName, lines)
with open(fileName, 'w') as f:
[f.write(x) for x in lines]
if __name__ == '__main__':
call, cumin, subs, reg, interfaces = [], [], [], [], []
for j in range(2): # The number of return types
for i in range(0, 7): # Number of parameters
if j == 0:
call.append(renderDeferred(i, j))
subs.append(renderHandler(i, j, 'subscribe'))
else:
reg.append(renderHandler(i, j, 'register'))
cumin.append(renderCumin(i, j))
interfaces.append(renderInterface(i, j))
foldAndWrite('cumin/Cumin.java', cumin)
foldAndWrite('CallDeferred.java', call)
foldAndWrite('Domain.java', subs + reg)
foldAndWrite('cumin/Handler.java', interfaces)