def _maybe_generate_deprecation_warning(self, route): if route.deprecated: msg = '{} is deprecated.'.format(fmt_func(route.name, route.version)) if route.deprecated.by: msg += ' Use {}.'.format( fmt_func(route.deprecated.by.name, route.deprecated.by.version)) self.emit('@available(*, unavailable, message:"{}")'.format(msg))
def _generate_route_objects(self, route_schema, namespace): check_route_name_conflict(namespace) self.emit() self.emit('/// Stone Route Objects') self.emit() for route in namespace.routes: var_name = fmt_func(route.name, route.version) with self.block('static let {} = Route('.format(var_name), delim=(None, None), after=')'): self.emit('name: \"{}\",'.format(route.name)) self.emit('version: {},'.format(route.version)) 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 _docf(self, tag, val): if tag == 'route': if ':' in val: val, version = val.split(':', 1) version = int(version) else: version = 1 return fmt_func(val, version) 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 _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 txt = 'return client.request({})'.format( self._func_args(return_args, not_init=True) ) self.emit(txt) self.emit()