def java_write_protocol(self, value, depth=0): key_ttype = self.key_type.thrift_ttype_name() key_type_name = self.key_type.java_declaration_name(boxed=True) key_write_protocol = \ indent(' ' * 4, self.key_type.java_write_protocol( "_iter%(depth)u.getKey()" % locals(), depth=depth + 1 ) ) value_ttype = self.value_type.thrift_ttype_name() value_type_name = self.value_type.java_declaration_name(boxed=True) value_write_protocol = \ indent(' ' * 4, self.value_type.java_write_protocol( "_iter%(depth)u.getValue()" % locals(), depth=depth + 1 ) ) return """\ oprot.writeMapBegin(org.thryft.protocol.Type.%(key_ttype)s, org.thryft.protocol.Type.%(value_ttype)s, %(value)s.size()); for (com.google.common.collect.ImmutableMap.Entry<%(key_type_name)s, %(value_type_name)s> _iter%(depth)u : %(value)s.entrySet()) { %(key_write_protocol)s %(value_write_protocol)s } oprot.writeMapEnd();""" % locals()
def js_validation(self): try: validation = self.annotations['validation'].copy() except KeyError: validation = {} validation['required'] = self.required name = self.js_name() qname = self.js_qname() validation.update(self.type.js_validation(depth=0, value='value', value_name=qname)) type_validation = validation.pop('type') if not self.required: type_validation = indent(' ' * 4, type_validation) type_validation = """\ if (typeof attr !== "undefined" && attr !== "null") { %(type_validation)s } """ % locals() type_validation = indent(' ' * 8, type_validation) validation = json.dumps(validation).lstrip('{').rstrip('}') return """\ %(name)s: { "fn": function(value, attr, computedState) { %(type_validation)s }, %(validation)s }""" % locals()
def __repr__(self): extends = self.java_extends() if extends is None: extends = '' else: extends = ' extends ' + extends javadoc = self.java_doc() name = self.java_name() sections = [] message_types = [] for function in self.functions: message_types.extend(function.java_message_types()) if len(message_types) > 0: message_types = \ "\n\n".join(indent(' ' * 4, (repr(message_type) for message_type in message_types) )) sections.append("""\ public static class Messages { %(message_types)s }""" % locals()) sections.append("\n\n".join(repr(function) for function in self.functions)) sections = lpad("\n", "\n\n".join(indent(' ' * 4, sections))) return """\ %(javadoc)spublic interface %(name)s%(extends)s {%(sections)s }""" % locals()
def __repr__(self): extends = self.java_extends() if extends is None: extends = '' else: extends = ' extends ' + extends javadoc = self.java_doc() name = self.java_name() sections = [] message_types = [] for function in self.functions: message_types.extend(function.java_message_types()) if len(message_types) > 0: message_types = \ "\n\n".join(indent(' ' * 4, (repr(message_type) for message_type in message_types) )) sections.append("""\ public static class Messages { %(message_types)s }""" % locals()) sections.append("\n\n".join( repr(function) for function in self.functions)) sections = lpad("\n", "\n\n".join(indent(' ' * 4, sections))) return """\ %(javadoc)spublic interface %(name)s%(extends)s {%(sections)s }""" % locals()
def __repr__(self): class_annotations = [] if len(self.__suppress_warnings) > 0: class_annotations.append( "@SuppressWarnings({%s})" % \ ', '.join('"' + warning + '"' for warning in sorted(self.__suppress_warnings))) class_annotations = rpad("\n".join(class_annotations), "\n") class_modifiers = rpad(' '.join(self.__class_modifiers), ' ') javadoc = self.java_doc() name = self.java_name() extends = lpad(' extends ', self._java_extends()) implements = lpad(' implements ', ', '.join(self._java_implements())) methods = self._java_methods() sections = [] sections.append(indent(' ' * 4, repr(self._JavaBuilder(self)))) sections.append("\n\n".join(indent(' ' * 4, self._java_constructors() + \ [methods[key] for key in sorted(methods.iterkeys())]))) sections.append("\n\n".join( indent(' ' * 4, self._java_member_declarations()))) sections = lpad( "\n", "\n\n".join(section for section in sections if len(section) > 0)) return """\ %(javadoc)s%(class_annotations)s%(class_modifiers)sclass %(name)s%(extends)s%(implements)s {%(sections)s }""" % locals()
def java_write_protocol(self, value, depth=0): key_ttype = self.key_type.thrift_ttype_name() key_type_name = self.key_type.java_boxed_qname() key_write_protocol = \ indent(' ' * 4, self.key_type.java_write_protocol( "_iter%(depth)u.getKey()" % locals(), depth=depth + 1 ) ) value_ttype = self.value_type.thrift_ttype_name() value_type_name = self.value_type.java_boxed_qname() value_write_protocol = \ indent(' ' * 4, self.value_type.java_write_protocol( "_iter%(depth)u.getValue()" % locals(), depth=depth + 1 ) ) return """\ oprot.writeMapBegin(org.thryft.protocol.Type.%(key_ttype)s, org.thryft.protocol.Type.%(value_ttype)s, %(value)s.size()); for (com.google.common.collect.ImmutableMap.Entry<%(key_type_name)s, %(value_type_name)s> _iter%(depth)u : %(value)s.entrySet()) { %(key_write_protocol)s %(value_write_protocol)s } oprot.writeMapEnd();""" % locals()
def js_validation(self): validation = {} for annotation in self.annotations: if annotation.name == 'validation': validation = annotation.value.copy() break validation.pop('blank', None) validation['required'] = self.required name = self.js_name() qname = self.js_qname() validation.update( self.type.js_validation(depth=0, value='value', value_name=qname)) type_validation = validation.pop('type') if not self.required: type_validation = indent(' ' * 4, type_validation) type_validation = """\ if (typeof attr !== "undefined" && attr !== "null") { %(type_validation)s } """ % locals() type_validation = indent(' ' * 8, type_validation) validation = json.dumps(validation).lstrip('{').rstrip('}') return """\ %(name)s: { "fn": function(value, attr, computedState) { %(type_validation)s }, %(validation)s }""" % locals()
def cpp_to_string(self, depth, oss, value): key_to_string = \ indent(' ' * 2, self.key_type.cpp_to_string( depth=depth+1, oss=oss, value="i%(depth)u->first" % locals() ) ) value_to_string = \ indent(' ' * 2, self.value_type.cpp_to_string( depth=depth+1, oss=oss, value="i%(depth)u->second" % locals() ) ) qname = self.cpp_qname() return """\ oss << "{"; for (%(qname)s::const_iterator i%(depth)u = %(value)s.begin(); i%(depth)u != %(value)s.end(); ++i%(depth)u) { if (i%(depth)u != %(value)s.begin()) { oss << ", "; } %(key_to_string)s oss << ": "; %(value_to_string)s } oss << "]";""" % locals()
def cpp_sync_handler(self): name = self.cpp_name() response_name = upper_camelize(self.__parent_function.cpp_name()) + 'Response' if self.__parent_function.return_field is not None: call_prefix = "request.respond(%(response_name)s(" % locals() call_suffix = "))" else: call_prefix = '' call_suffix = """; request.respond(%(response_name)s())""" % locals() call_parameters = \ ', '.join("request.%s()" % parameter.cpp_getter_name() for parameter in self.fields) call_method_name = self.__parent_function.name call = "%(call_prefix)simpl_->%(call_method_name)s(%(call_parameters)s)%(call_suffix)s;" % locals() if len(self.__parent_function.throws) > 0: catches = [] for exception in self.__parent_function.throws: exception_name = exception.cpp_name() exception_type_qname = exception.type.cpp_qname() catches.append("""\ } catch (const %(exception_type_qname)s& %(exception_name)s) { request.respond(%(exception_name)s);""" % locals()) catches = "\n".join(catches) + "\n}" call = indent(' ' * 2, call) call = """\ try { %(call)s %(catches)s""" % locals() call = indent(' ' * 2, call) return """\ virtual void handle(const %(name)s& request) { %(call)s }""" % locals()
def __java_markers(self): service_marker_variable_name = service_marker_name = decamelize( self.name).upper() add_function_markers = [] function_markers = [] for function in self.functions: function_marker_variable_name = function.java_marker_variable_name( ) function_markers.append( "public final static org.slf4j.Marker %s = org.slf4j.MarkerFactory.getMarker(\"%s\");" % (function_marker_variable_name, function.java_marker_name())) add_function_markers.append( "%(service_marker_variable_name)s.add(%(function_marker_variable_name)s);" % locals()) add_function_markers = "\n".join( indent(' ' * 8, add_function_markers)) function_markers = "\n".join(indent(' ' * 4, function_markers)) return """\ public static class Markers { %(function_markers)s public final static org.slf4j.Marker %(service_marker_variable_name)s = org.slf4j.MarkerFactory.getMarker("%(service_marker_name)s"); static { %(add_function_markers)s } }""" % locals()
def js_validation(self, value, value_name, depth=0): key_type_validation = \ indent(' ' * 4, self.key_type.js_validation( depth=depth + 1, value="__key" % locals(), value_name=value_name + " key" % locals() )['type'] ) value_type_validation = \ indent(' ' * 4, self.value_type.js_validation( depth=depth + 1, value="__value" % locals(), value_name=value_name + " value" % locals() )['type'] ) return {'type': """\ if (typeof %(value)s !== "object") { return "expected %(value_name)s to be an object"; } for (var __key in %(value)s) { var __value = %(value)s[__key]; %(key_type_validation)s %(value_type_validation)s }""" % locals()}
def _py_constructor(self): assert len(self.fields) > 0 doc = indent(' ' * 4, "\n".join(field.py_sphinx_doc() for field in self.fields)) required_parameters = [] optional_parameters = [] for field in self.fields: parameter = field.py_parameter() if '=' in parameter: optional_parameters.append(parameter) else: required_parameters.append(parameter) parameters = "\n".join(indent(' ' * 4, required_parameters + optional_parameters)) initializers = \ "\n\n".join(indent(' ' * 4, (field.py_initializer() for field in self.fields) )) return """\ def __init__( self, %(parameters)s ): ''' %(doc)s ''' %(initializers)s """ % locals()
def _py_constructor(self): if len(self.fields) == 0: return None doc = indent(' ' * 4, "\n".join(field.py_sphinx_doc() for field in self.fields)) parameters = \ "\n".join(indent(' ' * 4, ( field.py_parameter(default_value='None') for field in self.fields ))) initializers = \ "\n".join(indent(' ' * 4, ('self.__%s = %s' % (field.py_name(), field.py_name()) for field in self.fields) )) return """\ def __init__( self, %(parameters)s ): ''' %(doc)s ''' %(initializers)s """ % locals()
def js_validation(self): validation = {} for annotation in self.annotations: if annotation.name == 'validation': validation = annotation.value.copy() break validation.pop('blank', None) validation['required'] = self.required name = self.js_name() qname = self.js_qname() validation.update(self.type.js_validation(depth=0, value='value', value_name=qname)) type_validation = validation.pop('type') if not self.required: type_validation = indent(' ' * 4, type_validation) type_validation = """\ if (typeof attr !== "undefined" && attr !== "null") { %(type_validation)s } """ % locals() type_validation = indent(' ' * 8, type_validation) validation = json.dumps(validation).lstrip('{').rstrip('}') return """\ %(name)s: { "fn": function(value, attr, computedState) { %(type_validation)s }, %(validation)s }""" % locals()
def _py_method_update(self): if len(self.fields) == 0: return {} doc = indent(' ' * 4, "\n".join(field.py_sphinx_doc() for field in self.fields)) name = self.py_name() other_name = decamelize(self.py_name()) object_updates = \ "\n".join(indent(' ' * 8, ("self.%s(%s.%s)" % (field.py_setter_name(), other_name, field.py_getter_call()) for field in self.fields) )) return {'update': """\ def update(self, %(other_name)s): ''' %(doc)s ''' if isinstance(%(other_name)s, %(name)s): %(object_updates)s elif isinstance(%(other_name)s, dict): for key, value in %(other_name)s.iteritems(): getattr(self, 'set_' + key)(value) else: raise TypeError(%(other_name)s) return self """ % locals()}
def _py_method_update(self): if len(self.fields) == 0: return {} doc = indent(" " * 4, "\n".join(field.py_sphinx_doc() for field in self.fields)) name = self.py_name() other_name = decamelize(self.py_name()) object_updates = "\n".join( indent( " " * 8, ( "self.%s(%s.%s)" % (field.py_setter_name(), other_name, field.py_getter_call()) for field in self.fields ), ) ) return { "update": """\ def update(self, %(other_name)s): ''' %(doc)s ''' if isinstance(%(other_name)s, %(name)s): %(object_updates)s elif isinstance(%(other_name)s, dict): for key, value in %(other_name)s.iteritems(): getattr(self, 'set_' + key)(value) else: raise TypeError(%(other_name)s) return self """ % locals() }
def _py_constructor(self): assert len(self.fields) > 0 doc = indent(" " * 4, "\n".join(field.py_sphinx_doc() for field in self.fields)) required_parameters = [] optional_parameters = [] for field in self.fields: parameter = field.py_parameter() if "=" in parameter: optional_parameters.append(parameter) else: required_parameters.append(parameter) parameters = "\n".join(indent(" " * 4, required_parameters + optional_parameters)) initializers = "\n\n".join(indent(" " * 4, (field.py_initializer() for field in self.fields))) return ( """\ def __init__( self, %(parameters)s ): ''' %(doc)s ''' %(initializers)s """ % locals() )
def java_definitions(self): annotations = lpad("\n", "\n".join(self.java_annotations())) name = self.java_name() public_parameters = \ ', '.join(parameter.java_parameter(final=True) for parameter in self.parameters) public_parameter_names = ', '.join( parameter.java_name() for parameter in self.parameters) parameter_validations = [] request_type_name = self.java_request_type().java_name() service_qname = JavaService.java_qname(self.parent) for parameter in self.parameters: parameter_name = parameter.java_name() parameter_validate_method_name = parameter.java_validate_method_name( ) parameter_validations.append( "%(service_qname)s.Messages.%(request_type_name)s.DefaultConstructionValidator.getInstance().%(parameter_validate_method_name)s(%(parameter_name)s);" % locals()) if len(parameter_validations) > 0: parameter_validations = \ "\n".join(indent(' ' * 4, parameter_validations)) validate_method_name = '_validate' + upper_camelize( self.name) + 'Parameters' validate_method = lpad( "\n\n", """\ protected void %(validate_method_name)s(%(public_parameters)s) { %(parameter_validations)s }""" % locals()) validate_method_call = lpad( "\n", indent( ' ' * 4, "%s(%s);" % (validate_method_name, public_parameter_names))) else: validate_method = validate_method_call = '' delegation = \ "delegate.%s(%s)" % (name, ', '.join(parameter.java_name() for parameter in self.parameters)) if self.return_field is not None: response_type_name = self.java_response_type().java_name() return_field_validate_method_name = self.return_field.java_validate_method_name( ) delegation = "return %(service_qname)s.Messages.%(response_type_name)s.DefaultConstructionValidator.getInstance().%(return_field_validate_method_name)s(%(delegation)s)" % locals( ) return_type_name = self.return_field.type.java_qname() else: return_type_name = 'void' throws = \ lpad( ' throws ', ', '.join(field.type.java_qname() for field in self.throws) ) return [ """\ @Override%(annotations)s public final %(return_type_name)s %(name)s(%(public_parameters)s)%(throws)s {%(validate_method_call)s %(delegation)s; }%(validate_method)s """ % locals() ] + self._java_delegating_definitions()
def js_validation(self, value, value_name, depth=0): key_type_validation = \ indent(' ' * 4, self.key_type.js_validation( depth=depth + 1, value="__key" % locals(), value_name=value_name + " key" % locals() )['type'] ) value_type_validation = \ indent(' ' * 4, self.value_type.js_validation( depth=depth + 1, value="__value" % locals(), value_name=value_name + " value" % locals() )['type'] ) return { 'type': """\ if (typeof %(value)s !== "object") { return "expected %(value_name)s to be an object"; } for (var __key in %(value)s) { var __value = %(value)s[__key]; %(key_type_validation)s %(value_type_validation)s }""" % locals() }
def js_write_protocol(self, value, depth=0): key_ttype_id = self.key_type.thrift_ttype_id() key_write_protocol = \ indent(' ' * 4, self.key_type.js_write_protocol( "__key%(depth)u" % locals(), depth=depth + 1 ) ) value_ttype_id = self.value_type.thrift_ttype_id() value_write_protocol = \ indent(' ' * 4, self.value_type.js_write_protocol( "__map%(depth)u[__key%(depth)u]" % locals(), depth=depth + 1 ) ) return """\ var __map%(depth)u = %(value)s; var __mapSize%(depth)u = 0; for (var __key%(depth)u in __map%(depth)u) { __mapSize%(depth)u++; } oprot.writeMapBegin(%(key_ttype_id)u, %(value_ttype_id)u, __mapSize%(depth)u); for (var __key%(depth)u in __map%(depth)u) { %(key_write_protocol)s %(value_write_protocol)s } oprot.writeMapEnd();""" % locals()
def dart_repr(self): name = self.dart_name() sections = [] sections.append(indent(' ' * 2, "\n".join(self._dart_member_declarations()))) sections.append(indent(' ' * 2, "\n\n".join(self._dart_methods()))) sections = lpad("\n", "\n\n".join(section for section in sections if len(section) > 0)) return """\ class %(name)s {%(sections)s }""" % locals()
def _java_method_write(self): case_ttype_void = 'case VOID:' if len(self.fields) == 1: field = self.fields[0] from thryft.generators.java._java_container_type import _JavaContainerType from thryft.generators.java.java_struct_type import JavaStructType if isinstance(field.type, _JavaContainerType) or isinstance(field.type, JavaStructType): field_value_java_write_protocol = \ indent(' ' * 12, field.type.java_write_protocol(field.java_getter_name() + (field.required and '()' or '().get()'), depth=0)) field_thrift_ttype_name = field.type.thrift_ttype_name() case_ttype_void = """\ %(case_ttype_void)s { %(field_value_java_write_protocol)s break; } """ % locals() field_count = len(self.fields) field_write_protocols = \ lpad("\n\n", "\n\n".join(indent(' ' * 12, (field.java_write_protocol(depth=0, write_field=True) for field in self.fields) ))) field_value_write_protocols = \ pad("\n\n", "\n\n".join(indent(' ' * 12, (field.java_write_protocol(depth=0, write_field=False) for field in self.fields) )), "\n") name = self.java_name() return {'write': """\ @Override public void write(final org.thryft.protocol.OutputProtocol oprot) throws org.thryft.protocol.OutputProtocolException { write(oprot, org.thryft.protocol.Type.STRUCT); } public void write(final org.thryft.protocol.OutputProtocol oprot, final org.thryft.protocol.Type writeAsType) throws org.thryft.protocol.OutputProtocolException { switch (writeAsType) { %(case_ttype_void)s case LIST: oprot.writeListBegin(org.thryft.protocol.Type.VOID, %(field_count)u);%(field_value_write_protocols)s oprot.writeListEnd(); break; case STRUCT: default: oprot.writeStructBegin(\"%(name)s\");%(field_write_protocols)s oprot.writeFieldStop(); oprot.writeStructEnd(); break; } } """ % locals()}
def __repr__(self): extends = ', '.join(self._py_extends()) sections = [] sections.append(indent(' ' * 4, repr(self._PyBuilder(self)))) sections.append(indent(' ' * 4, "\n".join(self._py_methods()))) sections = "\n\n".join(sections) name = self.py_name() return """\ class %(name)s(%(extends)s): %(sections)s""" % locals()
def _cpp_method_write(self): case_ttype_void = 'case ::thryft::protocol::Type::VOID_:' if len(self.fields) == 1: field = self.fields[0] from thryft.generators.cpp._cpp_container_type import _CppContainerType from thryft.generators.cpp.cpp_struct_type import CppStructType if isinstance(field.type, _CppContainerType) or isinstance(field.type, CppStructType): field_value_cpp_write_protocol = \ indent(' ' * 4, field.type.cpp_write_protocol(field.cpp_getter_name() + (field.required and '()' or '().get()'))) case_ttype_void = """\ %(case_ttype_void)s %(field_value_cpp_write_protocol)s break; """ % locals() field_count = len(self.fields) field_write_protocols = \ lpad("\n\n", "\n\n".join(indent(' ' * 4, (field.cpp_write_protocol(write_field=True) for field in self.fields) ))) field_value_write_protocols = \ pad("\n\n", "\n\n".join(indent(' ' * 4, (field.cpp_write_protocol(write_field=False) for field in self.fields) )), "\n") name = self.cpp_name() return {'write': """\ void write(::thryft::protocol::OutputProtocol& oprot) const { write(oprot, ::thryft::protocol::Type::STRUCT); } void write(::thryft::protocol::OutputProtocol& oprot, ::thryft::protocol::Type as_type) const { switch (as_type) { %(case_ttype_void)s case ::thryft::protocol::Type::LIST: oprot.write_list_begin(::thryft::protocol::Type::VOID_, %(field_count)u);%(field_value_write_protocols)s oprot.write_list_end(); break; case ::thryft::protocol::Type::STRUCT: default: oprot.write_struct_begin();%(field_write_protocols)s oprot.write_field_stop(); oprot.write_struct_end(); break; } } """ % locals()}
def py_repr(self): name = self.py_name() enumerators = [] enumerator_placeholders = [] enumerator_qnames = [] value_of_statements = [] if len(self.enumerators) > 0: for enumerator in self.enumerators: enumerator_name = enumerator.name enumerator_value = enumerator.value enumerator_placeholders.append("%(enumerator_name)s = None" % locals()) enumerators.append( "%(name)s.%(enumerator_name)s = %(name)s('%(enumerator_name)s', %(enumerator_value)u)" % locals()) enumerator_qnames.append("%(name)s.%(enumerator_name)s" % locals()) value_of_statements.append("""\ if name == '%(enumerator_name)s' or name == '%(enumerator_value)u': return getattr(%(name)s, '%(enumerator_name)s') """ % locals()) enumerators = \ lpad("\n\n", "\n".join(enumerators)) enumerator_qnames = ', '.join(enumerator_qnames) enumerator_placeholders = \ pad("\n", "\n".join(indent(' ' * 4, enumerator_placeholders )), "\n") value_of_statements = \ lpad("\n", indent(' ' * 8, 'el'.join(value_of_statements))) return """\ class %(name)s(object):%(enumerator_placeholders)s def __init__(self, name, value): object.__init__(self) self.__name = name self.__value = value def __int__(self): return self.__value def __repr__(self): return self.__name def __str__(self): return self.__name @classmethod def value_of(cls, name):%(value_of_statements)s raise ValueError(name) @classmethod def values(cls): return (%(enumerator_qnames)s,)%(enumerators)s""" % locals()
def dart_repr(self): name = self.dart_name() sections = [] sections.append( indent(' ' * 2, "\n".join(self._dart_member_declarations()))) sections.append(indent(' ' * 2, "\n\n".join(self._dart_methods()))) sections = lpad( "\n", "\n\n".join(section for section in sections if len(section) > 0)) return """\ class %(name)s {%(sections)s }""" % locals()
def __repr__(self): name = self.java_name() methods = self._java_methods() sections = [] sections.append("\n\n".join(indent(' ' * 4, self._java_constructors() + [methods[key] for key in sorted(methods.iterkeys())] ))) sections.append("\n".join(indent(' ' * 4, self._java_member_declarations()))) sections = lpad("\n", "\n\n".join(section for section in sections if len(section) > 0)) return """\ public static class Builder {%(sections)s }""" % locals()
def __repr__(self): annotations = lpad("\n", "\n".join(self.java_annotations())) name = self.java_name() public_parameters = \ ', '.join(parameter.java_parameter(final=True) for parameter in self.parameters) public_parameter_names = ', '.join(parameter.java_name() for parameter in self.parameters) parameter_validations = [] for parameter in self.parameters: parameter_validation = parameter.java_validation() if parameter_validation != parameter.java_name(): parameter_validations.append(parameter_validation + ';') if len(parameter_validations) > 0: parameter_validations = \ "\n".join(indent(' ' * 4, parameter_validations)) validate_method_name = '_validate' + upper_camelize(self.name) + 'Parameters' validate_method = lpad("\n\n", """\ protected void %(validate_method_name)s(%(public_parameters)s) { %(parameter_validations)s }""" % locals()) validate_method_call = lpad("\n", indent(' ' * 4, "%s(%s);" % (validate_method_name, public_parameter_names))) else: validate_method = validate_method_call = '' protected_parameters = [parameter.java_parameter(final=True) for parameter in self.parameters] protected_parameter_names = [parameter.java_name() for parameter in self.parameters] if self.parent.parent.parent._include_current_user: protected_parameters.insert(0, 'org.apache.shiro.subject.Subject currentUser') protected_parameter_names.insert(0, 'org.apache.shiro.SecurityUtils.getSubject()') protected_delegation = \ "_%s(%s)" % (name, ', '.join(protected_parameter_names)) protected_parameters = ', '.join(protected_parameters) if self.return_field is not None: protected_delegation = 'return ' + self.return_field.java_validation(value=protected_delegation) return_type_name = self.return_field.type.java_declaration_name() else: return_type_name = 'void' throws = \ lpad( ' throws ', ', '.join(field.type.java_declaration_name() for field in self.throws) ) return """\ @Override%(annotations)s public %(return_type_name)s %(name)s(%(public_parameters)s)%(throws)s {%(validate_method_call)s %(protected_delegation)s; }%(validate_method)s protected abstract %(return_type_name)s _%(name)s(%(protected_parameters)s)%(throws)s; """ % locals()
def java_repr(self): final = 'final ' if self.__java_compound_type._java_is_final() else '' name = self.java_name() methods = self._java_methods() sections = [] sections.append("\n\n".join(indent(' ' * 4, self._java_constructors() + [methods[key] for key in sorted(methods.iterkeys())] ))) sections.append("\n".join(indent(' ' * 4, self._java_member_declarations()))) sections = lpad("\n", "\n\n".join(section for section in sections if len(section) > 0)) return """\ public %(final)sstatic class Builder {%(sections)s }""" % locals()
def js_repr(self): class_properties = ",\n\n".join(indent(' ' * 8, self._js_class_properties())) properties = ",\n\n".join(indent(' ' * 8, self._js_properties())) qname = self.js_qname() return """\ %(qname)s = Backbone.Model.extend( { %(properties)s }, { %(class_properties)s } );""" % locals()
def ts_repr(self): accessors = indent(' ' * 4, "\n\n".join(field.ts_accessors() for field in self.fields)) constructor = indent(' ' * 4, self.__ts_constructor()) methods = "\n\n".join(indent(' ' * 4, self.__ts_methods())) name = self.ts_name() return """\ export class %(name)s extends Backbone.Model { %(constructor)s %(accessors)s %(methods)s }""" % locals()
def js_repr(self): class_properties = ",\n\n".join( indent(' ' * 8, self._js_class_properties())) properties = ",\n\n".join(indent(' ' * 8, self._js_properties())) qname = self.js_qname() return """\ %(qname)s = Backbone.Model.extend( { %(properties)s }, { %(class_properties)s } );""" % locals()
def java_read_protocol(self): def try_catch(statement, throws): if len(throws) == 0: return statement statement = indent(' ' * 4, statement) return """\ try { %s }%s """ % (statement, ''.join("""\ catch (final %(exception_type_name)s e) { throw new org.thryft.protocol.InputProtocolException(e); }""" % locals() for exception_type_name in throws)) key_read_protocol = \ indent(' ' * 16, try_catch( 'key = ' + self.key_type.java_read_protocol() + ';', self.key_type.java_read_protocol_throws_checked() + self.key_type.java_read_protocol_throws_unchecked() )) key_type_name = self.key_type.java_boxed_qname() value_read_protocol = \ indent(' ' * 16, try_catch( 'value = ' + self.value_type.java_read_protocol() + ';', self.value_type.java_read_protocol_throws_checked() + self.value_type.java_read_protocol_throws_unchecked() )) value_type_name = self.value_type.java_boxed_qname() return """\ (new com.google.common.base.Function<org.thryft.protocol.InputProtocol, com.google.common.collect.ImmutableMap<%(key_type_name)s, %(value_type_name)s>>() { @Override public com.google.common.collect.ImmutableMap<%(key_type_name)s, %(value_type_name)s> apply(final org.thryft.protocol.InputProtocol iprot) { try { final org.thryft.protocol.MapBegin mapBegin = iprot.readMapBegin(); final com.google.common.collect.ImmutableMap.Builder<%(key_type_name)s, %(value_type_name)s> map = com.google.common.collect.ImmutableMap.builder(); for (int entryI = 0; entryI < mapBegin.getSize(); entryI++) { final %(key_type_name)s key; %(key_read_protocol)s final %(value_type_name)s value; %(value_read_protocol)s map.put(key, value); } iprot.readMapEnd(); return map.build(); } catch (final org.thryft.protocol.InputProtocolException e) { throw new org.thryft.protocol.UncheckedInputProtocolException(e); } } }).apply(iprot)""" % locals()
def _java_method_do_post(self): read_http_servlet_request_body = indent( ' ' * 4, self._java_read_http_servlet_request_body()) function_dispatches = [] if len(self.functions) == 0: function_dispatches = """\ __doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(-32601, String.format("the method '%s' does not exist / is not available", messageBegin.getName())), messageBegin.getId()); return; """ else: function_dispatches = \ indent(' ' * 8, ' else '.join( ["""\ if (messageBegin.getName().equals("%s")) { __doPost%s(httpServletRequest, httpServletResponse, iprot, messageBegin.getId()); }""" % (function.name, upper_camelize(function.name)) for function in self.functions ] + ['''\ { __doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(-32601, String.format("the method '%s' does not exist / is not available", messageBegin.getName())), messageBegin.getId()); return; }'''] )) return """\ @Override protected void doPost(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse) throws java.io.IOException, javax.servlet.ServletException { %(read_http_servlet_request_body)s org.thryft.protocol.MessageBegin messageBegin = null; try { final org.thryft.protocol.JsonRpcInputProtocol iprot; try { iprot = new org.thryft.protocol.JsonRpcInputProtocol(new org.thryft.protocol.JacksonJsonInputProtocol(httpServletRequestBody)); messageBegin = iprot.readMessageBegin(); } catch (final org.thryft.protocol.JsonRpcInputProtocolException e) { throw e; } catch (final org.thryft.protocol.InputProtocolException e) { throw new org.thryft.protocol.JsonRpcInputProtocolException(e, -32600); } if (messageBegin.getType() != org.thryft.protocol.MessageType.CALL) { throw new org.thryft.protocol.JsonRpcInputProtocolException(-32600, "expected request"); } %(function_dispatches)s } catch (final org.thryft.protocol.JsonRpcInputProtocolException e) { __doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(e), messageBegin != null ? messageBegin.getId() : null); return; } } """ % locals()
def py_repr(self): name = self.py_name() enumerators = [] enumerator_placeholders = [] enumerator_qnames = [] value_of_statements = [] if len(self.enumerators) > 0: for enumerator in self.enumerators: enumerator_name = enumerator.name enumerator_value = enumerator.value enumerator_placeholders.append("%(enumerator_name)s = None" % locals()) enumerators.append("%(name)s.%(enumerator_name)s = %(name)s('%(enumerator_name)s', %(enumerator_value)u)" % locals()) enumerator_qnames.append("%(name)s.%(enumerator_name)s" % locals()) value_of_statements.append("""\ if name == '%(enumerator_name)s' or name == '%(enumerator_value)u': return getattr(%(name)s, '%(enumerator_name)s') """ % locals()) enumerators = \ lpad("\n\n", "\n".join(enumerators)) enumerator_qnames = ', '.join(enumerator_qnames) enumerator_placeholders = \ pad("\n", "\n".join(indent(' ' * 4, enumerator_placeholders )), "\n") value_of_statements = \ lpad("\n", indent(' ' * 8, 'el'.join(value_of_statements))) return """\ class %(name)s(object):%(enumerator_placeholders)s def __init__(self, name, value): object.__init__(self) self.__name = name self.__value = value def __int__(self): return self.__value def __repr__(self): return self.__name def __str__(self): return self.__name @classmethod def value_of(cls, name):%(value_of_statements)s raise ValueError(name) @classmethod def values(cls): return (%(enumerator_qnames)s,)%(enumerators)s""" % locals()
def java_repr(self): javadoc = self.java_doc() name = self.java_bean_name() methods = self._java_methods() sections = [] sections.append(indent(' ' * 4, self._java_field_metadata_enum())) sections.append("\n\n".join(indent(' ' * 4, self._java_constructors() + \ [methods[key] for key in sorted(methods.iterkeys())]))) sections.append("\n\n".join(indent(' ' * 4, self._java_member_declarations()))) sections = lpad("\n", "\n\n".join(section for section in sections if len(section) > 0)) return """\ %(javadoc)spublic class %(name)s implements org.thryft.StructBean {%(sections)s }""" % locals()
def cpp_repr(self): name = self.cpp_name() extends = lpad(' : public ', self._cpp_extends()) template_parameters = rpad(self._cpp_template_parameters(), "\n") sections = [] # sections.append(indent(' ' * 4, repr(self._CppBuilder(self)))) sections.append(lpad("public:\n", "\n\n".join(indent(' ' * 2, self._cpp_constructors() + [self._cpp_destructor()] + self._cpp_methods_list() )))) sections.append(lpad("private:\n", "\n".join(indent(' ' * 2, self._cpp_member_declarations())))) sections = lpad("\n", "\n\n".join(section for section in sections if len(section) > 0)) return """\ %(template_parameters)sclass %(name)s%(extends)s {%(sections)s };""" % locals()
def java_read_protocol(self): element_read_protocol = self.element_type.java_read_protocol() add_element = "sequenceBuilder.add(%(element_read_protocol)s);" % locals() element_read_protocol_throws = ( self.element_type.java_read_protocol_throws_checked() + self.element_type.java_read_protocol_throws_unchecked() ) if len(element_read_protocol_throws) > 0: add_element = indent(" " * 4, add_element) add_element = """\ try { %s }%s """ % ( add_element, "".join( """\ catch (final %(exception_type_name)s e) { throw new org.thryft.protocol.InputProtocolException(e); }""" % locals() for exception_type_name in element_read_protocol_throws ), ) add_element = indent(" " * 16, add_element) element_type_name = self.element_type.java_boxed_qname() interface_simple_name = self._java_interface_simple_name() return ( """\ (new com.google.common.base.Function<org.thryft.protocol.InputProtocol, com.google.common.collect.Immutable%(interface_simple_name)s<%(element_type_name)s>>() { @Override public com.google.common.collect.Immutable%(interface_simple_name)s<%(element_type_name)s> apply(final org.thryft.protocol.InputProtocol iprot) { try { final org.thryft.protocol.%(interface_simple_name)sBegin sequenceBegin = iprot.read%(interface_simple_name)sBegin(); final com.google.common.collect.Immutable%(interface_simple_name)s.Builder<%(element_type_name)s> sequenceBuilder = com.google.common.collect.Immutable%(interface_simple_name)s.builder(); for (int elementI = 0; elementI < sequenceBegin.getSize(); elementI++) { %(add_element)s } iprot.read%(interface_simple_name)sEnd(); return sequenceBuilder.build(); } catch (final org.thryft.protocol.InputProtocolException e) { throw new org.thryft.protocol.UncheckedInputProtocolException(e); } } }).apply(iprot)""" % locals() )
def _java_method_do_post(self): read_http_servlet_request_body = indent(' ' * 4, self._java_read_http_servlet_request_body()) function_dispatches = [] if len(self.functions) == 0: function_dispatches = """\ __doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(-32601, String.format("the method '%s' does not exist / is not available", messageBegin.getName())), messageBegin.getId()); return; """ else: function_dispatches = \ indent(' ' * 8, ' else '.join( ["""\ if (messageBegin.getName().equals("%s")) { __doPost%s(httpServletRequest, httpServletResponse, iprot, messageBegin.getId()); }""" % (function.name, upper_camelize(function.name)) for function in self.functions ] + ['''\ { __doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(-32601, String.format("the method '%s' does not exist / is not available", messageBegin.getName())), messageBegin.getId()); return; }'''] )) return """\ @Override protected void doPost(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse) throws java.io.IOException, javax.servlet.ServletException { %(read_http_servlet_request_body)s org.thryft.protocol.MessageBegin messageBegin = null; try { final org.thryft.protocol.JsonRpcInputProtocol iprot; try { iprot = new org.thryft.protocol.JsonRpcInputProtocol(new org.thryft.protocol.JacksonJsonInputProtocol(httpServletRequestBody)); messageBegin = iprot.readMessageBegin(); } catch (final org.thryft.protocol.JsonRpcInputProtocolException e) { throw e; } catch (final org.thryft.protocol.InputProtocolException e) { throw new org.thryft.protocol.JsonRpcInputProtocolException(e, -32600); } if (messageBegin.getType() != org.thryft.protocol.MessageType.CALL) { throw new org.thryft.protocol.JsonRpcInputProtocolException(-32600, "expected request"); } %(function_dispatches)s } catch (final org.thryft.protocol.JsonRpcInputProtocolException e) { __doPostError(httpServletRequest, httpServletResponse, new org.thryft.protocol.JsonRpcErrorResponse(e), messageBegin != null ? messageBegin.getId() : null); return; } } """ % locals()
def py_repr(self): extends = ', '.join(self._py_extends()) sections = [] builder = self._py_builder() if builder is not None: sections.append(indent(' ' * 4, builder)) field_metadata_enum = self._py_field_metadata_enum() if field_metadata_enum is not None: sections.append(indent(' ' * 4, field_metadata_enum)) sections.append(indent(' ' * 4, "\n".join(self._py_methods()))) sections = "\n\n".join(sections) name = self.py_name() return """\ class %(name)s(%(extends)s): %(sections)s""" % locals()
def _java_method_fake(self): name = self.java_name() qname = self.java_qname() setter_calls = [] for field in self.fields: recursive = False for type_ in [field.type] + list(field.type.type_parameters): if qname == type_.java_qname(): assert not field.required, qname + '.' + field.name recursive = True break if not recursive: setter_calls.append( "builder.%s(%s);" % (field.java_setter_name(), field.java_faker())) setter_calls = \ lpad("\n", "\n".join(indent(' ' * 4, setter_calls))) return { 'fakeBuilder': """\ public static Builder fakeBuilder() { Builder builder = new Builder();%(setter_calls)s return builder; }""" % locals(), 'fake': """\ public static %(name)s fake() { return fakeBuilder().build(); }""" % locals() }
def cpp_declaration(self, line_ending="\n", override=False): override = ' override' if override else '' name = self.cpp_name() parameters = \ ', '.join(parameter.cpp_parameter() for parameter in self.parameters) if self.return_field is not None: return_type_name = self.return_field.type.cpp_qname() else: return_type_name = 'void' declaration = """\ %(return_type_name)s %(name)s(%(parameters)s)%(override)s""" % locals() if len(declaration) < 80: return declaration parameters = indent(' ' * 2, (',' + line_ending).join( parameter.cpp_parameter() for parameter in self.parameters)) return """\ %(return_type_name)s%(line_ending)s%(name)s(%(line_ending)s%(parameters)s%(line_ending)s)%(override)s""" % locals( )
def _cpp_constructor_required(self): if len(self.fields) == 0: return None # Will be covered by default constructor elif len(set([field.required for field in self.fields])) <= 1: # All fields are optional or all fields are required return None # Will be covered by total constructor body = lpad("\n", indent(' ' * 2, self._cpp_constructor_body())) initializers = [] name = self.cpp_name() parameters = [] for field in self.fields: if field.required: initializers.append(field.cpp_initializer()) parameters.append(field.cpp_parameter()) else: default_initializer = field.cpp_default_initializer() if default_initializer is not None: initializers.append(default_initializer) initializers = \ lpad("\n : ", ', '.join(initializers)) parameters = ", ".join(parameters) return """\ %(name)s(%(parameters)s)%(initializers)s {%(body)s }""" % locals()
def cpp_declaration(self, line_ending="\n", override=False): override = ' override' if override else '' name = self.cpp_name() parameters = \ ', '.join(parameter.cpp_parameter() for parameter in self.parameters) if self.return_field is not None: return_type_name = self.return_field.type.cpp_qname() else: return_type_name = 'void' declaration = """\ %(return_type_name)s %(name)s(%(parameters)s)%(override)s""" % locals() if len(declaration) < 80: return declaration parameters = indent(' ' * 2, (',' + line_ending).join(parameter.cpp_parameter() for parameter in self.parameters)) return """\ %(return_type_name)s%(line_ending)s%(name)s(%(line_ending)s%(parameters)s%(line_ending)s)%(override)s""" % locals()
def cpp_write_protocol(self, write_field=True): id_ = self.id if self.id is not None else 0 name = self.name getter_name = self.cpp_getter_name() ttype = self.type.thrift_ttype_name() value = getter_name + "()" if not self.required: value += '.get()' write_protocol = self.type.cpp_write_protocol(value) if write_field: write_protocol = """\ oprot.write_field_begin("%(name)s", ::thryft::protocol::Type::%(ttype)s, static_cast<int16_t>(%(id_)d)); %(write_protocol)s oprot.write_field_end(); """ % locals() if not self.required: write_protocol = indent(' ' * 4, write_protocol) write_protocol = """\ if (%(getter_name)s().present()) { %(write_protocol)s }""" % locals() if not write_field: write_protocol += """\ else { oprot.write_null(); }""" return write_protocol
def _py_method_repr(self, method_name='__repr__'): name = self.name if len(self.fields) == 0: return { method_name: """\ def %(method_name)s(self): return '%(name)s()' """ % locals() } field_reprs = [] for field in self.fields: field_name = field.name field_getter_call = field.py_getter_call() field_repr = field.type.py_repr('self.' + field.py_getter_call()) field_repr = "field_reprs.append('%(field_name)s=' + %(field_repr)s)" % locals( ) if not field.required: field_repr = """\ if self.%(field_getter_call)s is not None: %(field_repr)s """ % locals() field_reprs.append(field_repr) field_reprs = "\n".join(indent(' ' * 4, field_reprs)) return { method_name: """\ def %(method_name)s(self): field_reprs = [] %(field_reprs)s return '%(name)s(' + ', '.join(field_reprs) + ')' """ % locals() }
def __repr__(self): return "service %s%s {%s}" % ( self.name, self.extends is not None and (' ' + self.extends) or '', pad( "\n", "\n".join( indent(' ' * 4, (repr(function) + ';' for function in self.functions))), "\n"))
def py_add_arguments(self): name = self.py_name() add_arguments = [] parse_args = [] for parameter in self.parameters: parameter_action = parameter.py_argparse_action() parameter_name = parameter.py_argparse_name() parameter_required = ', required=True' if parameter.py_argparse_required( ) else '' parameter_type = ", type=%s" % parameter.py_argparse_type( ) if parameter_action == 'store' else '' add_arguments.append( "%(name)s_argument_parser.add_argument('--%(parameter_name)s', action='%(parameter_action)s'%(parameter_required)s%(parameter_type)s)" % locals()) parse_args.append(parameter.py_argparse_parse()) add_arguments = lpad("\n", "\n".join(add_arguments)) call_kwds = ', '.join("%s=%s" % (parameter.py_name(), parameter.py_name()) for parameter in self.parameters) parse_args = lpad("\n", "\n".join(indent(' ' * 4, parse_args))) return """\ def %(name)s(__args):%(parse_args)s return cls().%(name)s(%(call_kwds)s) %(name)s_argument_parser = argument_subparsers.add_parser('%(name)s')%(add_arguments)s %(name)s_argument_parser.set_defaults(func=%(name)s) """ % locals()
def js_validation(self, value, value_name, depth=0): if isinstance(self.element_type, _JsCompoundType): element_type_qname = self.element_type.js_qname() return {'type': """\ if (!(%(value)s instanceof Backbone.Collection)) { return "expected %(value_name)s to be a Backbone.Collection"; } if (%(value)s.model !== %(element_type_qname)s) { return "expected %(value_name)s to be a Backbone.Collection with model=%(element_type_qname)s"; } if (!%(value)s.isValid(true)) { return %(value)s.validationError; }""" % locals()} else: element_validate = \ indent(' ' * 4, self.element_type.js_validation( depth=depth + 1, value=value + "[__i%(depth)u]" % locals(), value_name=value_name + "[i]" % locals() )['type'] ) return {'type': """\ if (!Array.isArray(%(value)s)) { return "expected %(value_name)s to be an Array"; } for (var __i%(depth)u = 0; __i%(depth)u < %(value)s.length; __i%(depth)u++) { %(element_validate)s }""" % locals()}
def _dart_method_to_map(self): field_puts = [] for field in self.fields: field_name = field.name field_dart_name = field.dart_name() field_to_core_type = field.type.dart_to_core_type( "this.%(field_dart_name)s" % locals()) field_put = """map["%(field_name)s"] = %(field_to_core_type)s;""" % locals( ) if not field.required: field_put = """\ if (this.%(field_dart_name)s != null) { %(field_put)s }""" % locals() field_puts.append(field_put) field_puts = \ lpad("\n", "\n".join(indent(' ' * 2, field_puts))) return { 'toMap': """\ Map<String, Object> toMap() { Map<String, Object> map = new Map<String, Object>();%(field_puts)s return map; }""" % locals() }
def java_write_protocol(self, write_field=True, depth=0): id_ = self.id if self.id is not None else 0 name = self.name getter_name = self.java_getter_name() ttype = self.type.thrift_ttype_name() value = getter_name + "()" if not self.required: value += '.get()' write_protocol = \ self.type.java_write_protocol(value, depth=depth) if write_field: write_protocol = """\ oprot.writeFieldBegin("%(name)s", org.thryft.protocol.Type.%(ttype)s, (short)%(id_)d); %(write_protocol)s oprot.writeFieldEnd(); """ % locals() if not self.required: write_protocol = indent(' ' * 4, write_protocol) write_protocol = """\ if (%(getter_name)s().isPresent()) { %(write_protocol)s }""" % locals() if not write_field: write_protocol += """\ else { oprot.writeNull(); }""" return write_protocol
def _cpp_declaration(self): name = self.cpp_name() parameters = \ ', '.join(parameter.cpp_parameter() for parameter in self.parameters) if self.return_field is not None: return_type_name = self.return_field.type.cpp_qname() else: return_type_name = 'void' declaration = """\ %(return_type_name)s %(name)s(%(parameters)s)""" % locals() if len(declaration) < 80: return declaration parameters = indent( ' ' * 2, ',\n'.join(parameter.cpp_parameter() for parameter in self.parameters)) return """\ %(return_type_name)s %(name)s( %(parameters)s )""" % locals()
def _java_method_do_post_response(self): write_http_servlet_response_body = indent(' ' * 4, self._java_write_http_servlet_response_body()) return """\ private void __doPostResponse(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse, final String httpServletResponseBody) throws java.io.IOException { %(write_http_servlet_response_body)s } """ % locals()
def _java_method_do_post_response(self): write_http_servlet_response_body = indent( ' ' * 4, self._java_write_http_servlet_response_body()) return """\ private void __doPostResponse(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse, final Object jsonRpcRequestId, final Object jsonRpcResult) throws java.io.IOException { final java.io.StringWriter httpServletResponseBodyWriter = new java.io.StringWriter(); try { final org.thryft.protocol.JsonRpcOutputProtocol oprot = new org.thryft.protocol.JsonRpcOutputProtocol(new org.thryft.protocol.JacksonJsonOutputProtocol(httpServletResponseBodyWriter)); oprot.writeMessageBegin("", org.thryft.protocol.MessageType.REPLY, jsonRpcRequestId); if (jsonRpcResult != null) { oprot.writeMixed(jsonRpcResult); } else { oprot.writeStructBegin("response"); oprot.writeStructEnd(); } oprot.writeMessageEnd(); oprot.flush(); } catch (final org.thryft.protocol.OutputProtocolException e) { logger.error("error serializing service error response: ", e); throw new IllegalStateException(e); } __doPostResponse(httpServletRequest, httpServletResponse, httpServletResponseBodyWriter.toString()); } private void __doPostResponse(final javax.servlet.http.HttpServletRequest httpServletRequest, final javax.servlet.http.HttpServletResponse httpServletResponse, final String httpServletResponseBody) throws java.io.IOException { %(write_http_servlet_response_body)s } """ % locals()
def js_validation(self, value, value_name, depth=0): if isinstance(self.element_type, _JsCompoundType): element_type_qname = self.element_type.js_qname() return { 'type': """\ if (!(%(value)s instanceof Backbone.Collection)) { return "expected %(value_name)s to be a Backbone.Collection"; } if (%(value)s.model !== %(element_type_qname)s) { return "expected %(value_name)s to be a Backbone.Collection with model=%(element_type_qname)s"; } if (!%(value)s.isValid(true)) { return %(value)s.validationError; }""" % locals() } else: element_validate = \ indent(' ' * 4, self.element_type.js_validation( depth=depth + 1, value=value + "[__i%(depth)u]" % locals(), value_name=value_name + "[i]" % locals() )['type'] ) return { 'type': """\ if (!Array.isArray(%(value)s)) { return "expected %(value_name)s to be an Array"; } for (var __i%(depth)u = 0; __i%(depth)u < %(value)s.length; __i%(depth)u++) { %(element_validate)s }""" % locals() }