private static IParsingService GetParser(OptionSet options)
{
var lang = options.GetValue <string>(Options.InputLanguage);
switch (lang.ToLowerInvariant())
{
case "ecs":
return(EcsLanguageService.Value);
case "les":
return(LesLanguageService.Value);
case "les2":
return(Les2LanguageService.Value);
case "les3":
return(Les3LanguageService.Value);
default:
Log.Log(
new LogEntry(
Pixie.Severity.Error,
"unknown input language",
"input language ",
Quotation.CreateBoldQuotation(lang),
" could not be matched to a known input language.",
new Paragraph("Option usage:"),
new Paragraph(
new OptionHelp(
Options.InputLanguage,
GnuOptionPrinter.Instance))));
return(EcsLanguageService.Value);
}
}
/// <summary>
/// parse command args return a object
/// </summary>
/// <param name="args">command line args</param>
/// <returns>RunArgs</returns>
private static RunArgs ParseArgs(string[] args)
{
RunArgs runArgs = new RunArgs();
bool showHelp = false;
OptionSet p = new OptionSet {
{
"i|input=", "{INPUT} markdown file path.",
v => runArgs.MarkdonwPath = v
},
{
"o|output=", "{OUTPUT} docx file path.",
v => runArgs.DocxPath = v
},
{
"r|rules=", "{RULES} for pure text block",
v => runArgs.RulesPath = v
},
{
"c|config=", "{CONFIG} file for coverting",
v => runArgs.ConfigPath = v
},
{
"h|help", "show this message and exit",
v => showHelp = v != null
},
};
try {
p.Parse(args);
} catch (OptionException e) {
Console.Write("md2docx: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try`md2docx --help' for more information.");
Environment.Exit(1);
}
if (showHelp)
{
Usage(p);
Environment.Exit(0);
}
if (runArgs.GetType().GetProperties()
.Any(p => string.IsNullOrWhiteSpace((p.GetValue(runArgs) as string))))
{
Usage(p);
Environment.Exit(1);
}
return(runArgs);
}
/// <summary>
/// Checks that a mandatory string-valued option actually
/// has an argument.
/// </summary>
/// <param name="option">The mandatory string-valued option.</param>
/// <param name="parsedOptions">Parsed command-line arguments.</param>
/// <param name="log">A log to send errors to.</param>
private static void CheckMandatoryStringOptionHasArg(
Option option,
OptionSet parsedOptions,
ILog log)
{
if (string.IsNullOrWhiteSpace(parsedOptions.GetValue <string>(option)))
{
log.Log(
new Pixie.LogEntry(
Severity.Error,
"missing option",
Quotation.QuoteEvenInBold(
"option ",
option.Forms[0].ToString(),
" is mandatory but left blank.")));
}
}
/// <summary>
/// Parse the domain names as an array of URIs.
/// </summary>
/// <param name="parsedOptions">The set of all parsed options.</param>
/// <param name="log">A log to send errors to.</param>
/// <returns>An array of URIs.</returns>
private static Uri[] ParseDomains(OptionSet parsedOptions, ILog log)
{
var domainUris = new List <Uri>();
var domainNames = parsedOptions.GetValue <IReadOnlyList <string> >(Options.Domains);
if (domainNames.Count == 0)
{
// Zero domains doesn't make no sense. Make the user pick a domain.
log.Log(
new LogEntry(
Severity.Error,
"no domain",
"at least one URI must be specified as a base domain for the server."));
return(domainUris.ToArray());
}
foreach (var name in domainNames)
{
Uri domainUri;
if (Uri.TryCreate(name, UriKind.Absolute, out domainUri))
{
domainUris.Add(domainUri);
}
else
{
log.Log(
new LogEntry(
Severity.Error,
"bad domain",
Quotation.QuoteEvenInBold(
"all domains must be well-formed absolute URIs, but ",
name,
" is not a well-formed URI.")));
}
}
return(domainUris.ToArray());
}
