示例#1
0
文件: HelpTask.cs 项目: ramarag/XTask
        public virtual ExitCode Execute(ITaskInteraction interaction)
        {
            interaction.Loggers[LoggerType.Result].WriteLine(WriteStyle.Fixed, this.generalHelp);
            interaction.Loggers[LoggerType.Result].WriteLine();

            Table table = Table.Create(1, 1, 2);
            table.AddRow(XTaskStrings.OverviewColumn1, XTaskStrings.OverviewColumn2, XTaskStrings.OverviewColumn3);
            foreach (var entry in registry.Tasks)
            {
                if (entry.Task.GetAttributes<HiddenAttribute>(inherit: true).Any()) continue;

                string[] aliases = entry.Aliases.ToArray();
                if (aliases.Length == 0) continue;

                ITaskDocumentation docs = entry.Task as ITaskDocumentation;

                table.AddRow(
                    aliases[0],
                    aliases.Length == 1 ? String.Empty : String.Join(", ", aliases.Skip(1)),
                    docs == null || docs.Summary == null ? String.Empty : docs.Summary);
            }

            interaction.Loggers[LoggerType.Result].Write(table);

            return ExitCode.Success;
        }
示例#2
0
文件: Task.cs 项目: JeremyKuhne/XTask
        public void GetUsage(ITaskInteraction interaction)
        {
            // Guidance for argument syntax:
            // IEEE Std 1003.1 http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap12.html

            ILogger logger = interaction.Loggers[LoggerType.Result];

            if (string.IsNullOrEmpty(this.GeneralHelp))
            {
                logger.Write(XTaskStrings.HelpNone);
                return;
            }

            logger.WriteLine(WriteStyle.Fixed, this.GeneralHelp);

            string optionDetails = this.OptionDetails;

            if (string.IsNullOrEmpty(optionDetails))
            {
                return;
            }

            logger.WriteLine();
            logger.WriteLine(WriteStyle.Fixed | WriteStyle.Underline, XTaskStrings.HelpOptionDetailHeader);
            logger.WriteLine();
            logger.WriteLine(WriteStyle.Fixed, optionDetails);
        }
示例#3
0
文件: HelpTask.cs 项目: ramarag/XTask
        public virtual ExitCode Execute(ITaskInteraction interaction)
        {
            interaction.Loggers[LoggerType.Result].WriteLine(WriteStyle.Fixed, this.generalHelp);
            interaction.Loggers[LoggerType.Result].WriteLine();

            Table table = Table.Create(1, 1, 2);

            table.AddRow(XTaskStrings.OverviewColumn1, XTaskStrings.OverviewColumn2, XTaskStrings.OverviewColumn3);
            foreach (var entry in registry.Tasks)
            {
                if (entry.Task.GetAttributes <HiddenAttribute>(inherit: true).Any())
                {
                    continue;
                }

                string[] aliases = entry.Aliases.ToArray();
                if (aliases.Length == 0)
                {
                    continue;
                }

                ITaskDocumentation docs = entry.Task as ITaskDocumentation;

                table.AddRow(
                    aliases[0],
                    aliases.Length == 1 ? String.Empty : String.Join(", ", aliases.Skip(1)),
                    docs == null || docs.Summary == null ? String.Empty : docs.Summary);
            }

            interaction.Loggers[LoggerType.Result].Write(table);

            return(ExitCode.Success);
        }
示例#4
0
        public void HandlesNullHelp()
        {
            TestTask         testTask    = Substitute.ForPartsOf <TestTask>();
            ITaskInteraction interaction = Substitute.For <ITaskInteraction>();

            testTask.OutputUsage(interaction);
            testTask.Received(1).TestGetGeneralHelp();
        }
示例#5
0
        public void OutputOutputs()
        {
            TestTask         testTask    = Substitute.ForPartsOf <TestTask>();
            ITaskInteraction interaction = Substitute.For <ITaskInteraction>();

            testTask.Execute(interaction);
            interaction.Received(1).Output("TestOutput");
        }
示例#6
0
        public void HandlesNullOptionDetails()
        {
            TestTask testTask = Substitute.ForPartsOf <TestTask>();

            testTask.TestGetGeneralHelp().Returns("GeneralHelp");
            ITaskInteraction interaction = Substitute.For <ITaskInteraction>();

            testTask.OutputUsage(interaction);
            testTask.Received(2).TestGetGeneralHelp();
            testTask.Received(1).TestGetOptionDetails();
        }
示例#7
0
        public ExitCode Execute(ITaskInteraction interaction)
        {
            _usageTracker.RecordUsage(TaskFeatureIdentifier);
            ITaskExecutor executor = _task.GetService <ITaskExecutor>();

            if (executor != null)
            {
                return(executor.Execute(interaction));
            }

            return(ExitCode.Success);
        }
示例#8
0
        /// <summary>
        /// Executes the given task
        /// </summary>
        public static ExitCode Execute(this ITask task, ITaskInteraction interaction)
        {
            ITaskExecutor executor = task.GetService <ITaskExecutor>();

            if (executor != null)
            {
                return(executor.Execute(interaction));
            }
            else
            {
                return(ExitCode.Success);
            }
        }
示例#9
0
        /// <summary>
        /// Outputs usage if any help is provided
        /// </summary>
        public static void OutputUsage(this ITask task, ITaskInteraction interaction)
        {
            ITaskDocumentation documentation = task.GetService <ITaskDocumentation>();

            if (documentation == null)
            {
                interaction.Loggers[LoggerType.Result].WriteLine(WriteStyle.Fixed, XTaskStrings.HelpNone);
            }
            else
            {
                documentation.GetUsage(interaction);
            }
        }
示例#10
0
        public override ExitCode Execute(ITaskInteraction interaction)
        {
            if (string.IsNullOrEmpty(interaction.Arguments.Command))
            {
                interaction.Loggers[LoggerType.Status].WriteLine(WriteStyle.Error, XTaskStrings.ErrorNoParametersSpecified);
            }
            else
            {
                interaction.Loggers[LoggerType.Status].WriteLine(WriteStyle.Error, XTaskStrings.UnknownCommand, interaction.Arguments.Command);
            }

            base.Execute(interaction);
            return(ExitCode.InvalidArgument);
        }
示例#11
0
        public override ExitCode Execute(ITaskInteraction interaction)
        {
            if (string.IsNullOrEmpty(interaction.Arguments.Command))
            {
                interaction.Loggers[LoggerType.Status].WriteLine(WriteStyle.Error, XTaskStrings.ErrorNoParametersSpecified);
            }
            else
            {
                interaction.Loggers[LoggerType.Status].WriteLine(WriteStyle.Error, XTaskStrings.UnknownCommand, interaction.Arguments.Command);
            }

            base.Execute(interaction);
            return ExitCode.InvalidArgument;
        }
示例#12
0
        public void NoParameters()
        {
            ITaskRegistry    registry    = Substitute.For <ITaskRegistry>();
            UnknownTask      task        = new UnknownTask(registry, "GeneralHelp");
            ITaskInteraction interaction = Substitute.For <ITaskInteraction>();
            ILoggers         loggers     = Substitute.For <ILoggers>();

            interaction.Loggers.Returns(loggers);
            ILogger logger = Substitute.For <ILogger>();

            loggers[LoggerType.Status].Returns(logger);

            task.Execute(interaction).Should().Be(ExitCode.InvalidArgument);
            logger.Received().WriteLine(WriteStyle.Error, XTaskStrings.ErrorNoParametersSpecified);
        }
示例#13
0
        public void UnknownTaskLogsHelp()
        {
            ITaskRegistry    registry    = Substitute.For <ITaskRegistry>();
            UnknownTask      task        = new UnknownTask(registry, "GeneralHelp");
            ITaskInteraction interaction = Substitute.For <ITaskInteraction>();
            ILoggers         loggers     = Substitute.For <ILoggers>();

            interaction.Loggers.Returns(loggers);
            ILogger logger = Substitute.For <ILogger>();

            loggers[LoggerType.Result].Returns(logger);

            task.Execute(interaction).Should().Be(ExitCode.InvalidArgument);
            logger.Received().WriteLine(WriteStyle.Fixed, "GeneralHelp");
        }
示例#14
0
        public void ListSettings_CountIsCorrect()
        {
            // Ensure we output the location table and all settings when listing settings

            // Set up loggers
            List <ITable> outputTables = new List <ITable>();
            ILogger       logger       = Substitute.For <ILogger>();

            logger.Write(Arg.Do <ITable>(x => outputTables.Add(x)));
            ILoggers loggers = Substitute.For <ILoggers>();

            loggers[Arg.Any <LoggerType>()].Returns(logger);

            // Set up to list settings
            ITaskInteraction interaction = Substitute.For <ITaskInteraction>();

            interaction.Loggers.Returns(loggers);
            IArgumentProvider argumentProvider = Substitute.For <IArgumentProvider, IClientSettings>();

            argumentProvider.GetOption <SettingsLocation?>(StandardOptions.List).Returns(new Nullable <SettingsLocation>(SettingsLocation.Local));
            interaction.Arguments.Returns(argumentProvider);

            // Prepare the configuration results
            ((IClientSettings)argumentProvider).GetConfigurationPath(SettingsLocation.Local).Returns("LocalPath");
            ((IClientSettings)argumentProvider).GetConfigurationPath(SettingsLocation.Roaming).Returns("RoamingPath");
            ((IClientSettings)argumentProvider).GetConfigurationPath(SettingsLocation.RunningExecutable).Returns("ExePath");

            ClientSetting[] settings =
            {
                new ClientSetting("foo", "one", SettingsLocation.Local),
                new ClientSetting("bar", "two", SettingsLocation.Roaming)
            };
            ((IClientSettings)argumentProvider).GetAllSettings().Returns(settings);

            DefaultsTask task = new DefaultsTask("Foo");

            task.Execute(interaction).Should().Be(ExitCode.Success);

            outputTables.Count.Should().Be(2, "table for locations and table for settings");
            outputTables[0].Rows.Skip(1).ForEachDoOne(
                row => row.Should().Contain(SettingsLocation.Local.ToString(), "LocalPath"),
                row => row.Should().Contain(SettingsLocation.Roaming.ToString(), "RoamingPath"),
                row => row.Should().Contain(SettingsLocation.RunningExecutable.ToString(), "ExePath"));

            outputTables[1].Rows.Skip(1).ForEachDoOne(
                row => row.Should().Contain("foo", SettingsLocation.Local.ToString(), "one"),
                row => row.Should().Contain("bar", SettingsLocation.Roaming.ToString(), "two"));
        }
示例#15
0
文件: HelpTask.cs 项目: Priya91/XTask
        public ExitCode Execute(ITaskInteraction interaction)
        {
            if (this.unknownCommand)
            {
                if (String.IsNullOrEmpty(interaction.Arguments.Command))
                {
                    interaction.Loggers[LoggerType.Status].WriteLine(WriteStyle.Error, XTaskStrings.ErrorNoParametersSpecified);
                }
                else
                {
                    interaction.Loggers[LoggerType.Status].WriteLine(WriteStyle.Error, XTaskStrings.UnknownCommand, interaction.Arguments.Command);
                }
            }

            interaction.Loggers[LoggerType.Result].WriteLine(WriteStyle.Fixed, this.generalHelp);
            return this.unknownCommand ? ExitCode.InvalidArgument : ExitCode.Success;
        }
示例#16
0
        public void UnkownCommand()
        {
            ITaskRegistry     registry    = Substitute.For <ITaskRegistry>();
            UnknownTask       task        = new UnknownTask(registry, "GeneralHelp");
            ITaskInteraction  interaction = Substitute.For <ITaskInteraction>();
            IArgumentProvider arguments   = Substitute.For <IArgumentProvider>();
            string            commandName = "Foo";

            interaction.Arguments.Returns(arguments);
            interaction.Arguments.Command.Returns(commandName);
            ILoggers loggers = Substitute.For <ILoggers>();

            interaction.Loggers.Returns(loggers);
            ILogger logger = Substitute.For <ILogger>();

            loggers[LoggerType.Status].Returns(logger);

            task.Execute(interaction).Should().Be(ExitCode.InvalidArgument);
            logger.Received().WriteLine(WriteStyle.Error, XTaskStrings.UnknownCommand, commandName);
        }
示例#17
0
        public void RemoveSetting_Removes()
        {
            // Ensure actually add a setting when adding

            // Set up to add settings
            ITaskInteraction  interaction      = Substitute.For <ITaskInteraction>();
            IArgumentProvider argumentProvider = Substitute.For <IArgumentProvider, IClientSettings>();

            argumentProvider.GetOption <SettingsLocation?>(StandardOptions.Remove).Returns(new Nullable <SettingsLocation>(SettingsLocation.Roaming));
            interaction.Arguments.Returns(argumentProvider);

            argumentProvider.Options.Returns(new Dictionary <string, string>
            {
                { "Boy", "Howdy" }
            });

            DefaultsTask task = new DefaultsTask("Foo");

            task.Execute(interaction).Should().Be(ExitCode.Success);

            ((IClientSettings)argumentProvider).Received(1).RemoveSetting(SettingsLocation.Roaming, "Boy");
        }
示例#18
0
        public ExitCode ExecuteTask()
        {
            ITask            task        = _taskRegistry[ArgumentProvider.Command];
            ITaskInteraction interaction = GetInteraction(task);

            ExitCode result = ExitCode.GeneralFailure;

            using (interaction as IDisposable)
                using (task as IDisposable)
                {
                    if (ArgumentProvider.HelpRequested)
                    {
                        task.OutputUsage(interaction);
                    }
                    else
                    {
                        result = task.Execute(interaction);
                    }
                }

            return(result);
        }
示例#19
0
        public void AddSetting_SkipOptions()
        {
            // Ensure we skip saving options that directly apply to the defaults task

            // Set up to add settings
            ITaskInteraction  interaction      = Substitute.For <ITaskInteraction>();
            IArgumentProvider argumentProvider = Substitute.For <IArgumentProvider, IClientSettings>();

            argumentProvider.GetOption <SettingsLocation?>(StandardOptions.Add).Returns(new Nullable <SettingsLocation>(SettingsLocation.Local));
            interaction.Arguments.Returns(argumentProvider);

            argumentProvider.Options.Returns(new Dictionary <string, string>
            {
                { StandardOptions.List[0], "one" },
                { StandardOptions.Add[0], "two" },
                { StandardOptions.Remove[0], "three" },
            });

            DefaultsTask task = new DefaultsTask("Foo");

            task.Execute(interaction).Should().Be(ExitCode.Success);

            ((IClientSettings)argumentProvider).DidNotReceiveWithAnyArgs().SaveSetting(SettingsLocation.Local, "", "");
        }
示例#20
0
 public TestTaskExecution(IArgumentProvider argumentProvider, ITaskRegistry taskRegistry, ITaskInteraction interaction)
     : base(argumentProvider, taskRegistry, null)
 {
     this.interaction = interaction;
 }
示例#21
0
文件: HelpTask.cs 项目: ramarag/XTask
 public void GetUsage(ITaskInteraction interaction)
 {
     this.Execute(interaction);
 }
示例#22
0
文件: Task.cs 项目: JeremyKuhne/XTask
 public ExitCode Execute(ITaskInteraction interaction)
 {
     _interaction = interaction;
     return(ExecuteInternal());
 }
示例#23
0
文件: HelpTask.cs 项目: ramarag/XTask
 public void GetUsage(ITaskInteraction interaction)
 {
     this.Execute(interaction);
 }
示例#24
0
文件: Task.cs 项目: ramarag/XTask
 public ExitCode Execute(ITaskInteraction interaction)
 {
     this.interaction = interaction;
     return(this.ExecuteInternal());
 }