public bool Execute(IEnumerable <string> arguments, IOptionParser options) { foreach (var file in _file.GetDuplicates()) { _consoleWriter.WriteLine("--- Duplicate ---"); _consoleWriter.WriteLine($"CreatedAt (oldest): {file.CreatedAt}"); _consoleWriter.WriteLine($"File Size: {file.Size}"); _consoleWriter.WriteLine($"File Tags: {string.Join(", ", file.GetTags().Result.Select(t => t.FullName))}"); var table = new ConsoleTable(5); foreach (var path in file.GetPaths().Result) { var fileInfo = new FileInfo(path); if (fileInfo.Exists) { table.Append(fileInfo.CreationTimeUtc, fileInfo.Length.HumanSize(), fileInfo.Name, string.Empty, fileInfo.Directory.FullName); } else { table.Append(string.Empty, string.Empty, fileInfo.Name, "*", fileInfo.Directory.FullName); } } table.WriteTo(_consoleWriter); _consoleWriter.WriteLine(); } _consoleWriter.WriteLine("Files with an asterisk (*) are in the database, but at the given path they seem to be deleted."); return(true); }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { var search = string.Join(" ", arguments); _consoleWriter.WriteLine($"Find Files: {search}"); var files = _file.Search(search).ToList(); if (files.Any()) { var table = FileTable(); foreach (var file in files) { if (options.HasOption <OpenOption>()) { FileHelper.OpenWithAssociatedProgram(file.Path); } table.Append(file.Hash.Result.ShortHash(), file.CreatedAt, file.Size.HumanSize(), file.Path); } table.WriteTo(_consoleWriter); } else { _consoleWriter.WriteLine("No files found for your search query..."); } return(true); }
public ClientHost(IOptionParser optionParser, IRestClientProtocol clientProtocol, IRestDataTransferProtocol dataTransferProtocol, ICommandDispatcher commandDispatcher, ICommandFactory commandFactory) { _optionParser = optionParser; _clientProtocol = clientProtocol; _dataTransferProtocol = dataTransferProtocol; _commandDispatcher = commandDispatcher; _commandFactory = commandFactory; }
private bool PrintOverview(IOptionParser options) { PrintHelpHeader(); PrintHelpCommands(_container.Resolve <IEnumerable <ICommand> >()); PrintHelpOptions(_container.Resolve <IEnumerable <IOption> >()); PrintTagVariables(options); PrintHelpExamples(); return(true); }
private void ParseShortOption(IOptionParser parser, OptionToken token) { if (!m_ShortOptionList.TryGetValue(token.Value[0], out OptionData optionData)) { throw new OptionUnknownException(token.ToString(parser)); } ParseOptionParameter(parser, optionData, token); }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { foreach (var project in _projects.GetProjects()) { FormatProject(project); } return(true); }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { var projects = arguments.ToList(); return(projects.Count switch { 0 => NotEnoughArguments(), _ => DestroyProjects(projects) });
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { _logger.LogTrace("Help Command executed"); var firstArgument = arguments.FirstOrNone(); return(firstArgument.Match( none: PrintOverview(options), some: argument => PrintSpecificHelp(argument, _container.Resolve <IEnumerable <ICommand> >()))); }
public bool Execute(IEnumerable <string> lazyArguments, IOptionParser options) { var arguments = lazyArguments.ToList(); return(arguments.Count switch { 0 => NotEnoughArguments(), 1 => CreateProject(arguments.First()), _ => TooManyArguments() });
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { if (arguments.Any()) { _consoleWriter.WriteLine("Too many arguments given, the plugin command does not take any arguments."); return(false); } return(ListPlugins()); }
public bool Execute(IEnumerable <string> lazyArguments, IOptionParser options) { var arguments = lazyArguments.ToList(); return(arguments.Count switch { 0 => NotEnoughArguments(), 1 => ExportProject(arguments.First(), CurrentDirectory), 2 => ExportProject(arguments.First(), arguments.Last()), _ => TooManyArguments() });
private void ParseLongOption(IOptionParser parser, OptionToken token) { string option = parser.LongOptionCaseInsensitive ? token.Value.ToLowerInvariant() : token.Value; if (!m_LongOptionList.TryGetValue(option, out OptionData optionData)) { throw new OptionUnknownException(token.ToString(parser)); } ParseOptionParameter(parser, optionData, token); }
public bool ExportFiles(IEnumerable <string> lazyArguments, IOptionParser options, string longCommand) { var arguments = lazyArguments.ToList(); return(arguments.Count switch { 0 => NotEnoughArguments(longCommand), 1 => NotEnoughArguments(longCommand), 2 => ExportFiles(GetSearchArgument(arguments), GetDestinationPath(arguments)), _ => TooManyArguments(longCommand) });
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { foreach (var path in _file.GetPaths()) { if (File.Exists(path) == false) { _consoleWriter.WriteLine($"File '{path}' does not exist, removed from index"); } } return(true); }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { foreach (var argument in _filePathExtractor.FromFilePatterns(arguments, false)) { _consoleWriter.WriteLine($"File: {argument}"); if (FileType(argument) is { } fileType) { _consoleWriter.WriteLine($"Category : {fileType.Category}"); _consoleWriter.WriteLine($"Name : {fileType.Name}"); _consoleWriter.WriteLine($"Extension: {string.Join(",", fileType.Extensions)}"); }
private void ParseOption(IOptionParser parser, OptionToken token) { switch (token.Token) { case OptionTokenKind.ShortOption: ParseShortOption(parser, token); break; case OptionTokenKind.LongOption: ParseLongOption(parser, token); break; } }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { var project = arguments.First(); if (_projects.GetProjects().Contains(project)) { _settings[DB.Constants.ProjectDatabaseKey] = project; _consoleWriter.WriteLine($"You switched to project '{project}'"); return(true); } _consoleWriter.WriteLine($"There is no project with the name '{project}' please create it first."); return(false); }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { var table = StatisticsTable(); foreach (var(key, value) in _db.GetStatistics()) { table.Append(key, "=", value); } _consoleWriter.WriteLine("Statistics:"); _consoleWriter.WriteLine(); table.WriteTo(_consoleWriter); return(true); }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { foreach (var filePath in _filePathExtractor.FromFilePatterns(arguments, false)) { IEnumerable <Directory> directories = ReadMetadata(filePath); foreach (var directory in directories) { foreach (var tag in directory.Tags) { _consoleWriter.WriteLine($"{directory.Name} - {tag.Name} ({tag.Type}) = {tag.Description}"); } } } return(true); }
private void SetOption(IOptionParser parser, OptionData optionData, string value) { if (optionData.IsList) { IList list = optionData.GetList(m_Options); SplitList(list, parser.ListSeparator, value); return; } if (optionData.Set) { throw new OptionAssignedException(value); } optionData.SetValue(m_Options, value); }
private void ParseOptionParameter(IOptionParser parser, OptionData optionData, OptionToken token) { string argument = null; try { if (optionData.ExpectsValue) { OptionToken argumentToken = parser.GetToken(true); if (argumentToken == null) { OptionDefaultAttribute defaultAttribute = null; if (optionData.Member != null) { defaultAttribute = GetAttribute <OptionDefaultAttribute>(optionData.Member); } if (defaultAttribute == null) { throw new OptionMissingArgumentException(token.ToString(parser)); } argument = defaultAttribute.DefaultValue; } else { argument = argumentToken.Value; } SetOption(parser, optionData, argument); } else { // This is a boolean type. We can only set it to true. SetBoolean(optionData, true); } optionData.Set = true; } catch (OptionException) { throw; } catch (Exception e) { string message; if (argument == null) { message = string.Format("Error parsing option '{0}'", token.ToString(parser)); throw new OptionException(message); } message = string.Format("Wrong format '{0}' given to option {1}", argument, token.ToString(parser)); throw new OptionFormatException(token.Value, message, e); } }
public bool Execute(IEnumerable <string> lazyArguments, IOptionParser options) { var arguments = lazyArguments.ToList(); var result = false; if (arguments.Count >= 2) { result = MoveTags(arguments); } if (result == false) { _logger.LogWarning("Rename failed"); } return(result); }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { var version = GetVersion(); _consoleWriter.WriteLine($"{nameof(SortingHat)} {version.Version}"); _consoleWriter.WriteLine(); var table = new ConsoleTable(2); table.Columns[0].Alignment = ConsoleTableColumnAlignment.Right; table.Append("Culture:", version.CultureName ?? "<NULL>"); table.Append("Current Culture:", CultureInfo.CurrentCulture); table.WriteTo(_consoleWriter); return(true); }
public async Task ExecuteAsync(IEnumerable <string> lazyArguments, IOptionParser options) { var arguments = lazyArguments.ToList(); var tags = arguments.Where(a => a.IsTag()).ToList(); var files = arguments.Where(IsFile); foreach (var file in _filePathExtractor.FromFilePatterns(files, options.HasOption <RecursiveOption>()).Select(FileFromPath)) { if (tags.Count == 0) { _file.Store(file); } else { await TagFile(tags, file); } } }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { foreach (var tagString in arguments) { var tag = _tagParser.Parse(tagString); if (tag is null) { _logger.LogWarning($"Remove tag '{tagString}' failed (parse)"); } else if (tag.Destroy() == false) { _logger.LogWarning($"Remove tag '{tagString}' failed (db)"); } } return(true); }
private bool PrintTagVariables(IOptionParser options) { var autoTagHandler = _container.Resolve <IAutoTagHandler>(); _console.Writer.WriteLine("Possible Tag Variables:"); _console.Writer.WriteLine(); foreach (var tag in autoTagHandler.AutoTags.OrderBy(tag => tag.AutoTagKey)) { _console.Writer.WriteLine($"* {tag.HumanReadableAutoTagsKey}"); if (options.HasOption <VerboseOption>()) { _console.Writer.WriteLine($"=> {tag.Description}"); _console.Writer.WriteLine(); } } return(true); }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { var tags = arguments.Where(a => a.IsTag()); var files = arguments.Where(IsFile); foreach (var file in _filePathExtractor.FromFilePatterns(files, options.HasOption <RecursiveOption>()).Select(FileFromPath)) { foreach (var tag in tags.Select(_tagParser.Parse)) { if (tag != null) { _logger.LogInformation($"File {file.Path} tagged with {tag.Name}"); file.Untag(tag); } } } return(true); }
/// <summary> /// Returns a <see cref="string" /> that represents this instance. /// </summary> /// <param name="parser">The parser.</param> /// <returns>A <see cref="string" /> that represents this instance.</returns> /// <remarks> /// This method differs that the format of the string can change depending on /// the parser being used. /// </remarks> public virtual string ToString(IOptionParser parser) { switch (Token) { case OptionTokenKind.ShortOption: return(parser.ShortOptionPrefix + Value); case OptionTokenKind.LongOption: return(parser.LongOptionPrefix + Value); case OptionTokenKind.Argument: return(Value); case OptionTokenKind.Value: return(Value); default: return(Value); } }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { var result = false; if (arguments.Count() == 2) { result = RenameTag(arguments); } else { _logger.LogWarning("rename tag has exactly two arguments, the tag to rename, and a new name: hat rename-tag :tag new_name"); _consoleWriter.WriteLine("rename tag has exactly two arguments, the tag to rename, and a new name: hat rename-tag :tag new_name"); } if (result == false) { _logger.LogWarning("Rename failed"); } return(result); }
public bool Execute(IEnumerable <string> arguments, IOptionParser options) { foreach (var filePath in _filePathExtractor.FromFilePatterns(arguments, options.HasOption <RecursiveOption>())) { _consoleWriter.WriteLine(); _consoleWriter.WriteLine($"File: {filePath}"); var file = _newFile(); file.LoadByPathFromDb(filePath); if (file.Hash == null) { _consoleWriter.WriteLine("File not in index!"); } else { _consoleWriter.WriteLine($"CreatedAt (oldest): {file.CreatedAt}"); _consoleWriter.WriteLine($"File Size: {file.Size}"); _consoleWriter.WriteLine($"File Hash: {file.Hash.Result}"); foreach (var tag in file.GetTags().Result) { _consoleWriter.WriteLine($"Tag: {tag.FullName}"); } foreach (var name in file.GetNames().Result) { _consoleWriter.WriteLine($"Name: {name}"); } foreach (var path in file.GetPaths().Result) { _consoleWriter.WriteLine($"Path: {path}"); } } } return(true); }