Exemplo n.º 1
0
        /// <summary>
        /// Executes this directive, if applicable.
        /// </summary>
        /// <param name="context">DB Context.</param>
        /// <param name="text">SQL statement text</param>
        /// <param name="directive">Source information.</param>
        /// <param name="initState">Initialization state.</param>
        /// <returns><c>true</c> if this processor can execute the current statement, otherwise <c>false</c></returns>
        /// <exception cref="UnrecognizedStatementException">If this directive's <c>callback</c> returns <c>false</c></exception>
        public bool TryExecute(CompositeProcessorContext context, string text, ScriptDirective directive, object initState)
        {
            if (directive.Name != DirectiveName)
            {
                return(false);
            }

            var statementName = ((InitializedState)initState).StatementName;

            if (!callback(statementName, text))
            {
                throw new UnrecognizedStatementException(statementName, directive);
            }

            return(true);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Executes this directive against the given context, if applicable.
        /// </summary>
        /// <param name="context">DB context</param>
        /// <param name="text">SQL statement text</param>
        /// <param name="directive">Source information</param>
        /// <param name="initState">Initialization state</param>
        /// <returns><see langword="true"/> if this processor is able to execute the given directive, otherwise <see langword="false" /></returns>
        public bool TryExecute(CompositeProcessorContext context, string text, ScriptDirective directive, object initState)
        {
            if (directive.Name != DirectiveName && directive.Name != NegatedDirectiveName)
            {
                return(false);
            }

            var initData = (InitializedState)initState;

            if (Eval(initData.PropertyName, initData.PropertyValue, initData.Negated))
            {
                var command = context.NewCommand();
                command.CommandText = text;
                command.ExecuteNonQuery();
            }

            return(true);
        }
 /// <summary>
 /// Constructs an <see cref="UnrecognizedDirectiveException"/> with the given <see cref="ScriptDirective"/>.
 /// </summary>
 /// <param name="directive">The unrecognized script directive.</param>
 public UnrecognizedDirectiveException(ScriptDirective directive) : base($"Unrecognized directive: {directive}")
 {
     Directive = directive;
 }
 /// <summary>
 /// Construct a new <see cref="InvalidDirectiveException"/> with the given error <c>message</c>, and the offending
 /// <see cref="ScriptDirective"/>.
 /// </summary>
 /// <param name="message">Message explaining why the direcitve or its configuration is invalid.</param>
 /// <param name="directive">The invalid directive.</param>
 public InvalidDirectiveException(string message, ScriptDirective directive) : base($"{message} ({directive.FileName}: {directive.LineNumber})")
 {
     Error     = message;
     Directive = directive;
 }
Exemplo n.º 5
0
 /// <summary>
 /// N/A
 /// </summary>
 /// <param name="context"></param>
 /// <param name="directive"></param>
 /// <param name="initState"></param>
 /// <returns></returns>
 /// <exception cref="NotImplementedException"></exception>
 public DirectiveInitialization SetupDirective(CompositeProcessorContext context, ScriptDirective directive, object initState)
 {
     throw new NotImplementedException();
 }
Exemplo n.º 6
0
        /// <summary>
        /// Initializes this directive.
        /// </summary>
        /// <param name="context">DB context.</param>
        /// <param name="directive">Directive to test.</param>
        /// <returns><c>null</c> if not applicable, otherwise this directive's initialization state</returns>
        /// <exception cref="InvalidDirectiveException">If the number of argments provided to this directive is not exactly <c>1</c></exception>
        public DirectiveInitialization InitDirective(CompositeProcessorContext context, ScriptDirective directive)
        {
            if (directive.Name != DirectiveName)
            {
                return(null);
            }
            if (directive.Arguments.Count != 1)
            {
                throw new InvalidDirectiveException("Callback directive must have exactly 1 argument.", directive);
            }

            return(new DirectiveInitialization(new InitializedState(directive.Arguments[0])));
        }
Exemplo n.º 7
0
 internal UnrecognizedStatementException(string statementName, ScriptDirective directive) : base($"Unrecognized statement name: {statementName}; Directive: {directive}")
 {
     StatementName = statementName;
     Directive     = directive;
 }
Exemplo n.º 8
0
        /// <summary>
        /// Initializes this directive as configured in the source script.
        /// </summary>
        /// <param name="context">DB context</param>
        /// <param name="directive">Source information</param>
        /// <returns>Initialization state if this processor can handle the given directive, otherwise <see langword="null" /></returns>
        /// <exception cref="InvalidDirectiveException">If the provided argument count is less than 1 or greater than 2</exception>
        public DirectiveInitialization InitDirective(CompositeProcessorContext context, ScriptDirective directive)
        {
            bool negated;

            switch (directive.Name)
            {
            case DirectiveName:
                negated = false;
                break;

            case NegatedDirectiveName:
                negated = true;
                break;

            default:
                return(null);
            }

            if (directive.Name != directive.Name)
            {
                return(null);
            }

            if (directive.Arguments.Count < 1)
            {
                throw new InvalidDirectiveException($"{directive.Name} must have at least 1 argument (property name).", directive);
            }
            if (directive.Arguments.Count > 2)
            {
                throw new InvalidDirectiveException($"{directive.Name} can have at most 2 arguments.", directive);
            }

            var propertyName = directive.Arguments[0];
            var value        = directive.Arguments.Count > 1 ? directive.Arguments[1] : null;

            return(new DirectiveInitialization(new InitializedState(propertyName, value, negated)));
        }
        /// <summary>
        /// Evaluates the given <see cref="ScriptDirective"/>.
        /// </summary>
        /// <remarks>
        /// <para>If the given <c>directive</c> matches the <c>directiveName</c> or <c>negatedDirectiveName</c> given in the constructor,
        /// the directive will be evaluated.</para>
        ///
        /// <para>Properties replace directives have between 2 and 4 arguments:</para>
        /// <list type="number">
        ///     <item>
        ///         <term><c>propertyName</c></term>
        ///         <description>Property name.</description>
        ///     </item>
        ///     <item>
        ///         <term><c>replaceValue</c> OR <c>propertyValue</c></term>
        ///         <description>If argument count is two, value to replace in statement text if <c>propertyName</c> is defined.
        ///         Otherwise, the value to evaluate <c>propertyName</c> against to determine replacement.</description>
        ///     </item>
        ///     <item>
        ///         <term><c>replaceValue</c></term>
        ///         <description>Value to replace in statement text if <c>propertyName</c> equals <c>propertyValue</c>, following
        ///         the semantics described in <see cref="PropertiesEvaluator.Eval"/>.</description>
        ///     </item>
        ///     <item>
        ///         <term><c>elseValue</c></term>
        ///         <description>Value to replace in statement text if the evaluation fails. Default is the empty string.</description>
        ///     </item>
        /// </list>
        /// </remarks>
        /// <param name="context">Not used.</param>
        /// <param name="directive"><see cref="ScriptDirective"/> to process.</param>
        /// <returns>Appropriate <see cref="DirectiveInitialization"/> if <c>directive</c> is supported, otherwise <see langword="null" />.</returns>
        public DirectiveInitialization InitDirective(CompositeProcessorContext context, ScriptDirective directive)
        {
            bool negated;

            if (directive.Name == directiveName)
            {
                negated = false;
            }
            else if (directive.Name == negatedDirectiveName)
            {
                negated = true;
            }
            else
            {
                return(null);
            }

            if (directive.Arguments.Count < 2)
            {
                throw new InvalidDirectiveException($"{directiveName} must have at least 2 arguments (property name, replace value).", directive);
            }
            if (directive.Arguments.Count > 4)
            {
                throw new InvalidDirectiveException($"{directiveName} can have at most 4 arguments.", directive);
            }

            var propertyName  = directive.Arguments[0];
            var propertyValue = directive.Arguments.Count > 2 ? directive.Arguments[1] : null;
            var replaceValue  = directive.Arguments[directive.Arguments.Count > 2 ? 2 : 1];
            var elseValue     = directive.Arguments.Count > 3 ? directive.Arguments[3] : null;

            if (deferRuntime)
            {
                return(new DirectiveInitialization(new InitializedState(propertyName, replaceValue, propertyValue, elseValue, negated), DirectiveInitializationAction.DeferSetup));
            }

            if (Eval(propertyName, propertyValue, negated))
            {
                return(new DirectiveInitialization(action: DirectiveInitializationAction.ReplaceText | DirectiveInitializationAction.NoStore, replacementText: replaceValue));
            }
            else
            {
                if (elseValue is not null)
                {
                    return(new DirectiveInitialization(action: DirectiveInitializationAction.ReplaceText | DirectiveInitializationAction.NoStore, replacementText: elseValue));
                }
                else
                {
                    return(new DirectiveInitialization(action: DirectiveInitializationAction.NoStore));
                }
            }
        }
 /// <summary>
 /// Always returns <see langword="false"/> (does nothing). All necessary operations are performed in <see cref="InitDirective"/>
 /// and <see cref="SetupDirective" />, if applicable.
 /// </summary>
 /// <param name="context"></param>
 /// <param name="text"></param>
 /// <param name="directive"></param>
 /// <param name="initState"></param>
 /// <returns><see langword="false"/></returns>
 public bool TryExecute(CompositeProcessorContext context, string text, ScriptDirective directive, object initState)
 {
     return(false);
 }
        /// <summary>
        /// Performs property <see cref="PropertiesEvaluator.Eval">evaluation</see> if <c>deferRuntime</c> was specified in the constructor.
        /// </summary>
        /// <param name="context">Not used.</param>
        /// <param name="directive"><see cref="ScriptDirective"/> to process.</param>
        /// <param name="initState">Processed directive argument information from <see cref="InitDirective"/>.</param>
        /// <returns></returns>
        public DirectiveInitialization SetupDirective(CompositeProcessorContext context, ScriptDirective directive, object initState)
        {
            if (!deferRuntime)
            {
                throw new NotImplementedException();
            }

            var initData = (InitializedState)initState;

            if (Eval(initData.PropertyName, initData.PropertyValue, initData.Negated))
            {
                return(new DirectiveInitialization(action: DirectiveInitializationAction.ReplaceText, replacementText: initData.ReplaceValue));
            }
            else
            {
                if (initData.ElseValue is not null)
                {
                    return(new DirectiveInitialization(action: DirectiveInitializationAction.ReplaceText, replacementText: initData.ElseValue));
                }
                else
                {
                    return(new DirectiveInitialization());
                }
            }
        }