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_struct_class(self, namespace, data_type): if data_type.doc: doc = self.process_doc(data_type.doc, self._docf) else: doc = 'The {} struct'.format(fmt_class(data_type.name)) self.emit_wrapped_text(doc, prefix='/// ', width=120) protocols = [] if not data_type.parent_type: protocols.append('CustomStringConvertible') with self.class_block(data_type, protocols=protocols): for field in data_type.fields: fdoc = self.process_doc( field.doc, self._docf) if field.doc else undocumented self.emit_wrapped_text(fdoc, prefix='/// ', width=120) self.emit('open let {}: {}'.format( fmt_var(field.name), fmt_type(field.data_type), )) self._generate_struct_init(namespace, data_type) decl = 'open var' if not data_type.parent_type else 'open override var' with self.block('{} description: String'.format(decl)): cls = fmt_class(data_type.name) + 'Serializer' self.emit( 'return "\\(SerializeUtil.prepareJSONForSerialization' + '({}().serialize(self)))"'.format(cls)) self._generate_struct_class_serializer(namespace, data_type)
def _generate_struct_class_serializer(self, namespace, data_type): with self.serializer_block(data_type): with self.serializer_func(data_type): if not data_type.all_fields: self.emit('let output = [String: JSON]()') else: intro = 'var' if data_type.has_enumerated_subtypes() else 'let' self.emit("{} output = [ ".format(intro)) for field in data_type.all_fields: self.emit('"{}": {}.serialize(value.{}),'.format( field.name, fmt_serial_obj(field.data_type), fmt_var(field.name) )) self.emit(']') if data_type.has_enumerated_subtypes(): self._generate_enumerated_subtype_serializer(namespace, data_type) self.emit('return .Dictionary(output)') with self.deserializer_func(data_type): with self.block("switch json"): self.emit("case .Dictionary(let dict):") with self.indent(): if data_type.has_enumerated_subtypes(): self._generate_enumerated_subtype_deserializer(namespace, data_type) else: self._generate_struct_base_class_deserializer(namespace, data_type) self.emit("default:") with self.indent(): self.emit('fatalError("Type error deserializing")')
def _generate_union_type(self, namespace, data_type): if data_type.doc: doc = self.process_doc(data_type.doc, self._docf) else: doc = 'The {} union'.format(fmt_class(data_type.name)) self.emit_wrapped_text(doc, prefix='/// ', width=120) class_type = fmt_class(data_type.name) with self.block( 'public enum {}: CustomStringConvertible'.format(class_type)): for field in data_type.all_fields: typ = self._format_tag_type(namespace, field.data_type) fdoc = self.process_doc( field.doc, self._docf) if field.doc else 'An unspecified error.' self.emit_wrapped_text(fdoc, prefix='/// ', width=120) self.emit('case {}{}'.format(fmt_var(field.name), typ)) self.emit() with self.block('public var description: String'): cls = class_type + 'Serializer' self.emit( 'return "\\(SerializeUtil.prepareJSONForSerialization' + '({}().serialize(self)))"'.format(cls)) self._generate_union_serializer(data_type)
def _generate_struct_class(self, namespace, data_type): if data_type.doc: doc = self.process_doc(data_type.doc, self._docf) else: doc = 'The {} struct'.format(fmt_class(data_type.name)) self.emit_wrapped_text(doc, prefix='/// ', width=120) protocols = [] if not data_type.parent_type: protocols.append('CustomStringConvertible') with self.class_block(data_type, protocols=protocols): for field in data_type.fields: fdoc = self.process_doc(field.doc, self._docf) if field.doc else undocumented self.emit_wrapped_text(fdoc, prefix='/// ', width=120) self.emit('public let {}: {}'.format( fmt_var(field.name), fmt_type(field.data_type), )) self._generate_struct_init(namespace, data_type) decl = 'public var' if not data_type.parent_type else 'public override var' with self.block('{} description: String'.format(decl)): cls = fmt_class(data_type.name)+'Serializer' self.emit('return "\(SerializeUtil.prepareJSONForSerialization' + '({}().serialize(self)))"'.format(cls)) self._generate_struct_class_serializer(namespace, data_type)
def _generate_struct_class_serializer(self, namespace, data_type): with self.serializer_block(data_type): with self.serializer_func(data_type): if not data_type.all_fields: self.emit('let output = [String: JSON]()') else: intro = 'var' if data_type.has_enumerated_subtypes( ) else 'let' self.emit("{} output = [ ".format(intro)) for field in data_type.all_fields: self.emit('"{}": {}.serialize(value.{}),'.format( field.name, fmt_serial_obj(field.data_type), fmt_var(field.name))) self.emit(']') if data_type.has_enumerated_subtypes(): self._generate_enumerated_subtype_serializer( namespace, data_type) self.emit('return .dictionary(output)') with self.deserializer_func(data_type): with self.block("switch json"): dict_name = "let dict" if data_type.all_fields else "_" self.emit("case .dictionary({}):".format(dict_name)) with self.indent(): if data_type.has_enumerated_subtypes(): self._generate_enumerated_subtype_deserializer( namespace, data_type) else: self._generate_struct_base_class_deserializer( namespace, data_type) self.emit("default:") with self.indent(): self.emit('fatalError("Type error deserializing")')
def _generate_struct_init(self, namespace, data_type): # pylint: disable=unused-argument # init method args = self._struct_init_args(data_type) if data_type.parent_type and not data_type.fields: return with self.function_block('public init', self._func_args(args)): for field in data_type.fields: v = fmt_var(field.name) validator = self._determine_validator_type(field.data_type, v) if validator: self.emit('{}({})'.format(validator, v)) self.emit('self.{} = {}'.format(v, v)) if data_type.parent_type: func_args = [(fmt_var(f.name), fmt_var(f.name)) for f in data_type.parent_type.all_fields] self.emit('super.init({})'.format(self._func_args(func_args)))
def _generate_union_serializer(self, data_type): with self.serializer_block(data_type): with self.serializer_func(data_type), self.block('switch value'): for field in data_type.all_fields: field_type = field.data_type case = '.{}{}'.format(fmt_var(field.name), '' if is_void_type(field_type) else '(let arg)') self.emit('case {}:'.format(case)) with self.indent(): if is_void_type(field_type): self.emit('var d = [String: JSON]()') elif (is_struct_type(field_type) and not field_type.has_enumerated_subtypes()): self.emit('var d = Serialization.getFields({}.serialize(arg))'.format( fmt_serial_obj(field_type))) else: self.emit('var d = ["{}": {}.serialize(arg)]'.format( field.name, fmt_serial_obj(field_type))) self.emit('d[".tag"] = .str("{}")'.format(field.name)) self.emit('return .dictionary(d)') with self.deserializer_func(data_type): with self.block("switch json"): self.emit("case .dictionary(let d):") with self.indent(): self.emit('let tag = Serialization.getTag(d)') with self.block('switch tag'): for field in data_type.all_fields: field_type = field.data_type self.emit('case "{}":'.format(field.name)) tag_type = self._tag_type(data_type, field) with self.indent(): if is_void_type(field_type): self.emit('return {}'.format(tag_type)) else: if (is_struct_type(field_type) and not field_type.has_enumerated_subtypes()): subdict = 'json' else: subdict = 'd["{}"] ?? .null'.format(field.name) self.emit('let v = {}.deserialize({})'.format( fmt_serial_obj(field_type), subdict )) self.emit('return {}(v)'.format(tag_type)) self.emit('default:') with self.indent(): if data_type.catch_all_field: self.emit('return {}'.format( self._tag_type(data_type, data_type.catch_all_field) )) else: self.emit('fatalError("Unknown tag \(tag)")') self.emit("default:") with self.indent(): self.emit('fatalError("Failed to deserialize")')
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 _generate_union_serializer(self, data_type): with self.serializer_block(data_type): with self.serializer_func(data_type), self.block('switch value'): for field in data_type.all_fields: field_type = field.data_type case = '.{}{}'.format(fmt_var(field.name), '' if is_void_type(field_type) else '(let arg)') self.emit('case {}:'.format(case)) with self.indent(): if is_void_type(field_type): self.emit('var d = [String: JSON]()') elif (is_struct_type(field_type) and not field_type.has_enumerated_subtypes()): self.emit('var d = Serialization.getFields({}.serialize(arg))'.format( fmt_serial_obj(field_type))) else: self.emit('var d = ["{}": {}.serialize(arg)]'.format( field.name, fmt_serial_obj(field_type))) self.emit('d[".tag"] = .str("{}")'.format(field.name)) self.emit('return .dictionary(d)') with self.deserializer_func(data_type): with self.block("switch json"): self.emit("case .dictionary(let d):") with self.indent(): self.emit('let tag = Serialization.getTag(d)') with self.block('switch tag'): for field in data_type.all_fields: field_type = field.data_type self.emit('case "{}":'.format(field.name)) tag_type = self._tag_type(data_type, field) with self.indent(): if is_void_type(field_type): self.emit('return {}'.format(tag_type)) else: if (is_struct_type(field_type) and not field_type.has_enumerated_subtypes()): subdict = 'json' else: subdict = 'd["{}"] ?? .null'.format(field.name) self.emit('let v = {}.deserialize({})'.format( fmt_serial_obj(field_type), subdict )) self.emit('return {}(v)'.format(tag_type)) self.emit('default:') with self.indent(): if data_type.catch_all_field: self.emit('return {}'.format( self._tag_type(data_type, data_type.catch_all_field) )) else: self.emit('fatalError("Unknown tag \\(tag)")') self.emit("default:") with self.indent(): self.emit('fatalError("Failed to deserialize")')
def _generate_struct_init(self, namespace, data_type): # init method args = self._struct_init_args(data_type) if data_type.parent_type and not data_type.fields: return with self.function_block('public init', self._func_args(args)): for field in data_type.fields: v = fmt_var(field.name) validator = self._determine_validator_type(field.data_type, v) if validator: self.emit('{}({})'.format(validator, v)) self.emit('self.{} = {}'.format(v, v)) if data_type.parent_type: func_args = [(fmt_var(f.name), fmt_var(f.name)) for f in data_type.parent_type.all_fields] self.emit('super.init({})'.format(self._func_args(func_args)))
def _get_route_args(self, namespace, route): data_type = route.arg_data_type arg_type = fmt_type(data_type) if is_struct_type(data_type): arg_list = self._struct_init_args(data_type, namespace=namespace) doc_list = [(fmt_var(f.name), self.process_doc(f.doc, self._docf) if f.doc else undocumented) for f in data_type.fields if f.doc] elif is_union_type(data_type): arg_list = [(fmt_var(data_type.name), '{}.{}'.format( fmt_class(namespace.name), fmt_class(data_type.name)))] doc_list = [(fmt_var(data_type.name), self.process_doc(data_type.doc, self._docf) if data_type.doc else 'The {} union'.format(fmt_class(data_type.name)))] else: arg_list = [] if is_void_type(data_type) else [('request', arg_type)] doc_list = [] return arg_list, doc_list
def _struct_init_args(self, data_type, namespace=None): # pylint: disable=unused-argument args = [] for field in data_type.all_fields: name = fmt_var(field.name) value = fmt_type(field.data_type) data_type, nullable = unwrap_nullable(field.data_type) if field.has_default: if is_union_type(data_type): default = '.{}'.format(fmt_var(field.default.tag_name)) else: default = fmt_obj(field.default) value += ' = {}'.format(default) elif nullable: value += ' = nil' arg = (name, value) args.append(arg) return args
def _struct_init_args(self, data_type, namespace=None): args = [] for field in data_type.all_fields: name = fmt_var(field.name) value = fmt_type(field.data_type) data_type, nullable = unwrap_nullable(field.data_type) if field.has_default: if is_union_type(data_type): default = '.{}'.format(fmt_var(field.default.tag_name)) else: default = fmt_obj(field.default) value += ' = {}'.format(default) elif nullable: value += ' = nil' arg = (name, value) args.append(arg) return args
def _get_route_args(self, namespace, route): arg_type = self._swift_type_mapping(route.arg_data_type) if is_struct_type(route.arg_data_type): arg_list = self._struct_init_args(route.arg_data_type, namespace=namespace) doc_list = [(fmt_var(f.name), self.process_doc(f.doc, self._docf)) for f in route.arg_data_type.fields if f.doc] else: arg_list = [] if is_void_type(route.arg_data_type) else [('request', arg_type)] doc_list = [] return arg_list, doc_list
def _generate_struct_base_class_deserializer(self, namespace, data_type): args = [] for field in data_type.all_fields: var = fmt_var(field.name) self.emit('let {} = {}.deserialize(dict["{}"] ?? .Null)'.format( var, fmt_serial_obj(field.data_type), field.name, )) args.append((var, var)) self.emit('return {}({})'.format(fmt_class(data_type.name), self._func_args(args)))
def _generate_struct_base_class_deserializer(self, namespace, data_type): args = [] for field in data_type.all_fields: var = fmt_var(field.name) value = 'dict["{}"]'.format(field.name) self.emit('let {} = {}.deserialize({} ?? {})'.format( var, fmt_serial_obj(field.data_type), value, fmt_default_value(namespace, field) if field.has_default else '.null')) args.append((var, var)) self.emit('return {}({})'.format(fmt_class(data_type.name), self._func_args(args)))
def _get_route_args(self, namespace, route): data_type = route.arg_data_type arg_type = fmt_type(data_type) if is_struct_type(data_type): arg_list = self._struct_init_args(data_type, namespace=namespace) doc_list = [(fmt_var(f.name), self.process_doc(f.doc, self._docf) if f.doc else undocumented) for f in data_type.fields if f.doc] elif is_union_type(data_type): arg_list = [(fmt_var(data_type.name), '{}.{}'.format(fmt_class(namespace.name), fmt_class(data_type.name)))] doc_list = [ (fmt_var(data_type.name), self.process_doc(data_type.doc, self._docf) if data_type.doc else 'The {} union'.format(fmt_class(data_type.name))) ] else: arg_list = [] if is_void_type(data_type) else [('request', arg_type)] doc_list = [] return arg_list, doc_list
def _generate_struct_base_class_deserializer(self, namespace, data_type): args = [] for field in data_type.all_fields: var = fmt_var(field.name) self.emit('let {} = {}.deserialize(dict["{}"] ?? .Null)'.format( var, fmt_serial_obj(field.data_type), field.name, )) args.append((var, var)) self.emit('return {}({})'.format( fmt_class(data_type.name), self._func_args(args) ))
def _generate_enumerated_subtype_serializer(self, namespace, data_type): with self.block('switch value'): for tags, subtype in data_type.get_all_subtypes_with_tags(): assert len(tags) == 1, tags tag = tags[0] tagvar = fmt_var(tag) self.emit('case let {} as {}:'.format(tagvar, fmt_type(subtype))) with self.indent(): with self.block( 'for (k,v) in Serialization.getFields({}.serialize({}))' .format(fmt_serial_obj(subtype), tagvar)): self.emit('output[k] = v') self.emit('output[".tag"] = .Str("{}")'.format(tag)) self.emit( 'default: fatalError("Tried to serialize unexpected subtype")')
def _generate_struct_base_class_deserializer(self, namespace, data_type): args = [] for field in data_type.all_fields: var = fmt_var(field.name) value = 'dict["{}"]'.format(field.name) self.emit('let {} = {}.deserialize({} ?? {})'.format( var, fmt_serial_obj(field.data_type), value, fmt_default_value(namespace, field) if field.has_default else '.null' )) args.append((var, var)) self.emit('return {}({})'.format( fmt_class(data_type.name), self._func_args(args) ))
def _generate_enumerated_subtype_serializer(self, namespace, data_type): with self.block('switch value'): for tags, subtype in data_type.get_all_subtypes_with_tags(): assert len(tags) == 1, tags tag = tags[0] tagvar = fmt_var(tag) self.emit('case let {} as {}:'.format( tagvar, fmt_type(subtype) )) with self.indent(): with self.block('for (k,v) in Serialization.getFields({}.serialize({}))'.format( fmt_serial_obj(subtype), tagvar )): self.emit('output[k] = v') self.emit('output[".tag"] = .Str("{}")'.format(tag)) self.emit('default: fatalError("Tried to serialize unexpected subtype")')
def _generate_union_type(self, namespace, data_type): if data_type.doc: doc = self.process_doc(data_type.doc, self._docf) else: doc = 'The {} union'.format(fmt_class(data_type.name)) self.emit_wrapped_text(doc, prefix='/// ', width=120) class_type = fmt_class(data_type.name) with self.block('public enum {}: CustomStringConvertible'.format(class_type)): for field in data_type.all_fields: typ = self._format_tag_type(namespace, field.data_type) fdoc = self.process_doc(field.doc, self._docf) if field.doc else 'An unspecified error.' self.emit_wrapped_text(fdoc, prefix='/// ', width=120) self.emit('case {}{}'.format(fmt_var(field.name), typ)) self.emit() with self.block('public var description: String'): cls = class_type + 'Serializer' self.emit('return "\\(SerializeUtil.prepareJSONForSerialization' + '({}().serialize(self)))"'.format(cls)) self._generate_union_serializer(data_type)
def _struct_init_args(self, data_type, namespace=None): args = [] for field in data_type.all_fields: name = fmt_var(field.name) value = self._swift_type_mapping(field.data_type) field_type = field.data_type if is_nullable_type(field_type): field_type = field_type.data_type nullable = True else: nullable = False if field.has_default: if is_union_type(field_type): default = '.{}'.format(fmt_class(field.default.tag_name)) else: default = fmt_obj(field.default) value += ' = {}'.format(default) elif nullable: value += ' = nil' arg = (name, value) args.append(arg) return args
def _tag_type(self, data_type, field): return "{}.{}".format( fmt_class(data_type.name), fmt_var(field.name) )
def _tag_type(self, data_type, field): return "{}.{}".format(fmt_class(data_type.name), fmt_var(field.name))
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()