def _fmt_default(self, data_type):
data_type, nullable = unwrap_nullable(data_type)
result = 'DEFAULT'
if nullable:
return 'nil'
if is_user_defined_type(data_type):
result = fmt_func_call(fmt_alloc_call(fmt_class_prefix(data_type)),
'init', [])
elif is_list_type(data_type):
result = fmt_func_call(fmt_alloc_call('NSArray'), 'init', [])
elif is_numeric_type(data_type):
if is_float_type(data_type):
result = '[NSNumber numberWithDouble:5]'
else:
result = '[NSNumber numberWithInt:5]'
elif is_timestamp_type(data_type):
result = '[[NSDateFormatter new] setDateFormat:[self convertFormat:@"test"]]'
elif is_string_type(data_type):
result = '@"teststring"'
elif is_boolean_type(data_type):
result = '@YES'
return result
def generate_validator_constructor(ns, data_type):
"""
Given a Stone data type, returns a string that can be used to construct
the appropriate validation object in Python.
"""
dt, nullable_dt = unwrap_nullable(data_type)
if is_list_type(dt):
v = generate_func_call(
'bv.List',
args=[
generate_validator_constructor(ns, dt.data_type)],
kwargs=[
('min_items', dt.min_items),
('max_items', dt.max_items)],
)
elif is_numeric_type(dt):
v = generate_func_call(
'bv.{}'.format(dt.name),
kwargs=[
('min_value', dt.min_value),
('max_value', dt.max_value)],
)
elif is_string_type(dt):
pattern = None
if dt.pattern is not None:
pattern = repr(dt.pattern)
v = generate_func_call(
'bv.String',
kwargs=[
('min_length', dt.min_length),
('max_length', dt.max_length),
('pattern', pattern)],
)
elif is_timestamp_type(dt):
v = generate_func_call(
'bv.Timestamp',
args=[repr(dt.format)],
)
elif is_user_defined_type(dt):
v = fmt_class(dt.name) + '_validator'
if ns.name != dt.namespace.name:
v = '{}.{}'.format(dt.namespace.name, v)
elif is_alias(dt):
# Assume that the alias has already been declared elsewhere.
name = fmt_class(dt.name) + '_validator'
if ns.name != dt.namespace.name:
name = '{}.{}'.format(dt.namespace.name, name)
v = name
elif is_boolean_type(dt) or is_bytes_type(dt) or is_void_type(dt):
v = generate_func_call('bv.{}'.format(dt.name))
else:
raise AssertionError('Unsupported data type: %r' % dt)
if nullable_dt:
return generate_func_call('bv.Nullable', args=[v])
else:
return v
def generate_validator_constructor(ns, data_type):
"""
Given a Stone data type, returns a string that can be used to construct
the appropriate validation object in Python.
"""
dt, nullable_dt = unwrap_nullable(data_type)
if is_list_type(dt):
v = generate_func_call(
'bv.List',
args=[
generate_validator_constructor(ns, dt.data_type)],
kwargs=[
('min_items', dt.min_items),
('max_items', dt.max_items)],
)
elif is_numeric_type(dt):
v = generate_func_call(
'bv.{}'.format(dt.name),
kwargs=[
('min_value', dt.min_value),
('max_value', dt.max_value)],
)
elif is_string_type(dt):
pattern = None
if dt.pattern is not None:
pattern = repr(dt.pattern)
v = generate_func_call(
'bv.String',
kwargs=[
('min_length', dt.min_length),
('max_length', dt.max_length),
('pattern', pattern)],
)
elif is_timestamp_type(dt):
v = generate_func_call(
'bv.Timestamp',
args=[repr(dt.format)],
)
elif is_user_defined_type(dt):
v = fmt_class(dt.name) + '_validator'
if ns.name != dt.namespace.name:
v = '{}.{}'.format(dt.namespace.name, v)
elif is_alias(dt):
# Assume that the alias has already been declared elsewhere.
name = fmt_class(dt.name) + '_validator'
if ns.name != dt.namespace.name:
name = '{}.{}'.format(dt.namespace.name, name)
v = name
elif is_boolean_type(dt) or is_bytes_type(dt) or is_void_type(dt):
v = generate_func_call('bv.{}'.format(dt.name))
else:
raise AssertionError('Unsupported data type: %r' % dt)
if nullable_dt:
return generate_func_call('bv.Nullable', args=[v])
else:
return v
def fmt_default_value(field):
if is_tag_ref(field.default):
return '[[{} alloc] initWith{}]'.format(
fmt_class_prefix(field.default.union_data_type),
fmt_class(field.default.tag_name))
elif is_numeric_type(field.data_type):
return '@({})'.format(field.default)
elif is_boolean_type(field.data_type):
if field.default:
bool_str = 'YES'
else:
bool_str = 'NO'
return '@{}'.format(bool_str)
else:
raise TypeError('Can\'t handle default value type %r' %
type(field.data_type))
def fmt_ns_number_call(data_type):
result = ''
if is_numeric_type(data_type):
if isinstance(data_type, UInt32):
result = 'numberWithUnsignedInt'
elif isinstance(data_type, UInt64):
result = 'numberWithUnsignedLong'
elif isinstance(data_type, Int32):
result = 'numberWithInt'
elif isinstance(data_type, Int64):
result = 'numberWithLong'
elif isinstance(data_type, Float32):
result = 'numberWithDouble'
elif isinstance(data_type, Float64):
result = 'numberWithDouble'
elif is_boolean_type:
result = 'numberWithBool'
return result
def fmt_ns_number_call(data_type):
result = ''
if is_numeric_type(data_type):
if isinstance(data_type, UInt32):
result = 'numberWithUnsignedInt'
elif isinstance(data_type, UInt64):
result = 'numberWithUnsignedLong'
elif isinstance(data_type, Int32):
result = 'numberWithInt'
elif isinstance(data_type, Int64):
result = 'numberWithLong'
elif isinstance(data_type, Float32):
result = 'numberWithDouble'
elif isinstance(data_type, Float64):
result = 'numberWithDouble'
elif is_boolean_type(data_type):
result = 'numberWithBool'
return result
def fmt_default_value(field):
if is_tag_ref(field.default):
return '[[{} alloc] initWith{}]'.format(
fmt_class_prefix(field.default.union_data_type),
fmt_class(field.default.tag_name))
elif is_numeric_type(field.data_type):
return '@({})'.format(field.default)
elif is_boolean_type(field.data_type):
if field.default:
bool_str = 'YES'
else:
bool_str = 'NO'
return '@{}'.format(bool_str)
elif is_string_type(field.data_type):
return '@"{}"'.format(field.default)
else:
raise TypeError('Can\'t handle default value type %r' %
type(field.data_type))
def _determine_validator_type(self, data_type):
if is_nullable_type(data_type):
data_type = data_type.data_type
nullable = True
else:
nullable = False
if is_list_type(data_type):
item_validator = self._determine_validator_type(data_type.data_type)
if item_validator:
v = "arrayValidator({})".format(
self._func_args([
("minItems", data_type.min_items),
("maxItems", data_type.max_items),
("itemValidator", item_validator),
])
)
else:
return None
elif is_numeric_type(data_type):
v = "comparableValidator({})".format(
self._func_args([
("minValue", data_type.min_value),
("maxValue", data_type.max_value),
])
)
elif is_string_type(data_type):
pat = data_type.pattern if data_type.pattern else None
if isinstance(pat, six.text_type):
pat = pat.encode('unicode_escape')
v = "stringValidator({})".format(
self._func_args([
("minLength", data_type.min_length),
("maxLength", data_type.max_length),
("pattern", '"{}"'.format(pat) if pat else None),
])
)
else:
return None
if nullable:
v = "nullableValidator({})".format(v)
return v
def fmt_default_value(namespace, field):
if is_tag_ref(field.default):
return '{}.{}Serializer().serialize(.{})'.format(
fmt_class(namespace.name),
fmt_class(field.default.union_data_type.name),
fmt_var(field.default.tag_name))
elif is_list_type(field.data_type):
return '.array({})'.format(field.default)
elif is_numeric_type(field.data_type):
return '.number({})'.format(field.default)
elif is_string_type(field.data_type):
return '.str({})'.format(field.default)
elif is_boolean_type(field.data_type):
if field.default:
bool_str = '1'
else:
bool_str = '0'
return '.number({})'.format(bool_str)
else:
raise TypeError('Can\'t handle default value type %r' %
type(field.data_type))
def fmt_default_value(namespace, field):
if is_tag_ref(field.default):
return '{}.{}Serializer().serialize(.{})'.format(
fmt_class(namespace.name),
fmt_class(field.default.union_data_type.name),
fmt_var(field.default.tag_name))
elif is_list_type(field.data_type):
return '.array({})'.format(field.default)
elif is_numeric_type(field.data_type):
return '.number({})'.format(field.default)
elif is_string_type(field.data_type):
return '.str({})'.format(field.default)
elif is_boolean_type(field.data_type):
if field.default:
bool_str = '1'
else:
bool_str = '0'
return '.number({})'.format(bool_str)
else:
raise TypeError('Can\'t handle default value type %r' %
type(field.data_type))
def _determine_validator_type(self, data_type, value):
data_type, nullable = unwrap_nullable(data_type)
if is_list_type(data_type):
item_validator = self._determine_validator_type(data_type.data_type, value)
if item_validator:
v = "arrayValidator({})".format(
self._func_args([
("minItems", data_type.min_items),
("maxItems", data_type.max_items),
("itemValidator", item_validator),
])
)
else:
return None
elif is_numeric_type(data_type):
v = "comparableValidator({})".format(
self._func_args([
("minValue", data_type.min_value),
("maxValue", data_type.max_value),
])
)
elif is_string_type(data_type):
pat = data_type.pattern if data_type.pattern else None
pat = pat.encode('unicode_escape').replace("\"", "\\\"") if pat else pat
v = "stringValidator({})".format(
self._func_args([
("minLength", data_type.min_length),
("maxLength", data_type.max_length),
("pattern", '"{}"'.format(pat) if pat else None),
])
)
else:
return None
if nullable:
v = "nullableValidator({})".format(v)
return v
def _determine_validator_type(self, data_type, value):
data_type, nullable = unwrap_nullable(data_type)
if is_list_type(data_type):
item_validator = self._determine_validator_type(data_type.data_type, value)
if item_validator:
v = "arrayValidator({})".format(
self._func_args([
("minItems", data_type.min_items),
("maxItems", data_type.max_items),
("itemValidator", item_validator),
])
)
else:
return None
elif is_numeric_type(data_type):
v = "comparableValidator({})".format(
self._func_args([
("minValue", data_type.min_value),
("maxValue", data_type.max_value),
])
)
elif is_string_type(data_type):
pat = data_type.pattern if data_type.pattern else None
pat = pat.encode('unicode_escape').replace("\"", "\\\"") if pat else pat
v = "stringValidator({})".format(
self._func_args([
("minLength", data_type.min_length),
("maxLength", data_type.max_length),
("pattern", '"{}"'.format(pat) if pat else None),
])
)
else:
return None
if nullable:
v = "nullableValidator({})".format(v)
return v
def _get_example_data(self, example_value, field):
data_type, nullable = unwrap_nullable(field.data_type)
field_name = fmt_var(field.name)
result_args = []
if is_user_defined_type(data_type):
obj_args = []
if is_union_type(data_type):
for field in data_type.all_fields:
if field.name == example_value['.tag']:
if not is_void_type(field.data_type):
if field.name in example_value:
self._get_example_data(
example_value[field.name], field)
else:
self._get_example_data(example_value, field)
obj_args.append(
(fmt_var(field.name), fmt_var(field.name)))
field_value = fmt_func_call(
caller=fmt_alloc_call(fmt_class_prefix(data_type)),
callee='initWith{}'.format(
fmt_camel_upper(example_value['.tag'])),
args=fmt_func_args(obj_args))
self.emit('{} *{} = {};'.format(fmt_class_prefix(data_type),
field_name, field_value))
else:
if data_type.has_enumerated_subtypes():
for tags, subtype in data_type.get_all_subtypes_with_tags(
):
assert len(tags) == 1, tags
tag = tags[0]
if tag == example_value['.tag']:
self._get_example_data(example_value, subtype)
else:
for field in data_type.all_fields:
if field.name in example_value:
obj_args.append((fmt_var(field.name),
self._get_example_data(
example_value[field.name],
field.data_type)))
else:
if not is_void_type(field.data_type):
obj_args.append(
(fmt_var(field.name),
self._fmt_default(field.data_type)))
field_value = fmt_func_call(
fmt_alloc_call(fmt_class_prefix(data_type)),
'initWith{}'.format(
fmt_camel_upper(data_type.all_fields[0].name)),
fmt_func_args(obj_args))
self.emit('{} *{} = {};'.format(
fmt_class_prefix(data_type), field_name, field_value))
result_args.append((field_name, field_name))
elif is_list_type(data_type):
if example_value:
field_value = '@[{}]'.format(
self._get_example_data(example_value[0], field))
else:
field_value = 'nil'
self.emit('NSArray *{} = {};'.format(field_name, field_value))
result_args.append((field_name, field_name))
elif is_numeric_type(data_type):
if is_float_type(data_type):
field_value = '[NSNumber numberWithDouble:{}]'.format(
example_value)
elif isinstance(data_type, (UInt64, Int64)):
field_value = '[NSNumber numberWithLong:{}]'.format(
example_value)
else:
field_value = '[NSNumber numberWithInt:{}]'.format(
example_value)
result_args.append((field_name, field_value))
elif is_timestamp_type(data_type):
field_value = '[DbxNSDateSerializer deserialize:@"{}" dateFormat:@"{}"]'.format(
example_value, data_type.format)
self.emit('NSDate *{} = {};'.format(field_name, field_value))
result_args.append((field_name, field_name))
elif is_string_type(data_type):
field_value = '@"{}"'.format(example_value)
result_args.append((field_name, field_value))
elif is_boolean_type(data_type):
field_value = '@YES' if bool(example_value) else '@NO'
result_args.append((field_name, field_value))
return result_args
