CommandLine.UnParserExtensions Class Reference

Provides overloads to unparse options instance. More...

Static Public Member Functions
static string	FormatCommandLine< T > (this Parser parser, T options)
	Format a command line argument string from a parsed instance.
static string[]	FormatCommandLineArgs< T > (this Parser parser, T options)
	Format a command line argument string from a parsed instance in the form of string[].
static string	FormatCommandLine< T > (this Parser parser, T options, Action< UnParserSettings > configuration)
	Format a command line argument string from a parsed instance.
static string[]	FormatCommandLineArgs< T > (this Parser parser, T options, Action< UnParserSettings > configuration)
	Format a command line argument string[] from a parsed instance.
static string[]	SplitArgs (this string command, bool keepQuote=false)
	Returns a string array that contains the substrings in this instance that are delimited by space considering string between double quote.

Static Private Member Functions
static string	FormatValue (Specification spec, object value)
static object	FormatWithQuotesIfString (object value)
static char	SeperatorOrSpace (this Specification spec)
static string	FormatOption (OptionSpecification spec, object value, UnParserSettings settings)
static string	FormatName (this OptionSpecification optionSpec, object value, UnParserSettings settings)
static object	NormalizeValue (this object value)
static bool	IsEmpty (this object value, Specification specification, bool skipDefault)

Detailed Description

Provides overloads to unparse options instance.

Definition at line 97 of file UnParserExtensions.cs.

Member Function Documentation

FormatCommandLine< T >() [1/2]

static string CommandLine.UnParserExtensions.FormatCommandLine< T > ( this Parser  parser, T  options  )

static

Format a command line argument string from a parsed instance.

Template Parameters

T	Type of options .

Parameters

parser	Parser instance.
options	A parsed (or manually correctly constructed instance).

Returns

A string with command line arguments.

Definition at line 106 of file UnParserExtensions.cs.

        {
            return parser.FormatCommandLine(options, config => { });
        }

FormatCommandLine< T >() [2/2]

static string CommandLine.UnParserExtensions.FormatCommandLine< T > ( this Parser  parser, T  options, Action< UnParserSettings >  configuration  )

static

Format a command line argument string from a parsed instance.

Template Parameters

T	Type of options .

Parameters

parser	Parser instance.
options	A parsed (or manually correctly constructed instance).
configuration	The Action<UnParserSettings> lambda used to configure aspects and behaviors of the unparsersing process.

Returns

A string with command line arguments.

Definition at line 135 of file UnParserExtensions.cs.

        {
            if (options == null)
            {
                throw new ArgumentNullException("options");
            }
 
            UnParserSettings settings = new UnParserSettings();
            configuration(settings);
            settings.Consumed = true;
 
            Type type = options.GetType();
            StringBuilder builder = new StringBuilder();
 
            type.GetVerbSpecification()
                .MapValueOrDefault(verb => builder.Append(verb.Name)
                                                  .Append(' '),
                                   builder
                                  );
 
            var specs =
                (from info in
                     type.GetSpecifications(pi => new
                                            {
                                                Specification = Specification.FromProperty(pi),
                                                Value = pi.GetValue(options, null)
                                                          .NormalizeValue(),
                                                PropertyValue = pi.GetValue(options, null),
                                            }
                                           )
                 where !info.PropertyValue.IsEmpty(info.Specification, settings.SkipDefault)
                 select info)
                .Memoize();
 
            var allOptSpecs = from info in specs.Where(i => i.Specification.Tag == SpecificationType.Option)
                              let o = (OptionSpecification)info.Specification
                              where o.TargetType != TargetType.Switch ||
                                    (o.TargetType == TargetType.Switch && o.FlagCounter && (int)info.Value > 0) ||
                                    (o.TargetType == TargetType.Switch && (bool)info.Value)
                              where !o.Hidden || settings.ShowHidden
                              orderby o.UniqueName()
                              select info;
 
            var shortSwitches = from info in allOptSpecs
                                let o = (OptionSpecification)info.Specification
                                where o.TargetType == TargetType.Switch
                                where o.ShortName.Length > 0
                                orderby o.UniqueName()
                                select info;
 
            var optSpecs = settings.GroupSwitches
                               ? allOptSpecs.Where(info => !shortSwitches.Contains(info))
                               : allOptSpecs;
 
            var valSpecs = from info in specs.Where(i => i.Specification.Tag == SpecificationType.Value)
                           let v = (ValueSpecification)info.Specification
                           orderby v.Index
                           select info;
 
            builder = settings.GroupSwitches && shortSwitches.Any()
                          ? builder.Append('-')
                                   .Append(string.Join(string.Empty,
                                                       shortSwitches.Select(info =>
                                                                            {
                                                                                OptionSpecification o =
                                                                                    (OptionSpecification)info
                                                                                        .Specification;
 
                                                                                return o.FlagCounter
                                                                                    ? string
                                                                                        .Concat(Enumerable
                                                                                                .Repeat(o.ShortName,
                                                                                                     (int)info.Value
                                                                                                    )
                                                                                            )
                                                                                    : o.ShortName;
                                                                            }
                                                                           )
                                                                    .ToArray()
                                                      )
                                          )
                                   .Append(' ')
                          : builder;
 
            optSpecs.ForEach(opt =>
                                 builder
                                     .Append(FormatOption((OptionSpecification)opt.Specification, opt.Value, settings))
                                     .Append(' ')
                            );
 
            builder.AppendWhen(valSpecs.Any() && parser.Settings.EnableDashDash, "-- ");
 
            valSpecs.ForEach(val => builder.Append(FormatValue(val.Specification, val.Value))
                                           .Append(' ')
                            );
 
            return builder
                   .ToString()
                   .TrimEnd(' ');
        }

FormatCommandLineArgs< T >() [1/2]

static string[] CommandLine.UnParserExtensions.FormatCommandLineArgs< T > ( this Parser  parser, T  options  )

static

Format a command line argument string from a parsed instance in the form of string[].

Template Parameters

T	Type of options .

Parameters

parser	Parser instance.
options	A parsed (or manually correctly constructed instance).

Returns

A string[] with command line arguments.

Definition at line 118 of file UnParserExtensions.cs.

        {
            return parser.FormatCommandLine(options, config => { })
                         .SplitArgs();
        }

FormatCommandLineArgs< T >() [2/2]

static string[] CommandLine.UnParserExtensions.FormatCommandLineArgs< T > ( this Parser  parser, T  options, Action< UnParserSettings >  configuration  )

static

Format a command line argument string[] from a parsed instance.

Template Parameters

T	Type of options .

Parameters

parser	Parser instance.
options	A parsed (or manually correctly constructed instance).
configuration	The Action<UnParserSettings> lambda used to configure aspects and behaviors of the unparsersing process.

Returns

A string[] with command line arguments.

Definition at line 247 of file UnParserExtensions.cs.

        {
            return FormatCommandLine(parser, options, configuration)
                .SplitArgs();
        }

FormatName()

static string CommandLine.UnParserExtensions.FormatName ( this OptionSpecification  optionSpec, object  value, UnParserSettings  settings  )

staticprivate

Definition at line 320 of file UnParserExtensions.cs.

        {
            // Have a long name and short name not preferred? Go with long! 
            // No short name? Has to be long!
            bool longName = (optionSpec.LongName.Length > 0 && !settings.PreferShortName) ||
                            optionSpec.ShortName.Length == 0;
 
            string formattedName =
                new StringBuilder(longName
                                      ? "--".JoinTo(optionSpec.LongName)
                                      : "-".JoinTo(optionSpec.ShortName)
                                 )
                    .AppendWhen(optionSpec.TargetType != TargetType.Switch,
                                longName && settings.UseEqualToken ? "=" : " "
                               )
                    .ToString();
 
            return optionSpec.FlagCounter
                       ? string.Join(" ", Enumerable.Repeat(formattedName, (int)value))
                       : formattedName;
        }

FormatOption()

static string CommandLine.UnParserExtensions.FormatOption ( OptionSpecification  spec, object  value, UnParserSettings  settings  )

staticprivate

Definition at line 312 of file UnParserExtensions.cs.

        {
            return new StringBuilder()
                   .Append(spec.FormatName(value, settings))
                   .AppendWhen(spec.TargetType != TargetType.Switch, FormatValue(spec, value))
                   .ToString();
        }

FormatValue()

static string CommandLine.UnParserExtensions.FormatValue ( Specification  spec, object  value  )

staticprivate

Definition at line 255 of file UnParserExtensions.cs.

        {
            StringBuilder builder = new StringBuilder();
 
            switch (spec.TargetType)
            {
                case TargetType.Scalar:
                    builder.Append(FormatWithQuotesIfString(value));
 
                    break;
                case TargetType.Sequence:
                    char sep = spec.SeperatorOrSpace();
 
                    Func<object, object> format = v
                        => sep == ' ' ? FormatWithQuotesIfString(v) : v;
                    IEnumerator e = ((IEnumerable)value).GetEnumerator();
 
                    while (e.MoveNext())
                    {
                        builder.Append(format(e.Current))
                               .Append(sep);
                    }
 
                    builder.TrimEndIfMatch(sep);
 
                    break;
            }
 
            return builder.ToString();
        }

FormatWithQuotesIfString()

static object CommandLine.UnParserExtensions.FormatWithQuotesIfString ( object  value )

staticprivate

Definition at line 286 of file UnParserExtensions.cs.

        {
            string s = value.ToString();
 
            if (!string.IsNullOrEmpty(s) && !s.Contains("\"") && s.Contains(" "))
            {
                return $"\"{s}\"";
            }
 
            Func<string, string> doubQt = v
                => v.Contains("\"") ? v.Replace("\"", "\\\"") : v;
 
            return s.ToMaybe()
                    .MapValueOrDefault(v => v.Contains(' ') || v.Contains("\"")
                                                ? "\"".JoinTo(doubQt(v), "\"")
                                                : v,
                                       value
                                      );
        }

IsEmpty()

static bool CommandLine.UnParserExtensions.IsEmpty ( this object  value, Specification  specification, bool  skipDefault  )

staticprivate

Definition at line 355 of file UnParserExtensions.cs.

        {
            if (value == null)
            {
                return true;
            }
 
            if (skipDefault && value.Equals(specification.DefaultValue.FromJust()))
            {
                return true;
            }
 
            if (Nullable.GetUnderlyingType(specification.ConversionType) != null)
            {
                return false; //nullable
            }
 
#if !SKIP_FSHARP
            if (ReflectionHelper.IsFSharpOptionType(value.GetType()) && !FSharpOptionHelper.IsSome(value)) return true;
#endif
            if (value is ValueType &&
                value.Equals(value.GetType()
                                  .GetDefaultValue()
                            ))
            {
                return true;
            }
 
            if (value is string && ((string)value).Length == 0)
            {
                return true;
            }
 
            if (value is IEnumerable &&
                !((IEnumerable)value).GetEnumerator()
                                     .MoveNext())
            {
                return true;
            }
 
            return false;
        }

NormalizeValue()

static object CommandLine.UnParserExtensions.NormalizeValue ( this object  value )

staticprivate

Definition at line 342 of file UnParserExtensions.cs.

        {
#if !SKIP_FSHARP
            if (value != null
                && ReflectionHelper.IsFSharpOptionType(value.GetType())
                && FSharpOptionHelper.IsSome(value))
            {
                return FSharpOptionHelper.ValueOf(value);
            }
#endif
            return value;
        }

SeperatorOrSpace()

static char CommandLine.UnParserExtensions.SeperatorOrSpace ( this Specification  spec )

staticprivate

Definition at line 306 of file UnParserExtensions.cs.

        {
            return (spec as OptionSpecification).ToMaybe()
                                                .MapValueOrDefault(o => o.Separator != '\0' ? o.Separator : ' ', ' ');
        }

SplitArgs()

static string[] CommandLine.UnParserExtensions.SplitArgs ( this string  command, bool  keepQuote = false  )

static

Returns a string array that contains the substrings in this instance that are delimited by space considering string between double quote.

Parameters

command	the commandline string
keepQuote	don't remove the quote

Returns

a string array that contains the substrings in this instance

Definition at line 408 of file UnParserExtensions.cs.

        {
            if (string.IsNullOrEmpty(command))
            {
                return new string[0];
            }
 
            bool inQuote = false;
 
            char[] chars = command.ToCharArray()
                                  .Select(v =>
                                          {
                                              if (v == '"')
                                              {
                                                  inQuote = !inQuote;
                                              }
 
                                              return !inQuote && v == ' ' ? '\n' : v;
                                          }
                                         )
                                  .ToArray();
 
            return new string(chars).Split('\n')
                                    .Select(x => keepQuote ? x : x.Trim('"'))
                                    .Where(x => !string.IsNullOrWhiteSpace(x))
                                    .ToArray();
        }

---

The documentation for this class was generated from the following file:

• deps/commandlineparser/src/CommandLine/UnParserExtensions.cs