# HG changeset patch # User bgo-osimis # Date 1550692290 -3600 # Node ID 8e7e151ef4729e2168aead13adf78e1ab78d8d2a # Parent 6470248790db7ee008d09e42314b4de56578bf10 Unit tests pass for enum generation diff -r 6470248790db -r 8e7e151ef472 Resources/CodeGeneration/playground.ts --- a/Resources/CodeGeneration/playground.ts Mon Feb 18 15:38:05 2019 +0100 +++ b/Resources/CodeGeneration/playground.ts Wed Feb 20 20:51:30 2019 +0100 @@ -34,7 +34,6 @@ printf(`About to serialize value. Type is ${valueType}`) printf(`About to serialize value. Type is ${typeof value}`) return "Choucroute"; - } function main():number diff -r 6470248790db -r 8e7e151ef472 Resources/CodeGeneration/playground3.ts --- a/Resources/CodeGeneration/playground3.ts Mon Feb 18 15:38:05 2019 +0100 +++ b/Resources/CodeGeneration/playground3.ts Wed Feb 20 20:51:30 2019 +0100 @@ -3,7 +3,7 @@ 12345678901234567890123456789012345678901234567890123456789012345678901234567890 */ -namespace VsolStuff { +namespace VsolStuff222 { export enum EnumMonth0 { January, February, @@ -17,7 +17,7 @@ d: boolean; public StoneSerialize(): string { let container: object = {}; - container['type'] = 'Message1'; + container['type'] = 'VsolStuff.Message1'; container['value'] = this; return JSON.stringify(container); } @@ -32,7 +32,7 @@ public StoneSerialize(): string { let container: object = {}; - container['type'] = 'Message1'; + container['type'] = 'VsolStuff.Message2'; container['value'] = this; return JSON.stringify(container); } @@ -69,7 +69,7 @@ msg2_0.tata.push(msg1_0); msg2_0.tata.push(msg1_1); msg2_0.tutu.push("Mercadet"); - msg2_0.tutu.push("Poisson"); + msg2_0.tutu.push("Poisson");ing msg2_0.titi["44"] = "key 44"; msg2_0.titi["45"] = "key 45"; msg2_0.lulu["54"] = msg1_1; diff -r 6470248790db -r 8e7e151ef472 Resources/CodeGeneration/stonegentool.py --- a/Resources/CodeGeneration/stonegentool.py Mon Feb 18 15:38:05 2019 +0100 +++ b/Resources/CodeGeneration/stonegentool.py Wed Feb 20 20:51:30 2019 +0100 @@ -1,6 +1,8 @@ import json +import yaml import re import sys +from jinja2 import Template from typing import ( Any, Dict, @@ -22,7 +24,34 @@ 12345678901234567890123456789012345678901234567890123456789012345678901234567890 """ -class GeneratedCode: +# see https://stackoverflow.com/a/2504457/2927708 +def trim(docstring): + if not docstring: + return '' + # Convert tabs to spaces (following the normal Python rules) + # and split into a list of lines: + lines = docstring.expandtabs().splitlines() + # Determine minimum indentation (first line doesn't count): + indent = sys.maxsize + for line in lines[1:]: + stripped = line.lstrip() + if stripped: + indent = min(indent, len(line) - len(stripped)) + # Remove indentation (first line is special): + trimmed = [lines[0].strip()] + if indent < sys.maxsize: + for line in lines[1:]: + trimmed.append(line[indent:].rstrip()) + # Strip off trailing and leading blank lines: + while trimmed and not trimmed[-1]: + trimmed.pop() + while trimmed and not trimmed[0]: + trimmed.pop(0) + # Return a single string: + return '\n'.join(trimmed) + + +class GenCode: def __init__(self): # file-wide preamble (#include directives, comment...) @@ -45,10 +74,6 @@ raise NotImplementedError() -raise Exception(""" -$$$$TODO check field names are unique -""") - class JsonHelpers: """A set of utilities to perform JSON operations""" @@ -83,13 +108,13 @@ def LoadSchemaFromJson(filePath: str): return JsonHelpers.loadJsonWithComments(filePath) -def GetCppTypeNameFromCanonical(canonicalTypeName: str) -> str: +def GetCppTypenameFromCanonical(canonicalTypename: str) -> str: # C++: prefix map vector and string with std::map, std::vector and # std::string # replace int32 by int32_t # replace float32 by float # replace float64 by double - retVal: str = canonicalTypeName + retVal: str = canonicalTypename retVal = retVal.replace("map", "std::map") retVal = retVal.replace("vector", "std::vector") retVal = retVal.replace("int32", "int32_t") @@ -97,13 +122,13 @@ retVal = retVal.replace("float64", "double") return retVal -def GetTypeScriptTypeNameFromCanonical(canonicalTypeName: str) -> str: +def GetTypeScriptTypenameFromCanonical(canonicalTypename: str) -> str: # TS: replace vector with Array and map with Map # string remains string # replace int32 by number # replace float32 by number # replace float64 by number - retVal: str = canonicalTypeName + retVal: str = canonicalTypename retVal = retVal.replace("map", "Map") retVal = retVal.replace("vector", "Array") retVal = retVal.replace("int32", "number") @@ -112,54 +137,6 @@ retVal = retVal.replace("bool", "boolean") return retVal -# class Schema: -# def __init__(self, root_prefix : str, defined_types : List[Type]): -# self.rootName : str = root_prefix -# self.definedTypes : str = defined_types - -def CheckTypeSchema(definedType: Dict) -> None: - allowedDefinedTypeKinds = ["enum", "struct"] - if not "name" in definedType: - raise Exception("type lacks the 'name' key") - name = definedType["name"] - if not "kind" in definedType: - raise Exception(f"type {name} lacks the 'kind' key") - kind = definedType["kind"] - if not (kind in allowedDefinedTypeKinds): - raise Exception( - f"type {name} : kind {kind} is not allowed. " - + f"It must be one of {allowedDefinedTypeKinds}" - ) - - if not "fields" in definedType: - raise Exception("type {name} lacks the 'fields' key") - - # generic check on all kinds of types - fields = definedType["fields"] - for field in fields: - fieldName = field["name"] - if not "name" in field: - raise Exception("field in type {name} lacks the 'name' key") - - # fields in struct must have types - if kind == "struct": - for field in fields: - fieldName = field["name"] - if not "type" in field: - raise Exception( - f"field {fieldName} in type {name} " + "has no 'type' key" - ) - - -def CheckSchemaSchema(schema: Dict) -> None: - if not "root_name" in schema: - raise Exception("schema lacks the 'root_name' key") - if not "types" in schema: - raise Exception("schema lacks the 'types' key") - for definedType in schema["types"]: - CheckTypeSchema(definedType) - - def EatToken(sentence: str) -> Tuple[str, str]: """splits "A,B,C" into "A" and "B,C" where A, B and C are type names (including templates) like "int32", "TotoTutu", or @@ -183,7 +160,7 @@ return (sentence, "") -def SplitListOfTypes(typeName: str) -> List[str]: +def SplitListOfTypes(typename: str) -> List[str]: """Splits something like vector,int32,map> in: @@ -195,7 +172,7 @@ """ stillStuffToEat: bool = True tokenList = [] - restOfString = typeName + restOfString = typename while stillStuffToEat: firstToken, restOfString = EatToken(restOfString) tokenList.append(firstToken) @@ -208,16 +185,16 @@ re.compile(r"([a-zA-Z0-9_]*[a-zA-Z0-9_]*)<([a-zA-Z0-9_,:<>]+)>") -def ParseTemplateType(typeName) -> Tuple[bool, str, List[str]]: - """ If the type is a template like "SOMETHING>>", then - it returns (true,"SOMETHING","SOME>") +def ParseTemplateType(typename) -> Tuple[bool, str, List[str]]: + """ If the type is a template like "SOMETHING>>", + then it returns (true,"SOMETHING","SOME>") otherwise it returns (false,"","")""" # let's remove all whitespace from the type # split without argument uses any whitespace string as separator # (space, tab, newline, return or formfeed) - typeName = "".join(typeName.split()) - matches = templateRegex.match(typeName) + typename = "".join(typename.split()) + matches = templateRegex.match(typename) if matches == None: return (False, "", []) else: @@ -228,234 +205,220 @@ listOfDependentTypes = SplitListOfTypes(m.group(2)) return (True, m.group(1), listOfDependentTypes) -def ProcessTypeTree( - ancestors: List[str], - genOrderQueue: List[str], - structTypes: Dict[str, Dict], - typeName: str) -> None: - if typeName in ancestors: + +def ComputeOrderFromTypeTree( + ancestors: List[str], + genOrder: List[str], + shortTypename: str, schema: Dict[str, Dict]) -> None: + + if shortTypename in ancestors: raise Exception( f"Cyclic dependency chain found: the last of {ancestors} " - + f"depends on {typeName} that is already in the list." + + f"depends on {shortTypename} that is already in the list." ) - if not (typeName in genOrderQueue): - # if we reach this point, it means the type is NOT a struct or an enum. - # it is another (non directly user-defined) type that we must parse and - # create. Let's do it! - (isTemplate, _, dependentTypeNames) = ParseTemplateType(typeName) + if not (shortTypename in genOrder): + (isTemplate, _, dependentTypenames) = ParseTemplateType(shortTypename) if isTemplate: - for dependentTypeName in dependentTypeNames: + # if it is a template, it HAS dependent types... They can be + # anything (primitive, collection, enum, structs..). + # Let's process them! + for dependentTypename in dependentTypenames: # childAncestors = ancestors.copy() NO TEMPLATE ANCESTOR!!! - # childAncestors.append(typeName) - ProcessTypeTree( - ancestors, genOrderQueue, structTypes, dependentTypeName + # childAncestors.append(typename) + ComputeOrderFromTypeTree( + ancestors, genOrder, dependentTypename, schema ) else: - if typeName in structTypes: - ProcessStructType_DepthFirstRecursive( - genOrderQueue, structTypes, structTypes[typeName] - ) + # If it is not template, we are only interested if it is a + # dependency that we must take into account in the dep graph, + # i.e., a struct. + if IsShortStructType(shortTypename, schema): + struct:Dict = schema[GetLongTypename(shortTypename, schema)] + # The keys in the struct dict are the member names + # The values in the struct dict are the member types + for field in struct.keys(): + # we fill the chain of dependent types (starting here) + ancestors.append(shortTypename) + ComputeOrderFromTypeTree( + ancestors, genOrder, struct[field], schema) + # don't forget to restore it! + ancestors.pop() + + # now we're pretty sure our dependencies have been processed, + # we can start marking our code for generation (it might + # already have been done if someone referenced us earlier) + if not shortTypename in genOrder: + genOrder.append(shortTypename) -def ProcessStructType_DepthFirstRecursive(genOrderQueue: List[str], \ - structTypes: Dict[str, Dict], typeDict: Dict) -> None: - # let's generate the code according to the - typeName: str = typeDict["name"] - if typeDict["kind"] != "struct": - raise Exception( - f"Unexpected kind '{typeDict['kind']}' for " + "type '{typeName}'" - ) - typeFields: List[Dict] = typeDict["fields"] - for typeField in typeFields: - ancestors = [typeName] - ProcessTypeTree(ancestors, genOrderQueue, structTypes, typeField["type"]) - # now we're pretty sure our dependencies have been processed, - # we can start marking our code for generation (it might already have - # been done if someone referenced us earlier) - if not typeName in genOrderQueue: - genOrderQueue.append(typeName) +# +-----------------------+ +# | Utility functions | +# +-----------------------+ + +def IsShortStructType(typename: str, schema: Dict[str, Dict]) -> bool: + fullStructName = "struct " + typename + return (fullStructName in schema) -def ProcessEnumerationType(outputStreams: GeneratedCode, typeDict: Dict) -> None: +def GetLongTypename(shortTypename: str, schema: Dict): + if shortTypename.startswith("enum "): + raise RuntimeError('shortTypename.startswith("enum "):') + enumName: str = "enum " + shortTypename + isEnum = enumName in schema - # enumeration declarations - tsDeclText: StringIO = StringIO() - tsDeclText.write("enum %s\n" % typeDict["name"]) - tsDeclText.write("{\n") + if shortTypename.startswith("struct "): + raise RuntimeError('shortTypename.startswith("struct "):') + structName: str = "struct " + shortTypename + isStruct = ("struct " + shortTypename) in schema - cppDeclText: StringIO = StringIO() - cppDeclText.write("enum %s\n" % typeDict["name"]) - cppDeclText.write("{\n") + if isEnum and isStruct: + raise RuntimeError('Enums and structs cannot have the same name') - cppToStringText: StringIO = StringIO() - cppToStringText.write("enum %s\n" % typeDict["name"]) - cppToStringText.write("{\n") + if isEnum: + return enumName + if isStruct: + return structName + +def IsTypename(fullName: str) -> bool: + return (fullName.startswith("enum ") or fullName.startswith("struct ")) + +def IsEnumType(fullName: str) -> bool: + return fullName.startswith("enum ") - cppFromStringText: StringIO = StringIO() - cppFromStringText.write("enum %s\n" % typeDict["name"]) - cppFromStringText.write("{\n") +def IsStructType(fullName: str) -> bool: + return fullName.startswith("struct ") - for i in range(len(typeDict["fields"])): - field = typeDict["fields"][i] - name = field["name"] +def GetShortTypename(fullTypename: str) -> str: + if fullTypename.startswith("struct "): + return fullTypename[7:] + elif fullTypename.startswith("enum"): + return fullTypename[5:] + else: + raise RuntimeError \ + ('fullTypename should start with either "struct " or "enum "') - tsText.write(" %s" % name) - if i < len(typeDict["fields"]) - 1: - tsText.write(",") - tsText.write("\n") +def CheckSchemaSchema(schema: Dict) -> None: + if not "rootName" in schema: + raise Exception("schema lacks the 'rootName' key") + for name in schema.keys(): + if (not IsEnumType(name)) and (not IsStructType(name)) and \ + (name != 'rootName'): + raise RuntimeError \ + (f'Type "{name}" should start with "enum " or "struct "') + + # TODO: check enum fields are unique (in whole namespace) + # TODO: check struct fields are unique (in each struct) + +# +-----------------------+ +# | Main processing logic | +# +-----------------------+ + +def ComputeRequiredDeclarationOrder(schema: dict) -> List[str]: + # sanity check + CheckSchemaSchema(schema) - cppText.write(" %s" % name) - if i < len(typeDict["fields"]) - 1: - cppText.write(",") - cppText.write("\n") + # we traverse the type dependency graph and we fill a queue with + # the required struct types, in a bottom-up fashion, to compute + # the declaration order + # The genOrder list contains the struct full names in the order + # where they must be defined. + # We do not care about the enums here... They do not depend upon + # anything and we'll handle them, in their original declaration + # order, at the start + genOrder: List = [] + for fullName in schema.keys(): + if IsStructType(fullName): + realName: str = GetShortTypename(fullName) + ancestors: List[str] = [] + ComputeOrderFromTypeTree(ancestors, genOrder, realName, schema) + return genOrder - tsText.write("};\n\n") - cppText.write("};\n\n") - - outputStreams.tsEnums.write(tsText.getvalue()) - outputStreams.cppEnums.write(cppText.getvalue()) +def ProcessSchema(schema: dict, genOrder: List[str]) -> Dict: + # sanity check + CheckSchemaSchema(schema) -def GetSerializationCode(typeName: str,valueName: str, tempName: str) - if IsPrimitiveType(typeName): - """ - json::Value val(objectTypeInt...) - val.setValue(valueName) <--- val - """ - elif IsArray(typeName) - """ - { - json::Value val(objectTypeArray...) - for(size_t i = 0; i < {fieldName}.size(); ++i) - { - json::Value val(objectTypeArray...) - } - val.setValue(valueName) - // <--- the calling code will insert collection/field writing here, - // like "parent.set("{fieldName}",val) or parent.append(val) - $collectValue - } - """ + # let's doctor the schema to clean it up a bit + # order DOES NOT matter for enums, even though it's a list + enums: List[Dict] = [] + for fullName in schema.keys(): + if IsEnumType(fullName): + # convert "enum Toto" to "Toto" + typename:str = GetShortTypename(fullName) + enum = {} + enum['name'] = typename + assert(type(schema[fullName]) == list) + enum['fields'] = schema[fullName] # must be a list + enums.append(enum) - - -def ProcessStructType(outputStreams: GeneratedCode, typeDict) -> None: - tsText: StringIO = StringIO() - cppText: StringIO = StringIO() + # now that the order has been established, we actually store\ + # the structs in the correct order + # the structs are like: + # example = [ + # { + # "name": "Message1", + # "fields": { + # "someMember":"int32", + # "someOtherMember":"vector" + # } + # }, + # { + # "name": "Message2", + # "fields": { + # "someMember":"int32", + # "someOtherMember22":"vector" + # } + # } + # ] - tsText.write("class %s\n" % typeDict["name"]) - tsText.write("{\n") - - cppText.write("struct %s\n" % typeDict["name"]) - cppText.write("{\n") - - """ + structs: List[Dict] = [] + for i in range(len(genOrder)): + # this is already the short name + typename = genOrder[i] + fieldDict = schema["struct " + typename] + struct = {} + struct['name'] = typename + struct['fields'] = fieldDict + structs.append(struct) - GenerateSerializationCode(typeName,valueName) + templatingDict = {} + templatingDict['enums'] = enums + templatingDict['structs'] = structs + templatingDict['rootName'] = schema['rootName'] - primitives: - ----------- - int - jsonValue val(objectInt); - val.setValue("$name") - parent.add(("$name",$name) - double - ... - string - ... - - collections: - ----------- - dict { } - - - - - - serializeValue() - """ + return templatingDict - for i in range(len(typeDict["fields"])): - field = typeDict["fields"][i] - name = field["name"] - tsType = GetTypeScriptTypeNameFromCanonical(field["type"]) - tsText.write(" public %s %s;\n" % (tsType, name)) - cppType = GetCppTypeNameFromCanonical(field["type"]) - cppText.write(" %s %s;\n" % (cppType, name)) - - tsText.write("};\n\n") - cppText.write("};\n\n") +# +-----------------------+ +# | Write to files | +# +-----------------------+ - outputStreams.tsStructs.write(tsText.getvalue()) - outputStreams.cppStructs.write(cppText.getvalue()) - - -def WritePreambles(rootName: str, outputStreams: GeneratedCode) -> None: - outputStreams.cppPreamble.write( -"""// autogenerated by stonegentool on %s for module %s -#include -#include -#include -#include - -""" % (time.ctime(), rootName)) +# def WriteStreamsToFiles(rootName: str, genc: Dict[str, StringIO]) \ +# -> None: +# pass - outputStreams.tsPreamble.write( - """// autogenerated by stonegentool on %s for module %s -""" % (time.ctime(), rootName)) - - -def ProcessSchema(schema: dict) -> Tuple[str, GeneratedCode, List[str]]: - CheckSchemaSchema(schema) - rootName: str = schema["root_name"] - definedTypes: list = schema["types"] - - # this will be filled with the generation queue. That is, the type - # names in the order where they must be defined. - genOrderQueue: List = [] - - # the struct names are mapped to their JSON dictionary - structTypes: Dict[str, Dict] = {} - - outputStreams: GeneratedCode = GeneratedCode() - - WritePreambles(rootName, outputStreams) +def LoadSchema(fn): + with open(fn, 'rb') as f: + schema = yaml.load(f) + return schema - # the order here is the generation order - for definedType in definedTypes: - if definedType["kind"] == "enum": - ProcessEnumerationType(outputStreams, definedType) - - for definedType in definedTypes: - if definedType["kind"] == "struct": - structTypes[definedType["name"]] = definedType +def GetTemplatingDictFromSchemaFilename(fn): + obj = LoadSchema(fn) + genOrder: str = ComputeRequiredDeclarationOrder(obj) + templatingDict = ProcessSchema(obj, genOrder) + return templatingDict - # the order here is NOT the generation order: the types - # will be processed according to their dependency graph - for definedType in definedTypes: - if definedType["kind"] == "struct": - ProcessStructType_DepthFirstRecursive( - genOrderQueue, structTypes, definedType - ) - - for i in range(len(genOrderQueue)): - typeName = genOrderQueue[i] - typeDict = structTypes[typeName] - ProcessStructType(outputStreams, typeDict) - - return (rootName, outputStreams, genOrderQueue) - - -def WriteStreamsToFiles(rootName: str, outputStreams: Dict[str, StringIO]) -> None: - pass +# +-----------------------+ +# | ENTRY POINT | +# +-----------------------+ if __name__ == "__main__": import argparse parser = argparse.ArgumentParser( - usage="""stonegentool.py [-h] [-o OUT_DIR] [-v] input_schemas - EXAMPLE: python command_gen.py -o "generated_files/" """ - + """ "mainSchema.json,App Specific Commands.json" """ + usage="""stonegentool.py [-h] [-o OUT_DIR] [-v] input_schema + EXAMPLE: python stonegentool.py -o "generated_files/" """ + + """ "mainSchema.yaml,App Specific Commands.json" """ ) - parser.add_argument("input_schema", type=str, help="path to the schema file") + parser.add_argument("input_schema", type=str, \ + help="path to the schema file") parser.add_argument( "-o", "--out_dir", @@ -479,6 +442,219 @@ inputSchemaFilename = args.input_schema outDir = args.out_dir - (rootName, outputStreams, _) = ProcessSchema(LoadSchema(inputSchemaFilename)) - WriteStreamsToFiles(rootName, outputStreams) + schema: Dict = LoadSchema(inputSchemaFilename) + genOrder: List[str] = ComputeRequiredDeclarationOrder(schema) + processedSchema: Dict = ProcessSchema(schema,genOrder) + + +# def GenEnumDecl(genc: GenCode, fullName: str, schema: Dict) -> None: +# """Writes the enumerations in genc""" +# enumDict:Dict=schema[fullName] +# # jinja2 template +# j2cppEnum = Template(trim( +# """ {{fullName}} +# { +# {% for key in enumDict.keys()%} +# {{key}}, +# {%endfor%} +# }; +# """)) +# j2cppEnumR = j2cppEnum.render(locals()) +# genc.cppEnums.write(j2cppEnumR) + +# j2tsEnum = Template(trim( +# """ export {{fullName}} +# { +# {% for key in enumDict.keys()%} +# {{key}}, +# {%endfor%} +# }; +# """)) +# j2cppEnumR = j2cppEnum.render(locals()) +# genc.tsEnums.write(j2cppEnumR) + + + +# def GetSerializationCode(typename: str,valueName: str, tempName: str) +# if IsPrimitiveType(typename) or IsTemplateCollection(typename): +# # no need to write code for the primitive types or collections. +# # It is handled in C++ by the template functions and in TS by +# # the JSON.stringify code. +# elif IsStructType(typename): +# pass + +# def GenStructTypeDeclAndSerialize(genc: GenCode, type, schema) -> None: +# ###### +# # CPP +# ###### +# sampleCpp = """ struct Message1 +# { +# int32_t a; +# std::string b; +# EnumMonth0 c; +# bool d; +# }; + +# Json::Value StoneSerialize(const Message1& value) +# { +# Json::Value result(Json::objectValue); +# result["a"] = StoneSerialize(value.a); +# result["b"] = StoneSerialize(value.b); +# result["c"] = StoneSerialize(value.c); +# result["d"] = StoneSerialize(value.d); +# return result; +# } +# """ + + +# ###### +# # TS +# ###### +# sampleTs = """ +# { +# export class Message1 { +# a: number; +# b: string; +# c: EnumMonth0; +# d: boolean; +# public StoneSerialize(): string { +# let container: object = {}; +# container['type'] = 'Message1'; +# container['value'] = this; +# return JSON.stringify(container); +# } +# }; +# } +# """ + + + + +# tsText: StringIO = StringIO() +# cppText: StringIO = StringIO() + +# tsText.write("class %s\n" % typeDict["name"]) +# tsText.write("{\n") + +# cppText.write("struct %s\n" % typeDict["name"]) +# cppText.write("{\n") + +# """ + +# GenerateSerializationCode(typename,valueName) +# primitives: +# ----------- +# int +# jsonValue val(objectInt); +# val.setValue("$name") +# parent.add(("$name",$name) +# double +# ... +# string +# ... + +# collections: +# ----------- +# dict { } + +# serializeValue() +# """ + +# for i in range(len(typeDict["fields"])): +# field = typeDict["fields"][i] +# name = field["name"] +# tsType = GetTypeScriptTypenameFromCanonical(field["type"]) +# tsText.write(" public %s %s;\n" % (tsType, name)) +# cppType = GetCppTypenameFromCanonical(field["type"]) +# cppText.write(" %s %s;\n" % (cppType, name)) + +# tsText.write("};\n\n") +# cppText.write("};\n\n") + +# genc.tsStructs.write(tsText.getvalue()) +# genc.cppStructs.write(cppText.getvalue()) + + +# def GenerateCodeFromTsTemplate(genc) + + +# +-----------------------+ +# | CODE GENERATION | +# +-----------------------+ + +# def GenPreambles(rootName: str, genc: GenCode) -> None: +# cppPreambleT = Template(trim( +# """// autogenerated by stonegentool on {{time.ctime()}} +# // for module {{rootName}} +# #include +# #include +# #include +# #include +# namespace {{rootName}} +# { +# Json::Value StoneSerialize(int32_t value) +# { +# Json::Value result(value); +# return result; +# } +# Json::Value StoneSerialize(double value) +# { +# Json::Value result(value); +# return result; +# } +# Json::Value StoneSerialize(bool value) +# { +# Json::Value result(value); +# return result; +# } +# Json::Value StoneSerialize(const std::string& value) +# { +# // the following is better than +# Json::Value result(value.data(),value.data()+value.size()); +# return result; +# } +# template +# Json::Value StoneSerialize(const std::map& value) +# { +# Json::Value result(Json::objectValue); + +# for (std::map::const_iterator it = value.cbegin(); +# it != value.cend(); ++it) +# { +# // it->first it->second +# result[it->first] = StoneSerialize(it->second); +# } +# return result; +# } +# template +# Json::Value StoneSerialize(const std::vector& value) +# { +# Json::Value result(Json::arrayValue); +# for (size_t i = 0; i < value.size(); ++i) +# { +# result.append(StoneSerialize(value[i])); +# } +# return result; +# } +# """ +# cppPreambleR = cppPreambleT.render(locals()) +# genc.cppPreamble.write(cppPreambleR) + +# tsPreambleT = Template(trim( +# """// autogenerated by stonegentool on {{time.ctime()}} +# // for module {{rootName}} + +# namespace {{rootName}} +# { +# """ +# tsPreambleR = tsPreambleT.render(locals()) +# genc.tsPreamble.write(tsPreambleR) + +# def ComputeOrder_ProcessStruct( \ +# genOrder: List[str], name:str, schema: Dict[str, str]) -> None: +# # let's generate the code according to the +# struct = schema[name] + +# if not IsStructType(name): +# raise Exception(f'{typename} should start with "struct "') diff -r 6470248790db -r 8e7e151ef472 Resources/CodeGeneration/stonegentool_test.py --- a/Resources/CodeGeneration/stonegentool_test.py Mon Feb 18 15:38:05 2019 +0100 +++ b/Resources/CodeGeneration/stonegentool_test.py Wed Feb 20 20:51:30 2019 +0100 @@ -1,8 +1,46 @@ +# +# 1 2 3 4 5 6 7 8 +# 345678901234567890123456789012345678901234567890123456789012345678901234567890 +# + from stonegentool import \ -EatToken,SplitListOfTypes,ParseTemplateType,LoadSchema,CheckSchemaSchema,ProcessSchema +EatToken,SplitListOfTypes,ParseTemplateType,ProcessSchema, \ +CheckSchemaSchema,LoadSchema,trim,ComputeRequiredDeclarationOrder, \ +GetTemplatingDictFromSchemaFilename import unittest import os import re +import pprint +from jinja2 import Template + +ymlSchema = trim("""rootName: VsolMessages + +struct B: + someAs: vector + someInts: vector + +struct C: + someBs: vector + ddd: vector + +struct A: + someStrings: vector + someInts2: vector + movies: vector + +enum MovieType: + - RomCom + - Horror + - ScienceFiction + - Vegetables + +enum CrispType: + - SaltAndPepper + - CreamAndChives + - Paprika + - Barbecue +) +""") def RemoveDateTimeLine(s : str): # regex are non-multiline by default, and $ does NOT match the end of the line @@ -78,129 +116,87 @@ self.assertEqual(b4,["int","vector"]) def test_ParseSchema(self): - fn = os.path.join(os.path.dirname(__file__), 'test', 'test1.jsonc') + fn = os.path.join(os.path.dirname(__file__), 'test_data', 'test1.yaml') obj = LoadSchema(fn) - # we're happy if it does not crash + # we're happy if it does not crash :) CheckSchemaSchema(obj) - def test_ParseSchema_bogus_json(self): - fn = os.path.join(os.path.dirname(__file__), 'test', 'test1_bogus_json.jsonc') - self.assertRaises(Exception,LoadSchema,fn) + # def test_ParseSchema_bogus_json(self): + # fn = os.path.join(os.path.dirname(__file__), 'test', 'test1_bogus_json.jsonc') + # self.assertRaises(Exception,LoadSchema,fn) + + # def test_ParseSchema_bogus_schema(self): + # fn = os.path.join(os.path.dirname(__file__), 'test', 'test1_bogus_schema.jsonc') + # obj = LoadSchema(fn) + # self.assertRaises(Exception,CheckSchemaSchema,obj) - def test_ParseSchema_bogus_schema(self): - fn = os.path.join(os.path.dirname(__file__), 'test', 'test1_bogus_schema.jsonc') + def test_ComputeRequiredDeclarationOrder(self): + fn = os.path.join(os.path.dirname(__file__), 'test_data', 'test1.yaml') obj = LoadSchema(fn) - self.assertRaises(Exception,CheckSchemaSchema,obj) + genOrder: str = ComputeRequiredDeclarationOrder(obj) + self.assertEqual(3,len(genOrder)) + self.assertEqual("A",genOrder[0]) + self.assertEqual("B",genOrder[1]) + self.assertEqual("C",genOrder[2]) - def test_GenOrderQueue(self): - fn = os.path.join(os.path.dirname(__file__), 'test', 'test1.jsonc') + # def test_GeneratePreambleEnumerationAndStructs(self): + # fn = os.path.join(os.path.dirname(__file__), 'test', 'test1.jsonc') + # obj = LoadSchema(fn) + # (_,genc,_) = ProcessSchema(obj) + + def test_genEnums(self): + fn = os.path.join(os.path.dirname(__file__), 'test_data', 'test1.yaml') obj = LoadSchema(fn) - genOrderQueue:str - _, _, genOrderQueue = ProcessSchema(obj) - self.assertEqual(3,len(genOrderQueue)) - self.assertEqual("A",genOrderQueue[0]) - self.assertEqual("B",genOrderQueue[1]) - self.assertEqual("C",genOrderQueue[2]) + genOrder: str = ComputeRequiredDeclarationOrder(obj) + processedSchema = ProcessSchema(obj, genOrder) + processedSchemaStr = pprint.pformat(processedSchema,indent=2) + processedSchemaStrRef = """{ 'enums': [ { 'fields': ['RomCom', 'Horror', 'ScienceFiction', 'Vegetables'], + 'name': 'MovieType'}, + { 'fields': [ 'SaltAndPepper', + 'CreamAndChives', + 'Paprika', + 'Barbecue'], + 'name': 'CrispType'}], + 'rootName': 'VsolMessages', + 'structs': [ { 'fields': { 'movies': 'vector', + 'someInts2': 'vector', + 'someStrings': 'vector'}, + 'name': 'A'}, + { 'fields': {'someAs': 'vector', 'someInts': 'vector'}, + 'name': 'B'}, + { 'fields': {'ddd': 'vector', 'someBs': 'vector'}, + 'name': 'C'}]}""" - def test_GeneratePreambleEnumerationAndStructs(self): - fn = os.path.join(os.path.dirname(__file__), 'test', 'test1.jsonc') - obj = LoadSchema(fn) - (_,outputStreams,_) = ProcessSchema(obj) + self.assertEqual(processedSchemaStrRef,processedSchemaStr) - tsPreambleRef: str = "// autogenerated by stonegentool on Fri Feb 15 07:36:51 2019\n" - tsEnumsRef: str = """enum MovieType -{ - Romcom, + def test_GenerateTypeScriptEnums(self): + fn = os.path.join(os.path.dirname(__file__), 'test_data', 'test1.yaml') + tdico = GetTemplatingDictFromSchemaFilename(fn) + template = Template(""" // end of generic methods +{% for enum in enums%} export enum {{enum['name']}} { +{% for key in enum['fields']%} {{key}}, +{%endfor%} }; + +{%endfor%}""") + renderedCode = template.render(**tdico) + renderedCodeRef = """ // end of generic methods + export enum MovieType { + RomCom, Horror, ScienceFiction, - Vegetables -}; + Vegetables, + }; -enum CrispType -{ + export enum CrispType { SaltAndPepper, CreamAndChives, Paprika, - Barbecue -}; - -""" - - tsStructsRef: str = """class A -{ - public Array someStrings; - public Array someInts2; -}; - -class B -{ - public Array someAs; - public Array someInts; -}; - -class C -{ - public Array someBs; - public Array ddd; -}; - -""" - - tsPreambleRefCastrated: str = RemoveDateTimeLine(tsPreambleRef) - tsPreambleCastrated: str = RemoveDateTimeLine(outputStreams.tsPreamble.getvalue()) - self.assertEqual(tsPreambleRefCastrated,tsPreambleCastrated) - self.assertEqual(tsEnumsRef,outputStreams.tsEnums.getvalue()) - self.assertEqual(tsStructsRef,outputStreams.tsStructs.getvalue()) - - cppPreambleRef: str = """// autogenerated by stonegentool on Fri Feb 15 07:36:51 2019 -#include -#include -#include -#include + Barbecue, + }; """ - - cppEnumsRef: str = """enum MovieType -{ - Romcom, - Horror, - ScienceFiction, - Vegetables -}; - -enum CrispType -{ - SaltAndPepper, - CreamAndChives, - Paprika, - Barbecue -}; + self.assertEqual(renderedCodeRef,renderedCode) -""" - cppStructsRef: str = """struct A -{ - std::vector someStrings; - std::vector someInts2; -}; - -struct B -{ - std::vector someAs; - std::vector someInts; -}; - -struct C -{ - std::vector someBs; - std::vector ddd; -}; - -""" - cppPreambleRefCastrated: str = RemoveDateTimeLine(cppPreambleRef) - cppPreambleCastrated: str = RemoveDateTimeLine(outputStreams.cppPreamble.getvalue()) - self.assertEqual(cppPreambleRefCastrated,cppPreambleCastrated) - self.assertEqual(cppEnumsRef,outputStreams.cppEnums.getvalue()) - self.assertEqual(cppStructsRef,outputStreams.cppStructs.getvalue()) def test_GenerateTypeScriptHandlerInterface(self): pass diff -r 6470248790db -r 8e7e151ef472 Resources/CodeGeneration/template.in.ts --- a/Resources/CodeGeneration/template.in.ts Mon Feb 18 15:38:05 2019 +0100 +++ b/Resources/CodeGeneration/template.in.ts Wed Feb 20 20:51:30 2019 +0100 @@ -1,38 +1,125 @@ -class Greeter { - greeting: string; - constructor(message: string) { - this.greeting = message; +/* + 1 2 3 4 5 6 7 +12345678901234567890123456789012345678901234567890123456789012345678901234567890 +*/ + +namespace {{rootName}} +{ + function StoneCheckSerializedValueType(value: any, typeStr: string) + { + StoneCheckSerializedValueTypeGeneric(value); + + if (value['type'] != typeStr) + { + throw new Error( + `Cannot deserialize type ${value['type']} into ${typeStr}`); } - greet() { - return "Hello, " + this.greeting; + } + + function isString(val: any) :boolean + { + return ((typeof val === 'string') || (val instanceof String)); + } + + function StoneCheckSerializedValueTypeGeneric(value: any) + { + if ( (!('type' in value)) || (!isString(value)) ) + { + throw new Error( + "Cannot deserialize value ('type' key invalid)"); } -} -enum Color { Red, Green, Blue }; + } + +// end of generic methods +{% for enum in enums%} + export enum {{enum['name']}} { + {% for key in enumDict.keys()%} + {{key}}, + {%endfor%} + }; +{%endfor%} + + export class Message1 { + a: number; + b: string; + c: EnumMonth0; + d: boolean; + public StoneSerialize(): string { + let container: object = {}; + container['type'] = 'VsolStuff.Message1'; + container['value'] = this; + return JSON.stringify(container); + } + }; -class TestMessage { - s1: string; - s2: Array; - s3: Array>; - s4: Map; - s5: Map>; - s6: Color; - s7: boolean; -} + export class Message2 { + constructor() + { + this.tata = new Array(); + this.tutu = new Array(); + this.titi = new Map(); + this.lulu = new Map(); + } + toto: string; + tata: Message1[]; + tutu: string[]; + titi: Map; + lulu: Map; + + public StoneSerialize(): string { + let container: object = {}; + container['type'] = 'VsolStuff.Message2'; + container['value'] = this; + return JSON.stringify(container); + } + public static StoneDeserialize(valueStr: string) : Message2 + { + let value: any = JSON.parse(valueStr); + StoneCheckSerializedValueType(value, "VsolStuff.Message2"); + let result: Message2 = value['value'] as Message2; + return result; + } + }; + + export interface IDispatcher + { + HandleMessage1(value: Message1): boolean; + HandleMessage2(value: Message2): boolean; + }; -let tm = new TestMessage(); -tm.s2 = new Array() -tm.s2.push("toto"); -tm.s2.push("toto2"); -tm.s2.push("toto3"); -tm.s4 = new Map(); -tm.s4["toto"] = 42; -tm.s4["toto"] = 1999; -tm.s4["tatata"] = 1999; -tm.s6 = Color.Red; -tm.s7 = true + /** Service function for StoneDispatchToHandler */ + export function StoneDispatchJsonToHandler( + jsonValueStr: string, dispatcher: IDispatcher): boolean + { + let jsonValue: any = JSON.parse(jsonValueStr); + StoneCheckSerializedValueTypeGeneric(jsonValue); + let type: string = jsonValue["type"]; + if (type == "") + { + // this should never ever happen + throw new Error("Caught empty type while dispatching"); + } + else if (type == "VsolStuff.Message1") + { + let value = jsonValue["value"] as Message1; + return dispatcher.HandleMessage1(value); + } + else if (type == "VsolStuff.Message2") + { + let value = jsonValue["value"] as Message2; + return dispatcher.HandleMessage2(value); + } + else + { + return false; + } + } -let txt = JSON.stringify(tm) -console.log(txt); - -let greeter = new Greeter("world"); - + /** Takes a serialized type and passes this to the dispatcher */ + export function StoneDispatchToHandler( + strValue: string, dispatcher: IDispatcher): boolean + { + let jsonValue: any = JSON.parse(strValue) + return StoneDispatchJsonToHandler(jsonValue, dispatcher); + } +} diff -r 6470248790db -r 8e7e151ef472 Resources/CodeGeneration/test_data/test1.yaml --- a/Resources/CodeGeneration/test_data/test1.yaml Mon Feb 18 15:38:05 2019 +0100 +++ b/Resources/CodeGeneration/test_data/test1.yaml Wed Feb 20 20:51:30 2019 +0100 @@ -10,7 +10,7 @@ struct C: someBs: vector - ddd: vector + ddd: vector struct A: someStrings: vector