/// <summary>Process the output file path.</summary>
/// <param name="parsedOptions">The parsed options.</param>
/// <param name="processedOptions">The processed options.</param>
/// <param name="startingDirectory">The starting directory.</param>
public void ProcesOutputFountainFilePath(ParsedCommandLineOptions parsedOptions, CommandLineToolOptions processedOptions, string startingDirectory)
{
// Without a parsed object and a input file path we can't do anything.
if (parsedOptions == null || processedOptions == null)
{
return;
}
// Generate an output-path when none is given.
if (!string.IsNullOrEmpty(parsedOptions.OutputFountainFilePath))
{
// if the GIVEN output-path is not rooted we strip of the filename and tag the directory on it.
processedOptions.RootedOutputFountainFilePath = Path.IsPathRooted(parsedOptions.OutputFountainFilePath)
? parsedOptions.OutputFountainFilePath
: Path.Combine(startingDirectory, parsedOptions.OutputFountainFilePath);
}
else
{
processedOptions.GeneratedOutputFountainFilePath = Path.ChangeExtension(parsedOptions.InputFilePath, ".ink.fountain");
// if the GENERATED output-path is not rooted we strip of the filename and tag the directory on it.
processedOptions.RootedOutputFountainFilePath = Path.IsPathRooted(processedOptions.GeneratedOutputFountainFilePath)
? processedOptions.GeneratedOutputFountainFilePath
: Path.Combine(startingDirectory, processedOptions.GeneratedOutputFountainFilePath);
}
}
/// <summary> Read the configuration from the config files, environment and command line. </summary>
/// <param name="args">The arguments.</param>
/// <returns>Configuration object</returns>
private static IConfigurationRoot ReadConfiguration(string[] args, ParsedCommandLineOptions options)
{
IConfigurationRoot config = GetConfig(args);
if (config != null)
{
// We do not get a whole object from a config section, config.GetSection("ConfiguredOptions").Get<ConfiguredOptions>()
// because command line options would then have to be prepended with the region
options.InputFilePath = config.GetValue <string>("InputFile");
options.OutputFilePath = config.GetValue <string>("OutputFile");
options.OutputFountainFilePath = config.GetValue <string>("OutputFountainFile");
options.IsCountAllVisitsNeeded = config.GetValue <bool>("CountAllVisits");
options.IsPlayMode = config.GetValue <bool>("PlayMode");
options.IsVerboseMode = config.GetValue <bool>("Verbose");
options.IsOnlyShowJsonStatsActive = config.GetValue <bool>("OnlyShowJsonStats");
options.IsKeepOpenAfterStoryFinishNeeded = config.GetValue <bool>("KeepRunningAfterStoryFinished");
// the config.GetValue<List<string>>("PluginNames") does not work, so we use a bind here
config.Bind("PluginNames", options.PluginNames);
}
return(config);
}
/// <summary>Process the flags by copying them from the parsed options to the processed options so we can always compare them.</summary>
/// <param name="parsedOptions">The parsed options.</param>
/// <param name="processedOptions">The processed options.</param>
public void ProcesFlags(ParsedCommandLineOptions parsedOptions, CommandLineToolOptions processedOptions)
{
// Without a parsed object and a input file path we can't do anything.
if (parsedOptions == null || processedOptions == null)
{
return;
}
// Most of the flags are not changed while running except for IsPlayMode.
processedOptions.IsPlayMode = parsedOptions.IsPlayMode;
processedOptions.IsVerboseMode = parsedOptions.IsVerboseMode;
processedOptions.IsCountAllVisitsNeeded = parsedOptions.IsCountAllVisitsNeeded;
processedOptions.IsOnlyShowJsonStatsActive = parsedOptions.IsOnlyShowJsonStatsActive;
processedOptions.IsJsonOutputNeeded = parsedOptions.IsJsonOutputNeeded;
processedOptions.IsKeepRunningAfterStoryFinishedNeeded = parsedOptions.IsKeepOpenAfterStoryFinishNeeded;
processedOptions.PluginNames = parsedOptions.PluginNames;
}
/// <summary>Process the input file path.</summary>
/// <param name="parsedOptions">The parsed options.</param>
/// <param name="processedOptions">The processed options.</param>
/// <param name="startingDirectory">The starting directory.</param>
public void ProcesInputFilePath(ParsedCommandLineOptions parsedOptions, CommandLineToolOptions processedOptions, string startingDirectory)
{
// Without a parsed object and a input file path we can't do anything.
if (parsedOptions == null || processedOptions == null)
{
return;
}
processedOptions.InputFilePath = parsedOptions.InputFilePath;
// Get the file's actual name, needed for reading after the working directory has changed.
processedOptions.InputFileName = Path.GetFileName(parsedOptions.InputFilePath);
processedOptions.RootedInputFilePath = Path.IsPathRooted(parsedOptions.InputFilePath)
? parsedOptions.InputFilePath
: Path.Combine(startingDirectory, parsedOptions.InputFilePath);
processedOptions.InputFileDirectory = Path.GetDirectoryName(processedOptions.RootedInputFilePath);
}
/// <summary>Creates the command line tool options.</summary>
/// <param name="args">The arguments.</param>
/// <returns></returns>
private CommandLineToolOptions CreateCommandLineToolOptions(string[] args)
{
toolOptions = new CommandLineToolOptions();
// Getting the current dir early is better in unstable situations.
string startingDirectory = Directory.GetCurrentDirectory();
var parsedOptions = new ParsedCommandLineOptions();
#if USE_NETCORE_CONFIGURATION
IConfigurationRoot config = ReadConfiguration(args, parsedOptions);
Logger = new LoggerConfiguration()
.ReadFrom.Configuration(config)
.CreateLogger();
Logger.Information("Started on {0}", _startTime);
Logger.Information("Config read.");
Logger.Debug("Config {@0}", config);
#else
Logger = new LoggerConfiguration().CreateLogger();
parsedOptions = ParseArguments(args, options);
#endif
if (parsedOptions == null || !parsedOptions.IsInputPathGiven)
{
ExitWithUsageInstructions();
}
ProcesOutputFilePath(parsedOptions, toolOptions, startingDirectory);
ProcesOutputFountainFilePath(parsedOptions, toolOptions, startingDirectory);
ProcesInputFilePath(parsedOptions, toolOptions, startingDirectory);
ProcesFlags(parsedOptions, toolOptions);
return(toolOptions);
}
/// <summary>Parses the command line arguments.</summary>
/// <param name="args">The command line arguments.</param>
/// <returns>An options object.</returns>
public void ParseArguments(string[] args, ParsedCommandLineOptions options)
{
if (args == null || args.Length == 0 || options == null)
{
return;
}
bool expectingOutputFilename = false;
bool expectingPluginName = false;
// Process arguments
int lastArgumentIndex = args.Length - 1;
for (int i = 0; i < args.Length; i++)
{
string argument = args[i];
if (i == lastArgumentIndex)
{
// When on the last argument we assume it's the file.
options.InputFilePath = argument;
}
else if (expectingOutputFilename)
{
// When a output filename flag preceded the current argument we assume it's the output filename.
options.OutputFilePath = argument;
expectingOutputFilename = false;
}
else if (expectingPluginName)
{
// When a plug-in name flag preceded the current argument we assume it's a plug-in name.
options.PluginNames.Add(argument);
expectingPluginName = false;
}
else if (argument.StartsWith("-"))
{
// Determine options
switch (argument)
{
case "-p": options.IsPlayMode = true; break;
case "-v": options.IsVerboseMode = true; break;
case "-j": options.IsJsonOutputNeeded = true; break;
case "-s": options.IsOnlyShowJsonStatsActive = true; break;
case "-o": expectingOutputFilename = true; break;
case "-c": options.IsCountAllVisitsNeeded = true; break;
case "-x": expectingPluginName = true; break;
case "-k": options.IsKeepOpenAfterStoryFinishNeeded = true; break;
default: ConsoleInteractor.WriteWarning("Unsupported argument flag: '{0}'", argument); break;
}
}
else
{
ConsoleInteractor.WriteWarning("Unexpected argument: '{0}'", argument); break;
}
}
}
