summaryrefslogtreecommitdiff
path: root/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionSet.cs
diff options
context:
space:
mode:
Diffstat (limited to 'Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionSet.cs')
-rw-r--r--Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionSet.cs718
1 files changed, 718 insertions, 0 deletions
diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionSet.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionSet.cs
new file mode 100644
index 00000000..5d406705
--- /dev/null
+++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionSet.cs
@@ -0,0 +1,718 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace Mono.Options
+{
+ public class OptionSet : KeyedCollection<string, Option>
+ {
+ const int OptionWidth = 29;
+ const int DescriptionFirstWidth = 80 - OptionWidth;
+ const int DescriptionRemWidth = 80 - OptionWidth - 2;
+
+ readonly Regex _valueOption = new Regex(
+ @"^(?<flag>--|-|/)(?<name>[^:=]+)((?<sep>[:=])(?<value>.*))?$");
+
+ readonly List<ArgumentSource> _sources = new List<ArgumentSource>();
+
+ public OptionSet()
+ : this(delegate(string f) { return f; })
+ {
+ }
+
+ public OptionSet(Converter<string, string> localizer)
+ {
+ MessageLocalizer = localizer;
+ ArgumentSources = new ReadOnlyCollection<ArgumentSource>(_sources);
+ }
+
+ public Converter<string, string> MessageLocalizer { get; }
+
+ public ReadOnlyCollection<ArgumentSource> ArgumentSources { get; }
+
+ protected override string GetKeyForItem(Option item)
+ {
+ if (item == null)
+ throw new ArgumentNullException("option");
+ if (item.Names != null && item.Names.Length > 0)
+ return item.Names[0];
+ // This should never happen, as it's invalid for Option to be
+ // constructed w/o any names.
+ throw new InvalidOperationException("Option has no names!");
+ }
+
+ [Obsolete("Use KeyedCollection.this[string]")]
+ protected Option GetOptionForName(string option)
+ {
+ if (option == null)
+ throw new ArgumentNullException("option");
+ try
+ {
+ return base[option];
+ }
+ catch (KeyNotFoundException)
+ {
+ return null;
+ }
+ }
+
+ protected override void InsertItem(int index, Option item)
+ {
+ base.InsertItem(index, item);
+ AddImpl(item);
+ }
+
+ protected override void RemoveItem(int index)
+ {
+ Option p = Items[index];
+ base.RemoveItem(index);
+ // KeyedCollection.RemoveItem() handles the 0th item
+ for (int i = 1; i < p.Names.Length; ++i)
+ Dictionary.Remove(p.Names[i]);
+ }
+
+ protected override void SetItem(int index, Option item)
+ {
+ base.SetItem(index, item);
+ AddImpl(item);
+ }
+
+ void AddImpl(Option option)
+ {
+ if (option == null)
+ throw new ArgumentNullException("option");
+ List<string> added = new List<string>(option.Names.Length);
+ try
+ {
+ // KeyedCollection.InsertItem/SetItem handle the 0th name.
+ for (int i = 1; i < option.Names.Length; ++i)
+ {
+ Dictionary.Add(option.Names[i], option);
+ added.Add(option.Names[i]);
+ }
+ }
+ catch (Exception)
+ {
+ foreach (string name in added)
+ Dictionary.Remove(name);
+ throw;
+ }
+ }
+
+ public OptionSet Add(string header)
+ {
+ if (header == null)
+ throw new ArgumentNullException("header");
+ Add(new Category(header));
+ return this;
+ }
+
+ public new OptionSet Add(Option option)
+ {
+ base.Add(option);
+ return this;
+ }
+
+ public OptionSet Add(string prototype, Action<string> action)
+ {
+ return Add(prototype, null, action);
+ }
+
+ public OptionSet Add(string prototype, string description, Action<string> action)
+ {
+ return Add(prototype, description, action, false);
+ }
+
+ public OptionSet Add(string prototype, string description, Action<string> action, bool hidden)
+ {
+ if (action == null)
+ throw new ArgumentNullException("action");
+ Option p = new ActionOption(prototype, description, 1,
+ delegate(OptionValueCollection v) { action(v[0]); }, hidden);
+ base.Add(p);
+ return this;
+ }
+
+ public OptionSet Add(string prototype, OptionAction<string, string> action)
+ {
+ return Add(prototype, null, action);
+ }
+
+ public OptionSet Add(string prototype, string description, OptionAction<string, string> action)
+ {
+ return Add(prototype, description, action, false);
+ }
+
+ public OptionSet Add(string prototype, string description, OptionAction<string, string> action, bool hidden)
+ {
+ if (action == null)
+ throw new ArgumentNullException("action");
+ Option p = new ActionOption(prototype, description, 2,
+ delegate(OptionValueCollection v) { action(v[0], v[1]); }, hidden);
+ base.Add(p);
+ return this;
+ }
+
+ public OptionSet Add<T>(string prototype, Action<T> action)
+ {
+ return Add(prototype, null, action);
+ }
+
+ public OptionSet Add<T>(string prototype, string description, Action<T> action)
+ {
+ return Add(new ActionOption<T>(prototype, description, action));
+ }
+
+ public OptionSet Add<TKey, TValue>(string prototype, OptionAction<TKey, TValue> action)
+ {
+ return Add(prototype, null, action);
+ }
+
+ public OptionSet Add<TKey, TValue>(string prototype, string description, OptionAction<TKey, TValue> action)
+ {
+ return Add(new ActionOption<TKey, TValue>(prototype, description, action));
+ }
+
+ public OptionSet Add(ArgumentSource source)
+ {
+ if (source == null)
+ throw new ArgumentNullException("source");
+ _sources.Add(source);
+ return this;
+ }
+
+ protected virtual OptionContext CreateOptionContext()
+ {
+ return new OptionContext(this);
+ }
+
+ public List<string> Parse(IEnumerable<string> arguments)
+ {
+ if (arguments == null)
+ throw new ArgumentNullException("arguments");
+ OptionContext c = CreateOptionContext();
+ c.OptionIndex = -1;
+ bool process = true;
+ List<string> unprocessed = new List<string>();
+ Option def = Contains("<>") ? this["<>"] : null;
+ ArgumentEnumerator ae = new ArgumentEnumerator(arguments);
+ foreach (string argument in ae)
+ {
+ ++c.OptionIndex;
+ if (argument == "--")
+ {
+ process = false;
+ continue;
+ }
+ if (!process)
+ {
+ Unprocessed(unprocessed, def, c, argument);
+ continue;
+ }
+ if (AddSource(ae, argument))
+ continue;
+ if (!Parse(argument, c))
+ Unprocessed(unprocessed, def, c, argument);
+ }
+ if (c.Option != null)
+ c.Option.Invoke(c);
+ return unprocessed;
+ }
+
+ bool AddSource(ArgumentEnumerator ae, string argument)
+ {
+ foreach (ArgumentSource source in _sources)
+ {
+ IEnumerable<string> replacement;
+ if (!source.GetArguments(argument, out replacement))
+ continue;
+ ae.Add(replacement);
+ return true;
+ }
+ return false;
+ }
+
+ static bool Unprocessed(ICollection<string> extra, Option def, OptionContext c, string argument)
+ {
+ if (def == null)
+ {
+ extra.Add(argument);
+ return false;
+ }
+ c.OptionValues.Add(argument);
+ c.Option = def;
+ c.Option.Invoke(c);
+ return false;
+ }
+
+ protected bool GetOptionParts(string argument, out string flag, out string name, out string sep, out string value)
+ {
+ if (argument == null)
+ throw new ArgumentNullException("argument");
+
+ flag = name = sep = value = null;
+ Match m = _valueOption.Match(argument);
+ if (!m.Success)
+ return false;
+ flag = m.Groups["flag"].Value;
+ name = m.Groups["name"].Value;
+ if (m.Groups["sep"].Success && m.Groups["value"].Success)
+ {
+ sep = m.Groups["sep"].Value;
+ value = m.Groups["value"].Value;
+ }
+ return true;
+ }
+
+ protected virtual bool Parse(string argument, OptionContext c)
+ {
+ if (c.Option != null)
+ {
+ ParseValue(argument, c);
+ return true;
+ }
+
+ string f, n, s, v;
+ if (!GetOptionParts(argument, out f, out n, out s, out v))
+ return false;
+
+ Option p;
+ if (Contains(n))
+ {
+ p = this[n];
+ c.OptionName = f + n;
+ c.Option = p;
+ switch (p.OptionValueType)
+ {
+ case OptionValueType.None:
+ c.OptionValues.Add(n);
+ c.Option.Invoke(c);
+ break;
+ case OptionValueType.Optional:
+ case OptionValueType.Required:
+ ParseValue(v, c);
+ break;
+ }
+ return true;
+ }
+ // no match; is it a bool option?
+ if (ParseBool(argument, n, c))
+ return true;
+ // is it a bundled option?
+ if (ParseBundledValue(f, string.Concat(n + s + v), c))
+ return true;
+
+ return false;
+ }
+
+ void ParseValue(string option, OptionContext c)
+ {
+ if (option != null)
+ {
+ foreach (string o in c.Option.ValueSeparators != null
+ ? option.Split(c.Option.ValueSeparators, c.Option.MaxValueCount - c.OptionValues.Count, StringSplitOptions.None)
+ : new[] { option })
+ c.OptionValues.Add(o);
+ }
+ if (c.OptionValues.Count == c.Option.MaxValueCount ||
+ c.Option.OptionValueType == OptionValueType.Optional)
+ c.Option.Invoke(c);
+ else if (c.OptionValues.Count > c.Option.MaxValueCount)
+ {
+ throw new OptionException(MessageLocalizer(string.Format(
+ "Error: Found {0} option values when expecting {1}.",
+ c.OptionValues.Count, c.Option.MaxValueCount)),
+ c.OptionName);
+ }
+ }
+
+ bool ParseBool(string option, string n, OptionContext c)
+ {
+ Option p;
+ string rn;
+ if (n.Length >= 1 && (n[n.Length - 1] == '+' || n[n.Length - 1] == '-') &&
+ Contains((rn = n.Substring(0, n.Length - 1))))
+ {
+ p = this[rn];
+ string v = n[n.Length - 1] == '+' ? option : null;
+ c.OptionName = option;
+ c.Option = p;
+ c.OptionValues.Add(v);
+ p.Invoke(c);
+ return true;
+ }
+ return false;
+ }
+
+ bool ParseBundledValue(string f, string n, OptionContext c)
+ {
+ if (f != "-")
+ return false;
+ for (int i = 0; i < n.Length; ++i)
+ {
+ Option p;
+ string opt = f + n[i];
+ string rn = n[i].ToString();
+ if (!Contains(rn))
+ {
+ if (i == 0)
+ return false;
+ throw new OptionException(string.Format(MessageLocalizer(
+ "Cannot bundle unregistered option '{0}'."), opt), opt);
+ }
+ p = this[rn];
+ switch (p.OptionValueType)
+ {
+ case OptionValueType.None:
+ Invoke(c, opt, n, p);
+ break;
+ case OptionValueType.Optional:
+ case OptionValueType.Required:
+ {
+ string v = n.Substring(i + 1);
+ c.Option = p;
+ c.OptionName = opt;
+ ParseValue(v.Length != 0 ? v : null, c);
+ return true;
+ }
+ default:
+ throw new InvalidOperationException("Unknown OptionValueType: " + p.OptionValueType);
+ }
+ }
+ return true;
+ }
+
+ static void Invoke(OptionContext c, string name, string value, Option option)
+ {
+ c.OptionName = name;
+ c.Option = option;
+ c.OptionValues.Add(value);
+ option.Invoke(c);
+ }
+
+ public void WriteOptionDescriptions(TextWriter o)
+ {
+ foreach (Option p in this)
+ {
+ int written = 0;
+
+ if (p.Hidden)
+ continue;
+
+ Category c = p as Category;
+ if (c != null)
+ {
+ WriteDescription(o, p.Description, "", 80, 80);
+ continue;
+ }
+
+ if (!WriteOptionPrototype(o, p, ref written))
+ continue;
+
+ if (written < OptionWidth)
+ o.Write(new string(' ', OptionWidth - written));
+ else
+ {
+ o.WriteLine();
+ o.Write(new string(' ', OptionWidth));
+ }
+
+ WriteDescription(o, p.Description, new string(' ', OptionWidth + 2),
+ DescriptionFirstWidth, DescriptionRemWidth);
+ }
+
+ foreach (ArgumentSource s in _sources)
+ {
+ string[] names = s.GetNames();
+ if (names == null || names.Length == 0)
+ continue;
+
+ int written = 0;
+
+ Write(o, ref written, " ");
+ Write(o, ref written, names[0]);
+ for (int i = 1; i < names.Length; ++i)
+ {
+ Write(o, ref written, ", ");
+ Write(o, ref written, names[i]);
+ }
+
+ if (written < OptionWidth)
+ o.Write(new string(' ', OptionWidth - written));
+ else
+ {
+ o.WriteLine();
+ o.Write(new string(' ', OptionWidth));
+ }
+
+ WriteDescription(o, s.Description, new string(' ', OptionWidth + 2),
+ DescriptionFirstWidth, DescriptionRemWidth);
+ }
+ }
+
+ void WriteDescription(TextWriter o, string value, string prefix, int firstWidth, int remWidth)
+ {
+ bool indent = false;
+ foreach (string line in GetLines(MessageLocalizer(GetDescription(value)), firstWidth, remWidth))
+ {
+ if (indent)
+ o.Write(prefix);
+ o.WriteLine(line);
+ indent = true;
+ }
+ }
+
+ bool WriteOptionPrototype(TextWriter o, Option p, ref int written)
+ {
+ string[] names = p.Names;
+
+ int i = GetNextOptionIndex(names, 0);
+ if (i == names.Length)
+ return false;
+
+ if (names[i].Length == 1)
+ {
+ Write(o, ref written, " -");
+ Write(o, ref written, names[0]);
+ }
+ else
+ {
+ Write(o, ref written, " --");
+ Write(o, ref written, names[0]);
+ }
+
+ for (i = GetNextOptionIndex(names, i + 1);
+ i < names.Length;
+ i = GetNextOptionIndex(names, i + 1))
+ {
+ Write(o, ref written, ", ");
+ Write(o, ref written, names[i].Length == 1 ? "-" : "--");
+ Write(o, ref written, names[i]);
+ }
+
+ if (p.OptionValueType == OptionValueType.Optional ||
+ p.OptionValueType == OptionValueType.Required)
+ {
+ if (p.OptionValueType == OptionValueType.Optional)
+ Write(o, ref written, MessageLocalizer("["));
+ Write(o, ref written, MessageLocalizer("=" + GetArgumentName(0, p.MaxValueCount, p.Description)));
+ string sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0
+ ? p.ValueSeparators[0]
+ : " ";
+ for (int c = 1; c < p.MaxValueCount; ++c)
+ Write(o, ref written, MessageLocalizer(sep + GetArgumentName(c, p.MaxValueCount, p.Description)));
+ if (p.OptionValueType == OptionValueType.Optional)
+ Write(o, ref written, MessageLocalizer("]"));
+ }
+ return true;
+ }
+
+ static int GetNextOptionIndex(string[] names, int i)
+ {
+ while (i < names.Length && names[i] == "<>")
+ ++i;
+ return i;
+ }
+
+ static void Write(TextWriter o, ref int n, string s)
+ {
+ n += s.Length;
+ o.Write(s);
+ }
+
+ static string GetArgumentName(int index, int maxIndex, string description)
+ {
+ if (description == null)
+ return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
+ string[] nameStart;
+ if (maxIndex == 1)
+ nameStart = new[] { "{0:", "{" };
+ else
+ nameStart = new[] { "{" + index + ":" };
+ for (int i = 0; i < nameStart.Length; ++i)
+ {
+ int start, j = 0;
+ do
+ {
+ start = description.IndexOf(nameStart[i], j);
+ } while (start >= 0 && j != 0 ? description[j++ - 1] == '{' : false);
+ if (start == -1)
+ continue;
+ int end = description.IndexOf("}", start);
+ if (end == -1)
+ continue;
+ return description.Substring(start + nameStart[i].Length, end - start - nameStart[i].Length);
+ }
+ return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
+ }
+
+ static string GetDescription(string description)
+ {
+ if (description == null)
+ return string.Empty;
+ StringBuilder sb = new StringBuilder(description.Length);
+ int start = -1;
+ for (int i = 0; i < description.Length; ++i)
+ {
+ switch (description[i])
+ {
+ case '{':
+ if (i == start)
+ {
+ sb.Append('{');
+ start = -1;
+ }
+ else if (start < 0)
+ start = i + 1;
+ break;
+ case '}':
+ if (start < 0)
+ {
+ if ((i + 1) == description.Length || description[i + 1] != '}')
+ throw new InvalidOperationException("Invalid option description: " + description);
+ ++i;
+ sb.Append("}");
+ }
+ else
+ {
+ sb.Append(description.Substring(start, i - start));
+ start = -1;
+ }
+ break;
+ case ':':
+ if (start < 0)
+ goto default;
+ start = i + 1;
+ break;
+ default:
+ if (start < 0)
+ sb.Append(description[i]);
+ break;
+ }
+ }
+ return sb.ToString();
+ }
+
+ static IEnumerable<string> GetLines(string description, int firstWidth, int remWidth)
+ {
+ return StringCoda.WrappedLines(description, firstWidth, remWidth);
+ }
+
+ internal sealed class Category : Option
+ {
+ // Prototype starts with '=' because this is an invalid prototype
+ // (see Option.ParsePrototype(), and thus it'll prevent Category
+ // instances from being accidentally used as normal options.
+ public Category(string description)
+ : base("=:Category:= " + description, description)
+ {
+ }
+
+ protected override void OnParseComplete(OptionContext c)
+ {
+ throw new NotSupportedException("Category.OnParseComplete should not be invoked.");
+ }
+ }
+
+ sealed class ActionOption : Option
+ {
+ readonly Action<OptionValueCollection> _action;
+
+ public ActionOption(string prototype, string description, int count, Action<OptionValueCollection> action)
+ : this(prototype, description, count, action, false)
+ {
+ }
+
+ public ActionOption(string prototype, string description, int count, Action<OptionValueCollection> action,
+ bool hidden)
+ : base(prototype, description, count, hidden)
+ {
+ if (action == null)
+ throw new ArgumentNullException("action");
+ _action = action;
+ }
+
+ protected override void OnParseComplete(OptionContext c)
+ {
+ _action(c.OptionValues);
+ }
+ }
+
+ sealed class ActionOption<T> : Option
+ {
+ readonly Action<T> _action;
+
+ public ActionOption(string prototype, string description, Action<T> action)
+ : base(prototype, description, 1)
+ {
+ if (action == null)
+ throw new ArgumentNullException("action");
+ _action = action;
+ }
+
+ protected override void OnParseComplete(OptionContext c)
+ {
+ _action(Parse<T>(c.OptionValues[0], c));
+ }
+ }
+
+ sealed class ActionOption<TKey, TValue> : Option
+ {
+ readonly OptionAction<TKey, TValue> _action;
+
+ public ActionOption(string prototype, string description, OptionAction<TKey, TValue> action)
+ : base(prototype, description, 2)
+ {
+ if (action == null)
+ throw new ArgumentNullException("action");
+ _action = action;
+ }
+
+ protected override void OnParseComplete(OptionContext c)
+ {
+ _action(
+ Parse<TKey>(c.OptionValues[0], c),
+ Parse<TValue>(c.OptionValues[1], c));
+ }
+ }
+
+ class ArgumentEnumerator : IEnumerable<string>
+ {
+ readonly List<IEnumerator<string>> _sources = new List<IEnumerator<string>>();
+
+ public ArgumentEnumerator(IEnumerable<string> arguments)
+ {
+ _sources.Add(arguments.GetEnumerator());
+ }
+
+ public IEnumerator<string> GetEnumerator()
+ {
+ do
+ {
+ IEnumerator<string> c = _sources[_sources.Count - 1];
+ if (c.MoveNext())
+ yield return c.Current;
+ else
+ {
+ c.Dispose();
+ _sources.RemoveAt(_sources.Count - 1);
+ }
+ } while (_sources.Count > 0);
+ }
+
+ IEnumerator IEnumerable.GetEnumerator()
+ {
+ return GetEnumerator();
+ }
+
+ public void Add(IEnumerable<string> arguments)
+ {
+ _sources.Add(arguments.GetEnumerator());
+ }
+ }
+ }
+} \ No newline at end of file