MetricsCalculator.cs

Go to the documentation of this file.

using ArchUnitNET.Domain;
 
namespace Ucu.Andis.ArchitectureMetrics;

public static class MetricsCalculator
{
    public static IReadOnlyCollection<Component> BuildAssemblyComponents(
        Architecture architecture,
        params string[] assemblyNames)
    {
        return assemblyNames
            .Select(assemblyName =>
                new Component(
                    assemblyName,
                    architecture.Types
                        .Where(t => t.Assembly.Name == assemblyName)
                        .ToList()))
            .ToList();
    }

    public static IReadOnlyCollection<ComponentDependencies>
        BuildDependencyGraph(IEnumerable<Component> components)
    {
        var componentMap = components
            .SelectMany(
                c => c.Types,
                (component, type) => (type, component.Name))
            .ToDictionary(x => x.type, x => x.Name);
 
        var graph = components.ToDictionary(
            c => c.Name,
            _ => new HashSet<string>());
 
        foreach (var component in components)
        {
            foreach (var type in component.Types)
            {
                foreach (var dependency in type.Dependencies)
                {
                    var targetType = dependency.Target;
 
                    if (!componentMap.TryGetValue(
                            targetType,
                            out var targetComponent))
                    {
                        continue;
                    }
 
                    if (targetComponent != component.Name)
                    {
                        graph[component.Name]
                            .Add(targetComponent);
                    }
                }
            }
        }
 
        return graph
            .Select(kv => new ComponentDependencies(kv.Key, kv.Value))
            .ToList();
    }

    public static ComponentCouplings CalculateCouplings(
        IReadOnlyCollection<ComponentDependencies> graph)
    {
        var fanOut = graph.ToDictionary(
            cd => cd.ComponentName,
            cd => cd.Dependencies.Count);
 
        var fanIn = graph.ToDictionary(
            cd => cd.ComponentName,
            _ => 0);
 
        foreach (var componentDep in graph)
        {
            foreach (var target in componentDep.Dependencies)
            {
                fanIn[target]++;
            }
        }
 
        return new ComponentCouplings(fanIn, fanOut);
    }

    public static double CalculateAbstractness(Component component)
    {
        var totalTypes = component.Types.Count;
 
        if (totalTypes == 0)
            return 0;
 
        var abstractTypes = component.Types.Count(t =>
            IsAbstractOrExtensible(t));
 
        return (double)abstractTypes / totalTypes;
    }

    private static bool IsAbstractOrExtensible(IType type)
    {
        // Interfaces son siempre abstractas
        if (type is Interface)
            return true;
 
        // Clases abstractas
        if (type is Class c && c.IsAbstract == true)
            return true;
 
        // Tipos genéricos son extensibles por parametrización
        if (type.GenericParameters.Count > 0)
            return true;
 
        return false;
    }

    public static IReadOnlyCollection<ComponentMetrics> CalculateMetrics(
        IReadOnlyCollection<Component> components)
    {
        var graph = BuildDependencyGraph(components);
 
        var couplings = CalculateCouplings(graph);
 
        return components
            .Select(component =>
            {
                var fanIn = couplings.FanIn[component.Name];
                var fanOut = couplings.FanOut[component.Name];
 
                var a = CalculateAbstractness(component);
 
                var i = fanIn + fanOut == 0 ? 0 : (double)fanOut / (fanIn + fanOut);
 
                var d = Math.Abs(a + i - 1);
 
                return new ComponentMetrics(component.Name, fanIn, fanOut, a, i, d);
            })
            .ToList();
    }
}