/// <summary>
/// Loads the configuration from disk.
/// </summary>
/// <returns>Loaded configuration, if found on disk.</returns>
protected override SanitizedConfiguration LoadConfiguration()
{
if (_config == null)
{
if (_options.Input == Constants.CurrentDirectory)
{
_config = base.LoadConfiguration();
}
else
{
string fullPath = Path.GetFullPath(_options.Input);
if (Directory.Exists(fullPath) == true)
{
string configPath = Path.Combine(fullPath, Constants.ConfigFileName);
_config = ConfigIO.ReadConfigFile(configPath);
if (_config != null)
{
foreach (Models.Volume volume in _config.Volumes)
{
volume.InputPath = volume.InputPath.Replace(".", _options.Input);
volume.OutputPath = volume.OutputPath.Replace(".", _options.Output);
}
}
}
}
}
return(_config);
}
/// <summary>
/// Loads the configuration from disk.
/// </summary>
/// <returns>Loaded configuration, if found on disk.</returns>
protected override SanitizedConfiguration LoadConfiguration()
{
SanitizedConfiguration result = null;
if (_options.Input == Constants.CurrentDirectory)
{
result = base.LoadConfiguration();
}
else
{
string fullPath = Path.GetFullPath(_options.Input);
if (Directory.Exists(fullPath) == true)
{
string configPath = Path.Combine(fullPath, Constants.ConfigFileName);
result = ConfigIO.ReadConfigFile(configPath);
if (result != null)
{
foreach (Volume volume in result.Volumes)
{
volume.InputPath = volume.InputPath.Replace(".", _options.Input);
volume.OutputPath = volume.OutputPath.Replace(".", _options.Output);
}
}
else
{
_commonLogger.NoConfigurationFound();
}
}
}
return(result);
}
/// <summary>
/// Creates a default configuration.
/// </summary>
/// <returns>Resulting configuration.</returns>
private SanitizedConfiguration CreateDefaultConfig()
{
SanitizedConfiguration result = new SanitizedConfiguration();
// Config info.
result.Name = GetProjectNameDefault();
result.Description = "A Kerboscript project.";
result.Archive = FindKSPInstallation();
// Volume info.
result.Volumes.Add(new Volume
{
Index = 1,
Name = "boot",
InputPath = Constants.DefaultBootVolumePath,
OutputPath = Constants.DistBootDirectory,
DeployPath = "./boot"
});
result.Volumes.Add(new Volume
{
Index = 2,
Name = GetProjectNameDefault(),
InputPath = Constants.DefaultVolumePath,
OutputPath = Constants.DistDirectory,
DeployPath = "./"
});
// Scripts.
AddDefaultScripts(result);
return(result);
}
/// <summary>
/// Loads all scripts to compiler based on either the configuration or the CLI options.
/// </summary>
/// <returns>All found scripts.</returns>
private List <Kerboscript> LoadScripts()
{
List <Kerboscript> result = null;
_logger.StartScriptLoading();
{
if ((_options.Input == Constants.CurrentDirectory &&
_options.Output == Constants.CurrentDirectory) ||
ConfigIO.IsDirectory(_options.Input) == true)
{
if (_options.Output == Constants.CurrentDirectory)
{
_options.Output = _options.Input;
}
SanitizedConfiguration config = LoadConfiguration();
if (config != null)
{
result = _scriptLoader.LoadScriptsFromConfig(config);
}
}
else
{
result = _scriptLoader.LoadScriptsFromOptions();
}
}
if (result != null)
{
_logger.StopScriptLoading(result.Count);
}
return(result);
}
/// <summary>
/// Runs the run action.
/// </summary>
/// <returns></returns>
public override int Run()
{
int result = 0;
SanitizedConfiguration config = LoadConfiguration();
if (IsKerboscript(_options.Script) == true)
{
string fullScriptPath = Path.GetFullPath(_options.Script);
_logger.StartKerboscriptExecution(fullScriptPath);
result = ExecuteKerboscript(fullScriptPath, config);
if (result == 0)
{
_logger.StopKerboscriptExecution(fullScriptPath);
}
}
else
{
if (config != null)
{
Models.Script script = config.Scripts.Find(s => s.Name == _options.Script);
if (script != null)
{
result = ExecuteConfigScript(script);
}
else
{
_logger.ScriptNotFound(_options.Script);
result = 1;
}
}
}
return(result);
}
/// <summary>
/// Removes compiled scripts based on either given options or configuration.
/// </summary>
/// <param name="config">Loaded project configuration.</param>
public void RemoveCompiledScripts(SanitizedConfiguration config)
{
if (config != null)
{
foreach (var volume in config.GetVolumesForOption(_options.Volume))
{
if (Directory.Exists(volume.OutputPath) == true)
{
Directory.Delete(volume.OutputPath, true);
}
}
}
else
{
if (_options.Output != Constants.CurrentDirectory)
{
if (Directory.Exists(_options.Output) == true)
{
Directory.Delete(_options.Output, true);
}
else if (File.Exists(_options.Output) == true)
{
File.Delete(_options.Output);
}
}
}
}
/// <summary>
/// Reads a configuration from a file from disk.
/// </summary>
/// <param name="filepath">Filepath to the configuration file.</param>
/// <returns>Read configuration.</returns>
public static SanitizedConfiguration ReadConfigFile(string filepath)
{
SanitizedConfiguration result = null;
if (File.Exists(filepath) == true)
{
string configJSON = File.ReadAllText(filepath);
result = Configuration.FromJson(configJSON).GetSanitized();
}
return(result);
}
/// <summary>
/// Reads the config file from the current directory.
/// </summary>
/// <returns>Read configuration.</returns>
public static SanitizedConfiguration ReadConfigFileFromCurrentDirectory()
{
SanitizedConfiguration result = null;
string configFilepath = Path.Combine(Directory.GetCurrentDirectory(), Constants.ConfigFileName);
if (File.Exists(configFilepath) == true)
{
result = ConfigIO.ReadConfigFile(configFilepath);
}
return(result);
}
public void InitConfigWithProjectName([Values("foobar", "foo-bar", "foo_bar")] string ProjectName)
{
// Build up.
string arguments = "init " + ProjectName + " -y";
// Test.
int result = ActionDispatcher.Dispatch(arguments.Split(' '), false);
// General asserts.
Assert.AreEqual(0, result);
string configFilePath = Path.GetFullPath(Path.Combine("./", Constants.ConfigFileName));
Assert.IsTrue(File.Exists(configFilePath));
// Content asserts.
string configContent = File.ReadAllText(configFilePath);
Assert.IsNotNull(configContent);
// Data model asserts.
SanitizedConfiguration config = Configuration.FromJson(configContent).GetSanitized();
Assert.IsNotNull(config);
Assert.IsNotNull(config.Name);
Assert.AreEqual(ProjectName, config.Name);
// Volumes asserts.
Assert.IsNotNull(config.Volumes);
Assert.AreEqual(2, config.Volumes.Count);
Assert.AreEqual(1, config.Volumes[0].Index);
Assert.AreEqual(2, config.Volumes[1].Index);
Assert.AreEqual("boot", config.Volumes[0].Name);
Assert.AreEqual(ProjectName, config.Volumes[1].Name);
Assert.AreEqual(Constants.DefaultBootVolumePath, config.Volumes[0].InputPath);
Assert.AreEqual(Constants.DefaultVolumePath, config.Volumes[1].InputPath);
// Scripts asserts.
Assert.IsNotNull(config.Scripts);
Assert.AreEqual(2, config.Scripts.Count);
Assert.AreEqual("compile", config.Scripts[0].Name);
Assert.AreEqual("deploy", config.Scripts[1].Name);
// Default files and directory asserts.
// Tear down.
File.Delete(configFilePath);
Directory.Delete(Path.GetFullPath(Constants.DefaultVolumePath), true);
Directory.Delete(Path.GetFullPath(Constants.DefaultBootVolumePath), true);
Directory.Delete(Path.GetFullPath(Constants.DefaultScriptVolumePath), true);
}
/// <summary>
/// Asks the user interactively for the config information.
/// </summary>
/// <returns>Resulting configuration.</returns>
private SanitizedConfiguration AskConfig()
{
PrintWelcomeText();
SanitizedConfiguration result = new SanitizedConfiguration();
// Ask the mandatory information.
if (_options.ProjectName == string.Empty)
{
result.Name = Ask("Project name", GetProjectNameDefault());
}
else
{
result.Name = _options.ProjectName;
}
result.Description = Ask("Project description");
result.Archive = Ask("Project archive (used KSP installation)", FindKSPInstallation());
if (result.Archive == Constants.DefaultKSPSteamInstallationWin32 ||
result.Archive == Constants.DefaultKSPSteamInstallationWin64)
{
result.Archive = result.Archive + Constants.ArchivePath;
}
// Ask for volumes.
Volume volume = new Volume();
volume.Index = 2;
volume.Name = Ask("Project volume name (volume with your code)", GetProjectNameDefault());
volume.InputPath = Ask("Project volume source directory", Constants.DefaultVolumePath);
volume.OutputPath = Ask("Project volume dist directory", Constants.DistDirectory);
volume.DeployPath = Constants.CurrentDirectory;
Console.WriteLine("You can add more volumes in the created config file!");
result.Volumes.Add(new Volume
{
Index = 1,
Name = "boot",
InputPath = Constants.DefaultBootVolumePath,
OutputPath = Constants.DistBootDirectory,
DeployPath = "./boot"
});
result.Volumes.Add(volume);
// Create two default scripts.
AddDefaultScripts(result);
return(result);
}
/// <summary>
/// Loads scripts based on a given configuration.
/// </summary>
/// <param name="config">Configuration to load from.</param>
/// <returns>List of loaded Kerboscripts.</returns>
public List <Kerboscript> LoadScriptsFromConfig(SanitizedConfiguration config)
{
List <Kerboscript> result = new List <Kerboscript>();
foreach (var volume in config.GetVolumesForOption(_compilerOptions.Volume))
{
List <Kerboscript> scripts = LoadScriptsAndAddVolumes(volume.InputPath, volume.OutputPath, volume.Name);
if (scripts != null)
{
scripts.ForEach(ks => ks.DeployPath = volume.DeployPath.Replace(".", config.Archive));
result.AddRange(scripts);
}
}
return(result);
}
/// <summary>
/// Runs the deployment action.
/// </summary>
/// <returns></returns>
public override int Run()
{
int result = 0;
if (_compiler.Run() == 0)
{
SanitizedConfiguration config = LoadConfiguration();
if (config != null)
{
_logger.StartScriptDeployment();
result = Deploy(_compiler.CompiledScripts, config);
_logger.StopScriptDeployment(_compiler.CompiledScripts.Count);
}
}
return(result);
}
/// <summary>
/// Executes a Kerboscript.
/// </summary>
/// <param name="filepath">Filepath to the Kerboscript to execute.</param>
/// <returns>CLI return code.</returns>
private int ExecuteKerboscript(string filepath, SanitizedConfiguration config)
{
int result = 0;
Executer executer = new Executer(_logger, config);
List <string> output = executer.ExecuteScript(filepath);
if (executer.Error == true)
{
result = 1;
}
else
{
_logger.PrintScriptOutput(output);
}
return(result);
}
/// <summary>
/// Creates the default directories "./src".
/// </summary>
/// <param name="basePath">Base path where to create the default directories.</param>
private void CreateDefaultDirectoriesAndFiles(SanitizedConfiguration config, string basePath)
{
foreach (Volume volume in config.Volumes)
{
string pathToCreate = Path.Combine(basePath, volume.InputPath);
Directory.CreateDirectory(Path.GetFullPath(pathToCreate));
if (volume.InputPath == Constants.DefaultBootVolumePath)
{
File.WriteAllText(Path.Combine(Path.GetFullPath(pathToCreate), Constants.DefaultBootScriptFilename), Constants.DefaultBootScriptContent);
}
}
string defaultScriptPath = Path.Combine(basePath, Constants.DefaultScriptVolumePath);
Directory.CreateDirectory(Path.GetFullPath(defaultScriptPath));
File.WriteAllText(Path.Combine(defaultScriptPath, Constants.DefaultCompileScriptFilename), Constants.DefaultCompileScriptContent);
File.WriteAllText(Path.Combine(defaultScriptPath, Constants.DefaultDeployScriptFilename), Constants.DefaultDeployScriptContent);
}
/// <summary>
/// Returns all paths that need to be watched.
/// </summary>
/// <returns>List of paths.</returns>
private List <string> GetWatchPaths()
{
List <string> result = new List <string>();
if ((_options.Input == Constants.CurrentDirectory &&
_options.Output == Constants.CurrentDirectory) &&
ConfigIO.IsDirectory(_options.Input) == true)
{
SanitizedConfiguration config = LoadConfiguration();
if (config != null)
{
if (_options.Volume == Constants.AllVolumes)
{
result = config.Volumes.Select((v) => v.InputPath).ToList();
}
else
{
Volume volume = null;
if (int.TryParse(_options.Volume, out int index) == true)
{
volume = config.Volumes.Find(v => v.Index == index);
}
else
{
volume = config.Volumes.Find(v => v.Name == _options.Volume);
}
if (volume != null)
{
result.Add(volume.InputPath);
}
}
}
}
else
{
result.Add(_options.Input);
}
result = result.Select(p => Path.GetFullPath(p)).ToList();
result = result.FindAll(p => File.Exists(p) || Directory.Exists(p));
return(result);
}
/// <summary>
/// Runs the initializer.
/// </summary>
/// <returns>Returns the CLI return code.</returns>
public override int Run()
{
int result = -1;
// Create the configuration based on given options.
SanitizedConfiguration config = _options.Yes == true?CreateDefaultConfig() : AskConfig();
// Write the configuration to disk based on given options.
if (_options.ProjectPath != string.Empty && _options.ProjectPath != null)
{
string path = Path.Combine(_options.ProjectPath, _options.ProjectName);
result = ConfigIO.WriteConfigFile(config.ToConfiguration(), Path.Combine(_options.ProjectPath, _options.ProjectName), true);
CreateDefaultDirectoriesAndFiles(config, path);
}
else
{
result = ConfigIO.WriteConfigFile(config.ToConfiguration(), Constants.CurrentDirectory, true);
CreateDefaultDirectoriesAndFiles(config, basePath: Constants.CurrentDirectory);
}
return(result);
}
/// <summary>
/// Deploys the scripts based on the options and given configuration.
/// </summary>
/// <param name="scripts">Scripts to deploy.</param>
/// <param name="config">Configuration used for the deployment.</param>
/// <returns>CLI return code.</returns>
private int Deploy(List <Kerboscript> scripts, SanitizedConfiguration config)
{
int result = 0;
List <Volume> volumes = config.GetVolumesForOption(_options.Volume);
foreach (Volume volume in volumes)
{
string deployDirectory = volume.DeployPath.Replace(Constants.CurrentDirectory, config.Archive);
if (deployDirectory != config.Archive && Directory.Exists(deployDirectory))
{
Directory.Delete(deployDirectory, true);
}
else
{
string[] files = Directory.GetFiles(deployDirectory);
foreach (string file in files)
{
File.Delete(file);
}
}
}
foreach (Kerboscript script in scripts)
{
_logger.DeployingScript(script);
string fileName = _options.DeploySource ? Path.GetFileName(script.InputPath) : Path.GetFileName(script.OutputPath);
string deployPath = Path.Combine(script.DeployPath, fileName);
Directory.CreateDirectory(Path.GetDirectoryName(deployPath));
File.Copy(script.OutputPath, deployPath, true);
}
return(result);
}
/// <summary>
/// Adds default scripts to a configuration.
/// </summary>
/// <param name="config">Configuration to add it to.</param>
private void AddDefaultScripts(SanitizedConfiguration config)
{
config.Scripts.Add(new Script("compile", "ksc run " + Constants.DefaultScriptVolumePath + "/" + Constants.DefaultCompileScriptFilename));
config.Scripts.Add(new Script("deploy", "ksc run compile && ksc run " + Constants.DefaultScriptVolumePath + "/" + Constants.DefaultDeployScriptFilename));
}
public void InitConfigWithProjectNameAndPath(
[Values("project-name")] string ProjectName,
[Values("./foo/bar", "./foobar", "./foo/bar/test/dasfasdf")] string ProjectPath
)
{
// Build up.
string arguments = "init " + ProjectName + " " + ProjectPath + " -y";
// Test.
int result = ActionDispatcher.Dispatch(arguments.Split(' '), false);
// General asserts.
Assert.AreEqual(0, result);
string configFilePath = Path.GetFullPath(Path.Combine(Path.Combine(Path.GetFullPath(ProjectPath), ProjectName), Constants.ConfigFileName));
Assert.IsTrue(File.Exists(configFilePath));
// Content asserts.
string configContent = File.ReadAllText(configFilePath);
Assert.IsNotNull(configContent);
// Data model asserts.
SanitizedConfiguration config = Configuration.FromJson(configContent).GetSanitized();
Assert.IsNotNull(config);
Assert.IsNotNull(config.Name);
Assert.AreEqual(ProjectName, config.Name);
// Volumes asserts.
Assert.IsNotNull(config.Volumes);
Assert.AreEqual(2, config.Volumes.Count);
Assert.AreEqual(1, config.Volumes[0].Index);
Assert.AreEqual(2, config.Volumes[1].Index);
Assert.AreEqual("boot", config.Volumes[0].Name);
Assert.AreEqual(ProjectName, config.Volumes[1].Name);
Assert.AreEqual(Constants.DefaultBootVolumePath, config.Volumes[0].InputPath);
Assert.AreEqual(Constants.DefaultVolumePath, config.Volumes[1].InputPath);
// Scripts asserts.
Assert.IsNotNull(config.Scripts);
Assert.AreEqual(2, config.Scripts.Count);
Assert.AreEqual("compile", config.Scripts[0].Name);
Assert.AreEqual("deploy", config.Scripts[1].Name);
// Default files and directory asserts.
// Tear down.
File.Delete(configFilePath);
DirectoryInfo dirInfo = new DirectoryInfo(Path.GetFullPath(ProjectPath));
int count = ProjectPath.Count(s => s == '/');
if (count > 1)
{
for (int i = count - 1; i > 0; i--)
{
dirInfo = Directory.GetParent(dirInfo.FullName);
}
}
Directory.Delete(dirInfo.FullName, true);
}
