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 _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_class(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_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_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_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_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_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_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 _generate_enumerated_subtype_deserializer(self, namespace, data_type):
self.emit('let tag = Serialization.getTag(dict)')
with self.block('switch tag'):
for tags, subtype in data_type.get_all_subtypes_with_tags():
assert len(tags) == 1, tags
tag = tags[0]
self.emit('case "{}":'.format(tag))
with self.indent():
self.emit('return {}.deserialize(json)'.format(fmt_serial_obj(subtype)))
self.emit('default:')
with self.indent():
if data_type.is_catch_all():
self._generate_struct_base_class_deserializer(namespace, data_type)
else:
self.emit('fatalError("Unknown tag \\(tag)")')
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_deserializer(self, namespace, data_type):
self.emit('let tag = Serialization.getTag(dict)')
with self.block('switch tag'):
for tags, subtype in data_type.get_all_subtypes_with_tags():
assert len(tags) == 1, tags
tag = tags[0]
self.emit('case "{}":'.format(tag))
with self.indent():
self.emit('return {}.deserialize(json)'.format(fmt_serial_obj(subtype)))
self.emit('default:')
with self.indent():
if data_type.is_catch_all():
self._generate_struct_base_class_deserializer(namespace, data_type)
else:
self.emit('fatalError("Unknown tag \\(tag)")')
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_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")')
