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);
}
}
}
}
