Exemple #1
0
        private static async Task <int> MainAsync(string[] args)
        {
            Mp3YearTagger onlineMp3Retagger = null;

            try
            {
                _optionsCli = new Mp3YearTaggerOptionsCli();
                CommandLineParser.ParseArguments(args, _optionsCli);

                if (!_optionsCli.ValidateOptions())
                {
                    return(1);
                }

                onlineMp3Retagger = new Mp3YearTagger(_optionsCli);
                onlineMp3Retagger.VerboseOutput += HandleVerboseOutput;

                if (_optionsCli.CollectionsOnly)
                {
                    await onlineMp3Retagger.ProcessCollectionsDirectoriesAsync(_optionsCli.Directory);
                }
                else
                {
                    await onlineMp3Retagger.ProcessDirectoryAsync(_optionsCli.Directory);
                }
                return(0);
            }
            catch (ApplicationException ex)
            {
                Console.Error.WriteLine(ex.Message);
                return(1);
            }
            catch (ArgumentException ex)
            {
                Console.Error.WriteLine(ex.Message);
                return(1);
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine(ex.ToString());
                return(1);
            }
            finally
            {
                if (onlineMp3Retagger != null)
                {
                    onlineMp3Retagger.VerboseOutput -= HandleVerboseOutput;
                }
            }
        }
        private static bool TryExpandMergedArgs(int argIndex, ref string[] args, Mp3YearTaggerOptionsCli optionsCli)
        {
            string potentiallyMergedArgs = args[argIndex];

            if (potentiallyMergedArgs == null || potentiallyMergedArgs.Length <= 2 || potentiallyMergedArgs[0] != '-' || potentiallyMergedArgs[1] == '-')
            {
                return(false);
            }

            var newArgs  = potentiallyMergedArgs.Substring(1).Select(ch => $"-{ch}");
            var argsList = new List <string>(args);

            // Replace the merged args with expanded args
            argsList.RemoveAt(argIndex);
            argsList.InsertRange(argIndex, newArgs);
            args = argsList.ToArray();

            return(true);
        }
        private static void ShowHelp()
        {
            var defaultValues = new Mp3YearTaggerOptionsCli();

            Console.WriteLine($"Usage: Mp3YearTagger [OPTIONS]... [DIRECTORY]");
            Console.WriteLine();
            Console.WriteLine($"Required arguments:");
            Console.WriteLine($"  [DIRECTORY]                    directory path with MP3 files to process");
            Console.WriteLine();
            Console.WriteLine($"Optional arguments:");
            Console.WriteLine($"  -c, --collections-only         process collection directories recursively (see -k, --collection-keywords)");
            Console.WriteLine($"  -d, --dry-run                  dry run - do not make any file changes - will output changes that would have been made");
            Console.WriteLine($"  -f, --flag-filename            override the filename to create in each directory after processing (use \"\" to disable)");
            Console.WriteLine($"                                   (default: {defaultValues.FlagFilename})");
            Console.WriteLine($"  -k, --collection-keywords      comma-separated list of directory key words that indicate a collection (override)");
            Console.WriteLine($"                                   (default: {string.Join(", ", defaultValues.CollectionKeywords)})");
            Console.WriteLine($"  -q, --quiet                    quite, no output (except for errors)");
            Console.WriteLine($"  -r, --recursive                process directory recursively");
            Console.WriteLine($"  -t, --web-api-throttle-ms      milliseconds to wait between MusicBrainz API requests to avoid getting banned (default: {defaultValues.WebApiThrottleMs})");
            Console.WriteLine($"  -v, --verbose                  increase verbose output (Example: -vvv for verbosity level 3)");
        }
 public static int ParseArguments(string[] args, Mp3YearTaggerOptionsCli optionsCli)
 {
     return(ParseArgumentsInternal(args, optionsCli));
 }
        private static int ParseArgumentsInternal(string[] args, Mp3YearTaggerOptionsCli optionsCli)
        {
            if (args == null)
            {
                return(0);
            }

            var argsNotUsedCount           = 0;
            var argIndex                   = 0;
            var requiredArgumentCandidates = new List <string>();

            try
            {
                while (argIndex < args.Length)
                {
                    string arg = args[argIndex];
                    switch (arg)
                    {
                    case "--collections-only":
                    case "-c":
                        optionsCli.CollectionsOnly = true;
                        break;

                    case "--dry-run":
                    case "-d":
                        optionsCli.DryRunMode = true;
                        break;

                    case "--flag-filename":
                    case "-f":
                        optionsCli.FlagFilename = GetNextArg(args, ref argIndex);
                        break;

                    case "--collection-keywords":
                    case "-k":
                        optionsCli.CollectionKeywords = GetNextArgAsStringEnumerable(args, ref argIndex).ToList();
                        break;

                    case "--web-api-throttle-ms":
                    case "-t":
                        optionsCli.WebApiThrottleMs = GetNextArgAsInt(args, ref argIndex);
                        break;

                    case "--recursive":
                    case "-r":
                        optionsCli.IsRecursive = true;
                        break;

                    case "--verbose":
                    case "-v":
                        optionsCli.ShowVerboseLevel++;
                        break;

                    case "--quiet":
                    case "-q":
                        optionsCli.ShowVerboseLevel = -1;
                        break;

                    case "--help":
                    case "-h":
                    case "/h":
                    case "/?":
                        ShowHelp();
                        Environment.Exit(0);
                        break;

                    default:
                        if (TryExpandMergedArgs(argIndex, ref args, optionsCli))
                        {
                            continue;
                        }
                        else
                        {
                            requiredArgumentCandidates.Add(arg);
                            argsNotUsedCount++;
                        }
                        break;
                    }

                    argIndex++;
                }
            }
            catch (ArgumentException ex)
            {
                Console.Error.WriteLine(ex.Message);
                Environment.Exit(1);
            }

            if (requiredArgumentCandidates.Count != 1)
            {
                Console.Error.WriteLine($"Invalid arguments: {string.Join(", ", requiredArgumentCandidates)}");
                Environment.Exit(1);
            }

            optionsCli.Directory = requiredArgumentCandidates[0];
            argsNotUsedCount--;

            return(argsNotUsedCount);
        }