/// <summary>
/// Add template specific type references
/// </summary>
/// <param name="configuration"></param>
private static void AddTemplateReferences(ICompilerConfiguration <S> configuration)
{
configuration.References.Add(typeof(Dictionary <,>));
configuration.References.Add(typeof(S));
configuration.References.Add(typeof(IExecutor <>));
configuration.References.Add(typeof(DynamicAttribute));
}
public DefaultCodeDomContext(ICompilerConfiguration configuration, Type handlerType)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(handlerType, "handlerType");
Configuration = configuration;
HandlerType = handlerType;
}
/// <summary>
/// Creates new instance.
/// </summary>
/// <param name="behaviorProvider">Collection of behaviors.</param>
/// <param name="compilerConfiguration">Pipeline compiler configuration.</param>
public CodeDomPipelineConfiguration(IBehaviorProvider behaviorProvider, ICompilerConfiguration compilerConfiguration)
{
Ensure.NotNull(behaviorProvider, "behaviorProvider");
Ensure.NotNull(compilerConfiguration, "compilerConfiguration");
BehaviorProvider = behaviorProvider;
CompilerConfiguration = compilerConfiguration;
}
/// <summary>
/// Sets collection of references.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <param name="references">Collection of references.</param>
/// <returns>Self (for fluency).</returns>
public static ICompilerConfiguration AddReferences(this ICompilerConfiguration configuration, CompilerReferenceCollection references)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(references, "references");
configuration.Add("References", references);
return(configuration);
}
/// <summary>
/// Sets collection of SharpKit plugins.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <param name="plugins">Collection of SharpKit plugins.</param>
/// <returns>Self (for fluency).</returns>
public static ICompilerConfiguration Plugins(this ICompilerConfiguration configuration, SharpKitPluginCollection plugins)
{
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(plugins, "plugins");
configuration.Add("Plugins", plugins);
return(configuration);
}
public Task<string> CompileFile(FileInfo file, ICompilerConfiguration compilerConfig)
{
if (file == null) { throw new ArgumentNullException("file"); }
if (compilerConfig == null) { throw new ArgumentNullException("compilerConfig"); }
var compiler = compilerConfig.GetCompiler(file.Name);
if (compiler == null)
{
throw new InvalidOperationException("Compiler could not be found for '" + file.Extension + "' type file");
}
ICompiler minCompiler = null;
if (_minimise)
{
minCompiler = compilerConfig.GetCompiler(Path.GetFileNameWithoutExtension(file.Name) + _compileExtension + ".min");
if (minCompiler == null)
{
throw new InvalidOperationException("Minimising compiler could not be found for '" + _compileExtension + "' type file");
}
}
// First step is grab the file contents, then continue
return Task.Factory.StartNew(() =>
{
// Do the initial compile
var fileData = file.Exists ? File.ReadAllText(file.FullName) : string.Empty;
var result = string.Empty;
bool hasErrored = false;
if (!string.IsNullOrEmpty(fileData))
{
try
{
result = compiler.Compile(fileData, file).Result;
}
catch (Exception e)
{
result = "An error occurred during initial compilation: \r\n" + e.Message;
hasErrored = true;
}
}
// Do the minimisation if it has been selected
if (!hasErrored && _minimise && !string.IsNullOrEmpty(result))
{
try
{
result = minCompiler.Compile(result, null).Result;
}
catch (Exception e)
{
result = "An error occurred during minification: \r\n" + e.Message;
}
}
return result;
});
}
/// <summary>
/// Creates new instance for <paramref name="handlerType"/>.
/// </summary>
/// <param name="handlerType">Target handler type.</param>
/// <param name="behaviorProvider">Behavior collection.</param>
/// <param name="configuration">Generator configuration.</param>
public CodeDomPipelineGenerator(Type handlerType, IBehaviorProvider behaviorProvider, ICompilerConfiguration configuration)
{
Ensure.NotNull(handlerType, "handlerType");
Ensure.NotNull(behaviorProvider, "behaviorProvider");
Ensure.NotNull(configuration, "configuration");
this.handlerType = handlerType;
this.behaviorProvider = behaviorProvider;
this.compilerFactory = new CompilerFactory(configuration);
this.configuration = configuration;
this.nameFormatter = new CodeDomNameFormatter(handlerType);
}
/// <summary>
/// Returns collection of references.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <returns>Collection of references.</returns>
public static CompilerReferenceCollection References(this ICompilerConfiguration configuration)
{
Ensure.NotNull(configuration, "configuration");
CompilerReferenceCollection references;
if (!configuration.TryGet("References", out references))
{
configuration.Add("References", references = new CompilerReferenceCollection());
}
return(references);
}
/// <summary>
/// Returns collection of SharpKit plugins.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <returns>Collection of SharpKit plugins.</returns>
public static SharpKitPluginCollection Plugins(this ICompilerConfiguration configuration)
{
Ensure.NotNull(configuration, "configuration");
SharpKitPluginCollection collection;
if (!configuration.TryGet("Plugins", out collection))
{
configuration.Add("Plugins", collection = new SharpKitPluginCollection());
}
return(collection);
}
/// <summary>
/// Generate a full list of references necessary for compilation
/// </summary>
/// <param name="configuration"></param>
/// <returns></returns>
private static IEnumerable <MetadataReference> GenerateRequiredReferences(ICompilerConfiguration <S> configuration)
{
var references = new List <MetadataReference>();
// adding references supplied by the user fo executor
references.AddRange(configuration.References.Select(refType => MetadataReference.CreateFromFile(refType.Assembly.Location)));
// adding required references to compile successfully
references.AddRange(new List <MetadataReference>
{
MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("Microsoft.CSharp")).Location),
MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("netstandard")).Location),
MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("System.Runtime")).Location)
});
return(references);
}
public SharpKitTempProvider(IUniqueNameProvider tempNameProvider, ICompilerConfiguration configuration)
{
if (!Directory.Exists(configuration.TempDirectory()))
{
Directory.CreateDirectory(configuration.TempDirectory());
}
TempDirectory = Path.Combine(configuration.TempDirectory(), tempNameProvider.Next());
if (!Directory.Exists(TempDirectory))
{
Directory.CreateDirectory(TempDirectory);
}
string key = Guid.NewGuid().ToString("N");
InputCsFileName = String.Format("{0}.cs", key);
InputCsFilePath = Path.Combine(TempDirectory, InputCsFileName);
if (File.Exists(InputCsFilePath))
{
File.Delete(InputCsFilePath);
}
OutputDllFileName = String.Format("{0}.dll", key);
OutputDllFilePath = Path.Combine(TempDirectory, OutputDllFileName);
if (File.Exists(OutputDllFilePath))
{
File.Delete(OutputDllFilePath);
}
OutputJsFileName = String.Format("{0}.js", key);
OutputJsFilePath = Path.Combine(TempDirectory, OutputJsFileName);
if (File.Exists(OutputJsFilePath))
{
File.Delete(OutputJsFilePath);
}
ManifestFileName = String.Format("{0}.skccache", key);
ManifestFilePath = Path.Combine(TempDirectory, ManifestFileName);
if (File.Exists(ManifestFilePath))
{
File.Delete(ManifestFilePath);
}
}
private static void ValidateConfiguration(ICompilerConfiguration <S> configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (configuration.Actions == null || !configuration.Actions.Any())
{
throw new ArgumentException("Actions are null or empty", nameof(configuration.Actions));
}
if (configuration.References == null)
{
throw new ArgumentNullException(nameof(configuration.References));
}
}
/// <summary>
/// Compile the actions using C# compiler.
/// Important: Essential references for subject and executor types are added to the configuration automagically
/// </summary>
/// <param name="configuration">Compiler configuration</param>
/// <returns>Executor object</returns>
public IExecutor <S> Compile(ICompilerConfiguration <S> configuration)
{
ValidateConfiguration(configuration);
AddTemplateReferences(configuration);
// generate code
var codeGenerator = new CSharpExecutorTemplate(configuration);
var session = new TextTemplatingSession();
codeGenerator.Session = session;
codeGenerator.Initialize();
var code = codeGenerator.TransformText();
var executorTypeName = $"{configuration.GetNamespace()}.{configuration.GetClassName()}";
CodeDomProvider codeProvider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters parameters = new CompilerParameters
{
GenerateExecutable = false,
CompilerOptions = "/t:library"
};
foreach (var reference in configuration.References)
{
var referenceAssembly = reference.Assembly.GetName().Name;
if (!parameters.ReferencedAssemblies.Contains(referenceAssembly))
{
parameters.ReferencedAssemblies.Add(referenceAssembly);
}
}
var results = codeProvider.CompileAssemblyFromSource(parameters, code);
ValidateCompilationResults(results);
var executorType = results.CompiledAssembly.GetType(executorTypeName);
var executorInstanceHandle = Activator.CreateInstance(executorType);
return((IExecutor <S>)executorInstanceHandle);
}
public static ICompilerResult Generate(IUniqueNameProvider tempNameProvider, ICompilerConfiguration configuration, TextReader input, TextWriter output)
{
Ensure.NotNull(tempNameProvider, "tempNameProvider");
Ensure.NotNull(configuration, "configuration");
Ensure.NotNull(input, "input");
Ensure.NotNull(output, "output");
using (SharpKitTempProvider tempProvider = new SharpKitTempProvider(tempNameProvider, configuration))
{
tempProvider.WriteInput(input);
SharpKitProcessBuilder skBuilder = new SharpKitProcessBuilder()
.Executable(SkcPath)
.Rebuild()
.OutDll(tempProvider.OutputDllFilePath)
.OutputGeneratedJsFile(tempProvider.OutputJsFilePath)
.ManifestFile(tempProvider.ManifestFileName)
.AddSourceFile(tempProvider.InputCsFileName)
.AddPlugin(configuration.Plugins())
.AddReference(CopyReferences(configuration));
ICompilerResult result;
if (!TryExecuteProcess(tempProvider, SkcPath, skBuilder.Arguments(), out result))
{
return(result);
}
if (!tempProvider.TryCopyOutputJs(output))
{
return(new CompilerResult(
new List <IErrorInfo>()
{
new ErrorInfo(0, 0, "No js files were generated")
},
new StringCollection()
));
}
return(new CompilerResult());
}
}
/// <summary>
/// Compile the actions using C# compiler.
/// Important: Essential references for subject and executor types are added to the configuration automagically
/// </summary>
/// <param name="configuration">Compiler configuration</param>
/// <returns>Executor object</returns>
public IExecutor <S> Compile(ICompilerConfiguration <S> configuration)
{
ValidateConfiguration(configuration);
AddTemplateReferences(configuration);
// generate code
var codeGenerator = new CSharpExecutorTemplate(configuration);
codeGenerator.Initialize();
var code = codeGenerator.TransformText();
var executorClassName = $"{configuration.GetNamespace()}.{configuration.GetClassName()}";
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(text: code);
Compilation compilation = CSharpCompilation.Create(
assemblyName: $"Assembly_{Guid.NewGuid().ToString().Replace("-", string.Empty)}",
syntaxTrees: new[] { syntaxTree },
references: GenerateRequiredReferences(configuration),
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
);
// Emit the image of this assembly
byte[] image = null;
using (var ms = new MemoryStream())
{
var emitResult = compilation.Emit(ms);
ValidateCompilationResults(emitResult);
image = ms.ToArray();
}
using var stream = new MemoryStream(image);
var assembly = AssemblyLoadContext.Default.LoadFromStream(stream);
var executorClassType = assembly.GetType(executorClassName);
var executorInstanceHandle = Activator.CreateInstance(executorClassType);
return((IExecutor <S>)executorInstanceHandle);
}
private static IEnumerable <string> CopyReferences(ICompilerConfiguration configuration)
{
List <string> references = new List <string>();
foreach (string referencedDirectory in configuration.References().Directories)
{
if (Directory.Exists(referencedDirectory))
{
references.AddRange(Directory.GetFiles(referencedDirectory, "*.dll"));
references.AddRange(Directory.GetFiles(referencedDirectory, "*.exe"));
}
}
foreach (string referencedAssembly in configuration.References().Assemblies)
{
string referencePath = ResolveReferencePath(referencedAssembly);
references.Add(referencePath);
}
return(references);
}
public Task SetPileAsSource(IPile pile, ICompilerConfiguration compilerManager)
{
if (pile == null) { throw new ArgumentNullException("pile"); }
if (compilerManager == null) { throw new ArgumentNullException("compilerManager"); }
if(_pile != null)
{
throw new InvalidOperationException("Cannot change the pile once set - use another Source Manager!");
}
_compilerManager = compilerManager;
_pile = pile;
// Make sure compilation global directory exists
foreach (var innerPile in _pile.FindAllPiles())
{
var dirPath = Path.Combine(_compilationDirectory.FullName, innerPile);
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
}
if (_pile.IsWatchingFiles)
{
_pile.FileCreated += PileOnFileUpdated;
_pile.FileDeleted += PileOnFileUpdated;
_pile.FileUpdated += PileOnFileUpdated;
}
return CompileAll();
}
/// <summary>
/// Returns behavior instance generator.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <param name="defaultValue">Fallback value, when <paramref name="configuration"/> doesn't contain generator.</param>
/// <returns>Behavior instance generator.</returns>
public static ICodeDomBehaviorGenerator GetBehaviorGenerator(this ICompilerConfiguration configuration, ICodeDomBehaviorGenerator defaultValue)
{
Ensure.NotNull(configuration, "configuration");
return(configuration.Get <ICodeDomBehaviorGenerator>("BehaviorGenerator", defaultValue));
}
internal Compiler(ICompilerConfiguration configuration)
: base(configuration)
{
}
public SharpKitCompiler(ICompilerConfiguration configuration)
: base(configuration)
{
}
/// <summary>
/// Sets behavior instance generator.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <param name="generator">Behavior instance generator.</param>
/// <returns>Self (for fluency).</returns>
public static ICompilerConfiguration AddBehaviorGenerator(this ICompilerConfiguration configuration, ICodeDomBehaviorGenerator generator)
{
Ensure.NotNull(configuration, "configuration");
configuration.Add("BehaviorGenerator", generator);
return(configuration);
}
/// <summary>
/// Creates empty instance with empty configuration.
/// </summary>
protected CompilerConfigurationWrapper()
{
Configuration = new CompilerConfiguration();
}
/// <summary>
/// Creates instance and copies configuration from <paramref name="configuration"/>.
/// </summary>
/// <param name="configuration">Configuration to copy values from.</param>
protected CompilerConfigurationWrapper(ICompilerConfiguration configuration)
{
Ensure.NotNull(configuration, "configuration");
Configuration = configuration;
}
/// <summary>
/// Returns path to temp directory.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <returns>Path to temp directory.</returns>
public static string TempDirectory(this ICompilerConfiguration configuration)
{
Ensure.NotNull(configuration, "configuration");
return(configuration.Get("TempDirectory", Path.GetTempPath()));
}
/// <summary>
/// Sets whether debug mode is enabled.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <param name="isDebugMode">New value for debug mode.</param>
/// <returns>Self (for fluency).</returns>
public static ICompilerConfiguration AddIsDebugMode(this ICompilerConfiguration configuration, bool isDebugMode)
{
Ensure.NotNull(configuration, "configuration");
configuration.Add("IsDebugMode", isDebugMode);
return(configuration);
}
/// <summary>
/// Returns whether debug mode is enabled.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <rereturns>Whether debug mode is enabled.</rereturns>
public static bool IsDebugMode(this ICompilerConfiguration configuration)
{
Ensure.NotNull(configuration, "configuration");
return(configuration.Get("IsDebugMode", false));
}
/// <summary>
/// Creates new instance and copies initial configuration from <paramref name="configuration"/>.
/// </summary>
/// <param name="configuration">Initial configuration.</param>
public CompilerFactory(ICompilerConfiguration configuration)
: base(configuration)
{
}
/// <summary>
/// Creates new instance from <paramref name="parentConfiguration"/>.
/// </summary>
/// <param name="parentConfiguration">Source configuration values.</param>
public CompilerConfiguration(ICompilerConfiguration parentConfiguration)
: base(parentConfiguration)
{
}
/// <summary>
/// Sets path to temp directory.
/// </summary>
/// <param name="configuration">Compiler configuration.</param>
/// <param name="tempDirectory">Path to temp directory.</param>
/// <returns>Self (for fluency).</returns>
public static ICompilerConfiguration AddTempDirectory(this ICompilerConfiguration configuration, string tempDirectory)
{
Ensure.NotNull(configuration, "configuration");
configuration.Add("TempDirectory", tempDirectory);
return(configuration);
}
/// <summary>
/// Creates new instance based on <paramref name="configuration"/>.
/// </summary>
/// <param name="configuration">Pipeline generator configuration.</param>
public CodeDomPipelineFactory(CodeDomPipelineConfiguration configuration)
{
Ensure.NotNull(configuration, "configuration");
behaviorProvider = configuration.BehaviorProvider;
compilerConfiguration = configuration.CompilerConfiguration;
}
