11755569045

Committed 09 Nov 2024 10:37AM UTC coverage: 80.033% (-1.7%) from 81.696%

Build # 11755569045

Build Type

push

github

Committed by

lucaslorentz

Commit Message

Add initial support for computed navigations and observers

Run Details

159 of 357 new or added lines in 22 files covered. (44.54%)

41 existing lines in 6 files now uncovered.

1459 of 1823 relevant lines covered (80.03%)

113.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.0

/src/LLL.AutoCompute.EFCore/Extensions/PropertyBuilderExtensions.cs

﻿using System.Linq.Expressions;
using LLL.AutoCompute.EFCore.Metadata.Internal;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace LLL.AutoCompute.EFCore;

public static class PropertyBuilderExtensions
{
    public static PropertyBuilder<TProperty> AutoCompute<TEntity, TProperty>(
        this PropertyBuilder<TProperty> propertyBuilder,
        Expression<Func<TEntity, TProperty>> computedExpression)
        where TEntity : class
    {
        return propertyBuilder.AutoCompute(computedExpression, static c => c.CurrentValue());
    }

    public static PropertyBuilder<TProperty> AutoCompute<TEntity, TProperty>(
        this PropertyBuilder<TProperty> propertyBuilder,
        Expression<Func<TEntity, TProperty>> computedExpression,
        ChangeCalculationSelector<TProperty, TProperty> calculationSelector)
        where TEntity : class
    {
        var changeCalculation = calculationSelector(ChangeCalculations<TProperty>.Instance);

        propertyBuilder.Metadata.AddComputedFactory(
            ComputedFactory.CreateComputedPropertyFactory(
                computedExpression,
                changeCalculation));

        return propertyBuilder;
    }

    public static PropertyBuilder<TProperty> Reaction<TEntity, TProperty, TValue>(
        this PropertyBuilder<TProperty> navigationBuilder,
        Expression<Func<TEntity, TValue>> computedExpression,
        Func<TProperty, TValue, TProperty> applyChange)
        where TEntity : class
    {
        return navigationBuilder.Reaction(computedExpression, static c => c.CurrentValue(), applyChange);
    }

    public static PropertyBuilder<TProperty> Reaction<TEntity, TProperty, TValue, TChange>(
        this PropertyBuilder<TProperty> navigationBuilder,
        Expression<Func<TEntity, TValue>> computedExpression,
        ChangeCalculationSelector<TValue, TChange> calculationSelector,
        Func<TProperty, TChange, TProperty> applyChange)
        where TEntity : class
    {
        var changeCalculation = calculationSelector(ChangeCalculations<TValue>.Instance);

        navigationBuilder.Metadata.AddComputedFactory(
            ComputedFactory.CreateComputedReactionFactory(
                computedExpression,
                changeCalculation,
                applyChange));

        return navigationBuilder;
    }
}

1	using System.Linq.Expressions;
2	using LLL.AutoCompute.EFCore.Metadata.Internal;
3	using Microsoft.EntityFrameworkCore.Metadata.Builders;
4
5	namespace LLL.AutoCompute.EFCore;
6
7	public static class PropertyBuilderExtensions
8	{
9	public static PropertyBuilder<TProperty> AutoCompute<TEntity, TProperty>(
10	this PropertyBuilder<TProperty> propertyBuilder,
11	Expression<Func<TEntity, TProperty>> computedExpression)
12	where TEntity : class
13	{
NEW 14	return propertyBuilder.AutoCompute(computedExpression, static c => c.CurrentValue());	×
15	}
16
17	public static PropertyBuilder<TProperty> AutoCompute<TEntity, TProperty>(
18	this PropertyBuilder<TProperty> propertyBuilder,
19	Expression<Func<TEntity, TProperty>> computedExpression,
20	ChangeCalculationSelector<TProperty, TProperty> calculationSelector)
21	where TEntity : class
22	{
23	var changeCalculation = calculationSelector(ChangeCalculations<TProperty>.Instance);	12✔
24
25	propertyBuilder.Metadata.AddComputedFactory(	12✔
26	ComputedFactory.CreateComputedPropertyFactory(	12✔
27	computedExpression,	12✔
28	changeCalculation));	12✔
29
30	return propertyBuilder;	12✔
31	}
32
33	public static PropertyBuilder<TProperty> Reaction<TEntity, TProperty, TValue>(
34	this PropertyBuilder<TProperty> navigationBuilder,
35	Expression<Func<TEntity, TValue>> computedExpression,
36	Func<TProperty, TValue, TProperty> applyChange)
37	where TEntity : class
38	{
NEW 39	return navigationBuilder.Reaction(computedExpression, static c => c.CurrentValue(), applyChange);	×
40	}
41
42	public static PropertyBuilder<TProperty> Reaction<TEntity, TProperty, TValue, TChange>(
43	this PropertyBuilder<TProperty> navigationBuilder,
44	Expression<Func<TEntity, TValue>> computedExpression,
45	ChangeCalculationSelector<TValue, TChange> calculationSelector,
46	Func<TProperty, TChange, TProperty> applyChange)
47	where TEntity : class
48	{
NEW 49	var changeCalculation = calculationSelector(ChangeCalculations<TValue>.Instance);	×
50
NEW 51	navigationBuilder.Metadata.AddComputedFactory(	×
NEW 52	ComputedFactory.CreateComputedReactionFactory(	×
NEW 53	computedExpression,	×
NEW 54	changeCalculation,	×
NEW 55	applyChange));	×
56
NEW 57	return navigationBuilder;	×
58	}
59	}

lucaslorentz / auto-compute / 11755569045

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous