/// <summary>
/// An easy factory method that uses an object's properties to
/// define the command line arguments required for the application.
/// </summary>
/// <typeparam name="T">The object class to initialize.</typeparam>
/// <param name="pOptions">The parser options</param>
/// <param name="pArgs">The command line arguments.</param>
/// <returns>A new class T with it's properties populated, or Null if command line arguments are invalid.</returns>
public static T Create <T>(CliOptions pOptions, IEnumerable <string> pArgs) where T : class, new()
{
PropertyInfo[] infos = typeof(T).GetProperties();
string pattern = ReflectDescriptions <T>(pOptions, infos);
List <Description> descs = DescriptionFactory.Create(pOptions, new HelpReflection(typeof(T)), pattern);
Request request = Create(pOptions, pArgs, descs, new ConsoleFactory());
if (!request.Valid)
{
return(null);
}
T instance = Activator.CreateInstance <T>();
foreach (Description desc in descs)
{
PropertyInfo info = ReflectProperty(infos, desc.Name);
if (!request.Contains(desc.Name) || info == null)
{
continue;
}
// TODO: Support multiples
info.SetValue(instance, Convert.ChangeType(request.First(desc.Name).Value, info.PropertyType));
}
return(instance);
}
private static void AssertNamed(CliOptions pOptions, string pPattern)
{
Description desc = DescriptionFactory.Parse(pOptions, new MockHelpProvider(), pPattern);
Assert.AreEqual(eROLE.NAMED, desc.Role);
AssertTypes(pOptions, pPattern);
}
private static void AssertMultiple(CliOptions pOptions, string pPattern)
{
Description desc = DescriptionFactory.Parse(pOptions, new MockHelpProvider(), pPattern);
Assert.AreEqual(eMULTIPLICITY.MULTIPLE, desc.Multiplicity);
AssertOptional(pOptions, "[" + pPattern + "]");
}
private static void AssertType <T>(CliOptions pOptions, string pPattern)
{
Description desc = DescriptionFactory.Parse(pOptions, new MockHelpProvider(), pPattern);
Assert.IsNotNull(desc.Type);
Assert.IsTrue(desc.Type is T);
AssertMultiple(pOptions, pPattern + "#");
AssertOptional(pOptions, "[" + pPattern + "]");
}
public void Validator_1()
{
Validator v = new Validator(null);
List <Description> descs = DescriptionFactory.Create(CliOptions.WindowsStyle, new MockHelpProvider(),
"/width:int");
Request request = RequestFactory.Create(CliOptions.WindowsStyle, new string[0], descs,
new MockOutputFactory());
Assert.IsTrue(v.Validate(descs, request));
}
private static void AssertParsable(CliOptions pOptions, string pName)
{
Description desc = DescriptionFactory.Parse(pOptions, new MockHelpProvider(), pName);
Assert.AreEqual(pName, desc.Name);
Assert.AreEqual(eSCOPE.REQUIRED, desc.Scope);
Assert.AreEqual(eMULTIPLICITY.ONCE, desc.Multiplicity);
AssertPassed(pOptions, pName);
AssertNamed(pOptions, pOptions.Prefix + pName);
}
public void SelectMissingValue()
{
List <Description> descs = DescriptionFactory.Create(CliOptions.WindowsStyle, new MockHelpProvider(),
"/width:int");
Request request = RequestFactory.Create(CliOptions.WindowsStyle, new[] { "/width" }, descs,
new MockOutputFactory());
Description[] missingValue = Validator.SelectMissingValue(descs, request).ToArray();
Assert.AreEqual(1, missingValue.Length);
Assert.AreEqual("width", missingValue[0].Name);
}
public void SelectDuplicates()
{
List <Description> descs = DescriptionFactory.Create(CliOptions.WindowsStyle, new MockHelpProvider(),
"/width:int");
Request request = RequestFactory.Create(CliOptions.WindowsStyle, new[] { "/width:10", "/width:20" }, descs,
new MockOutputFactory());
Description[] duplicates = Validator.SelectDuplicates(descs, request).ToArray();
Assert.AreEqual(1, duplicates.Length);
Assert.AreEqual("width", duplicates[0].Name);
}
public void Validate()
{
List <Description> descs = DescriptionFactory.Create(CliOptions.WindowsStyle, new MockHelpProvider(),
"/width:int");
Validator v = new Validator(new OutputMessages(CliOptions.WindowsStyle, new MockOutput()));
Assert.IsTrue(v.Validate(descs,
RequestFactory.Create(CliOptions.WindowsStyle, new[] { "/width:10" }, descs, new MockOutputFactory())));
Assert.IsFalse(v.Validate(descs,
RequestFactory.Create(CliOptions.WindowsStyle, new string[0], descs, new MockOutputFactory())));
Assert.IsFalse(v.Validate(descs,
RequestFactory.Create(CliOptions.WindowsStyle, new[] { "/width:10", "/width:10" }, descs,
new MockOutputFactory())));
Assert.IsFalse(v.Validate(descs,
RequestFactory.Create(CliOptions.WindowsStyle, new[] { "10" }, descs, new MockOutputFactory())));
}
public void Create()
{
List <Description> descs = DescriptionFactory
.Create(
CliOptions.WindowsStyle, new MockHelpProvider(),
"/debug /database:STRING /port:int# [/UserName:string] filename [INPUT:int#]"
);
Assert.AreEqual(6, descs.Count);
Assert.AreEqual(eROLE.NAMED, descs[0].Role);
Assert.AreEqual(eROLE.NAMED, descs[1].Role);
Assert.AreEqual(eROLE.NAMED, descs[2].Role);
Assert.AreEqual(eROLE.NAMED, descs[3].Role);
Assert.AreEqual(eROLE.PASSED, descs[4].Role);
Assert.AreEqual(eROLE.PASSED, descs[5].Role);
Assert.AreEqual("debug", descs[0].Name);
Assert.AreEqual("database", descs[1].Name);
Assert.AreEqual("port", descs[2].Name);
Assert.AreEqual("username", descs[3].Name);
Assert.AreEqual("filename", descs[4].Name);
Assert.AreEqual("input", descs[5].Name);
Assert.IsNull(descs[0].Type);
Assert.IsTrue(descs[1].Type is ParamString);
Assert.IsTrue(descs[2].Type is ParamInt);
Assert.IsTrue(descs[3].Type is ParamString);
Assert.IsTrue(descs[4].Type is ParamString);
Assert.IsTrue(descs[5].Type is ParamInt);
Assert.AreEqual(eMULTIPLICITY.ONCE, descs[0].Multiplicity);
Assert.AreEqual(eMULTIPLICITY.ONCE, descs[1].Multiplicity);
Assert.AreEqual(eMULTIPLICITY.MULTIPLE, descs[2].Multiplicity);
Assert.AreEqual(eMULTIPLICITY.ONCE, descs[3].Multiplicity);
Assert.AreEqual(eMULTIPLICITY.ONCE, descs[4].Multiplicity);
Assert.AreEqual(eMULTIPLICITY.MULTIPLE, descs[5].Multiplicity);
Assert.AreEqual(eSCOPE.REQUIRED, descs[0].Scope);
Assert.AreEqual(eSCOPE.REQUIRED, descs[1].Scope);
Assert.AreEqual(eSCOPE.REQUIRED, descs[2].Scope);
Assert.AreEqual(eSCOPE.OPTIONAL, descs[3].Scope);
Assert.AreEqual(eSCOPE.REQUIRED, descs[4].Scope);
Assert.AreEqual(eSCOPE.OPTIONAL, descs[5].Scope);
}
public void Parse_1()
{
string[] invalidStrings =
{
"/debug#", "", "/", "[]", "[/debug", "/debug]", "/debug:xxxx", "xxx:xxx",
"[:xxx]", ":", "23473", "1abc"
};
foreach (string invalid in invalidStrings)
{
try
{
Description desc = DescriptionFactory.Parse(CliOptions.WindowsStyle, new MockHelpProvider(),
invalid);
Assert.Fail("Expected SyntaxErrorException for {0}", invalid);
}
catch (SyntaxErrorException)
{
}
}
}
/// <summary>
/// The main entry point for the example.
/// </summary>
/// <param name="pArgs">The arguments from the command line.</param>
private static void Main(string[] pArgs)
{
WriteGreeting();
CliOptions options = CliOptions.WindowsStyle;
List <Description> descs = DescriptionFactory.Create(
options, new HelpResource(Help.ResourceManager),
"/echo [/mode:string#] /address:string /database:string /username:string [/password:string] filename [output:string]"
);
ConsoleFactory consoleFactory = new ConsoleFactory();
if (pArgs.Length == 0)
{
OutputHelp outputHelp = new OutputHelp(options, consoleFactory.Create());
outputHelp.Show(descs);
return;
}
Request request = RequestFactory.Create(options, pArgs, descs, consoleFactory);
}
/// <summary>
/// Entry
/// </summary>
/// <param name="pArgs">The arguments from the command line.</param>
private static void Main(string[] pArgs)
{
ConsoleFactory consoleFactory = new ConsoleFactory();
iOutputStream outS = consoleFactory.Create();
WriteGreeting(outS);
CliOptions options = CliOptions.WindowsStyle;
List <Description> descs = DescriptionFactory.Create(
options, new HelpResource(Help.ResourceManager),
"[/domains:string] [/limit:int] [/count] [/sort:string] [/desc] [/max:int] [/min:int] pattern"
);
if (pArgs.Length == 0)
{
OutputHelp outputHelp = new OutputHelp(options, consoleFactory.Create());
outputHelp.Show(descs);
return;
}
Request req = RequestFactory.Create(options, pArgs, descs, consoleFactory);
if (!req.Valid)
{
return;
}
string pattern = req.Get <string>("pattern");
outS.Standard(pattern);
outS.Standard("");
int max = req.Contains("max") ? Math.Min(req.Get <int>("max"), _MAX_LENGTH) :_MAX_LENGTH;
int min = req.Contains("min") ? Math.Max(req.Get <int>("min"), 1) : 1;
IEnumerable <string> domains = (from topLevel in getTopLevel(req)
from domain in getPattern(req)
where !domain.StartsWith("-") &&
!domain.EndsWith("-") &&
domain.Length <= max &&
domain.Length >= min
let str = string.Format("{0}.{1}", domain, topLevel)
where str.Length <= _MAX_LENGTH &&
!AnyLabelTooLong(domain, 63)
select str).Distinct();
if (req.Contains("count"))
{
outS.Standard(domains.Count().ToString(CultureInfo.InvariantCulture));
return;
}
if (req.Contains("sort"))
{
string sort = req.Get <string>("sort").ToLower();
domains = sort == "width"
? domains.OrderBy(pDomain => pDomain.Length)
: domains.OrderBy(pDomain => pDomain);
if (req.Contains("desc"))
{
domains = domains.Reverse();
}
}
foreach (string domain in setLimit(req, domains))
{
if (isFree(domain))
{
outS.Standard(domain);
}
}
}
private static void AssertOptional(CliOptions pOptions, string pPattern)
{
Description desc = DescriptionFactory.Parse(pOptions, new MockHelpProvider(), pPattern);
Assert.AreEqual(eSCOPE.OPTIONAL, desc.Scope);
}
