public void IterateMethodSignatures(string tab, Component jsonFile, Members thisMethod, string optionalFlag, bool useExport, bool isInterface, bool isSingleton) { string[] tokenizedTypes = GeneretorConfiguration.Settings.UseFullTyping ? TypeManager.getTokenizedReturnTypes(thisMethod.Return) : new string[] { "any" }; foreach (var tokenizedType in tokenizedTypes) { MethodParameters methodParameters = new MethodParameters(thisMethod); bool isStatic = !isInterface && ((isSingleton && (thisMethod.Static || thisMethod.Autodetected.Static)) || thisMethod.Static || SpecialCases.shouldStatic(jsonFile.Name, thisMethod.Name)); List <string> usedPermutations = new List <string>(); bool methodWritten = false; if (methodParameters.HasOnlyOneSignature()) { WriteMethod(tab, thisMethod.ShortDoc, thisMethod.Name, optionalFlag, methodParameters, tokenizedType, thisMethod.Return, useExport, isStatic, isInterface); } else if (ShouldCreateOverrideMethod(methodParameters.requiresOverrides, tokenizedTypes, tokenizedType)) { List <string> overrideTypes = methodParameters.paramNames.Select(a => "any").ToList(); MethodParameters overriddenMethodParams = methodParameters.CloneWithNewParamTypes(overrideTypes); WriteMethod(tab, thisMethod.ShortDoc, thisMethod.Name, optionalFlag, overriddenMethodParams, "any", thisMethod.Return, useExport, isStatic, isInterface); usedPermutations = overrideTypes; methodWritten = true; } if (GeneretorConfiguration.Settings.UseFullTyping && usedPermutations.Count > 0) { ProcessSignaturePermutations(tab, thisMethod, optionalFlag, tokenizedType, methodParameters, usedPermutations, methodWritten, useExport, isStatic); } } }
public void HandleReturnTypeSpecialCases(Members thisMethod, Component fileJson) { string propertyOverride = SpecialCases.getReturnTypeOverride(thisMethod.Return != null ? thisMethod.Return.Type : ""); if (!string.IsNullOrEmpty(propertyOverride)) { thisMethod.Return.Type = propertyOverride; } propertyOverride = SpecialCases.getReturnTypeOverride(fileJson.Name, thisMethod.Name); if ((thisMethod.Return != null || thisMethod.Return == null) && !string.IsNullOrEmpty(propertyOverride)) { if (thisMethod.Return == null) { var retorno = new Return() { Type = propertyOverride }; thisMethod.Return = retorno; } else { thisMethod.Return.Type = propertyOverride; } } }
public bool WriteMethods(Component jsonFile, List <string> processedNames, bool isInterface, bool useExport, bool staticOnly, bool isDeclare) { List <string> processedMethodNames = new List <string>(); string optionalFlag = ""; bool hasStaticMethods = false; bool isSingleton = !isInterface && (jsonFile.Singleton || staticOnly); var tab = isDeclare ? "\t" : "\t\t"; var classMethods = jsonFile.Members.Where(m => m.Tagname == "method"); foreach (var classMethod in classMethods) { var thisMethod = classMethod; if (ShouldIncludeMethod(jsonFile, thisMethod, isSingleton, isInterface, staticOnly, processedNames)) { if (SpecialCases.shouldRewriteMethod(jsonFile.Name, classMethod.Name)) { thisMethod = SpecialCases.getRewriteMethod(jsonFile.Name, classMethod.Name, classMethod); } processedMethodNames.Add(thisMethod.Name); NormalizeMethodDoc(thisMethod); HandleReturnTypeSpecialCases(thisMethod, jsonFile); optionalFlag = isInterface ? "?" : ""; if (SpecialCases.shouldConvertToProperty(jsonFile.Name, thisMethod.Name)) { WriteMethodAsProperty(thisMethod, tab, optionalFlag); } else { IterateMethodSignatures(tab, jsonFile, thisMethod, optionalFlag, useExport, isInterface, isSingleton); } } if (classMethod.Static && !hasStaticMethods && ShouldIncludeMethod(jsonFile, classMethod, isInterface, isSingleton, true, processedNames)) { hasStaticMethods = true; } } return(hasStaticMethods); }
public bool ShouldIncludeMethod(Component fileJson, Members thisMethod, bool isSingleton, bool isInterface, bool staticOnly, List <string> processedNames) { bool result = false; if (TypeManager.IsOwner(fileJson, thisMethod.Owner) || (fileJson.Mixins != null && fileJson.Mixins.Contains(thisMethod.Owner)) || isSingleton) { if ((!isInterface && (!isSingleton || (isSingleton && thisMethod.Name != "constructor"))) || (isInterface && thisMethod.Name != "constructor")) { if ((GeneretorConfiguration.Settings.IncludePrivate == thisMethod.Private || GeneretorConfiguration.Settings.IncludePrivate) || thisMethod.Protected || thisMethod.Template) { //Novo if (!staticOnly || (staticOnly && (thisMethod.Static || fileJson.Singleton || SpecialCases.shouldStatic(fileJson.Name, thisMethod.Name) || thisMethod.Name == "constructor"))) { if (!processedNames.Contains(thisMethod.Name) && thisMethod.Deprecated == null && !SpecialCases.shouldRemoveMethod(fileJson.Name, thisMethod.Name)) { if (!string.IsNullOrEmpty(thisMethod.Doc) || (!thisMethod.Doc.ToLower().Contains("overridden and disabled"))) { result = true; } } } } } if (isInterface && thisMethod.Static) { result = false; } } return(result); }
public List <string> WriteProperties(Component jsonFile, bool isInterface, bool useExport, bool isDeclare) { List <string> processedConfigNames = new List <string>(); var configs = jsonFile.Members.Where(m => m.Tagname == "cfg"); var properties = jsonFile.Members.Where(m => m.Tagname == "property"); string tab = isDeclare ? "\t" : "\t\t"; string optionalFlag = isInterface ? "?" : ""; string exportString = useExport ? "export var " : ""; if (!useExport && !isInterface && jsonFile.Singleton) { exportString = "static "; } foreach (var classConfig in configs) { if (classConfig.Owner == jsonFile.Name && classConfig.Name != "") { if (GeneretorConfiguration.Settings.IncludePrivate == classConfig.Private || GeneretorConfiguration.Settings.IncludePrivate) { if (classConfig.Static && !isInterface) { exportString = "static "; } if (!SpecialCases.shouldRemoveProperty(jsonFile.Name, classConfig.Name)) { string thisType = classConfig.Type; string overrideType = SpecialCases.getPropertyTypeOverride(jsonFile.Name, classConfig.Name); if (!string.IsNullOrEmpty(overrideType)) { thisType = overrideType; } // Property type conversions if (thisType.Contains("/") || thisType.Contains("|")) { string[] types = thisType.Split(new char[] { '/', '|' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < types.Count(); i++) { types[i] = TypeManager.NormalizeType(TypeManager.ConvertToInterface(types[i])); } thisType = string.Join(" | ", types); if (types.Contains("any") || types.Contains("any[]")) { thisType = "any"; } } else { thisType = TypeManager.NormalizeType(TypeManager.ConvertToInterface(thisType)); } definitionWriter.WriteToDefinition("{0}/** [Config Option] ({1}) {2} */", tab, classConfig.Type, definitionWriter.FormatCommentText(classConfig.ShortDoc)); definitionWriter.WriteToDefinition("{0}{1}{2}{3}: {4}", tab, exportString, classConfig.Name.Replace("-", ""), optionalFlag, thisType); } processedConfigNames.Add(classConfig.Name); } } } foreach (var classProperty in properties) { if ((!isInterface && jsonFile.Singleton) || (classProperty.Owner == jsonFile.Name && classProperty.Name != "")) { if (GeneretorConfiguration.Settings.IncludePrivate == classProperty.Private || GeneretorConfiguration.Settings.IncludePrivate) { if (classProperty.Static && !isInterface) { exportString = "static "; } if (!processedConfigNames.Contains(classProperty.Name) && !SpecialCases.shouldRemoveProperty(jsonFile.Name, classProperty.Name)) { string thisType = classProperty.Type; string overrideType = SpecialCases.getPropertyTypeOverride(jsonFile.Name, classProperty.Name); if (!string.IsNullOrEmpty(overrideType)) { thisType = overrideType; } // Property type conversions if (thisType.Contains("/") || thisType.Contains("|")) { string[] types = thisType.Split(new char[] { '/', '|' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < types.Count(); i++) { types[i] = TypeManager.NormalizeType(TypeManager.ConvertToInterface(types[i])); } if (!types.Contains("any")) { thisType = string.Join(" | ", types); } else { thisType = "any"; } } else { thisType = TypeManager.NormalizeType(TypeManager.ConvertToInterface(thisType)); } definitionWriter.WriteToDefinition("{0}/** [Property] ({1}) {2} */", tab, classProperty.Type, definitionWriter.FormatCommentText(classProperty.ShortDoc)); definitionWriter.WriteToDefinition("{0}{1}{2}{3}: {4}", tab, exportString, classProperty.Name.Replace('-', ' '), optionalFlag, thisType); } processedConfigNames.Add(classProperty.Name); } } } return(processedConfigNames); }