public bool Generate(ProcessedArgs args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
IPackage targetPackage = packageHandler.FetchPackage(args.PackageId, args.PackageVersion);
if (targetPackage == null)
{
return(false);
}
IEnumerable <IPackage> dependencyPackages = packageHandler.GetInstalledDependencies(targetPackage);
// Check that there are analyzers in the target package from which information can be extracted
// Create a mapping of packages to analyzers to avoid having to search for analyzers more than once
Dictionary <IPackage, IEnumerable <DiagnosticAnalyzer> > analyzersByPackage = new Dictionary <IPackage, IEnumerable <DiagnosticAnalyzer> >();
IEnumerable <DiagnosticAnalyzer> targetAnalyzers = GetAnalyzers(targetPackage, args.Language);
if (targetAnalyzers.Any())
{
analyzersByPackage.Add(targetPackage, targetAnalyzers);
}
else
{
logger.LogWarning(UIResources.APG_NoAnalyzersFound, targetPackage.Id);
if (!args.RecurseDependencies)
{
logger.LogWarning(UIResources.APG_NoAnalyzersInTargetSuggestRecurse);
return(false);
}
}
if (args.RecurseDependencies)
{
// Possible sub-case - target package has dependencies that contain analyzers
foreach (IPackage dependencyPackage in dependencyPackages)
{
IEnumerable <DiagnosticAnalyzer> dependencyAnalyzers = GetAnalyzers(dependencyPackage, args.Language);
if (dependencyAnalyzers.Any())
{
analyzersByPackage.Add(dependencyPackage, dependencyAnalyzers);
}
else
{
logger.LogWarning(UIResources.APG_NoAnalyzersFound, dependencyPackage.Id);
}
}
if (!analyzersByPackage.Any())
{
return(false);
}
}
// Check for packages that require the user to accept a license
IEnumerable <IPackage> licenseAcceptancePackages = GetPackagesRequiringLicenseAcceptance(targetPackage);
if (licenseAcceptancePackages.Any() && !args.AcceptLicenses)
{
// NB: This warns for all packages under the target that require license acceptance
// (even if they aren't related to the packages from which plugins were generated)
logger.LogError(UIResources.APG_NGPackageRequiresLicenseAcceptance, targetPackage.Id, targetPackage.Version.ToString());
ListPackagesRequiringLicenseAcceptance(licenseAcceptancePackages);
return(false);
}
List <string> generatedJarFiles = new List <string>();
// Initial run with the user-targeted package and arguments
if (analyzersByPackage.ContainsKey(targetPackage))
{
string generatedJarPath = GeneratePluginForPackage(args.OutputDirectory, args.Language, args.RuleFilePath, targetPackage, analyzersByPackage[targetPackage]);
if (generatedJarPath == null)
{
return(false);
}
generatedJarFiles.Add(generatedJarPath);
analyzersByPackage.Remove(targetPackage);
}
// Dependent package generation changes the arguments
if (args.RecurseDependencies)
{
logger.LogWarning(UIResources.APG_RecurseEnabled_RuleCustomizationNotEnabled);
foreach (IPackage currentPackage in analyzersByPackage.Keys)
{
// No way to specify the rules xml files for any but the user-targeted package at this time
string generatedJarPath = GeneratePluginForPackage(args.OutputDirectory, args.Language, null, currentPackage, analyzersByPackage[currentPackage]);
if (generatedJarPath == null)
{
return(false);
}
generatedJarFiles.Add(generatedJarPath);
}
}
LogAcceptedPackageLicenses(licenseAcceptancePackages);
foreach (string generatedJarFile in generatedJarFiles)
{
logger.LogInfo(UIResources.APG_PluginGenerated, generatedJarFile);
}
return(true);
}
