< Summary

Information
Class: Fluorite.Strainer.Services.Configuration.StrainerConfigurationBuilder
Assembly: Fluorite.Strainer
File(s): /builds/fluorite/strainer/src/Strainer/Services/Configuration/StrainerConfigurationBuilder.cs
Line coverage
100%
Covered lines: 73
Uncovered lines: 0
Coverable lines: 73
Total lines: 161
Line coverage: 100%
Branch coverage
100%
Covered branches: 6
Total branches: 6
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor()100%11100%
Build()100%11100%
WithPropertyMetadata(...)100%11100%
WithObjectMetadata(...)100%11100%
WithCustomFilterOperators(...)100%11100%
WithDefaultMetadata(...)100%11100%
WithCustomSortMethods(...)100%11100%
WithCustomFilterMethods(...)100%11100%
WithoutBuiltInFilterOperators(...)100%11100%
AddBuiltInFilterOperators(...)100%66100%

File(s)

/builds/fluorite/strainer/src/Strainer/Services/Configuration/StrainerConfigurationBuilder.cs

#LineLine coverage
 1using Fluorite.Extensions;
 2using Fluorite.Strainer.Collections;
 3using Fluorite.Strainer.Models.Configuration;
 4using Fluorite.Strainer.Models.Filtering;
 5using Fluorite.Strainer.Models.Filtering.Operators;
 6using Fluorite.Strainer.Models.Metadata;
 7using Fluorite.Strainer.Models.Sorting;
 8using Fluorite.Strainer.Services.Filtering;
 9using Fluorite.Strainer.Services.Modules;
 10
 11namespace Fluorite.Strainer.Services.Configuration;
 12
 13public class StrainerConfigurationBuilder : IStrainerConfigurationBuilder
 14{
 15    private Dictionary<Type, IReadOnlyDictionary<string, IPropertyMetadata>> propertyMetadata;
 16    private Dictionary<Type, IObjectMetadata> objectMetadata;
 17    private Dictionary<string, IFilterOperator> filterOperators;
 18    private Dictionary<Type, IPropertyMetadata> defaultMetadata;
 19    private Dictionary<Type, IReadOnlyDictionary<string, ICustomSortMethod>> customSortMethods;
 20    private Dictionary<Type, IReadOnlyDictionary<string, ICustomFilterMethod>> customFilterMethods;
 21    private HashSet<string> excludedBuiltInFilterOperators;
 22
 1223    public StrainerConfigurationBuilder()
 24    {
 1225        propertyMetadata = new Dictionary<Type, IReadOnlyDictionary<string, IPropertyMetadata>>();
 1226        objectMetadata = new Dictionary<Type, IObjectMetadata>();
 1227        filterOperators = new Dictionary<string, IFilterOperator>();
 1228        defaultMetadata = new Dictionary<Type, IPropertyMetadata>();
 1229        customSortMethods = new Dictionary<Type, IReadOnlyDictionary<string, ICustomSortMethod>>();
 1230        customFilterMethods = new Dictionary<Type, IReadOnlyDictionary<string, ICustomFilterMethod>>();
 1231        excludedBuiltInFilterOperators = new HashSet<string>();
 1232    }
 33
 34    public IStrainerConfiguration Build()
 35    {
 1236        var filterOperatorsWithAddedBuiltIn = AddBuiltInFilterOperators(
 1237            filterOperators,
 1238            excludedBuiltInFilterOperators,
 1239            FilterOperatorMapper.DefaultOperators);
 40
 1141        return new StrainerConfiguration(
 1142            customFilterMethods,
 1143            customSortMethods,
 1144            defaultMetadata,
 1145            filterOperatorsWithAddedBuiltIn,
 1146            new ReadOnlyHashSet<string>(excludedBuiltInFilterOperators),
 1147            objectMetadata,
 1148            propertyMetadata);
 49    }
 50
 51    public IStrainerConfigurationBuilder WithPropertyMetadata(ICollection<IStrainerModule> modules)
 52    {
 953        Guard.Against.Null(modules);
 54
 955        propertyMetadata = modules
 756            .SelectMany(module => module
 757            .PropertyMetadata
 758            .Select(pair =>
 859                new KeyValuePair<Type, IReadOnlyDictionary<string, IPropertyMetadata>>(
 860                    pair.Key, pair.Value.ToReadOnly())))
 961            .Merge();
 62
 963        return this;
 64    }
 65
 66    public IStrainerConfigurationBuilder WithObjectMetadata(ICollection<IStrainerModule> modules)
 67    {
 968        Guard.Against.Null(modules);
 69
 970        objectMetadata = modules
 771            .SelectMany(module => module.ObjectMetadata.ToReadOnly())
 972            .Merge();
 73
 974        return this;
 75    }
 76
 77    public IStrainerConfigurationBuilder WithCustomFilterOperators(ICollection<IStrainerModule> modules)
 78    {
 979        Guard.Against.Null(modules);
 80
 1681        filterOperators = modules.SelectMany(module => module.FilterOperators).Merge();
 82
 983        return this;
 84    }
 85
 86    public IStrainerConfigurationBuilder WithDefaultMetadata(ICollection<IStrainerModule> modules)
 87    {
 988        Guard.Against.Null(modules);
 89
 990        defaultMetadata = modules
 791            .SelectMany(module => module.DefaultMetadata)
 992            .Merge();
 93
 994        return this;
 95    }
 96
 97    public IStrainerConfigurationBuilder WithCustomSortMethods(ICollection<IStrainerModule> modules)
 98    {
 899        Guard.Against.Null(modules);
 100
 8101        customSortMethods = modules
 6102            .SelectMany(module => module
 6103            .CustomSortMethods
 6104            .Select(pair =>
 6105                new KeyValuePair<Type, IReadOnlyDictionary<string, ICustomSortMethod>>(
 6106                    pair.Key, pair.Value.ToReadOnly())))
 8107            .Merge();
 108
 8109        return this;
 110    }
 111
 112    public IStrainerConfigurationBuilder WithCustomFilterMethods(ICollection<IStrainerModule> modules)
 113    {
 8114        Guard.Against.Null(modules);
 115
 8116        customFilterMethods = modules
 6117            .SelectMany(module => module
 6118                .CustomFilterMethods
 6119                .Select(pair =>
 6120                    new KeyValuePair<Type, IReadOnlyDictionary<string, ICustomFilterMethod>>(
 6121                        pair.Key, pair.Value.ToReadOnly())))
 8122            .Merge();
 123
 8124        return this;
 125    }
 126
 127    public IStrainerConfigurationBuilder WithoutBuiltInFilterOperators(ICollection<IStrainerModule> modules)
 128    {
 8129        Guard.Against.Null(modules);
 130
 8131        excludedBuiltInFilterOperators = new HashSet<string>(
 14132            modules.SelectMany(module => module.ExcludedBuiltInFilterOperators));
 133
 8134        return this;
 135    }
 136
 137    private IReadOnlyDictionary<string, IFilterOperator> AddBuiltInFilterOperators(
 138        IDictionary<string, IFilterOperator> customFilterOperators,
 139        ISet<string> excludedBuiltInFilterOperators,
 140        IReadOnlyDictionary<string, IFilterOperator> defaultOperators)
 141    {
 465142        foreach (var pair in defaultOperators)
 143        {
 221144            if (!excludedBuiltInFilterOperators.Contains(pair.Key))
 145            {
 221146                if (customFilterOperators.ContainsKey(pair.Key))
 147                {
 1148                    throw new InvalidOperationException(
 1149                        $"A custom filter operator is conflicting with built-in filter operator on symbol {pair.Key}. " 
 1150                        $"Either mark the built-in filter operator to be excluded or remove custom filter operator.");
 151                }
 152                else
 153                {
 220154                    customFilterOperators.Add(pair.Key, pair.Value);
 155                }
 156            }
 157        }
 158
 231159        return customFilterOperators.OrderBy(x => x.Key.Length).ToReadOnlyDictionary();
 160    }
 161}
Generated by: ReportGenerator 5.4.4.0
03/01/2025 - 19:52:32
GitHub | reportgenerator.io

Methods/Properties

.ctor()
Build()
WithPropertyMetadata(System.Collections.Generic.ICollection`1<Fluorite.Strainer.Services.Modules.IStrainerModule>)
WithObjectMetadata(System.Collections.Generic.ICollection`1<Fluorite.Strainer.Services.Modules.IStrainerModule>)
WithCustomFilterOperators(System.Collections.Generic.ICollection`1<Fluorite.Strainer.Services.Modules.IStrainerModule>)
WithDefaultMetadata(System.Collections.Generic.ICollection`1<Fluorite.Strainer.Services.Modules.IStrainerModule>)
WithCustomSortMethods(System.Collections.Generic.ICollection`1<Fluorite.Strainer.Services.Modules.IStrainerModule>)
WithCustomFilterMethods(System.Collections.Generic.ICollection`1<Fluorite.Strainer.Services.Modules.IStrainerModule>)
WithoutBuiltInFilterOperators(System.Collections.Generic.ICollection`1<Fluorite.Strainer.Services.Modules.IStrainerModule>)
AddBuiltInFilterOperators(System.Collections.Generic.IDictionary`2<System.String,Fluorite.Strainer.Models.Filtering.Operators.IFilterOperator>,System.Collections.Generic.ISet`1<System.String>,System.Collections.Generic.IReadOnlyDictionary`2<System.String,Fluorite.Strainer.Models.Filtering.Operators.IFilterOperator>)