Пример #1
0
        /// <summary>
        /// Parsea el argumento de change.
        /// </summary>
        /// <param name="startIndex">Índice en el que
        /// comienza el argumento.</param>
        /// <returns>Resultados del parseo.</returns>
        private ChangeParseResult ParseChangeArgument(int startIndex)
        {
            var header    = startIndex;
            var from      = _args[++header];
            var delimiter = _args[++header];
            var to        = _args[++header];

            if (delimiter == "//")
            {
                var areValidNames = IsValidName(from) && IsValidName(to);
                if (areValidNames)
                {
                    var areValidFileNames =
                        _pathValidator.ValidateFileName(from).Valid&&
                        _pathValidator.ValidateFileName(to).Valid;

                    if (areValidFileNames)
                    {
                        var results = new ChangeParseResult
                        {
                            From      = from,
                            To        = to,
                            NextIndex = header
                        };

                        return(results);
                    }
                }
            }

            throw new ArgumentParseException("Badformed --change argument. It should have this format: FROM -> TO, where FROM and TO must be valid filenames.");
        }
Пример #2
0
        /// <summary>
        /// Parsea los argumentos de entrada y configura
        /// una búsqueda acorde con ellos.
        /// </summary>
        /// <param name="args">Argumentos de entrada.</param>
        /// <returns>Configuración de renombrado.</returns>
        public RenamingConfiguration Parse()
        {
            int             i          = 0;
            PathParseResult pathResult = ParsePathArgument(i);

            i = pathResult.NextIndex;

            ChangeParseResult  changeResult  = null;
            ExcludeParseResult excludeResult = null;

            for (; i < _args.Length; i++)
            {
                var arg = _args[i];

                if (arg.StartsWith("--"))
                {
                    var parsingArgument = arg
                                          .Substring(2)
                                          .ToLowerInvariant();

                    switch (parsingArgument)
                    {
                    case "change":
                        changeResult = ParseChangeArgument(i);
                        i            = changeResult.NextIndex;
                        break;

                    case "exclude":
                        excludeResult = ParseExcludeArgument(i);
                        i             = excludeResult.NextIndex;
                        break;

                    default:
                        throw new ArgumentParseException(string.Format("Argument \"{0}\" not recognized", arg));
                    }
                }
                else
                {
                    throw new ArgumentParseException("Badformed argument list");
                }
            }

            if (changeResult == null)
            {
                throw new ArgumentParseException("--change argument is required");
            }

            Search search;

            if (excludeResult == null)
            {
                search = new Search(pathResult.Path);
            }
            else
            {
                search = new Search(pathResult.Path, excludeResult.Exclude);
            }

            return(new RenamingConfiguration
            {
                PreparedSearch = search,
                From = changeResult.From,
                To = changeResult.To
            });
        }