public static TResult CreateElseNode <TResult>(FluentScope fluentScope)
{
var tmpScope = fluentScope.CreateChild();
tmpScope.Set(RegistryKeys.FluentScopeAction, new FluentScopeAction(BuilderHelper.SwitchToElse));
return(CreateFluentNode <TResult>(tmpScope));
}
public static TEndIf CreateEndIf <TEndIf>(FluentScope fluentScope)
{
var tmpScope = fluentScope.CreateChild(fluentScope.Get(RegistryKeys.IfScope));
//TODO: Make all IFluentNodes have a new() constructor and an Initialize(FluentScope2) method
return(CreateFluentNode <TEndIf>(tmpScope));
}
public static void RegisterMessage(FluentScope fluentScope, FluentBuilderToken token)
{
var sourceType = fluentScope.Get(RegistryKeys.SourceType);
var messageEntry = new MessageEntry(
sourceType,
fluentScope.Get(RegistryKeys.SetupExpression, Utilities.ReturnSelf(sourceType)),
fluentScope.Get(RegistryKeys.Rule, null),
fluentScope.Get(RegistryKeys.Message));
token.ErrorResolver.AddEntry(messageEntry);
}
public static ForClassElseEndIf <T, ENDIF> CreateIf <T, ENDIF>(FluentScope fluentScope, LambdaExpression conditionalExpression)
{
var tmpScope = fluentScope.CreateChild();
tmpScope.Set(RegistryKeys.FluentScopeAction, new FluentScopeAction(BuilderHelper.RegisterConditional));
tmpScope.Set(RegistryKeys.ConditionalExpression, conditionalExpression);
tmpScope.Set(RegistryKeys.IfScope, fluentScope);
var result = new ForClassElseEndIf <T, ENDIF>(tmpScope);
return(result);
}
public static void RegisterEnumerableComposition(FluentScope fluentScope, FluentBuilderToken token)
{
var usingEngine = fluentScope.Get(RegistryKeys.UsingEngine, token.RootEngine);
var compositionExpression = fluentScope.Get(RegistryKeys.SetupExpression);
var sourceType = compositionExpression.Parameters[0].Type;
var resultType = compositionExpression.ReturnType;
var result = (IRuleInvoker)Utilities.CreateType(typeof(EnumerableCompositionInvoker <,>), sourceType, resultType)
.CreateInstance(usingEngine, compositionExpression);
token.CurrentEngine.InvokerRegistry.RegisterInvoker(result);
}
public static void RegisterConditional(FluentScope fluentScope, FluentBuilderToken token)
{
var conditionalExpression = fluentScope.Get(RegistryKeys.ConditionalExpression);
var sourceType = conditionalExpression.Parameters[0].Type;
var engine = token.CurrentEngine;
var conditionalToken = token.Condition();
var invoker = (IRuleInvoker)Utilities.CreateType(typeof(ConditionalInvoker <>), sourceType)
.CreateInstance(conditionalExpression, conditionalToken.IfTrueEngine, conditionalToken.IfFalseEngine);
engine.InvokerRegistry.RegisterInvoker(invoker);
}
public ForClass <T> For <T>()
{
var tmpScope = new FluentScope();
tmpScope.Set(RegistryKeys.SourceType, typeof(T));
var result = new ForClass <T>(tmpScope);
_forScopes.Add(tmpScope);
return(result);
}
/// <summary>
/// Creates a child node
/// </summary>
/// <param name="getInheritedValuesFrom">Node to get inherited values from</param>
/// <returns></returns>
public FluentScope CreateChild(FluentScope getInheritedValuesFrom)
{
if (getInheritedValuesFrom == null)
{
throw new ArgumentNullException("getValuesFrom");
}
if (_child != null)
{
throw new InvalidOperationException("Cannot call CreateChild when Child already exists.");
}
var values = getInheritedValuesFrom._values.ToDictionary(kp => kp.Key, kp => kp.Value is IFluentScopeValue ? ((IFluentScopeValue)kp.Value).Copy() : kp.Value);
var result = new FluentScope(this, values);
_child = result;
return(result);
}
public static void RegisterRule(FluentScope fluentScope, FluentBuilderToken token)
{
var rule = fluentScope.Get(RegistryKeys.Rule);
var sourceType = fluentScope.Get(RegistryKeys.SourceType);
var setupExpression = fluentScope.Get(RegistryKeys.SetupExpression, Utilities.ReturnSelf(sourceType));
var valueResolverFactory = token.ValueResolverFactory;
var isCrossField = fluentScope.Get(RegistryKeys.IsCrossField, false);
var expressionToInvokeForValidation = isCrossField ? Utilities.ReturnSelf(sourceType) : fluentScope.Get(RegistryKeys.SetupExpression);
var resultType = expressionToInvokeForValidation.ReturnType;
var valueToValidateResolver = valueResolverFactory.CreateResolver(expressionToInvokeForValidation);
var culpritResolver = fluentScope.Get(RegistryKeys.CulpritResolver, token.CulpritResolverFactory.Create(null, setupExpression));
var result = (IRuleInvoker)Utilities.CreateType(typeof(RuleInvoker <,>), sourceType, resultType)
.CreateInstance(rule
, valueToValidateResolver
, new EquatableExpression(setupExpression)
, culpritResolver
);
token.CurrentEngine.InvokerRegistry.RegisterInvoker(result);
}
internal SetupClassEndIf(FluentScope fluentScope)
{
_fluentScope = fluentScope;
}
object IFluentNode.GetSelf(FluentScope fluentScope)
{
return(new SetupClassEndIf <T, R, ENDIF>(fluentScope));
}
object IFluentNode.GetSelf(FluentScope fluentScope)
{
return(new SetupClass <T, R>(fluentScope));
}
internal ForClassElseEndIf(FluentScope fluentScope)
{
_fluentScope = fluentScope;
}
object IFluentNode.GetSelf(FluentScope fluentScope)
{
return(new ForClassElseEndIf <T, ENDIF>(fluentScope));
}
private static object CreateFluentNode(Type type, FluentScope scope)
{
var binding = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.CreateInstance;
return(type.GetConstructors(binding).First(c => c.GetParameters().Any(p => p.ParameterType == typeof(FluentScope))).Invoke(new[] { scope }));
}
internal ForClass(FluentScope fluentScope)
{
_fluentScope = fluentScope;
}
public static T CreateFluentNode <T>(FluentScope scope)
{
return((T)CreateFluentNode(typeof(T), scope));
}
public static TResult CreateMustPassRule <TRule, TResult>(IRule <TRule> rule, FluentScope fluentScope, bool isCrossField)
{
var tmpScope = fluentScope.CreateChild();
tmpScope.Set(RegistryKeys.FluentScopeAction, new FluentScopeAction(BuilderHelper.RegisterRule));
tmpScope.Set(RegistryKeys.Rule, rule);
tmpScope.Set(RegistryKeys.IsCrossField, isCrossField);
return(CreateFluentNode <TResult>(tmpScope));
}
private FluentScope(FluentScope parent, Dictionary <string, object> values)
{
_parent = parent;
_values = values;
}
object IFluentNode.GetSelf(FluentScope fluentScope)
{
return(new ForClass <T>(fluentScope));
}
public static void SwitchToElse(FluentScope fluentScope, FluentBuilderToken token)
{
token.Else();
}
public void Execute(FluentScope scope, FluentBuilderToken token)
{
_action(scope, token);
}
