protected void readAndAddProp(ref ExtClass extClass, ExtObjectMember member, ParsedTypes types, bool ownedByCurrent, bool required) { string name = this.sanitizeName(member.Name); string[] docs = this.readJsDocs(member.Doc, JsDocsType.PROPERTY, extClass.Name.FullName, name); //if (extClass.Name.FullName == "Ext.Base") // Debugger.Break(); Property newPropItem = new Property( name, types.CfgOrProp, docs, member.Owner, ownedByCurrent ); //newPropItem.DefaultValue = String.IsNullOrEmpty(member.Default) ? "" : member.Default; newPropItem.DefaultValue = member.Default == "" ? "''" : member.Default; newPropItem.Deprecated = this.readJsDocsDeprecated( member.Deprecated, extClass.Name.FullName, name ); newPropItem.AccessModJs = this.readItemAccessModifier(member); newPropItem.AccessModTs = newPropItem.AccessModJs; newPropItem.IsStatic = (member.Static.HasValue && member.Static.Value == true); newPropItem.IsReadOnly = (member.Readonly.HasValue && member.Readonly.Value == true); if (!newPropItem.IsReadOnly) { string nameUpper = name.ToUpper(); if (name == nameUpper && types.CfgOrProp.Count == 1) { newPropItem.IsReadOnly = true; // it's looking like some contant: } } newPropItem.Renderable = extClass.Extends == null || name == "self"; // force render if it is class without any parent extClass.AddMemberProperty(newPropItem); }
protected void readAndAddCfgOrProp(ref ExtClass extClass, ExtObjectMember member, string currentClassName, bool cfgsCompleting) { string name = this.sanitizeName(member.Name); ParsedTypes types = this.typesParser.Parse( cfgsCompleting ? TypeDefinitionPlace.CONFIGURATION : TypeDefinitionPlace.PROPERTY, currentClassName, member.Name, member.Type ); bool ownedByCurrent = member.Owner.Length == currentClassName.Length && member.Owner == currentClassName; string rawDocs = String.IsNullOrEmpty(member.Doc) ? "" : member.Doc; bool required = member.Required.HasValue ? member.Required == true : rawDocs.Contains("(required)"); if (cfgsCompleting) { this.readAndAddCfg( ref extClass, member, types, ownedByCurrent, required ); } else { this.readAndAddProp( ref extClass, member, types, ownedByCurrent, required ); } }
protected bool isIdentifierNameWrong(string name, ExtObjectMember member) { if (name.Length == 0) { /*try { * throw new Exception( * "Empty identifier in class: `" + member.Owner + "`, member id: " + member.Id * ); * } catch (Exception e) { * this._exceptions.Add(e); * }*/ return(true); } if ( name.Contains("!") || name.Contains("%") || name.Contains("=") || name.Contains(".") ) { return(true); } return(false); }
protected void readAndAddMethod(ref ExtClass extClass, ExtObjectMember extObjectMember, ref FuncParamsSyntaxCollections funcParamsSyntaxCollections, string currentClassName, string methodName, bool ownedByCurrent, bool isStatic) { string[] docs = this.readJsDocs(extObjectMember.Doc, JsDocsType.METHOD, currentClassName, methodName); Method item = new Method( methodName, funcParamsSyntaxCollections.StandardParamsSyntax, docs, extObjectMember.Owner, ownedByCurrent ); item.Deprecated = this.readJsDocsDeprecated( extObjectMember.Deprecated, currentClassName, methodName ); item.AccessModJs = this.readItemAccessModifier(extObjectMember); item.AccessModTs = item.AccessModJs; item.ExistenceReason = ExistenceReasonType.NATURAL; item.IsStatic = isStatic; item.IsChainable = (extObjectMember.Chainable.HasValue && extObjectMember.Chainable.Value == true); item.IsTemplate = (extObjectMember.Template.HasValue && extObjectMember.Template.Value == true); item.Renderable = extClass.Extends == null || extObjectMember.Name == "statics"; // force render if it is class without any parent if (item.IsChainable) { item.Renderable = true; // always render chanable method with it's return type item.ReturnTypes.Add(extClass.Name.FullName); } else { if (extObjectMember.Return != null) { item.ReturnTypes = this.readAndAddMethodReturn( ref extClass, extObjectMember, currentClassName, isStatic ); } else { item.ReturnTypes.Add("void"); } } if (extObjectMember.Return != null && extObjectMember.Return.Doc != null) { item.ReturnDocs = this.readJsDocs( extObjectMember.Return.Doc, JsDocsType.METHOD_RETURN, currentClassName, "return" ); } extClass.AddMemberMethod(item); if (funcParamsSyntaxCollections.SpreadParamsSyntax.Count > 0) { // There is necessary to add second method form, // because there was last param with standard param // syntax mixed with spread param syntax: Method itemClone = item.Clone(); itemClone.OwnedByCurrent = item.OwnedByCurrent; itemClone.Params = funcParamsSyntaxCollections.SpreadParamsSyntax; extClass.AddMemberMethod(itemClone); } }
/** * Complete reference `funcParamsSyntaxCollections` with given `param` into proper collections. */ protected void readFunctionParam(ExtObjectMember extObjectMember, MemberParam param, ref FuncParamsSyntaxCollections funcParamsSyntaxCollections, ref ParsedTypes?lastParamTypes, bool eventCompleting, string currentClassName, string eventOrMethodName, bool isStatic, bool eventsCompleting, int lastParamIndex, int paramIndex) { ParsedTypes paramTypes; bool lastParamDefinition = paramIndex == lastParamIndex; // Parse param types - this types parsing result could have more result method forms: // - most often is form with normal params syntax // - but sometimes there could be another send method form // with params spread syntax or only this syntax if (lastParamDefinition) { paramTypes = lastParamTypes.Value; } else { paramTypes = this.typesParser.Parse( eventCompleting ? TypeDefinitionPlace.EVENT_PARAM : TypeDefinitionPlace.METHOD_PARAM, currentClassName + "." + extObjectMember.Name, param.Name, param.Type ); } // If param contains any sub-definitions, then param is probably // some kind of configuration object, which has all it's members // defined in Ext documentation. Then it's practicle to generate sub-interface: if (param.Properties != null && param.Properties.Count > 0) { this.readFunctionParamSpecials( param, ref paramTypes, eventCompleting, currentClassName, eventOrMethodName, isStatic, eventCompleting ); } //if (currentClassName == "Ext" && eventOrMethodName == "create") // Debugger.Break(); // Add completed param types into proper collection with name, param docs and all it's flags: this.readFunctionParamAddToParamsList( param, ref funcParamsSyntaxCollections, ref paramTypes, currentClassName, eventCompleting, lastParamDefinition ); }
protected AccessModifier readItemAccessModifier(ExtObjectMember member) { if (member.Private.HasValue && member.Private.Value == true) { return(AccessModifier.PRIVATE); } else if (member.Protected.HasValue && member.Protected.Value == true) { return(AccessModifier.PROTECTED); } else { return(AccessModifier.PUBLIC); } }
protected void readAndAddCfg(ref ExtClass extClass, ExtObjectMember member, ParsedTypes types, bool ownedByCurrent, bool required) { string name = this.sanitizeName(member.Name); string[] docs = this.readJsDocs(member.Doc, JsDocsType.CONFIGURATION, extClass.Name.FullName, name); Configuration newCfgItem = new Configuration( name, types.CfgOrProp, docs, member.Owner, ownedByCurrent ); newCfgItem.Required = required; //newCfgItem.DefaultValue = String.IsNullOrEmpty(member.Default) ? "" : member.Default; newCfgItem.DefaultValue = member.Default == "" ? "''" : member.Default; newCfgItem.Deprecated = this.readJsDocsDeprecated( member.Deprecated, extClass.Name.FullName, name ); extClass.AddMemberConfiguration(newCfgItem); }
protected FuncParamsSyntaxCollections readFunctionParams(ExtObjectMember extObjectMember, string currentClassName, bool eventCompleting, string eventOrMethodName, bool isStatic, bool eventsCompleting) { FuncParamsSyntaxCollections funcParamsSyntaxCollections = new FuncParamsSyntaxCollections() { SpreadParamsSyntax = new List <Param>(), StandardParamsSyntax = new List <Param>(), SpreadParamFound = false }; ParsedTypes?lastParamTypes = null; MemberParam lastParam; int lastParamIndex = 0; if (extObjectMember.Params.Count > 0) { lastParamIndex = extObjectMember.Params.Count - 1; lastParam = extObjectMember.Params[lastParamIndex]; lastParamTypes = this.typesParser.Parse( eventCompleting ? TypeDefinitionPlace.EVENT_PARAM : TypeDefinitionPlace.METHOD_PARAM, currentClassName + "." + extObjectMember.Name, lastParam.Name, lastParam.Type ); } int paramIndex = 0; List <string> readParamNames = new List <string>(); foreach (MemberParam param in extObjectMember.Params) { // Somethimes there could be probles with duplicated params in JSDuck output, // for example methods in version 6.2.0: Ext.util.Filter.isEqual? (filter: Ext.util.Filter, filter: Ext.util.Filter): boolean; ... if (readParamNames.Contains(param.Name)) { continue; } readParamNames.Add(param.Name); this.readFunctionParam( extObjectMember, param, ref funcParamsSyntaxCollections, ref lastParamTypes, eventCompleting, currentClassName, eventOrMethodName, isStatic, eventsCompleting, lastParamIndex, paramIndex ); paramIndex += 1; } return(funcParamsSyntaxCollections); }
protected void readAndAddEvent(ref ExtClass extClass, ExtObjectMember extObjectMember, ref FuncParamsSyntaxCollections funcParamsSyntaxCollections, string eventName, bool ownedByCurrent) { string[] docs = this.readJsDocs(extObjectMember.Doc, JsDocsType.EVENT, extClass.Name.FullName, eventName); Event newEventItem = new Event( eventName, funcParamsSyntaxCollections.StandardParamsSyntax, docs, extObjectMember.Owner, ownedByCurrent ); newEventItem.Deprecated = this.readJsDocsDeprecated( extObjectMember.Deprecated, extClass.Name.FullName, eventName ); /*if ( * funcParamsSyntaxCollections.StandardParamsSyntax.Count == 0 || ( * funcParamsSyntaxCollections.StandardParamsSyntax.Count > 0 && * funcParamsSyntaxCollections.StandardParamsSyntax[0].Name != "_this" * ) * ) { * Debugger.Break(); * }*/ if (extObjectMember.Return != null) { try { throw new Exception( $"Event methods couldn't have a return type: `{extClass.Name.FullName}:eventName`." ); } catch (Exception ex) { this.processor.Exceptions.Add(ex); } } extClass.AddMemberEvent(newEventItem); if (funcParamsSyntaxCollections.SpreadParamsSyntax.Count > 0) { // There is necessary to add second method form, // because there was last param with standard param // syntax mixed with spread param syntax: Event newEventItemClone = newEventItem.Clone(); newEventItemClone.Params = funcParamsSyntaxCollections.SpreadParamsSyntax; extClass.AddMemberEvent(newEventItemClone); } }
protected void readAndAddMethodOrEvent(ref ExtClass extClass, ExtObjectMember extObjectMember, string currentClassName, bool eventCompleting) { string funcOrEventName = this.sanitizeName(extObjectMember.Name); bool ownedByCurrent = extObjectMember.Owner.Length == currentClassName.Length && extObjectMember.Owner == currentClassName; bool isStatic = (extObjectMember.Static.HasValue && extObjectMember.Static.Value == true); FuncParamsSyntaxCollections funcParamsSyntaxCollections = this.readFunctionParams( extObjectMember, currentClassName, eventCompleting, funcOrEventName, isStatic, eventCompleting ); if (eventCompleting) { this.readAndAddEvent( ref extClass, extObjectMember, ref funcParamsSyntaxCollections, funcOrEventName, ownedByCurrent ); } else { this.readAndAddMethod( ref extClass, extObjectMember, ref funcParamsSyntaxCollections, currentClassName, funcOrEventName, ownedByCurrent, isStatic ); } }
protected List <string> readAndAddMethodReturn(ref ExtClass extClass, ExtObjectMember extObjectMember, string currentClassName, bool isStatic) { List <string> returnTypes = new List <string>(); List <string> rawReturnTypes = this.typesParser.Parse( TypeDefinitionPlace.METHOD_RETURN, currentClassName, extObjectMember.Name, extObjectMember.Return.Type ).MethodOrEventReturn; // check if there is any directly written object: string rawReturnType; List <string> rawMembers; string rawMember; string[] rawMemberNameAndType; string rawMemberName; List <string> rawMemberTypes; string[] returnDocs = null; Property prop; if (extObjectMember.Return != null && extObjectMember.Return.Doc != null) { returnDocs = this.readJsDocs( extObjectMember.Return.Doc, JsDocsType.METHOD_RETURN, currentClassName, "return" ); } for (int i = 0; i < rawReturnTypes.Count; i++) { rawReturnType = rawReturnTypes[i]; if (rawReturnType.Length > 2 && rawReturnType.StartsWith("{") && rawReturnType.EndsWith("}")) { // Ext.draw.engine.Canvas.getBBox(): {x: Number, y: Number, width: number, height: number} ExtClass returnClass = new ExtClass( this.extClassMethodReturnObjectPresudoClassName( currentClassName, extObjectMember.Name, isStatic ), SpecialsGenerator.BASE_RETURNS_INTERFACE_NAME, returnDocs ); returnClass.Package = extClass.Package; //returnClass.SrcJson = this.srcJson; returnClass.Name.PackagedNamespace = this.GetPackagedNamespaceFromFullClassName( extClass.Name.FullName ); returnClass.ClassType = ClassType.CLASS_METHOD_RETURN_OBJECT; returnClass.Link = new string[] { currentClassName + "." + extObjectMember.Name, this.GetLinkHrefForClassMethod( currentClassName, isStatic, extObjectMember.Name ) }; //returnClass.AddMemberProperty() rawReturnType = rawReturnType.TrimStart('{').TrimEnd('}'); rawMembers = rawReturnType.Split(',').ToList <string>(); for (int j = 0; j < rawMembers.Count; j++) { rawMember = rawMembers[j].Trim(); rawMemberNameAndType = rawMember.Split(':').ToArray <string>(); if (rawMemberNameAndType.Length == 1) { rawMemberName = rawMemberNameAndType[0]; rawMemberTypes = this.typesParser.Parse( TypeDefinitionPlace.METHOD_RETURN, currentClassName, extObjectMember.Name, extObjectMember.Return.Type ).MethodOrEventReturn; // rawMemberNameAndType[1] } else if (rawMemberNameAndType.Length > 1) { rawMemberName = rawMemberNameAndType[0]; rawMemberTypes = new List <string>() { "any" }; } else { continue; } prop = new Property( rawMemberName, rawMemberTypes, null, returnClass.Name.FullName, true ); prop.IsStatic = false; prop.IsReadOnly = false; prop.Inherited = false; prop.AccessModJs = AccessModifier.PUBLIC; prop.AccessModTs = AccessModifier.PUBLIC; returnClass.AddMemberProperty(prop); } this.processor.Store.AddExtClass(returnClass); returnTypes.Add(returnClass.Name.FullName); } else { returnTypes.Add(rawReturnType); } } return(returnTypes); }
protected void readClassMembers(ExtObject extObject, ExtClass extClass) { bool selfPropMatched = false; bool staticsMethodMatched = false; ExtObjectMember selfProp = null; ExtObjectMember staticsMethod = null; foreach (ExtObjectMember member in extObject.Members) { if (this.isIdentifierNameWrong(member.Name, member)) { continue; } if (member.Tagname == "cfg") { this.readAndAddCfgOrProp(ref extClass, member, extObject.Name, true); } else if (member.Tagname == "property") { if (member.Name == "self") { selfPropMatched = true; selfProp = member; } else { this.readAndAddCfgOrProp(ref extClass, member, extObject.Name, false); } } else if (member.Tagname == "event") { this.readAndAddMethodOrEvent(ref extClass, member, extObject.Name, true); } else if (member.Tagname == "method") { if (member.Name == "statics") { staticsMethodMatched = true; staticsMethod = member; } else { this.readAndAddMethodOrEvent(ref extClass, member, extObject.Name, false); } } else { throw new Exception(String.Format( "Unknown Ext class member tagname: `{0}` (`{1}`).", member.Tagname, extClass.Name.FullName )); } } // Add customly typed `self` protected property for any class with self property: if (selfPropMatched || staticsMethodMatched) { bool extClassHasStaticMembers = ( extClass.Members.PropertiesStatic.Count > 0 || extClass.Members.MethodsStatic.Count > 0 ); if (selfPropMatched) { if (extClassHasStaticMembers) { // Add custom self type: this.readAndAddCfgOrProp( ref extClass, new ExtObjectMember() { Name = "self", Doc = selfProp.Doc, Protected = true, Default = "Ext.Base", Static = false, Type = extClass.Name.FullName + SpecialsGenerator.STATICS_NAME_ADDITION, Owner = selfProp.Owner, }, extObject.Name, false ); } else { this.readAndAddCfgOrProp(ref extClass, selfProp, extObject.Name, false); } } if (staticsMethodMatched) { if (extClassHasStaticMembers) { // Add custom statics() return type: this.readAndAddMethodOrEvent( ref extClass, new ExtObjectMember() { Name = "statics", Doc = staticsMethod.Doc, Protected = true, Chainable = false, Template = false, Static = false, Params = staticsMethod.Params, Return = new Return() { Doc = null, Type = extClass.Name.FullName + SpecialsGenerator.STATICS_NAME_ADDITION }, Owner = staticsMethod.Owner, }, extObject.Name, false ); } else { this.readAndAddMethodOrEvent(ref extClass, staticsMethod, extObject.Name, false); } } } }