private void LoadFiles(
string packageDir,
IEnumerable <IPackageReference> packageReferences,
List <string> foundAssemblies,
bool strictLoad = true)
{
foreach (var packageRef in packageReferences)
{
var nugetPackage = _packageContainer.FindPackage(packageDir, packageRef);
if (nugetPackage == null)
{
_logger.WarnFormat(
CultureInfo.InvariantCulture,
"Cannot find: {0} {1}",
packageRef.PackageId,
packageRef.Version);
continue;
}
var compatibleFiles = nugetPackage.GetCompatibleDlls(packageRef.FrameworkName);
if (compatibleFiles == null)
{
_logger.WarnFormat(
CultureInfo.InvariantCulture,
"Cannot find compatible binaries for {0} in: {1} {2}",
packageRef.FrameworkName,
packageRef.PackageId,
packageRef.Version);
continue;
}
var compatibleFilePaths = compatibleFiles
.Select(packageFile => Path.Combine(packageDir, nugetPackage.FullName, packageFile))
.Concat(nugetPackage.FrameworkAssemblies);
foreach (var path in compatibleFilePaths)
{
if (foundAssemblies.Contains(path))
{
continue;
}
foundAssemblies.Add(path);
_logger.Debug("Found: " + path);
}
if (nugetPackage.Dependencies == null || !nugetPackage.Dependencies.Any() || !strictLoad)
{
continue;
}
var dependencyReferences = nugetPackage.Dependencies
.Where(i => _topLevelPackages.All(x => x.PackageId != i.Id))
.Select(i => new PackageReference(i.Id, i.FrameworkName, i.Version));
LoadFiles(packageDir, dependencyReferences, foundAssemblies, true);
}
}
private void LoadFiles(string packageDir, IEnumerable <IPackageReference> packageReferences, ref List <IPackageReference> missingAssemblies, ref List <string> foundAssemblies, bool strictLoad = true, Action <string> outputCallback = null)
{
foreach (var packageRef in packageReferences)
{
var nugetPackage = _packageContainer.FindPackage(packageDir, packageRef);
if (nugetPackage == null)
{
missingAssemblies.Add(packageRef);
if (outputCallback != null)
{
outputCallback("Cannot find: " + packageRef.PackageId + " " + packageRef.Version);
}
continue;
}
var compatibleFiles = nugetPackage.GetCompatibleDlls(packageRef.FrameworkName);
if (compatibleFiles == null)
{
missingAssemblies.Add(packageRef);
if (outputCallback != null)
{
outputCallback("Cannot find binaries for " + packageRef.FrameworkName + " in: " +
packageRef.PackageId + " " + packageRef.Version);
}
continue;
}
var compatibleFilePaths = compatibleFiles.Select(packageFile => Path.Combine(packageDir, nugetPackage.FullName, packageFile));
foreach (var path in compatibleFilePaths)
{
if (foundAssemblies.Contains(path))
{
continue;
}
foundAssemblies.Add(path);
if (outputCallback != null)
{
outputCallback("Found: " + path);
}
}
if (nugetPackage.Dependencies == null || !nugetPackage.Dependencies.Any() || !strictLoad)
{
continue;
}
var dependencyReferences = nugetPackage.Dependencies
.Where(i => _topLevelPackages.All(x => x.PackageId != i.Id))
.Select(i => new PackageReference(i.Id, i.FrameworkName, i.Version));
LoadFiles(packageDir, dependencyReferences, ref missingAssemblies, ref foundAssemblies, true, outputCallback);
}
}
private void GetAssemblyNames(
string packageDir,
IEnumerable <IPackageReference> packageReferences,
ICollection <string> names,
bool strictLoad)
{
foreach (var packageReference in packageReferences)
{
var packageObject = _packageContainer.FindPackage(packageDir, packageReference);
if (packageObject == null)
{
_logger.WarnFormat(
CultureInfo.InvariantCulture,
"Cannot find: {0} {1}",
packageReference.PackageId,
packageReference.Version);
continue;
}
var compatibleDlls = packageObject.GetCompatibleDlls(packageReference.FrameworkName);
if (compatibleDlls == null)
{
_logger.WarnFormat(
CultureInfo.InvariantCulture,
"Cannot find compatible binaries for {0} in: {1} {2}",
packageReference.FrameworkName,
packageReference.PackageId,
packageReference.Version);
continue;
}
foreach (var name in compatibleDlls
.Select(packageFile => Path.Combine(packageDir, packageObject.FullName, packageFile))
.Where(path => _assemblyUtility.IsManagedAssembly(path))
.Concat(packageObject.FrameworkAssemblies)
.Where(name => !names.Contains(name)))
{
names.Add(name);
_logger.Debug("Found: " + name);
}
if (packageObject.Dependencies == null || !packageObject.Dependencies.Any() || !strictLoad)
{
continue;
}
var dependencyReferences = packageObject.Dependencies
.Where(dependency =>
_topLevelPackages.All(topLevelPackage => topLevelPackage.PackageId != dependency.Id))
.Select(dependency =>
new PackageReference(dependency.Id, dependency.FrameworkName, dependency.Version));
GetAssemblyNames(packageDir, dependencyReferences, names, true);
}
}
protected internal virtual void ProcessPackage(
string packagesPath,
IPackageReference reference,
StringBuilder builder,
List <string> references,
List <string> namespaces)
{
Guard.AgainstNullArgument("reference", reference);
Guard.AgainstNullArgument("builder", builder);
Guard.AgainstNullArgument("references", references);
Guard.AgainstNullArgument("namespaces", namespaces);
_logger.DebugFormat("Finding package:{0}", reference.PackageId);
var package = _packageContainer.FindPackage(packagesPath, reference);
if (package == null)
{
_logger.WarnFormat("Package missing: {0}", reference.PackageId);
return;
}
_logger.Debug("Package found");
var script = GetMainScript(package);
if (script != null)
{
script = Path.Combine(packagesPath, string.Format("{0}.{1}", package.Id, package.TextVersion), script);
_logger.Debug("Pre-processing script");
var result = _preProcessor.ProcessFile(script);
var fileWithoutExtension = Path.GetFileNameWithoutExtension(script);
var classname = fileWithoutExtension.Substring(0, fileWithoutExtension.Length - 4);
_logger.DebugFormat("Created Script Libary class: {0}", classname);
var classBuilder = new StringBuilder();
classBuilder.AppendFormat("public class {0} : ScriptCs.ScriptLibraryWrapper {{{1}", classname, Environment.NewLine);
classBuilder.AppendLine(result.Code);
classBuilder.AppendLine("}");
var classDefinition = classBuilder.ToString();
_logger.TraceFormat("Class definition:{0}{0}{1}", Environment.NewLine, classDefinition);
builder.Append(classDefinition);
references.AddRange(result.References);
namespaces.AddRange(result.Namespaces);
}
}
