Parser.cs

Go to the documentation of this file.

// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
 
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
 
using CommandLine.Core;
using CommandLine.Text;
 
using CSharpx;
 
using RailwaySharp.ErrorHandling;
 
namespace CommandLine
{
    public class Parser : IDisposable
    {
        private static readonly Lazy<Parser> DefaultParser =
            new Lazy<Parser>(() => new Parser(new ParserSettings { HelpWriter = Console.Error }));
 
        private bool disposed;
 
        public Parser()
        {
            Settings = new ParserSettings { Consumed = true };
        }
 
        public Parser(Action<ParserSettings> configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }
 
            Settings = new ParserSettings();
            configuration(Settings);
            Settings.Consumed = true;
        }
 
        public Parser(Func<ParserSettings> factory)
        {
            if (factory == null)
            {
                throw new ArgumentNullException(nameof(factory));
            }
 
            Settings = factory();
            Settings.Consumed = true;
        }
 
        internal Parser(ParserSettings settings)
        {
            Settings = settings;
            Settings.Consumed = true;
        }
 
        public static Parser Default => DefaultParser.Value;
 
        public ParserSettings Settings { get; }
 
#region IDisposable Members
 
        public void Dispose()
        {
            Dispose(true);
 
            GC.SuppressFinalize(this);
        }
 
#endregion
 
        ~Parser()
        {
            Dispose(false);
        }
 
        public ParserResult<T> ParseArguments<T>(IEnumerable<string> args)
        {
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
 
            Maybe<Func<T>> factory = typeof(T).IsMutable()
                                         ? Maybe.Just<Func<T>>(Activator.CreateInstance<T>)
                                         : Maybe.Nothing<Func<T>>();
 
            return MakeParserResult(InstanceBuilder.Build(factory,
                                                          (arguments, optionSpecs) =>
                                                              Tokenize(arguments, optionSpecs, Settings),
                                                          args,
                                                          Settings.NameComparer,
                                                          Settings.CaseInsensitiveEnumValues,
                                                          Settings.ParsingCulture,
                                                          Settings.AutoHelp,
                                                          Settings.AutoVersion,
                                                          Settings.AllowMultiInstance,
                                                          HandleUnknownArguments(Settings.IgnoreUnknownArguments)
                                                         ),
                                    Settings
                                   );
        }
 
        public ParserResult<T> ParseArguments<T>(Func<T> factory, IEnumerable<string> args)
        {
            if (factory == null)
            {
                throw new ArgumentNullException("factory");
            }
 
            if (!typeof(T).IsMutable())
            {
                throw new ArgumentException("factory");
            }
 
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
 
            return MakeParserResult(InstanceBuilder.Build(Maybe.Just(factory),
                                                          (arguments, optionSpecs) =>
                                                              Tokenize(arguments, optionSpecs, Settings),
                                                          args,
                                                          Settings.NameComparer,
                                                          Settings.CaseInsensitiveEnumValues,
                                                          Settings.ParsingCulture,
                                                          Settings.AutoHelp,
                                                          Settings.AutoVersion,
                                                          Settings.AllowMultiInstance,
                                                          HandleUnknownArguments(Settings.IgnoreUnknownArguments)
                                                         ),
                                    Settings
                                   );
        }
 
        public ParserResult<object> ParseArguments(IEnumerable<string> args, params Type[] types)
        {
            if (args == null)
            {
                throw new ArgumentNullException("args");
            }
 
            if (types == null)
            {
                throw new ArgumentNullException("types");
            }
 
            if (types.Length == 0)
            {
                throw new ArgumentOutOfRangeException("types");
            }
 
            return MakeParserResult(InstanceChooser.Choose((arguments, optionSpecs) =>
                                                               Tokenize(arguments, optionSpecs, Settings),
                                                           types,
                                                           args,
                                                           Settings.NameComparer,
                                                           Settings.CaseInsensitiveEnumValues,
                                                           Settings.ParsingCulture,
                                                           Settings.AutoHelp,
                                                           Settings.AutoVersion,
                                                           Settings.AllowMultiInstance,
                                                           HandleUnknownArguments(Settings.IgnoreUnknownArguments)
                                                          ),
                                    Settings
                                   );
        }
 
        private static Result<IEnumerable<Token>, Error> Tokenize(IEnumerable<string> arguments,
                                                                  IEnumerable<OptionSpecification> optionSpecs,
                                                                  ParserSettings settings)
        {
            return settings.GetoptMode
                       ? GetoptTokenizer.ConfigureTokenizer(settings.NameComparer,
                                                            settings.IgnoreUnknownArguments,
                                                            settings.EnableDashDash,
                                                            settings.PosixlyCorrect
                                                           )(arguments, optionSpecs)
                       : Tokenizer.ConfigureTokenizer(settings.NameComparer,
                                                      settings.IgnoreUnknownArguments,
                                                      settings.EnableDashDash
                                                     )(arguments, optionSpecs);
        }
 
        private static ParserResult<T> MakeParserResult<T>(ParserResult<T> parserResult, ParserSettings settings)
        {
            return DisplayHelp(parserResult,
                               settings.HelpWriter,
                               settings.MaximumDisplayWidth
                              );
        }
 
        private static ParserResult<T> DisplayHelp<T>(ParserResult<T> parserResult,
                                                      TextWriter helpWriter,
                                                      int maxDisplayWidth)
        {
            parserResult.WithNotParsed(errors =>
                                           Maybe.Merge(errors.ToMaybe(), helpWriter.ToMaybe())
                                                .Do((_, writer) =>
                                                        writer.Write(HelpText.AutoBuild(parserResult, maxDisplayWidth))
                                                   )
                                      );
 
            return parserResult;
        }
 
        private static IEnumerable<ErrorType> HandleUnknownArguments(bool ignoreUnknownArguments)
        {
            return ignoreUnknownArguments
                       ? Enumerable.Empty<ErrorType>()
                                   .Concat(ErrorType.UnknownOptionError)
                       : Enumerable.Empty<ErrorType>();
        }
 
        private void Dispose(bool disposing)
        {
            if (disposed)
            {
                return;
            }
 
            if (disposing)
            {
                if (Settings != null)
                {
                    Settings.Dispose();
                }
 
                disposed = true;
            }
        }
    }
}