private void LoadAssemblyDefAndExport() { List <DocumentedAssembly> assemblies = new List <DocumentedAssembly>(); DocumentedAssembly documentedAssembly = new DocumentedAssembly(TestFile); assemblies.Add(documentedAssembly); ExportConfigFile config = ExportConfigFile.Create(ConfigFile); ExportSettings settings = new ExportSettings(); settings.PublishDirectory = string.Empty; settings.Settings = new DocumentSettings(); settings.Settings.VisibilityFilters = new List <Visibility> { Visibility.Public, Visibility.Internal, Visibility.InternalProtected, Visibility.Protected, Visibility.Private }; Document document = new Document(assemblies); document.Settings = settings.Settings; document.UpdateDocumentMap(); WebsiteExporter exporter = new WebsiteExporter(document, settings, config); exporter.Export(); }
public void GenerateMap_WhenAssemblyHasTypesWithoutNamespace_TypesAreContainedInNoneNamespaceContainer() { const string TypeName = "Issue45_TypeWithNoNamespace"; const string NoneNamespaceName = "NoneNamespaces"; List <DocumentedAssembly> assemblies = new List <DocumentedAssembly>(); DocumentedAssembly documentedAssembly = new DocumentedAssembly { FileName = DocumentationFile }; EntryCreator creator = new EntryCreator(); assemblies.Add(documentedAssembly); GroupedNamespaceDocumentMapper mapper = new GroupedNamespaceDocumentMapper(assemblies, false, creator); DocumentMap result = mapper.GenerateMap(); AssemblyDef assembly = documentedAssembly.LoadedAssembly; TypeDef type = assembly.FindType(string.Empty, TypeName); Entry entry = result.FindById(type.GetGloballyUniqueId()); Assert.AreSame(type, entry.Item); // the type has been mapped Assert.AreEqual(NoneNamespaceName, entry.Parent.Parent.SubKey); // is part of the nonenamespace container }
/// <summary> /// Removes the assembly with the <paramref name="name"/>. /// </summary> /// <param name="name">The assembly to remove.</param> public void Remove(string name) { DocumentedAssembly assembly = this._project.GetAssemblies().Find(a => a.Name == name); if (assembly != null) { _project.RemovedAssemblies.Add(assembly.Name); HasChanged = true; } }
/// <summary> /// Removes the assembly with the <paramref name="uniqueId"/>. /// </summary> /// <param name="uniqueId">The assembly to remove.</param> public void Remove(long uniqueId) { DocumentedAssembly assembly = _project.GetAssemblies().Find(a => a.UniqueId == uniqueId); if (assembly != null) { _project.RemovedAssemblies.Add(assembly.Name); HasChanged = true; } }
public IEncodedString AssemblyName(DocumentedAssembly assembly) { var identity = assembly.Identity; var index = identity.IndexOf(','); if (index != -1) { identity = identity.Substring(0, index); } identity = string.Concat(identity, ".dll"); return(new RawString(identity)); }
public void AssemblyFirstDocumentMapper_When_Should() { List <DocumentedAssembly> assemblies = new List <DocumentedAssembly>(); EntryCreator entryCreator = new EntryCreator(); bool useObservableCollection = false; DocumentedAssembly documented = new DocumentedAssembly(); documented.FileName = "test.dll"; assemblies.Add(documented); AssemblyFirstDocumentMapper mapper = new AssemblyFirstDocumentMapper(assemblies, useObservableCollection, entryCreator); DocumentMap map = mapper.GenerateMap(); Assert.AreEqual(0, entryCreator.Created); }
private static DocumentedAssembly MapAssembly(IAssemblyInfo assembly, XmlDocumentationModel model) { var types = new List <DocumentedType>(); // Iterate all types in assembly. foreach (var type in assembly.Types) { var documentedType = MapType(type, model); types.Add(documentedType); // Add a reference to the type for every constructor. foreach (var constructor in documentedType.Constructors) { constructor.Type = documentedType; } // Add a reference to the type for every property. foreach (var property in documentedType.Properties) { property.Type = documentedType; } // Add a reference to the type for every method. foreach (var method in documentedType.Methods) { method.Type = documentedType; } } // Now group all the types in this assembly by their namespace. var namespaces = new List <DocumentedNamespace>(); var namespaceGroups = types.GroupBy(x => x.Definition.Namespace); foreach (var namespaceGroup in namespaceGroups) { var namespaceTypes = namespaceGroup.ToList(); // Do we have a documentation for this namespace? var documentation = namespaceGroup.FirstOrDefault(x => x.Definition.Name.EndsWith("NamespaceDoc")); var summary = documentation != null ? documentation.Summary : null; if (documentation != null) { namespaceTypes.Remove(documentation); } // Create a namespace for each grouping. var @namespace = new DocumentedNamespace(namespaceGroup.Key, namespaceTypes, summary); namespaces.Add(@namespace); // Connect the types in this namespace to the namespace. foreach (var documentedType in namespaceGroup) { documentedType.Namespace = @namespace; } } // Create an documented assembly out of it. var documentedAssembly = new DocumentedAssembly(assembly, namespaces); // Add the documented assembly as a parent of all namespaces. foreach (var @namespace in namespaces) { @namespace.Assembly = documentedAssembly; } // Return the documented assembly. return(documentedAssembly); }
public AssemblyViewModel(DocumentedAssembly assembly) { _metadata = assembly.Metadata; _name = assembly.Name; _namespaces = new List <DocumentedNamespace>(assembly.Namespaces.Where(ns => ns.HasContent)); }
public static IHtmlString AssemblyName(this ApiServices context, DocumentedAssembly assembly) { return(MvcHtmlString.Create(assembly.Name)); }
/// <summary> /// Refreshes the specified assemblies documentation in the UI. /// </summary> /// <param name="documentedAssembly">The assembly whose documentation needs updating.</param> /// <remarks> /// <para> /// When an assembly is refreshed the <see cref="DocumentMapper"/> is used to regenerate the /// document map for that assembly. /// </para> /// <para> /// If the assembly was not compiled before the refresh, is has its document map generated /// and is then inserted in to the current <see cref="DocumentMap"/>. /// </para> /// </remarks> public void RefreshAssembly(DocumentedAssembly documentedAssembly) { this.Map = this.Mapper.GenerateMap(); }