public void Test_GetNamespace_IgnoredNamespaceGeneric() { TypeDefinition testType = GetType(typeof(ReadOnlySpan <>).Module.FullyQualifiedName, "mdoc.Test.SampleClasses.ReadOnlySpan`1"); var ns = DocUtils.GetNamespace(testType.GenericParameters.First()); Assert.AreEqual("", ns); }
public void DocidCheck() { XmlDocument doc = new System.Xml.XmlDocument(); doc.LoadXml(XmlConsts.CheckDocidXml); //c# MemberSignature is the same,but docid not var listA = doc.SelectNodes("/Type/Members/Member[@MemberName='op_Implicit']"); if (listA.Count == 2) { var Notequal = DocUtils.DocIdCheck(listA[0], (XmlElement)listA[1]); Assert.IsTrue(Notequal); } //note:c not have docid item in xml var b = doc.SelectSingleNode("/Type/Members/Member[@MemberName='op_Implicit']"); var c = doc.SelectSingleNode("/Type/Members/Member[@MemberName='.ctor']"); var flg1 = DocUtils.DocIdCheck(b, (XmlElement)c); Assert.IsFalse(flg1); //Parameter change position var flg2 = DocUtils.DocIdCheck(c, (XmlElement)b); Assert.IsFalse(flg2); // c# MemberSignature is not same,docid also var d = doc.SelectSingleNode("/Type/Members/Member[@MemberName='Value']"); var flg3 = DocUtils.DocIdCheck(b, (XmlElement)d); Assert.IsTrue(flg3); }
public bool HasNestedClassesDuplicateNames(TypeReference tref) { string inputName = DocUtils.GetFormattedTypeName(tref.Name); TypeDefinition parentType; try { parentType = tref.DeclaringType?.Resolve(); } catch { //Resolve() can fail as sometimes Cecil understands types as .net //needs to ignore those errors parentType = null; } if (parentType != null && parentType.HasNestedTypes) { var listOfNested = parentType.NestedTypes; int count = listOfNested.Select(x => DocUtils.GetFormattedTypeName(x.Name)).Count(y => y == inputName); if (count > 1) { return(true); } } return(false); }
public void UpdateDMVT() { DataTable dt = LibQLSX.Select("exec spGetNewModule"); if (dt.Rows.Count == 0) { return; } foreach (DataRow item in dt.Rows) { try { string moduleCode = TextUtils.ToString(item["FolderCode"]); string _serverPathCK = string.Format("Thietke.Ck/{0}/{1}.Ck/VT.{1}.xlsm", moduleCode.Substring(0, 6), moduleCode); DocUtils.InitFTPQLSX(); if (DocUtils.CheckExits(_serverPathCK)) { DocUtils.DownloadFile(_path, "VT." + moduleCode + ".xlsm", _serverPathCK); string filePathDMVT = _path + "VT." + moduleCode + ".xlsm"; if (!File.Exists(filePathDMVT)) { continue; } DataTable dtDMVT = TextUtils.ExcelToDatatableNoHeader(filePathDMVT, "DMVT"); TextUtils.AddDMVTfromModule(filePathDMVT); File.Delete(filePathDMVT); } } catch { } } }
protected virtual IList <GenericParameter> GetTypeSpecifiGenericParameters(TypeDefinition type) { var returnItems = new Collection <GenericParameter>(); List <TypeReference> decls = DocUtils.GetDeclaringTypes(type); List <TypeReference> genArgs = GetGenericArguments(type); int argIndex = 0; int previouslyAppliedCount = 0; var lastItem = decls.Last(); foreach (var decl in decls) { TypeReference declDef = decl.Resolve() ?? decl; int argumentCount = DocUtils.GetGenericArgumentCount(declDef); int countLeftUnupplied = argumentCount - previouslyAppliedCount; previouslyAppliedCount = argumentCount; if (decl != lastItem) { argIndex = argIndex + argumentCount; } if (countLeftUnupplied > 0 && decl == lastItem) { for (int i = 0; i < countLeftUnupplied; ++i) { returnItems.Add((GenericParameter)genArgs[argIndex++]); } } } return(returnItems); }
public void Update_ImportDoc_Test() { List <DocumentationImporter> setimporters = new List <DocumentationImporter>(); List <DocumentationImporter> importers = new List <DocumentationImporter>(); var filePath = Path.Combine(Path.GetDirectoryName(this.GetType().Module.Assembly.Location), "SampleClasses\\testImportDoc.xml"); MsxdocDocumentationImporter importer = new MsxdocDocumentationImporter( filePath); setimporters.Add(importer); XmlDocument doc = new System.Xml.XmlDocument(); doc.LoadXml(XmlConsts.internalEllXml); var type = GetType(typeof(mdoc.Test2.InternalEIICalss)); var docEnum = new DocumentationEnumerator(); var nodeMember = docEnum.GetDocumentationMembers(doc, type, FrameworkTypeEntry.Empty).FirstOrDefault(t => t.Member.FullName == "System.String mdoc.Test2.InternalEIICalss::Getstring(System.Int32)"); var testKeys = new string[] { "returns", "value", "related", "seealso" }; for (int i = 0; i < testKeys.Length; i++) { Assert.IsTrue(DocUtils.CheckRemoveByImporter(nodeMember, testKeys[i], importers, setimporters)); } }
private static bool ChkPropertyVisible(PropertyDefinition property) { MethodDefinition method; bool get_visible = false; bool set_visible = false; if ((method = property.GetMethod) != null && (DocUtils.IsExplicitlyImplemented(method) || (!method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly))) { get_visible = true; } if ((method = property.SetMethod) != null && (DocUtils.IsExplicitlyImplemented(method) || (!method.IsPrivate && !method.IsAssembly && !method.IsFamilyAndAssembly))) { set_visible = true; } if ((set_visible == false) && (get_visible == false)) { return(false); } else { return(true); } }
public void TestNodeCleaner2() { string xml = @"<Docs> <summary>To be added.</summary> <param name=""one"" name2=""n2"">To be added.</param> <!-- this is an xml comment --> <param name=""two"">written docs</param> random text <param name=""three"">Written but not provided</param> <![CDATA[ for some reason ]]> </Docs>"; string xml2 = @"<Docs> <summary>new summary</summary> <!-- this is another xml comment --> <param name=""one"" name2=""n2"">To be added.</param> random text <param name=""two"">written docs but changed</param> <param name=""three"">Written but and</param> <![CDATA[ for some reason ]]> </Docs>"; XmlDocument doc = new XmlDocument(); doc.LoadXml(xml); XmlDocument incomingDoc = new XmlDocument(); incomingDoc.LoadXml(xml2); DocUtils.ClearNodesIfNotDefault(doc.FirstChild, incomingDoc.FirstChild); Assert.IsTrue(doc.FirstChild.ChildNodes.Count == 0); }
protected override StringBuilder AppendGenericType(StringBuilder buf, TypeReference type, IAttributeParserContext context, bool appendGeneric = true, bool useTypeProjection = false, bool isTypeofOperator = false) { List <TypeReference> decls = DocUtils.GetDeclaringTypes( type is GenericInstanceType ? type.GetElementType() : type); bool first = true; foreach (var decl in decls) { TypeReference declDef = decl.Resolve() ?? decl; if (!first) { buf.Append(NestedTypeSeparator); } first = false; AppendTypeName(buf, declDef, context); } buf.Append('<'); first = true; foreach (TypeReference arg in GetGenericArguments(type)) { if (!first) { buf.Append(", "); } first = false; _AppendTypeName(buf, arg, context); } buf.Append('>'); return(buf); }
public void IsIgnored_GetMethodIsNotGeneratedByProperty_IsIgnoredFalse() { var method = GetMethod(typeof(SomeClass), nameof(SomeClass.get_Method)); var isIgnoredPropertyGeneratedMethod = DocUtils.IsIgnored(method); Assert.False(isIgnoredPropertyGeneratedMethod); }
protected override string GetMethodName(MethodReference method) { if (DocUtils.IsDestructor(method.Resolve())) { return("Close"); } return(CamelCase(method.Name)); }
public void IsIgnored_SetMethodIsGeneratedByProperty_IsIgnoredTrue() { var method = GetMethod(typeof(SomeClass), "set_" + nameof(SomeClass.Property4)); var isIgnoredPropertyGeneratedMethod = DocUtils.IsIgnored(method); Assert.IsTrue(isIgnoredPropertyGeneratedMethod); }
public void IsIgnored_GetMethodInIterfaceIsGeneratedByProperty_IsIgnoredTrue() { var method = GetMethod(typeof(SomeInterface), "get_B"); var isIgnoredPropertyGeneratedMethod = DocUtils.IsIgnored(method); Assert.IsTrue(isIgnoredPropertyGeneratedMethod); }
public void TestCase_OnlyDirectlyImplemented() { var type = GetTypeDef <TestClassWithInterfaces> (); var ifaces = DocUtils.GetUserImplementedInterfaces(type).ToArray(); Assert.AreEqual(2, ifaces.Count()); Assert.AreEqual("I2", ifaces[0].Name); Assert.AreEqual("ICombined", ifaces[1].Name); }
protected override string GetTypeDeclaration(TypeDefinition type) { var buf = new StringBuilder(); if (type.IsEnum) { // var value = [fully qualified type].[camel-cased name of first enum value]; var firstElement = type.GetMembers().Skip(1).First();//skip "__value element" buf.Append("var value = "); buf.Append(ProcessFullName(type.FullName)); buf.Append("."); buf.Append(CamelCase(firstElement.Name)); return(buf.ToString()); } if (type.IsValueType) { //Structures: Windows Runtime structures are objects in JavaScript. // If you want to pass a Windows Runtime structure to a Windows Runtime method, // don't instantiate the structure with the new keyword. Instead, create an object // and add the relevant members and their values. The names of the members should be in camel case: // SomeStruct.firstMember. // var [struct name, camel cased] = { // [fieldname, came cased] : /* Your value */ buf.Append("var "); buf.Append(CamelCase(GetName(type))); buf.Append(" = {"); buf.Append(GetLineEnding()); buf.Append(string.Join("," + GetLineEnding(), type.Fields.Select(i => CamelCase(i.Name) + " : /* Your value */"))); buf.Append(GetLineEnding()); buf.Append("}"); return(buf.ToString()); } if (DocUtils.IsDelegate(type)) { // var [delegateName, camel-cased]Handler = function([parameter name list, camel cased]){ // /* Your code */ // } MethodDefinition invoke = type.GetMethod("Invoke"); buf.Append("var "); buf.Append(CamelCase(GetName(type))); buf.Append("Handler = function("); AppendParameters(buf, invoke, invoke.Parameters); buf.Append("){"); buf.Append(GetLineEnding()); buf.Append("/* Your code */"); buf.Append(GetLineEnding()); buf.Append("}"); return(buf.ToString()); } var publicConstructor = GetConstructor(type); return(GetDeclaration(publicConstructor)); }
public void IsIgnored_GetMethodIsGeneratedByProperty_IsIgnoredTrue() { var method = GetMethod(typeof(DiscriminatedUnions.Shape.Circle), "get_" + nameof(DiscriminatedUnions.Shape.Circle.radius)); var isIgnoredPropertyGeneratedMethod = DocUtils.IsIgnored(method); Assert.IsTrue(isIgnoredPropertyGeneratedMethod); }
public void IsIgnored_GetMethodIsNotGeneratedByProperty_IsIgnoredFalse() { var method = GetMethod(typeof(Functions), nameof(Functions.get_function)); var isIgnoredPropertyGeneratedMethod = DocUtils.IsIgnored(method); Assert.IsFalse(isIgnoredPropertyGeneratedMethod); }
public void IsIgnored_GetMethodIsGeneratedByProperty2_IsIgnoredTrue() { var method = GetMethod(typeof(DiscriminatedUnions.SizeUnion), "get_" + nameof(DiscriminatedUnions.SizeUnion.Large)); var isIgnoredPropertyGeneratedMethod = DocUtils.IsIgnored(method); Assert.IsTrue(isIgnoredPropertyGeneratedMethod); }
protected override string GetPropertyDeclaration(PropertyDefinition property) { MethodDefinition gm = null, sm = null; string get_visible = null; if ((gm = property.GetMethod) != null && (DocUtils.IsExplicitlyImplemented(gm) || (!gm.IsPrivate && !gm.IsAssembly && !gm.IsFamilyAndAssembly))) { get_visible = AppendVisibility(new StringBuilder(), gm).ToString(); } string set_visible = null; if ((sm = property.SetMethod) != null && (DocUtils.IsExplicitlyImplemented(sm) || (!sm.IsPrivate && !sm.IsAssembly && !sm.IsFamilyAndAssembly))) { set_visible = AppendVisibility(new StringBuilder(), sm).ToString(); } if ((set_visible == null) && (get_visible == null)) { return(null); } StringBuilder buf = new StringBuilder() .Append(".property "); if (!(gm ?? sm).IsStatic) { buf.Append("instance "); } _AppendTypeName(buf, property.PropertyType, AttributeParserContext.Create(property)); buf.Append(' ').Append(property.Name); if (!property.HasParameters || property.Parameters.Count == 0) { return(buf.ToString()); } buf.Append('('); bool first = true; foreach (ParameterDefinition p in property.Parameters) { if (!first) { buf.Append(", "); } first = false; _AppendTypeName(buf, p.ParameterType, AttributeParserContext.Create(p)); } buf.Append(')'); return(buf.ToString()); }
public void TestCase() { var type = GetTypeDef <TestClassWithInterfaces> (); var ifaces = DocUtils.GetAllPublicInterfaces(type).ToArray(); Assert.AreEqual(3, ifaces.Count()); Assert.AreEqual("I2", ifaces[0].Name); Assert.AreEqual("ICombined", ifaces[1].Name); Assert.AreEqual("I1", ifaces[2].Name); }
protected override StringBuilder AppendNamespace(StringBuilder buf, TypeReference type) { string ns = DocUtils.GetNamespace(type, NestedTypeSeparator); if (GetCppType(type.FullName) == null && !string.IsNullOrEmpty(ns) && ns != "System") { buf.Append(ns).Append(NestedTypeSeparator); } return(buf); }
private bool IsMethodSupported(MethodDefinition methodDefinition) { bool isDestructor = DocUtils.IsDestructor(methodDefinition); return (!DocUtils.IsOperator(methodDefinition) && (!isDestructor || methodDefinition.DeclaringType.Interfaces.Any(i => i.InterfaceType.FullName == "Windows.Foundation.IClosable")) && methodDefinition.Parameters.All(i => IsSupported(i.CustomAttributes) && !(i.ParameterType is ByReferenceType)) && IsSupported(methodDefinition.MethodReturnType.CustomAttributes)); }
public void IsIgnored_PutMethodIsGeneratedByProperty_IsIgnoredTrue() { var classWithProperties = GetType(UWPTestComponentWinMD, "mdoc.Test.UWP.TestComponent.UwpClassWithProperties"); var method = GetMethod(classWithProperties, i => i.Name == "put_MyReadWriteProperty"); var isIgnoredPropertyGeneratedMethod = DocUtils.IsIgnored(method); Assert.IsTrue(isIgnoredPropertyGeneratedMethod); }
protected override StringBuilder AppendNamespace(StringBuilder buf, TypeReference type) { string ns = DocUtils.GetNamespace(type); if (GetCSharpType(type.FullName) == null && ns != null && ns.Length > 0 && ns != "System") { buf.Append(ns).Append('.'); } return(buf); }
private bool IsCustomAttribute(TypeDefinition typedef) { var containingTypeNamespace = DocUtils.GetNamespace(typedef); if (typedef.BaseType?.FullName == "System.Attribute" && !containingTypeNamespace.StartsWith("System.") && !containingTypeNamespace.StartsWith("System")) { return(true); } return(false); }
public void IsEiiignoredMethod() { var type = GetType(typeof(mdoc.Test2.InternalEIICalss)); var member = type.Methods.FirstOrDefault(t => t.FullName == "System.String mdoc.Test2.InternalEIICalss::mdoc.Test.SampleClasses.InterfaceA.get_color()"); Assert.IsTrue(member.IsSpecialName); member.IsSpecialName = false; var result = DocUtils.IsEiiIgnoredMethod(member, member.Overrides[0]); Assert.IsTrue(result); }
private static bool IsAttachedEventHandler(TypeReference typeReference) { var type = typeReference.Resolve(); if (!DocUtils.IsDelegate(type)) { return(false); } MethodDefinition invoke = type.GetMethod("Invoke"); return(invoke.Parameters.Count == 2); }
protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefinition method) { if (DocUtils.IsExplicitlyImplemented(method)) { TypeReference iface; MethodReference ifaceMethod; DocUtils.GetInfoForExplicitlyImplementedMethod(method, out iface, out ifaceMethod); return(buf.Append(new CSharpMemberFormatter(this.TypeMap).GetName(iface)) .Append('.') .Append(ifaceMethod.Name)); } return(base.AppendMethodName(buf, method)); }
protected override string GetPropertyDeclaration(PropertyDefinition property) { bool getVisible = property.GetMethod != null && property.GetMethod.IsPublic; bool setVisible = property.SetMethod != null && property.SetMethod.IsPublic; var method = property.SetMethod ?? property.GetMethod; // https://github.com/mono/api-doc-tools/issues/133 // var [property value type, camel-cased] = [typename, camel-cased].[property name, camel-cased]; // [typename, camel-cased].[property name, camel-cased] = [property value type, camel-cased]; // Static properties // var [property value type, camel-cased] = [typename].[property name, camel-cased]; // [typename].[property name, camel-cased] = [property value type, camel-cased]; var buf = new StringBuilder(); var propertyValueType = CamelCase(GetName(property.PropertyType)); var propertyName = DocUtils.GetPropertyName(property, NestedTypeSeparator); var propertyNameCamelCased = CamelCase(propertyName); var typeName = GetName(property.DeclaringType); if (!method.IsStatic) { typeName = CamelCase(typeName); } if (getVisible) { buf.Append("var "); buf.Append(propertyValueType); buf.Append(" = "); buf.Append(typeName); buf.Append("."); buf.Append(propertyNameCamelCased); buf.Append(";"); } if (setVisible) { if (getVisible) { buf.Append(GetLineEnding()); } buf.Append(typeName); buf.Append("."); buf.Append(propertyNameCamelCased); buf.Append(" = "); buf.Append(propertyValueType); buf.Append(";"); } return(buf.ToString()); }
public override bool IsSupportedMethod(MethodDefinition mdef) { if (DocUtils.IsExtensionMethod(mdef) //no support of 'params'; //can be substituted with 'Variadic functions' hovewer it's not full equivalent(not type safe + specific mechanism for reading) || mdef.Parameters.Any(IsParamsParameter) ) { return(false); } return (IsSupported(mdef.ReturnType) && mdef.Parameters.All(i => IsSupported(i.ParameterType))); }