public ChangeInfo(string caption, IDocumentation docOriginal, IDocumentation docChange) { m_caption = caption; m_original = docOriginal; m_change = docChange; m_accept = false; }
/// <summary> /// Explicit constructor /// </summary> /// <param name="rawName">Member name</param> /// <param name="displayName">Member display name</param> /// <param name="type">Member type</param> /// <param name="documentation">Documentation source</param> internal DocMember(string rawName, string displayName, MemberType type, IDocumentation documentation) { RawName = rawName; DisplayName = displayName; Type = type; Documentation = documentation; }
public INamespaceMetric CalculateFrom(NamespaceDeclarationSyntaxInfo namespaceNode, IEnumerable <ITypeMetric> metrics) { const string DocumentationTypeName = "NamespaceDoc"; var typeMetrics = metrics.AsArray(); var documentationType = typeMetrics.FirstOrDefault(x => x.Name == DocumentationTypeName); IDocumentation documentation = null; if (documentationType != null) { documentation = documentationType.Documentation; typeMetrics = typeMetrics.Where(x => x.Name != DocumentationTypeName).AsArray(); } var linesOfCode = typeMetrics.Sum(x => x.LinesOfCode); var source = typeMetrics.SelectMany(x => x.ClassCouplings) .GroupBy(x => x.ToString()) .Select(x => new TypeCoupling(x.First().TypeName, x.First().Namespace, x.First().Assembly, x.SelectMany(y => y.UsedMethods), x.SelectMany(y => y.UsedProperties), x.SelectMany(y => y.UsedEvents))) .Where(x => x.Namespace != namespaceNode.Name) .OrderBy(x => x.Assembly + x.Namespace + x.TypeName) .AsArray(); var maintainabilitySource = typeMetrics.Select(x => new Tuple <int, double>(x.LinesOfCode, x.MaintainabilityIndex)).AsArray(); var maintainabilityIndex = linesOfCode > 0 && maintainabilitySource.Any() ? maintainabilitySource.Sum(x => x.Item1 * x.Item2) / linesOfCode : 100.0; var cyclomaticComplexity = typeMetrics.Sum(x => x.CyclomaticComplexity); var depthOfInheritance = typeMetrics.Any() ? typeMetrics.Max(x => x.DepthOfInheritance) : 0; return(new NamespaceMetric( maintainabilityIndex, cyclomaticComplexity, linesOfCode, source, depthOfInheritance, namespaceNode.Name, typeMetrics, documentation)); }
/// <summary> /// An Iterator that returns fully formatted XML documentation for the C# programming language. /// </summary> /// <param name="documentation">The source code model that has documentation.</param> /// <returns>The enumerator that loads the formatted XML documentation for the CSharp Language.</returns> public static IEnumerable <string> CSharpFormatXmlDocumentationEnumerator(this IDocumentation documentation) { //No documentation was found for the model, stop the enumeration. if (documentation == null) { yield break; } //No documentation for this model has been set, stop the enumeration. if (!documentation.HasDocumentation) { yield break; } //Split the existing documentation into individual lines to be processed. var documentLines = documentation.Documentation.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None); //iterate over each document line and confirm it can be formatted for C# xml documentation. foreach (string docData in documentLines) { //Looping through each line of XML documentation and formatting it for visual studio output. var formattedDocLine = docData.CSharpFormatDocumentationLine(); if (formattedDocLine == null) { continue; } yield return(formattedDocLine); } }
public Generator(ISettings settings, int indent, IDocumentation behaviour, IList <Field>?fields = null, bool includePaging = false, bool includeCancellation = false) { if (indent is < 0 or > 20) { throw new ArgumentOutOfRangeException(nameof(indent)); } Settings = settings ?? throw new ArgumentNullException(nameof(settings)); _indent = indent; _documentation = behaviour ?? throw new ArgumentNullException(nameof(behaviour)); _fields = fields; _includePaging = includePaging; _includeCancellation = includeCancellation; }
/// <summary> /// Default constructor /// </summary> /// <param name="rawName">Member raw name</param> /// <param name="displayName">Member display name</param> /// <param name="typeKey">Member type key</param> /// <param name="source">Documentation source</param> internal DocMember(string rawName, string displayName, char typeKey, XElement source) { // If the source is null.. if (source is null) { // throw an exception throw new ArgumentNullException(nameof(source)); } RawName = rawName.Replace("/", ".", StringComparison.InvariantCultureIgnoreCase); DisplayName = displayName; Type = (MemberType)typeKey; Documentation = new DocumentationContent(source); }
public NamespaceMetric( double maintainabilityIndex, int cyclomaticComplexity, int linesOfCode, IEnumerable<ITypeCoupling> classCouplings, int depthOfInheritance, string name, IEnumerable<ITypeMetric> typeMetrics, IDocumentation documentation) { MaintainabilityIndex = maintainabilityIndex; CyclomaticComplexity = cyclomaticComplexity; LinesOfCode = linesOfCode; ClassCouplings = classCouplings; DepthOfInheritance = depthOfInheritance; Name = name; Documentation = documentation; TypeMetrics = typeMetrics.AsArray(); Abstractness = TypeMetrics.Count(x => x.IsAbstract) / (double)TypeMetrics.Count(); }
public IPage TryGetPage(IDocumentation item) { switch (item) { // all overloads of an method / operator are combined to a single page // so when the page of an overload is requested, return the combined page case MethodOverloadDocumentation methodOverload: return(TryGetPage(methodOverload.MethodDocumentation)); case ConstructorOverloadDocumentation construtorOverload: return(TryGetPage(construtorOverload.ConstructorDocumentation)); case OperatorOverloadDocumentation operatorOverload: return(TryGetPage(operatorOverload.OperatorDocumentation)); default: return(m_PagesByModel.GetValueOrDefault(item)); } }
public NamespaceMetric( double maintainabilityIndex, int cyclomaticComplexity, int linesOfCode, IEnumerable <ITypeCoupling> classCouplings, int depthOfInheritance, string name, IEnumerable <ITypeMetric> typeMetrics, IDocumentation documentation) { MaintainabilityIndex = maintainabilityIndex; CyclomaticComplexity = cyclomaticComplexity; LinesOfCode = linesOfCode; ClassCouplings = classCouplings.AsArray(); DepthOfInheritance = depthOfInheritance; Name = name; Documentation = documentation; TypeMetrics = typeMetrics.AsArray(); Abstractness = TypeMetrics.Count(x => x.IsAbstract) / (double)TypeMetrics.Count(); }
public static XElement GetDocumentation(this IDocumentation entity, string name = "documentation") { return(new XElement(name, new XElement("metadata-standards", entity.MetadataStandards ?? string.Empty))); }
public Console(IDocumentation documentEngine) { _documentEngine = documentEngine; }
public InternalLinkProvider(IDocumentation model, PageFactory pageFactory, DocumentSet <IDocument> documentSet) { m_Model = model; m_PageFactory = pageFactory; m_DocumentSet = documentSet; }
public Test(IDocumentation serv) { doc = serv; }