Пример #1
0
        public static ReplBuilder FromInstance(IServiceProvider serviceProvider, IReplBase replInstance)
        {
            if (replInstance is null)
            {
                throw new ArgumentNullException(nameof(replInstance));
            }

            var replType = replInstance.GetType();

            var builder = new ReplBuilder();

            var controller = replType.GetCustomAttribute <ReplControllerAttribute>();

            if (controller != null)
            {
                builder.WithCaption(controller.Caption)
                .WithVersion(controller.Version)
                .WithDescription(controller.Description);
            }

            builder.WithPrompt(() => replInstance.Prompt);

            if (replInstance.CanPersistState)
            {
                builder.WithStatePersistence(
                    () => replInstance.PersistState(),
                    state => replInstance.LoadState(state));
            }

            foreach (var replExample in replType.GetCustomAttributes <ReplExampleAttribute>())
            {
                builder.WithExample(replExample.Command, exampleBuilder =>
                {
                    exampleBuilder
                    .WithCaption(exampleBuilder.caption)
                    .WithDescription(exampleBuilder.description);
                });
            }

            foreach (var method in replType.GetMethods(BindingFlags.Public | BindingFlags.Instance))
            {
                var command = method.GetCustomAttribute <ReplCommandAttribute>();

                if (command != null)
                {
                    builder.WithCommand(command.Name, commandBuilder =>
                                        BuildCommand(serviceProvider, replInstance, builder, method, command, commandBuilder));
                }
            }

            return(builder);
        }
Пример #2
0
        private static void BuildCommand(
            IServiceProvider serviceProvider,
            IReplBase replInstance,
            ReplBuilder builder,
            MethodInfo method,
            ReplCommandAttribute command,
            ReplCommandBuilder commandBuilder)
        {
            commandBuilder
            .WithCaption(command.Caption)
            .WithDescription(command.Description);

            foreach (var namesAttr in method.GetCustomAttributes <ReplNamesAttribute>())
            {
                foreach (var name in namesAttr.Names)
                {
                    commandBuilder.WithName(name);
                }
            }

            foreach (var replExample in method.GetCustomAttributes <ReplExampleAttribute>())
            {
                commandBuilder.WithExample(replExample.Command, exampleBuilder =>
                {
                    exampleBuilder
                    .WithCaption(exampleBuilder.caption)
                    .WithDescription(exampleBuilder.description);
                });

                if (replExample.Scope >= ReplExampleScope.Parent)
                {
                    builder.WithExample(replExample.Command, exampleBuilder =>
                    {
                        exampleBuilder
                        .WithCaption(exampleBuilder.caption)
                        .WithDescription(exampleBuilder.description);
                    });
                }
            }

            var parameters = method.GetParameters();

            foreach (var parameter in parameters)
            {
                var replParam           = parameter.GetCustomAttribute <ReplParamAttribute>();
                var replOption          = parameter.GetCustomAttribute <ReplOptionAttribute>();
                var replFlag            = parameter.GetCustomAttribute <ReplFlagAttribute>();
                var fromServiceProvider = parameter.GetCustomAttribute <ReplServiceAttribute>() != null;

                if (replParam != null)
                {
                    commandBuilder.WithPositional(parameter.Name, paramBuilder =>
                    {
                        BuildPositionalParameter(builder, commandBuilder, parameter, replParam, paramBuilder);
                    });
                }
                else if (replOption != null)
                {
                    commandBuilder.WithOption(parameter.Name, paramBuilder =>
                    {
                        BuildOptionParameter(builder, commandBuilder, parameter, replOption, paramBuilder);
                    });
                }
                else if (replFlag != null)
                {
                    commandBuilder.WithFlag(parameter.Name, paramBuilder =>
                    {
                        BuildFlagParameter(builder, commandBuilder, parameter, replFlag, paramBuilder);
                    });
                }
                else
                {
                    if (!parameter.HasDefaultValue &&
                        !fromServiceProvider &&
                        parameter.ParameterType != typeof(CancellationToken) &&
                        parameter.ParameterType != typeof(Dictionary <string, object>))
                    {
                        string message = $"Parameter {parameter.Name} from command {method.Name} cannot be fulfilled";
                        ConsoleEx.WriteLine(ConsoleColor.Red, message);
                        throw new InvalidOperationException(message);
                    }
                }
            }

            Task ExecuteAsync(Dictionary <string, object> values, CancellationToken cancellationToken)
            {
                var paramValues = new object[parameters.Length];

                // TODO: Optimize
                for (int i = 0; i < parameters.Length; i++)
                {
                    if (values.TryGetValue(parameters[i].Name, out var value))
                    {
                        // TODO: Bind depending on the param type
                        paramValues[i] = value;
                    }
                    else if (parameters[i].GetCustomAttribute <ReplServiceAttribute>() != null)
                    {
                        if (parameters[i].HasDefaultValue)
                        {
                            paramValues[i] = serviceProvider.GetService(parameters[i].ParameterType);
                        }
                        else
                        {
                            paramValues[i] = serviceProvider.GetRequiredService(parameters[i].ParameterType);
                        }
                    }
                    else if (parameters[i].ParameterType == typeof(CancellationToken))
                    {
                        paramValues[i] = cancellationToken;
                    }
                    else if (parameters[i].ParameterType == typeof(Dictionary <string, object>))
                    {
                        paramValues[i] = values;
                    }
                    else if (parameters[i].HasDefaultValue)
                    {
                        paramValues[i] = parameters[i].DefaultValue;
                    }
                    else
                    {
                        string message = $"Parameter {parameters[i].Name} from command {method.Name} cannot be bound";
                        ConsoleEx.WriteLine(ConsoleColor.Red, message);
                        throw new InvalidOperationException(message);
                    }
                }

                var result = method.Invoke(replInstance, paramValues);

                // TODO: Catch exceptions here or in the engine?

                if (result is Task task && typeof(Task).IsAssignableFrom(method.ReturnType))
                {
                    return(task);
                }

                return(Task.CompletedTask);
            }

            commandBuilder.WithExecute(ExecuteAsync);
        }