// TODO: [TestCase()]
public void ValidJsonObjectIsProcessed(string definitionPath, string inputJsonFilePath)
{
var inputJson = File.ReadAllText(inputJsonFilePath);
var definition = JsonConvert.DeserializeObject <ScriptProcessorDefinition>(File.ReadAllText(definitionPath));
var sut = new ScriptProcessor(definition);
IProcessorResult processorResult = null;
Assert.That(async() => processorResult = await sut.Process(DataModificationType.Created, nameof(UnitTestInputObject), "FakeID", inputJson), Throws.Nothing);
Assert.That(processorResult, Is.Not.Null.And.TypeOf <SuccessProcessorResult>());
var outputObjects = ((SuccessProcessorResult)processorResult).Objects;
Assert.That(outputObjects, Is.Not.Null);
Assert.That(outputObjects.Count, Is.EqualTo(1));
var outputObject = outputObjects.Single();
Assert.That(outputObject.DataType, Is.EqualTo(definition.OutputType));
Assert.That(outputObject.Json, Is.Not.Empty);
Console.WriteLine(outputObject.Json);
}
private RequireFile enumerateDependenciesOf(string scriptFile)
{
var scriptText = File.ReadAllText(scriptFile, encoding);
var relativePath = PathHelpers.GetRelativePath(scriptFile, EntryPoint);
var processor = new ScriptProcessor(relativePath, scriptText, Configuration);
processor.Process();
var baseUrl = Path.Combine(ProjectPath, "Scripts");
var dependencies = processor.Dependencies
.Select(r => this.ResolvePhysicalPath(r, baseUrl))
.Where(r => r != null)
.Distinct()
.ToList();
return(new RequireFile
{
Name = scriptFile,
Content = processor.ProcessedString,
Dependencies = dependencies
});
}
public override List <Bundle> ParseConfigs()
{
var bundles = new List <Bundle>();
if (!Directory.Exists(ProjectPath))
{
throw new DirectoryNotFoundException("Could not find project directory.");
}
FindConfigs();
var loader = new ConfigLoader(
FilePaths,
new ExceptionThrowingLogger(),
new ConfigLoaderOptions {
ProcessBundles = true
});
Configuration = loader.Get();
foreach (var bundle in Configuration.AutoBundles.Bundles)
{
var files = new List <string>();
var bundleResult = new Bundle
{
Files = new List <FileSpec>(),
Output = this.GetOutputPath(bundle.OutputPath, bundle.Id),
ContainingConfig = bundle.ContainingConfig,
BundleId = bundle.Id
};
bundles.Add(bundleResult);
var tempFileList = new List <RequireFile>();
foreach (var include in bundle.Includes)
{
if (!string.IsNullOrEmpty(include.File))
{
files.Add(this.ResolvePhysicalPath(include.File));
}
else if (!string.IsNullOrEmpty(include.Directory))
{
var absDirectory = this.GetAbsoluteDirectory(include.Directory);
// not using filter for this since we're going to use the one the user provided in the future
var dirFiles = Directory.GetFiles(absDirectory, "*", SearchOption.AllDirectories).Where(r => Path.GetExtension(r) == ".js").ToList();
files.AddRange(dirFiles);
}
}
files = files.Distinct().ToList();
var fileQueue = new Queue <string>();
this.EnqueueFileList(tempFileList, fileQueue, files);
while (fileQueue.Any())
{
var file = fileQueue.Dequeue();
var fileText = File.ReadAllText(file, encoding);
var relativePath = PathHelpers.GetRelativePath(file, EntryPoint + Path.DirectorySeparatorChar);
var processor = new ScriptProcessor(relativePath, fileText, Configuration);
processor.Process();
var result = processor.ProcessedString;
var dependencies = processor.Dependencies.Select(r => this.ResolvePhysicalPath(r)).Distinct().ToList();
tempFileList.Add(new RequireFile
{
Name = file,
Content = result,
Dependencies = dependencies
});
this.EnqueueFileList(tempFileList, fileQueue, dependencies);
}
while (tempFileList.Any())
{
var addedFiles = bundleResult.Files.Select(r => r.FileName).ToList();
var noDeps = tempFileList.Where(r => !r.Dependencies.Any() ||
r.Dependencies.All(x => addedFiles.Contains(x))).ToList();
if (!noDeps.Any())
{
noDeps = tempFileList.ToList();
}
foreach (var requireFile in noDeps)
{
bundleResult.Files.Add(new FileSpec(requireFile.Name, string.Empty)
{
FileContent = requireFile.Content
});
tempFileList.Remove(requireFile);
}
}
}
this.WriteOverrideConfigs(bundles);
return(bundles);
}
