public static IEnumerable<IDocumentStorage> Build(IDocumentSchema schema, DocumentMapping[] mappings)
{
var code = GenerateDocumentStorageCode(mappings);
var generator = new AssemblyGenerator();
generator.ReferenceAssembly(Assembly.GetExecutingAssembly());
generator.ReferenceAssemblyContainingType<NpgsqlConnection>();
generator.ReferenceAssemblyContainingType<QueryModel>();
generator.ReferenceAssemblyContainingType<DbCommand>();
generator.ReferenceAssemblyContainingType<Component>();
mappings.Select(x => x.DocumentType.Assembly).Distinct().Each(assem => generator.ReferenceAssembly(assem));
var assembly = generator.Generate(code);
return assembly
.GetExportedTypes()
.Where(x => x.IsConcreteTypeOf<IDocumentStorage>())
.Select(x =>
{
var docType =
x.FindInterfaceThatCloses(typeof (IdAssignment<>)).GetGenericArguments().Single();
var mapping = mappings.Single(m => m.DocumentType == docType);
var arguments = mapping.IdStrategy.ToArguments().Select(arg => arg.GetValue(schema)).ToArray();
var ctor = x.GetConstructors().Single();
return ctor.Invoke(arguments).As<IDocumentStorage>();
});
}
public override TemplateInfo CompileTemplate(string templateBody, Dictionary<string, Type> globalsTypes, List<Assembly> referencedAssemblies)
{
lock (_templateInfoCacheLock)
{
// Generate template program
TemplateInfo ti = GenerateTemplateProgram(templateBody, globalsTypes, referencedAssemblies);
// Generated template found in cache
if (_templateInfoCache.ContainsKey(ti.TemplateKey))
{
return _templateInfoCache[ti.TemplateKey];
}
// Generate code
ICodeGenerator codeGenerator = new CodeGenerator();
ti.GeneratedSourceCode = codeGenerator.GenerateCode(ti);
// Generate assembly
var assemblyCompiler = new AssemblyGenerator();
Assembly assembly = assemblyCompiler.GenerateAssembly(ti, true, null, null);
// Try to load the Render() method from assembly
ti.RenderMethod = GetTemplateRenderMethod(assembly, ti);
// Try to load the template generator version from assembly
ti.GeneratorVersion = GetTemplateGeneratorVersion(assembly, ti);
_templateInfoCache.Add(ti.TemplateKey, ti);
return ti;
}
}
public static IEnumerable<IDocumentStorage> Build(IDocumentSchema schema, DocumentMapping[] mappings)
{
// Generate the actual source code
var code = GenerateDocumentStorageCode(mappings);
var generator = new AssemblyGenerator();
// Tell the generator which other assemblies that it should be referencing
// for the compilation
generator.ReferenceAssembly(Assembly.GetExecutingAssembly());
generator.ReferenceAssemblyContainingType<NpgsqlConnection>();
generator.ReferenceAssemblyContainingType<QueryModel>();
generator.ReferenceAssemblyContainingType<DbCommand>();
generator.ReferenceAssemblyContainingType<Component>();
generator.ReferenceAssemblyContainingType<DbDataReader>();
mappings.Select(x => x.DocumentType.Assembly).Distinct().Each(assem => generator.ReferenceAssembly(assem));
// build the new assembly -- this will blow up if there are any
// compilation errors with the list of errors and the actual code
var assembly = generator.Generate(code);
return assembly
.GetExportedTypes()
.Where(x => x.IsConcreteTypeOf<IDocumentStorage>())
.Select(x => BuildStorageObject(schema, mappings, x));
}
private static void GenerateAssembly(bool debug, StreamReader inputFile)
{
AssemblyGenerator assemblyGenerator = new AssemblyGenerator();
assemblyGenerator.Debug = debug;
assemblyGenerator.Name = _output;
AssemblyBuilder assemblyBuilder = assemblyGenerator.Generate(inputFile);
assemblyBuilder.Save(assemblyBuilder.GetName().Name);
if (assemblyGenerator.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
sb.Append(assemblyGenerator.Errors.Count);
sb.Append(" Errors:");
sb.Append(Environment.NewLine);
foreach (CompilerError error in assemblyGenerator.Errors)
{
sb.Append(error.ErrorText);
}
Console.WriteLine(sb.ToString());
}
if (debug)
{
Assembly assembly = Assembly.LoadFrom("test.debug.exe");
Type t = assembly.GetType("test.Program");
object o = Activator.CreateInstance(t);
MemberInfo[] memberInfos =
t.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Static);
EventInfo eventInfo = t.GetEvent("BreakEvent", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Static);
//eventInfo.AddEventHandler(o, new EventHandler<EventArgs>(Test));
//MethodInfo m = t.GetMethod("Break");
//m.Invoke(o, new object[0]);
}
//Console.ReadLine();
}
public void SetupContext()
{
Generator = new AssemblyGenerator();
_scenarios = new IScenario[]
{
TestHelper.BuildScenario("foo", "When I do seomthing",
"something else should happen")
};
var spec = new AssemblyGenerationSpec {Assemblies = new[] {this.GetType().Assembly.Location}};
spec.AddStory(new Story("foo", "bar", _scenarios), _scenarios);
GeneratedAssemblyPath = Generator.GenerateAssembly(spec);
}
private void VerifyTypeRefEntityProperty(AssemblyGenerator asmGen, Type serverEntityType, string propertyName, Type propertyType)
{
Type clientEntityType = asmGen.GetGeneratedType(serverEntityType.FullName);
Assert.IsNotNull(clientEntityType, "Expected entity of type " + serverEntityType);
Assert.AreNotSame(serverEntityType, clientEntityType, "Server and client entity types should not be the same instance");
PropertyInfo serverPropertyInfo = serverEntityType.GetProperty(propertyName);
Assert.IsNotNull(serverPropertyInfo, "Expected server property " + propertyName + " on entity type " + serverEntityType);
PropertyInfo clientPropertyInfo = clientEntityType.GetProperty(propertyName);
Assert.IsNotNull(clientPropertyInfo, "Expected client property " + propertyName + " on entity type " + clientEntityType);
Assert.AreEqual(serverPropertyInfo.PropertyType.Name, clientPropertyInfo.PropertyType.Name, "server and client properties have different return types");
}
internal static void GenerateAndVerifyCodeGenerators(string testName, Type[] domainServiceTypes, Type[] sharedTypes, string[] refAssemblies)
{
Assembly codeDomCodeGenAssembly = null;
Assembly t4CodeGenAssembly = null;
using (AssemblyGenerator asmGen = new AssemblyGenerator(testName, /* isCSharp */ true, /* useFullTypeNames */ false, domainServiceTypes))
{
foreach (Type t in sharedTypes)
{
asmGen.MockSharedCodeService.AddSharedType(t);
}
foreach (string refAssembly in refAssemblies)
{
asmGen.ReferenceAssemblies.Add(refAssembly);
}
string generatedCode = asmGen.GeneratedCode;
Assert.IsFalse(string.IsNullOrEmpty(generatedCode), "Failed to generate code:\r\n" + asmGen.ConsoleLogger.Errors);
codeDomCodeGenAssembly = asmGen.GeneratedAssembly;
Assert.IsNotNull(codeDomCodeGenAssembly, "Assembly failed to build: " + asmGen.ConsoleLogger.Errors);
}
using (T4AssemblyGenerator asmGen = new T4AssemblyGenerator(testName, /* isCSharp */ true, /* useFullTypeNames */ false, domainServiceTypes))
{
foreach (Type t in sharedTypes)
{
asmGen.MockSharedCodeService.AddSharedType(t);
}
foreach (string refAssembly in refAssemblies)
{
asmGen.ReferenceAssemblies.Add(refAssembly);
}
string generatedCode = asmGen.GeneratedCode;
Assert.IsFalse(string.IsNullOrEmpty(generatedCode), "Failed to generate code:\r\n" + asmGen.ConsoleLogger.Errors);
t4CodeGenAssembly = asmGen.GeneratedAssembly;
Assert.IsNotNull(t4CodeGenAssembly, "Assembly failed to build: " + asmGen.ConsoleLogger.Errors);
}
TestHelper.VerifyAssembliesEquality(codeDomCodeGenAssembly, t4CodeGenAssembly);
}
public void generate_a_small_class()
{
var code = @"
using System;
using Marten.Testing;
namespace RoslynGenerationSpike
{
public class Writer : IMessageWriter
{
public void WriteMessages()
{
Console.WriteLine('What is this?');
Console.WriteLine('Dynamic Code?');
Console.WriteLine('Really?');
}
}
}
".Replace("'", "\"");
// New helper for this mess called AssemblyGenerator
var builder = new AssemblyGenerator();
// you might need to help it out w/ references
builder.ReferenceAssembly(Assembly.GetExecutingAssembly());
// Make the new Assembly
var assembly = builder.Generate(code);
// Do stuff with it
var writerType = assembly.GetExportedTypes().Single();
var writer = Activator.CreateInstance(writerType).As<IMessageWriter>();
writer.WriteMessages();
writer.WriteMessages();
writer.WriteMessages();
writer.WriteMessages();
writer.WriteMessages();
writer.WriteMessages();
writer.WriteMessages();
}
// Common helper that does body of test
private void TypeReference_Common_Types_Helper(bool isCSharp, bool useFullTypeNames, string testFolderName)
{
using (AssemblyGenerator asmGen = new AssemblyGenerator(testFolderName, isCSharp, useFullTypeNames, new Type[] { typeof(TypeReferenceDomainService_Common_Types1), typeof(TypeReferenceDomainService_Common_Types2) }))
{
// Force this type to be shared to force failure
asmGen.MockSharedCodeService.AddSharedType(typeof(System.Reflection.BindingFlags));
string generatedCode = asmGen.GeneratedCode;
Assert.IsFalse(string.IsNullOrEmpty(generatedCode), "Failed to generate code:\r\n" + asmGen.ConsoleLogger.Errors);
Assembly assy = asmGen.GeneratedAssembly;
Assert.IsNotNull(assy, "Assembly failed to build: " + asmGen.ConsoleLogger.Errors);
TestHelper.AssertNoErrorsOrWarnings(asmGen.ConsoleLogger);
VerifyTypeRefEntity(asmGen, typeof(TypeReferenceCommonTypeEntity1));
VerifyTypeRefEntity(asmGen, typeof(TypeReferenceCommonTypeEntity2));
}
}
public static IEnumerable<IDocumentStorage> Build(DocumentMapping[] mappings)
{
var code = GenerateDocumentStorageCode(mappings);
var generator = new AssemblyGenerator();
generator.ReferenceAssembly(Assembly.GetExecutingAssembly());
generator.ReferenceAssemblyContainingType<NpgsqlConnection>();
generator.ReferenceAssemblyContainingType<QueryModel>();
generator.ReferenceAssemblyContainingType<DbCommand>();
generator.ReferenceAssemblyContainingType<Component>();
mappings.Select(x => x.DocumentType.Assembly).Distinct().Each(assem => generator.ReferenceAssembly(assem));
var assembly = generator.Generate(code);
return assembly
.GetExportedTypes()
.Where(x => x.IsConcreteTypeOf<IDocumentStorage>())
.Select(x => Activator.CreateInstance(x).As<IDocumentStorage>());
}
public static IEnumerable<IDocumentStorage> Build(IDocumentSchema schema, IDocumentMapping[] mappings)
{
// Generate the actual source code
var code = GenerateDocumentStorageCode(mappings);
var generator = new AssemblyGenerator();
// Tell the generator which other assemblies that it should be referencing
// for the compilation
generator.ReferenceAssembly(Assembly.GetExecutingAssembly());
generator.ReferenceAssemblyContainingType<NpgsqlConnection>();
generator.ReferenceAssemblyContainingType<QueryModel>();
generator.ReferenceAssemblyContainingType<DbCommand>();
generator.ReferenceAssemblyContainingType<Component>();
generator.ReferenceAssemblyContainingType<DbDataReader>();
mappings.Select(x => x.DocumentType.Assembly).Distinct().Each(assem => generator.ReferenceAssembly(assem));
// build the new assembly -- this will blow up if there are any
// compilation errors with the list of errors and the actual code
var assembly = generator.Generate(code);
return assembly
.GetExportedTypes()
.Where(x => x.IsConcreteTypeOf<IDocumentStorage>())
.Select(x =>
{
var docType =
x.FindInterfaceThatCloses(typeof (IdAssignment<>)).GetGenericArguments().Single();
var mapping = mappings.Single(m => m.DocumentType == docType);
var arguments = mapping.ToArguments().Select(arg => arg.GetValue(schema)).ToArray();
var ctor = x.GetConstructors().Single();
return ctor.Invoke(arguments).As<IDocumentStorage>();
});
}
public DocumentProvider <T> Generate <T>()
{
var assembly = new GeneratedAssembly(new GenerationRules(SchemaConstants.MartenGeneratedNamespace));
var operations = new DocumentOperations(assembly, _mapping, _options);
assembly.Namespaces.Add(typeof(CommandExtensions).Namespace);
assembly.Namespaces.Add(typeof(Weasel.Core.CommandExtensions).Namespace);
assembly.Namespaces.Add(typeof(TenantIdArgument).Namespace);
assembly.Namespaces.Add(typeof(NpgsqlCommand).Namespace);
var queryOnly = new DocumentStorageBuilder(_mapping, StorageStyle.QueryOnly, x => x.QueryOnlySelector)
.Build(assembly, operations);
var lightweight = new DocumentStorageBuilder(_mapping, StorageStyle.Lightweight, x => x.LightweightSelector)
.Build(assembly, operations);
var identityMap = new DocumentStorageBuilder(_mapping, StorageStyle.IdentityMap, x => x.IdentityMapSelector)
.Build(assembly, operations);
var dirtyTracking = new DocumentStorageBuilder(_mapping, StorageStyle.DirtyTracking, x => x.DirtyCheckingSelector)
.Build(assembly, operations);
var bulkWriterType = new BulkLoaderBuilder(_mapping).BuildType(assembly);
var compiler = new AssemblyGenerator();
var types = new[]
{
typeof(IDocumentStorage <>),
typeof(T),
};
foreach (var referencedAssembly in WalkReferencedAssemblies.ForTypes(types))
{
compiler.ReferenceAssembly(referencedAssembly);
}
var providerType = assembly.AddType(ProviderName,
typeof(DocumentProvider <>).MakeGenericType(_mapping.DocumentType));
providerType.AllInjectedFields.Clear();
providerType.AllInjectedFields.Add(new InjectedField(typeof(DocumentMapping), "mapping"));
var bulkWriterArgType = typeof(IBulkLoader <>).MakeGenericType(_mapping.DocumentType);
var bulkWriterArgs = $"new {queryOnly.TypeName}(mapping)";
if (bulkWriterType.AllInjectedFields.Count == 2)
{
bulkWriterArgs += ", mapping";
}
var bulkWriterCode = $"new {bulkWriterType.TypeName}({bulkWriterArgs})";
providerType.BaseConstructorArguments[0] = new Variable(bulkWriterArgType, bulkWriterCode);
providerType.BaseConstructorArguments[1] = new CreateFromDocumentMapping(_mapping, typeof(IDocumentStorage <>), queryOnly);
providerType.BaseConstructorArguments[2] = new CreateFromDocumentMapping(_mapping, typeof(IDocumentStorage <>), lightweight);
providerType.BaseConstructorArguments[3] = new CreateFromDocumentMapping(_mapping, typeof(IDocumentStorage <>), identityMap);
providerType.BaseConstructorArguments[4] = new CreateFromDocumentMapping(_mapping, typeof(IDocumentStorage <>), dirtyTracking);
try
{
compiler.Compile(assembly);
}
catch (Exception e)
{
if (e.Message.Contains("is inaccessible due to its protection level"))
{
throw new InvalidOperationException($"Requested document type '{_mapping.DocumentType.FullNameInCode()}' must be either scoped as 'public' or the assembly holding it must use the {nameof(InternalsVisibleToAttribute)} pointing to 'Marten.Generated'", e);
}
throw;
}
return((DocumentProvider <T>)Activator.CreateInstance(providerType.CompiledType, _mapping));
}
public override TemplateInfo CompileTemplate(string templateBody, Dictionary<string, Type> globalsTypes, List<Assembly> referencedAssemblies)
{
lock (_templateInfoCacheLock)
{
// Cache is empty, load templates from cache folder
if (_templateInfoCache == null)
{
_templateInfoCache = LoadTemplatesInfo(_templateCacheFolder);
}
// Generate template program
TemplateInfo ti = GenerateTemplateProgram(templateBody, globalsTypes, referencedAssemblies);
// Generated template found in cache
if (_templateInfoCache.ContainsKey(ti.TemplateKey))
{
return _templateInfoCache[ti.TemplateKey];
}
// Generate code
ICodeGenerator codeGenerator = new CodeGenerator();
ti.GeneratedSourceCode = codeGenerator.GenerateCode(ti);
// Path to output assembly
string assemblyFileName = _fileNamePattern.Replace("{key}", ti.TemplateKey);
string assemblyPath = Path.Combine(_templateCacheFolder, assemblyFileName);
// Generate assembly
var assemblyCompiler = new AssemblyGenerator();
Assembly assembly = assemblyCompiler.GenerateAssembly(ti, false, assemblyPath, null);
// Try to load the Render() method from assembly
ti.RenderMethod = GetTemplateRenderMethod(assembly, ti);
// Try to load the template generator version from assembly
ti.GeneratorVersion = GetTemplateGeneratorVersion(assembly, ti);
_templateInfoCache.Add(ti.TemplateKey, ti);
return ti;
}
}
static void GenSample(string name, TestAppConfig appConfig, SuiteConfig suiteConfig, CodeTypeDeclarationCollection instrumentedTypes, bool isLibrary)
{
CodeDomProvider provider = appConfig.provider;
CodeGeneratorOptions options = appConfig.options;
CodeStatementCollection testStatements = GenTestCases(instrumentedTypes);
CodeTypeDeclaration mainClass = AssemblyGenerator.GenMainClass(testStatements);
mainClass.Name = name + "App";
CodeNamespace codeNamespace = AssemblyGenerator.GenNamespaceForInstrumentation(name + "App", provider is VBCodeProvider);
codeNamespace.Types.Add(SupportedType.jscriptHackType);
codeNamespace.Types.AddRange(instrumentedTypes);
codeNamespace.Types.Add(mainClass);
CodeCompileUnit unit = AssemblyGenerator.GenInstrumentedAssembly("root\\TestAppZ");
unit.Namespaces.Add(codeNamespace);
// CodeCompileUnit unitMod = AssemblyGenerator.GenInstrumentedModule();
string fileName = name + "." + provider.FileExtension;
string assemblyName = name + "." + (isLibrary?"dll":"exe");
string target = (isLibrary?" /target:library":"");
#if SUBDIRSFORLANG
string subDir = Path.Combine(Environment.CurrentDirectory, provider.FileExtension);
Directory.CreateDirectory(subDir);
string oldDir = Environment.CurrentDirectory;
Environment.CurrentDirectory = subDir;
#endif
Console.WriteLine("Generating " + fileName);
using (StreamWriter writer = new StreamWriter(fileName, false, Encoding.ASCII))
{
provider.CreateGenerator().GenerateCodeFromCompileUnit(unit, writer, options);
}
#if xxx
string fileNameMod = name + "Mod." + provider.FileExtension;
string moduleName = name + "Mod." + "mod";
using (StreamWriter writer = new StreamWriter(fileNameMod, false, Encoding.ASCII))
{
provider.CreateGenerator().GenerateCodeFromCompileUnit(unitMod, writer, options);
}
#endif
#if SUBDIRSFORLANG
Environment.CurrentDirectory = oldDir;
#endif
#if SUBDIRSFORLANG
suiteConfig.commands1.Add("cd " + provider.FileExtension);
#endif
suiteConfig.commands1.Add("echo Building " + fileName);
suiteConfig.commands1.Add(appConfig.GetComplerCommand(unit) + target + " /out:" + assemblyName + " " + fileName);
// suiteConfig.commands1.Add(appConfig.GetComplerCommand(unit) + " /target:module /out:" + moduleName + " " + fileNameMod);
#if SUBDIRSFORLANG
suiteConfig.commands1.Add("cd ..");
#endif
#if SUBDIRSFORLANG
suiteConfig.commands2.Add("cd " + provider.FileExtension);
#endif
suiteConfig.commands2.Add("echo InstallUtil " + assemblyName);
suiteConfig.commands2.Add("InstallUtil /LogToConsole=false " + assemblyName);
#if SUBDIRSFORLANG
suiteConfig.commands2.Add("cd ..");
#endif
}
public void CreatesAssemblyInfo()
{
const string json =
@"{
""name"": ""jsii$aws_cdk_cx_api$"",
""description"": """",
""homepage"": """",
""repository"": {
""type"": """",
""url"": """"
},
""author"": {
""name"": """",
""roles"": []
},
""fingerprint"": """",
""license"": """",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.Cdk.CxApiNamespace"",
""packageId"": ""Aws.Cdk.CxApiPackageId""
}
},
""version"": """",
""types"": {}
}";
string jsonPath = GetJsonPath("aws-cdk-cx-api");
string projectFilePath = GetProjectFilePath("Aws.Cdk.CxApiPackageId", "Aws.Cdk.CxApiPackageId");
IFile file = Substitute.For <IFile>();
file.ReadAllText(jsonPath).Returns(json);
IFileSystem fileSystem = Substitute.For <IFileSystem>();
fileSystem.Directory.Returns(Substitute.For <IDirectory>());
fileSystem.File.Returns(file);
Symbols.MapTypeToPackage("aws-cdk-cx-api", "Aws.Cdk.CxApiPackageId");
AssemblyGenerator generator = new AssemblyGenerator
(
OutputRoot,
fileSystem
);
generator.Generate
(
Path.Combine(InputRoot, "aws-cdk-cx-api", "dist", Constants.SPEC_FILE_NAME),
Path.Combine(InputRoot, "aws-cdk-cx-api", "aws-cdk-cx-api-1.2.3.5.tgz"),
Symbols
);
file.Received().WriteAllText(Path.Combine(OutputRoot, "Aws.Cdk.CxApiPackageId", "AssemblyInfo.cs"),
Arg.Do <string>(
code => Assert.Equal(
@"using Amazon.JSII.Runtime.Deputy;
[assembly: JsiiAssembly(""jsii$aws_cdk_cx_api$"", """", ""aws-cdk-cx-api-1.2.3.5.tgz"")]",
code,
ignoreLineEndingDifferences: true
)
)
);
}
public ObjectBinderTest()
{
_fixture = new Fixture();
_assemblyGenerator = new AssemblyGenerator();
}
static void Generate(Options options)
{
AssemblyGenerator generator = new AssemblyGenerator(options.OutputDirectory, "", "");
generator.Generate(options.JsiiFile, options.Tarball);
}
private void VerifyTypeRefEntity(AssemblyGenerator asmGen, Type serverEntityType)
{
VerifyTypeRefEntityProperty(asmGen, serverEntityType, "NullableBindingFlags", typeof(Nullable<BindingFlags>));
VerifyTypeRefEntityProperty(asmGen, serverEntityType, "ListOfBindingFlags", typeof(List<BindingFlags>));
}
private static void AssemblyGeneratorBuildTest(AssemblyDefinition defs)
{
AssemblyGenerator.GenerateAssembly(MSBUILD_PATH, defs, $".\\{defs.AssemblyName}_Build\\",
AssemblyGeneratorBuildType.Publish, true);
}
public void CreatesBasicTypeFile()
{
const string json =
@"{
""name"": ""jsii$aws_cdk_cx_api$"",
""package"": ""aws-cdk-cx-api"",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.Cdk.CxApi""
}
},
""version"": """",
""types"": {
""jsii$aws_cdk_cx_api$.MissingContext"": {
""kind"": ""class"",
""fqn"": ""jsii$aws_cdk_cx_api$.MissingContext"",
""assembly"": ""jsii$aws_cdk_cx_api$"",
""namespace"": ""jsii$aws_cdk_cx_api$"",
""name"": ""MissingContext"",
""initializer"": {
""initializer"": true
}
}
}
}";
string jsonPath = GetJsonPath("aws-cdk-cx-api");
string typeFilePath = GetTypeFilePath("Aws.Cdk.CxApi", "MissingContext");
IFile file = Substitute.For <IFile>();
file.ReadAllText(jsonPath).Returns(json);
IFileSystem fileSystem = Substitute.For <IFileSystem>();
fileSystem.Directory.Returns(Substitute.For <IDirectory>());
fileSystem.File.Returns(file);
Symbols.MapTypeToPackage("aws-cdk-cx-api", "Aws.Cdk.CxApi");
Symbols.MapNamespace("jsii$aws_cdk_cx_api$", "Aws.Cdk.CxApi");
Symbols.MapTypeName("jsii$aws_cdk_cx_api$.MissingContext", "MissingContext", JsonModel.Spec.TypeKind.Class);
AssemblyGenerator generator = new AssemblyGenerator
(
OutputRoot,
"",
"",
fileSystem
);
generator.Generate
(
Path.Combine(InputRoot, "aws-cdk-cx-api", "dist", Constants.SPEC_FILE_NAME),
Path.Combine(InputRoot, "aws-cdk-cx-api", "aws-cdk-cx-api-1.1.1.tgz"),
Symbols
);
string expected =
@"using Amazon.JSII.Runtime.Deputy;
namespace Aws.Cdk.CxApi
{
[JsiiClass(typeof(MissingContext), ""jsii$aws_cdk_cx_api$.MissingContext"", ""[]"")]
public class MissingContext : DeputyBase
{
public MissingContext(): base(new DeputyProps(new object[]{}))
{
}
protected MissingContext(ByRefValue reference): base(reference)
{
}
protected MissingContext(DeputyProps props): base(props)
{
}
}
}";
file.Received().WriteAllText(typeFilePath,
Arg.Is <string>(actual => PlatformIndependentEqual(expected, actual))
);
}
public void AccessesFileSystemThroughShim()
{
const string json =
@"{
""name"": ""jsii$aws_cdk_cx_api$"",
""package"": ""aws-cdk-cx-api"",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.Cdk.CxApi""
}
},
""version"": """",
""types"": {
""jsii$aws_cdk_cx_api$.MissingContext"": {
""kind"": ""class"",
""fqn"": ""jsii$aws_cdk_cx_api$.MissingContext"",
""assembly"": ""jsii$aws_cdk_cx_api$"",
""namespace"": ""jsii$aws_cdk_cx_api$"",
""name"": ""MissingContext"",
""initializer"": {
""initializer"": true
}
}
}
}";
string jsonPath = GetJsonPath("aws-cdk-cx-api");
string packageOutputRoot = GetPackageOutputRoot("Aws.Cdk.CxApi");
string projectFilePath = GetProjectFilePath("Aws.Cdk.CxApi", "Aws.Cdk.CxApi");
string typeFilePath = GetTypeFilePath("Aws.Cdk.CxApi", "MissingContext");
IDirectory directory = Substitute.For <IDirectory>();
directory.Exists(packageOutputRoot).Returns(true, false);
IFile file = Substitute.For <IFile>();
file.ReadAllText(jsonPath).Returns(json);
IFileSystem fileSystem = Substitute.For <IFileSystem>();
fileSystem.Directory.Returns(directory);
fileSystem.File.Returns(file);
Symbols.MapTypeToPackage("aws-cdk-cx-api", "Aws.Cdk.CxApi");
Symbols.MapNamespace("jsii$aws_cdk_cx_api$", "Aws.Cdk.CxApi");
Symbols.MapTypeName("jsii$aws_cdk_cx_api$.MissingContext", "MissingContext", JsonModel.Spec.TypeKind.Class);
AssemblyGenerator generator = new AssemblyGenerator
(
OutputRoot,
"",
"",
fileSystem
);
generator.Generate
(
Path.Combine(InputRoot, "aws-cdk-cx-api", "dist", Constants.SPEC_FILE_NAME),
Path.Combine(InputRoot, "aws-cdk-cx-api", "aws-cdk-cx-api-1.2.3.5.tgz"),
Symbols
);
directory.Received().Delete(packageOutputRoot, true);
directory.Received().CreateDirectory(packageOutputRoot);
file.Received().ReadAllText(jsonPath);
file.Received().WriteAllText(projectFilePath, Arg.Any <string>());
file.Received().WriteAllText(typeFilePath, Arg.Any <string>());
}
public void CreatesProjectFileWithDependencies()
{
string json =
@"{
""name"": ""jsii$aws_cdk$"",
""package"": ""aws-cdk"",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.Cdk""
}
},
""version"": ""1.2.3"",
""types"": {},
""dependencies"": {
""jsii$aws_cdk_cx_api$"": {
""package"": ""aws-cdk-cx-api"",
""version"": """",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.Cdk.CxApi""
}
}
}
}
}";
string cxJson =
@"{
""name"": ""jsii$aws_cdk_cx_api$"",
""version"": """",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.Cdk.CxApi""
}
},
""types"": {}
}";
string jsonPath = GetJsonPath("aws-cdk");
string cxJsonPath = Path.Combine(Path.GetDirectoryName(jsonPath), "node_modules", "jsii$aws_cdk_cx_api$");
string projectFilePath = GetProjectFilePath("Aws.Cdk", "Aws.Cdk");
IFile file = Substitute.For <IFile>();
file.ReadAllText(jsonPath).Returns(json);
file.ReadAllText(Path.Combine(cxJsonPath, ".jsii")).Returns(cxJson);
IDirectory directory = Substitute.For <IDirectory>();
directory.Exists(cxJsonPath).Returns(true);
IFileSystem fileSystem = Substitute.For <IFileSystem>();
fileSystem.Directory.Returns(directory);
fileSystem.File.Returns(file);
Symbols.MapTypeToPackage("aws-cdk", "Aws.Cdk");
Symbols.MapTypeToPackage("aws-cdk-cx-api", "Aws.Cdk.CxApi");
Symbols.MapAssemblyName("jsii$aws_cdk_cx_api$", "Aws.Cdk.CxApi");
AssemblyGenerator generator = new AssemblyGenerator
(
OutputRoot,
"myAuthors",
"myCompany",
fileSystem
);
generator.Generate
(
Path.Combine(InputRoot, "aws-cdk", "dist", Constants.SPEC_FILE_NAME),
Path.Combine(InputRoot, "aws-cdk", "aws-cdk-1.2.3.4.tgz"),
Symbols
);
string expected =
@"<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<Authors>myAuthors</Authors>
<Company>myCompany</Company>
<PackageVersion>1.2.3</PackageVersion>
</PropertyGroup>
<ItemGroup>
<EmbeddedResource Include=""aws-cdk-1.2.3.4.tgz"" />
</ItemGroup>
<ItemGroup>
<PackageReference Include=""Amazon.JSII.Runtime"" Version=""" + JsiiVersion.Version + @""" />
<ProjectReference Include=""..\Aws.Cdk.CxApi\Aws.Cdk.CxApi.csproj"" Version=""" + JsiiVersion.Version + @""" />
</ItemGroup>
</Project>";
file.Received().WriteAllText(projectFilePath, Arg.Do <string>(actual => PlatformIndependentEqual(expected, actual)));
}
protected void PrintSchedule()
{
AssemblyGenerator asmg = new AssemblyGenerator(registerAssignment);
for (int i = 0; i < schedule.Steps; i++) {
textWriter.Write("[" + i + "] ");
InstructionNode[] istep = schedule[i];
for (int j = 0; j < istep.Length; j++) {
InstructionNode inode = istep[j];
if (inode != null) {
textWriter.Write(asmg.GetAssembly(inode));
textWriter.Write(" | ");
} else {
textWriter.Write(" | ");
}
}
textWriter.WriteLine();
}
textWriter.WriteLine();
}
public DocumentProvider <T> Generate <T>()
{
var assembly = new GeneratedAssembly(new GenerationRules(SchemaConstants.MartenGeneratedNamespace));
var operations = new DocumentOperations(assembly, _mapping, _options);
assembly.Namespaces.Add(typeof(CommandExtensions).Namespace);
assembly.Namespaces.Add(typeof(TenantIdArgument).Namespace);
assembly.Namespaces.Add(typeof(NpgsqlCommand).Namespace);
var queryOnly = new DocumentStorageBuilder(_mapping, StorageStyle.QueryOnly, x => x.QueryOnlySelector)
.Build(assembly, operations);
var lightweight = new DocumentStorageBuilder(_mapping, StorageStyle.Lightweight, x => x.LightweightSelector)
.Build(assembly, operations);
var identityMap = new DocumentStorageBuilder(_mapping, StorageStyle.IdentityMap, x => x.IdentityMapSelector)
.Build(assembly, operations);
var dirtyTracking = new DocumentStorageBuilder(_mapping, StorageStyle.DirtyTracking, x => x.DirtyCheckingSelector)
.Build(assembly, operations);
var bulkWriterType = new BulkLoaderBuilder(_mapping).BuildType(assembly);
var compiler = new AssemblyGenerator();
compiler.ReferenceAssembly(typeof(IDocumentStorage <>).Assembly);
compiler.ReferenceAssembly(typeof(T).Assembly);
try
{
compiler.Compile(assembly);
}
catch (Exception e)
{
if (e.Message.Contains("is inaccessible due to its protection level"))
{
throw new InvalidOperationException($"Requested document type '{_mapping.DocumentType.FullNameInCode()}' must be either scoped as 'public' or the assembly holding it must use the {nameof(InternalsVisibleToAttribute)} pointing to 'Marten.Generated'", e);
}
throw;
}
var slot = new DocumentProvider <T>
{
QueryOnly = (IDocumentStorage <T>)Activator.CreateInstance(queryOnly.CompiledType, _mapping),
Lightweight = (IDocumentStorage <T>)Activator.CreateInstance(lightweight.CompiledType, _mapping),
IdentityMap = (IDocumentStorage <T>)Activator.CreateInstance(identityMap.CompiledType, _mapping),
DirtyTracking = (IDocumentStorage <T>)Activator.CreateInstance(dirtyTracking.CompiledType, _mapping),
Operations = operations,
QueryOnlyType = queryOnly,
LightweightType = lightweight,
IdentityMapType = identityMap,
DirtyTrackingType = dirtyTracking
};
slot.BulkLoader = _mapping.IsHierarchy()
? (IBulkLoader <T>)Activator.CreateInstance(bulkWriterType.CompiledType, slot.QueryOnly, _mapping)
: (IBulkLoader <T>)Activator.CreateInstance(bulkWriterType.CompiledType, slot.QueryOnly);
slot.BulkLoaderType = bulkWriterType;
return(slot);
}
public Compilation(Linker linker, AssemblyGenerator assemblyGenerator)
{
m_Linker = linker;
m_AssemblyGenerator = assemblyGenerator;
}
public void CreatesAnchorFile()
{
string json =
@"{
""name"": ""jsii$aws_cdk$"",
""description"": """",
""homepage"": """",
""repository"": {
""type"": """",
""url"": """"
},
""author"": {
""name"": """",
""roles"": []
},
""fingerprint"": """",
""license"": """",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.CdkNamespace"",
""packageId"": ""Aws.CdkPackageId""
}
},
""version"": ""1.2.3"",
""types"": {},
""dependencies"": {
""jsii$aws_cdk_cx_api$"": {
""package"": ""aws-cdk-cx-api"",
""version"": """",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.Cdk.CxApi"",
""packageId"": ""Aws.Cdk.CxApi""
}
}
}
}
}";
string cxJson =
@"{
""name"": ""jsii$aws_cdk_cx_api$"",
""description"": """",
""homepage"": """",
""repository"": {
""type"": """",
""url"": """"
},
""author"": {
""name"": """",
""roles"": []
},
""fingerprint"": """",
""license"": """",
""version"": """",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.Cdk.CxApiNamespace"",
""packageId"": ""Aws.Cdk.CxApiPackageId""
}
},
""types"": {}
}";
string jsonPath = GetJsonPath("aws-cdk");
string cxJsonPath = Path.Combine(Path.GetDirectoryName(jsonPath), "node_modules", "jsii$aws_cdk_cx_api$");
string anchorFilePath = GetAnchorFilePath("Aws.CdkPackageId", "Aws.CdkNamespace");
IFile file = Substitute.For <IFile>();
file.ReadAllText(jsonPath).Returns(json);
file.ReadAllText(Path.Combine(cxJsonPath, ".jsii")).Returns(cxJson);
IDirectory directory = Substitute.For <IDirectory>();
directory.Exists(cxJsonPath).Returns(true);
IFileSystem fileSystem = Substitute.For <IFileSystem>();
fileSystem.Directory.Returns(directory);
fileSystem.File.Returns(file);
Symbols.MapTypeToPackage("aws-cdk", "Aws.CdkPackageId");
Symbols.MapTypeToPackage("aws-cdk-cx-api", "Aws.Cdk.CxApiNamespace");
Symbols.MapAssemblyName("jsii$aws_cdk_cx_api$", "Aws.Cdk.CxApiPackageId");
AssemblyGenerator generator = new AssemblyGenerator
(
OutputRoot,
fileSystem
);
generator.Generate
(
Path.Combine(InputRoot, "aws-cdk", "dist", Constants.SPEC_FILE_NAME),
Path.Combine(InputRoot, "aws-cdk", "aws-cdk-1.2.3.4.tgz"),
Symbols
);
string expected =
@"namespace Aws.CdkNamespace.Internal.DependencyResolution
{
public class Anchor
{
public Anchor()
{
new Aws.Cdk.CxApiNamespace.Internal.DependencyResolution.Anchor();
}
}
}";
file.Received().WriteAllText(anchorFilePath, Arg.Do <string>(actual => PlatformIndependentEqual(expected, actual)));
}
public void CreatesBasicProjectFile()
{
const string json =
@"{
""name"": ""jsii$aws_cdk_cx_api$"",
""description"": """",
""homepage"": """",
""repository"": {
""type"": """",
""url"": """"
},
""author"": {
""name"": """",
""roles"": []
},
""fingerprint"": """",
""license"": """",
""targets"": {
""dotnet"": {
""namespace"": ""Aws.Cdk.CxApiNamespace"",
""packageId"": ""Aws.Cdk.CxApiPackageId""
}
},
""version"": ""1.2.3"",
""types"": {}
}";
string jsonPath = GetJsonPath("aws-cdk-cx-api");
string projectFilePath = GetProjectFilePath("Aws.Cdk.CxApiPackageId", "Aws.Cdk.CxApiPackageId");
IFile file = Substitute.For <IFile>();
file.ReadAllText(jsonPath).Returns(json);
IFileSystem fileSystem = Substitute.For <IFileSystem>();
fileSystem.Directory.Returns(Substitute.For <IDirectory>());
fileSystem.File.Returns(file);
Symbols.MapTypeToPackage("aws-cdk-cx-api", "Aws.Cdk.CxApiPackageId");
AssemblyGenerator generator = new AssemblyGenerator
(
OutputRoot,
fileSystem
);
generator.Generate
(
Path.Combine(InputRoot, "aws-cdk-cx-api", "dist", Constants.SPEC_FILE_NAME),
Path.Combine(InputRoot, "aws-cdk-cx-api", "aws-cdk-cx-api-1.2.3.5.tgz"),
Symbols
);
string expected =
@"<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<Authors>myAuthors</Authors>
<Company>myCompany</Company>
<PackageVersion>1.2.3</PackageVersion>
</PropertyGroup>
<ItemGroup>
<EmbeddedResource Include=""aws-cdk-cx-api-1.2.3.5.tgz"" />
</ItemGroup>
<ItemGroup>
<PackageReference Include=""Amazon.JSII.Runtime"" Version=""" + JsiiVersion.Version + @""" />
</ItemGroup>
</Project>";
file.Received().WriteAllText(projectFilePath, Arg.Do <string>(actual => PlatformIndependentEqual(expected, actual)));
}