def _generate_route_objects(self, route_schema, namespace):
self.emit()
self.emit('/// Stone Route Objects')
self.emit()
for route in namespace.routes:
var_name = fmt_func(route.name)
with self.block('static let {} = Route('.format(var_name),
delim=(None, None),
after=')'):
self.emit('name: \"{}\",'.format(route.name))
self.emit('namespace: \"{}\",'.format(namespace.name))
self.emit('deprecated: {},'.format(
'true' if route.deprecated is not None else 'false'))
self.emit('argSerializer: {},'.format(
fmt_serial_obj(route.arg_data_type)))
self.emit('responseSerializer: {},'.format(
fmt_serial_obj(route.result_data_type)))
self.emit('errorSerializer: {},'.format(
fmt_serial_obj(route.error_data_type)))
attrs = []
for field in route_schema.fields:
attr_key = field.name
attr_val = ("\"{}\"".format(route.attrs.get(attr_key))
if route.attrs.get(attr_key) else 'nil')
attrs.append('\"{}\": {}'.format(attr_key, attr_val))
self.generate_multiline_list(attrs,
delim=('attrs: [', ']'),
compact=True)
def _emit_route(self, namespace, route, extra_args=None, extra_docs=None):
arg_list, doc_list = self._get_route_args(namespace, route)
extra_args = extra_args or []
extra_docs = extra_docs or []
arg_type = self._swift_type_mapping(route.arg_data_type)
func_name = fmt_func(route.name)
self.emit('/**')
if route.doc:
route_doc = self.process_doc(route.doc, self._docf)
else:
route_doc = 'The {} route'.format(func_name)
self.emit_wrapped_text(route_doc, prefix=' ', width=120)
self.emit()
for name, doc in doc_list + extra_docs:
if not doc:
doc = 'Undocumented'
self.emit_wrapped_text('- parameter {}: {}'.format(name, doc), prefix=' ', width=120)
self.emit()
self.emit_wrapped_text(' - returns: Through the response callback, the caller will ' +
'receive a `{}` object on success or a `{}` object on ' +
'failure.'.format(
self._swift_type_mapping(route.result_data_type),
self._swift_type_mapping(route.error_data_type)),
prefix=' ', width=120)
self.emit('*/')
route_type = self.STYLE_MAPPING[route.attrs.get('style')]
rtype = self._swift_type_mapping(route.result_data_type,
serializer=True)
etype = self._swift_type_mapping(route.error_data_type,
serializer=True)
host_ident = route.attrs.get('host', 'meta')
func_args = [
('client', 'self.client'),
('host', '"'+host_ident+'"'),
('route', '"/{}/{}"'.format(namespace.name, route.name)),
('params', '{}.serialize({})'.format(
self._serializer_obj(route.arg_data_type),
'' if is_void_type(route.arg_data_type) else 'request')),
('responseSerializer', self._serializer_obj(route.result_data_type)),
('errorSerializer', self._serializer_obj(route.error_data_type)),
]
for name, typ, value in extra_args:
arg_list.append((name, typ))
func_args.append((name, value))
with self.function_block('public func {}'.format(func_name),
args=self._func_args(arg_list, force_first=True),
return_type='Stone{}Request<{}, {}>'.format(route_type,
rtype,
etype)):
if is_struct_type(route.arg_data_type):
args = [(name, name) for name, _ in self._struct_init_args(route.arg_data_type)]
self.emit('let request = {}({})'.format(arg_type, self._func_args(args)))
self.emit('return Stone{}Request({})'.format(route_type, self._func_args(func_args)))
def _emit_route(self, namespace, route, req_obj_name, extra_args=None, extra_docs=None):
arg_list, doc_list = self._get_route_args(namespace, route)
extra_args = extra_args or []
extra_docs = extra_docs or []
arg_type = fmt_type(route.arg_data_type)
func_name = fmt_func(route.name)
if route.doc:
route_doc = self.process_doc(route.doc, self._docf)
else:
route_doc = 'The {} route'.format(func_name)
self.emit_wrapped_text(route_doc, prefix='/// ', width=120)
self.emit('///')
for name, doc in doc_list + extra_docs:
param_doc = '- parameter {}: {}'.format(name, doc if doc is not None else undocumented)
self.emit_wrapped_text(param_doc, prefix='/// ', width=120)
self.emit('///')
output = (' - returns: Through the response callback, the caller will ' +
'receive a `{}` object on success or a `{}` object on failure.')
output = output.format(fmt_type(route.result_data_type),
fmt_type(route.error_data_type))
self.emit_wrapped_text(output, prefix='/// ', width=120)
func_args = [
('route', '{}.{}'.format(fmt_class(namespace.name), func_name)),
]
client_args = []
return_args = [('route', 'route')]
for name, value, typ in extra_args:
arg_list.append((name, typ))
func_args.append((name, value))
client_args.append((name, value))
rtype = fmt_serial_type(route.result_data_type)
etype = fmt_serial_type(route.error_data_type)
self._maybe_generate_deprecation_warning(route)
with self.function_block('public func {}'.format(func_name),
args=self._func_args(arg_list, force_first=True),
return_type='{}<{}, {}>'.format(req_obj_name, rtype, etype)):
self.emit('let route = {}.{}'.format(fmt_class(namespace.name), func_name))
if is_struct_type(route.arg_data_type):
args = [(name, name) for name, _ in self._struct_init_args(route.arg_data_type)]
func_args += [('serverArgs', '{}({})'.format(arg_type, self._func_args(args)))]
self.emit('let serverArgs = {}({})'.format(arg_type, self._func_args(args)))
elif is_union_type(route.arg_data_type):
self.emit('let serverArgs = {}'.format(fmt_var(route.arg_data_type.name)))
if not is_void_type(route.arg_data_type):
return_args += [('serverArgs', 'serverArgs')]
return_args += client_args
self.emit('return client.request({})'.format(self._func_args(return_args, not_init=True)))
self.emit()
def _docf(self, tag, val):
if tag == 'route':
return fmt_func(val)
elif tag == 'field':
if '.' in val:
cls, field = val.split('.')
return ('{} in {}'.format(fmt_var(field), fmt_class(cls)))
else:
return fmt_var(val)
elif tag in ('type', 'val', 'link'):
return val
else:
import pdb
pdb.set_trace()
return val
def _docf(self, tag, val):
if tag == 'route':
return fmt_func(val)
elif tag == 'field':
if '.' in val:
cls, field = val.split('.')
return ('{} in {}'.format(fmt_var(field),
fmt_class(cls)))
else:
return fmt_var(val)
elif tag in ('type', 'val', 'link'):
return val
else:
import pdb
pdb.set_trace()
return val
def _generate_route_objects(self, route_schema, namespace):
self.emit()
self.emit('/// Stone Route Objects')
self.emit()
for route in namespace.routes:
var_name = fmt_func(route.name)
with self.block('static let {} = Route('.format(var_name),
delim=(None, None), after=')'):
self.emit('name: \"{}\",'.format(route.name))
self.emit('namespace: \"{}\",'.format(namespace.name))
self.emit('deprecated: {},'.format('true' if route.deprecated
is not None else 'false'))
self.emit('argSerializer: {},'.format(fmt_serial_obj(route.arg_data_type)))
self.emit('responseSerializer: {},'.format(fmt_serial_obj(route.result_data_type)))
self.emit('errorSerializer: {},'.format(fmt_serial_obj(route.error_data_type)))
attrs = []
for field in route_schema.fields:
attr_key = field.name
attr_val = ("\"{}\"".format(route.attrs.get(attr_key))
if route.attrs.get(attr_key) else 'nil')
attrs.append('\"{}\": {}'.format(attr_key, attr_val))
self.generate_multiline_list(
attrs, delim=('attrs: [', ']'), compact=True)
def _emit_route(self,
namespace,
route,
req_obj_name,
extra_args=None,
extra_docs=None):
arg_list, doc_list = self._get_route_args(namespace, route)
extra_args = extra_args or []
extra_docs = extra_docs or []
arg_type = fmt_type(route.arg_data_type)
func_name = fmt_func(route.name)
if route.doc:
route_doc = self.process_doc(route.doc, self._docf)
else:
route_doc = 'The {} route'.format(func_name)
self.emit_wrapped_text(route_doc, prefix='/// ', width=120)
self.emit('///')
for name, doc in doc_list + extra_docs:
param_doc = '- parameter {}: {}'.format(
name, doc if doc is not None else undocumented)
self.emit_wrapped_text(param_doc, prefix='/// ', width=120)
self.emit('///')
output = (
' - returns: Through the response callback, the caller will ' +
'receive a `{}` object on success or a `{}` object on failure.')
output = output.format(fmt_type(route.result_data_type),
fmt_type(route.error_data_type))
self.emit_wrapped_text(output, prefix='/// ', width=120)
func_args = [
('route', '{}.{}'.format(fmt_class(namespace.name), func_name)),
]
client_args = []
return_args = [('route', 'route')]
for name, value, typ in extra_args:
arg_list.append((name, typ))
func_args.append((name, value))
client_args.append((name, value))
rtype = fmt_serial_type(route.result_data_type)
etype = fmt_serial_type(route.error_data_type)
self._maybe_generate_deprecation_warning(route)
with self.function_block(
'@discardableResult open func {}'.format(func_name),
args=self._func_args(arg_list, force_first=False),
return_type='{}<{}, {}>'.format(req_obj_name, rtype, etype)):
self.emit('let route = {}.{}'.format(fmt_class(namespace.name),
func_name))
if is_struct_type(route.arg_data_type):
args = [
(name, name)
for name, _ in self._struct_init_args(route.arg_data_type)
]
func_args += [
('serverArgs', '{}({})'.format(arg_type,
self._func_args(args)))
]
self.emit('let serverArgs = {}({})'.format(
arg_type, self._func_args(args)))
elif is_union_type(route.arg_data_type):
self.emit('let serverArgs = {}'.format(
fmt_var(route.arg_data_type.name)))
if not is_void_type(route.arg_data_type):
return_args += [('serverArgs', 'serverArgs')]
return_args += client_args
self.emit('return client.request({})'.format(
self._func_args(return_args, not_init=True)))
self.emit()