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 ChangeInfo(string caption, IDocumentation docOriginal, IDocumentation docChange)
{
m_caption = caption;
m_original = docOriginal;
m_change = docChange;
m_accept = false;
}
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;
}
