private static void MergeOptionsToConfig(MergeCommandOptions options, ref MergeJsonConfig config)
{
// base directory for content from command line is current directory
// e.g. C:\folder1>docfx build folder2\docfx.json --content "*.cs"
// for `--content "*.cs*`, base directory should be `C:\folder1`
string optionsBaseDirectory = Environment.CurrentDirectory;
config.OutputFolder = options.OutputFolder;
if (!string.IsNullOrEmpty(options.OutputFolder))
{
config.Destination = Path.GetFullPath(Path.Combine(options.OutputFolder, config.Destination ?? string.Empty));
}
if (options.Content != null)
{
if (config.Content == null)
{
config.Content = new FileMapping(new FileMappingItem());
}
config.Content.Add(
new FileMappingItem
{
Files = new FileItems(options.Content),
SourceFolder = optionsBaseDirectory
});
}
config.FileMetadata = BuildCommand.GetFileMetadataFromOption(config.FileMetadata, options.FileMetadataFilePath, null);
config.GlobalMetadata = BuildCommand.GetGlobalMetadataFromOption(config.GlobalMetadata, options.GlobalMetadataFilePath, null, options.GlobalMetadata);
}
private static MergeJsonConfig ParseOptions(MergeCommandOptions options)
{
var configFile = options.ConfigFile;
MergeJsonConfig config;
if (string.IsNullOrEmpty(configFile))
{
if (!File.Exists(DocAsCode.Constants.ConfigFileName))
{
if (options.Content == null)
{
throw new ArgumentException("Either provide config file or specify content files to start building documentation.");
}
else
{
config = new MergeJsonConfig();
var item = new MergeJsonItemConfig();
MergeOptionsToConfig(options, ref item);
config.Add(item);
return(config);
}
}
else
{
Logger.Log(LogLevel.Verbose, $"Config file {DocAsCode.Constants.ConfigFileName} is found.");
configFile = DocAsCode.Constants.ConfigFileName;
}
}
config = CommandUtility.GetConfig <MergeConfig>(configFile).Item;
if (config == null)
{
var message = $"Unable to find build subcommand config in file '{configFile}'.";
Logger.LogError(message, code: ErrorCodes.Config.BuildConfigNotFound);
throw new DocumentException(message);
}
for (int i = 0; i < config.Count; i++)
{
var round = config[i];
round.BaseDirectory = Path.GetDirectoryName(configFile);
MergeOptionsToConfig(options, ref round);
}
return(config);
}
private static MergeJsonConfig ParseOptions(MergeCommandOptions options)
{
var configFile = options.ConfigFile;
MergeJsonConfig config;
if (string.IsNullOrEmpty(configFile))
{
if (!File.Exists(DocAsCode.Constants.ConfigFileName))
{
if (options.Content == null)
{
throw new ArgumentException("Either provide config file or specify content files to start building documentation.");
}
else
{
config = new MergeJsonConfig();
MergeOptionsToConfig(options, ref config);
return(config);
}
}
else
{
Logger.Log(LogLevel.Verbose, $"Config file {DocAsCode.Constants.ConfigFileName} is found.");
configFile = DocAsCode.Constants.ConfigFileName;
}
}
config = CommandUtility.GetConfig <MergeConfig>(configFile).Item;
if (config == null)
{
throw new DocumentException($"Unable to find build subcommand config in file '{configFile}'.");
}
config.BaseDirectory = Path.GetDirectoryName(configFile);
MergeOptionsToConfig(options, ref config);
return(config);
}
public MergeCommand(MergeCommandOptions options)
{
Config = ParseOptions(options);
}
public static async Task <int> Merge(MergeCommandOptions options)
{
Contract.Requires(options != null);
var outputToConsole = string.IsNullOrEmpty(options.OutputFile);
var outputFormat = options.OutputFormat;
if (outputFormat == StandardInputOutputSbomFormat.autodetect)
{
if (options.OutputFile != null && options.OutputFile.EndsWith(".json", StringComparison.InvariantCulture))
{
outputFormat = StandardInputOutputSbomFormat.json;
}
else if (options.OutputFile != null && options.OutputFile.EndsWith(".xml", StringComparison.InvariantCulture))
{
outputFormat = StandardInputOutputSbomFormat.xml;
}
else
{
Console.WriteLine($"Unable to auto-detect output format");
return((int)ExitCode.ParameterValidationError);
}
}
var outputBom = new Bom();
foreach (var inputFilename in options.InputFiles)
{
if (!outputToConsole)
{
Console.WriteLine($"Processing input file {inputFilename}");
}
var inputFormat = options.InputFormat;
if (inputFormat == StandardInputOutputSbomFormat.autodetect)
{
if (inputFilename.EndsWith(".json", StringComparison.InvariantCulture))
{
inputFormat = StandardInputOutputSbomFormat.json;
}
else if (inputFilename.EndsWith(".xml", StringComparison.InvariantCulture))
{
inputFormat = StandardInputOutputSbomFormat.xml;
}
else
{
Console.WriteLine($"Unable to auto-detect format of {inputFilename}");
return((int)ExitCode.ParameterValidationError);
}
}
var bomContents = await File.ReadAllTextAsync(inputFilename);
Bom inputBom;
if (inputFormat == StandardInputOutputSbomFormat.json)
{
inputBom = Json.Deserializer.Deserialize(bomContents);
}
else
{
inputBom = Xml.Deserializer.Deserialize(bomContents);
}
outputBom = CycloneDXUtils.Merge(outputBom, inputBom);
if (inputBom.Components != null && !outputToConsole)
{
Console.WriteLine($" Contains {inputBom.Components.Count} components");
}
}
string outputBomString;
if (outputFormat == StandardInputOutputSbomFormat.json)
{
outputBomString = Json.Serializer.Serialize(outputBom);
}
else
{
outputBomString = Xml.Serializer.Serialize(outputBom);
}
if (outputToConsole)
{
Console.WriteLine(outputBomString);
}
else
{
Console.WriteLine("Writing output file...");
Console.WriteLine($" Total {outputBom.Components.Count} components");
await File.WriteAllTextAsync(options.OutputFile, outputBomString);
}
return((int)ExitCode.Ok);
}
private static Dictionary <string, object> GetGlobalMetadataFromOption(MergeCommandOptions options)
{
Dictionary <string, object> globalMetadata = null;
if (options.GlobalMetadata != null)
{
using (var sr = new StringReader(options.GlobalMetadata))
{
try
{
globalMetadata = JsonUtility.Deserialize <Dictionary <string, object> >(sr, GetSerializer());
if (globalMetadata != null && globalMetadata.Count > 0)
{
Logger.LogInfo($"Global metadata from \"--globalMetadata\" overrides the one defined in config file");
}
}
catch (JsonException e)
{
Logger.LogWarning($"Metadata from \"--globalMetadata {options.GlobalMetadata}\" is not a valid JSON format global metadata, ignored: {e.Message}");
}
}
}
if (options.GlobalMetadataFilePath != null)
{
try
{
var globalMetadataFromFile = JsonUtility.Deserialize <MergeJsonConfig>(options.GlobalMetadataFilePath).GlobalMetadata;
if (globalMetadataFromFile == null)
{
Logger.LogWarning($" File from \"--globalMetadataFile {options.GlobalMetadataFilePath}\" does not contain \"globalMetadata\" definition.");
}
else
{
if (globalMetadata == null)
{
globalMetadata = globalMetadataFromFile;
}
else
{
foreach (var pair in globalMetadataFromFile)
{
if (globalMetadata.ContainsKey(pair.Key))
{
Logger.LogWarning($"Both --globalMetadata and --globalMetadataFile contain definition for \"{pair.Key}\", the one from \"--globalMetadata\" overrides the one from \"--globalMetadataFile {options.GlobalMetadataFilePath}\".");
}
else
{
globalMetadata[pair.Key] = pair.Value;
}
}
}
}
}
catch (FileNotFoundException)
{
Logger.LogWarning($"Invalid option \"--globalMetadataFile {options.GlobalMetadataFilePath}\": file does not exist, ignored.");
}
catch (JsonException e)
{
Logger.LogWarning($"File from \"--globalMetadataFile {options.GlobalMetadataFilePath}\" is not a valid JSON format global metadata, ignored: {e.Message}");
}
}
if (globalMetadata?.Count > 0)
{
return(globalMetadata);
}
return(null);
}
