private void buildInlineAggregationType()
{
var inlineBaseType =
typeof(AggregationRuntime <,>).MakeGenericType(typeof(T), _aggregateMapping.IdType);
_inlineType = _assembly.AddType(GetType().NameInCode().Sanitize() + "InlineHandler", inlineBaseType);
_createMethods.BuildCreateMethod(_inlineType, _aggregateMapping);
_inlineType.AllInjectedFields.Add(new InjectedField(GetType()));
var method = buildDetermineOperationMethod();
var upsertMethod = typeof(IDocumentStorage <>).MakeGenericType(typeof(T)).GetMethod("Upsert");
var upsert = new MethodCall(_storageType, upsertMethod)
{
ReturnAction = ReturnAction.Return
};
method.Frames.Add(upsert);
_inlineType.Setters.AddRange(_applyMethods.Setters());
_inlineType.Setters.AddRange(_createMethods.Setters());
_inlineType.Setters.AddRange(_shouldDeleteMethods.Setters());
}
public void generate_dynamic_types_with_no_fields()
{
var rules = new GenerationRules("Lamar.Compilation");
var assembly = new GeneratedAssembly(rules);
var adder = assembly.AddType("Adder", typeof(INumberGenerator));
adder.MethodFor("Generate").Frames.Append <AddFrame>();
var multiplier = assembly.AddType("Multiplier", typeof(INumberGenerator));
multiplier.MethodFor(nameof(INumberGenerator.Generate))
.Frames.Append <MultiplyFrame>();
assembly.CompileAll();
Activator.CreateInstance(adder.CompiledType)
.As <INumberGenerator>()
.Generate(3, 4).ShouldBe(7);
Activator.CreateInstance(multiplier.CompiledType)
.As <INumberGenerator>()
.Generate(3, 4).ShouldBe(12);
adder.SourceCode.ShouldContain("public class Adder");
multiplier.SourceCode.ShouldContain("public class Multiplier");
}
private void buildAsyncDaemonAggregation()
{
var daemonBuilderIsAsync = _applyMethods.IsAsync || _createMethods.IsAsync || _shouldDeleteMethods.IsAsync;
var baseType = (daemonBuilderIsAsync ? typeof(AsyncDaemonAggregationBase <,>) : typeof(SyncDaemonAggregationBase <,>))
.MakeGenericType(typeof(T), _aggregateMapping.IdType);
_asyncDaemonType =
_assembly.AddType(GetType().Name.Sanitize() + "AsyncDaemonAggregation", baseType);
_asyncDaemonType.AllInjectedFields.Add(new InjectedField(_storageType));
var injectedField = new InjectedField(GetType());
_asyncDaemonType.AllInjectedFields.Add(injectedField);
// Build the create method
_createMethods.BuildCreateMethod(_asyncDaemonType, _aggregateMapping);
buildDetermineOperationMethodForDaemonRunner(daemonBuilderIsAsync);
buildAsyncDaemonSplitMethod();
_asyncDaemonType.Setters.AddRange(_applyMethods.Setters());
_asyncDaemonType.Setters.AddRange(_createMethods.Setters());
_asyncDaemonType.Setters.AddRange(_shouldDeleteMethods.Setters());
}
private static GeneratedType buildInsertStream(GeneratedType builderType, GeneratedAssembly generatedAssembly,
EventGraph graph)
{
var operationType = generatedAssembly.AddType(InsertStreamOperationName, typeof(InsertStreamBase));
var columns = new StreamsTable(graph)
.Columns
.OfType <IStreamTableColumn>()
.Where(x => x.Writes)
.ToArray();
var sql = $"insert into {graph.DatabaseSchemaName}.mt_streams ({columns.Select(x => x.Name).Join(", ")}) values ({columns.Select(_ => "?").Join(", ")})";
var configureCommand = operationType.MethodFor("ConfigureCommand");
configureCommand.DerivedVariables.Add(new Variable(typeof(StreamAction), nameof(InsertStreamBase.Stream)));
configureCommand.Frames.Code($"var parameters = {{0}}.{nameof(CommandBuilder.AppendWithParameters)}(\"{sql}\");",
Use.Type <CommandBuilder>());
for (var i = 0; i < columns.Length; i++)
{
columns[i].GenerateAppendCode(configureCommand, i);
}
builderType.MethodFor(nameof(EventDocumentStorage.InsertStream))
.Frames.Code($"return new Marten.Generated.{InsertStreamOperationName}(stream);");
return(operationType);
}
public static (EventDocumentStorage, string) GenerateStorage(StoreOptions options)
{
var assembly = new GeneratedAssembly(new GenerationRules(SchemaConstants.MartenGeneratedNamespace));
assembly.ReferenceAssembly(typeof(EventGraph).Assembly);
var builderType = assembly.AddType(EventDocumentStorageTypeName, typeof(EventDocumentStorage));
buildSelectorMethods(options, builderType);
var appendType = buildAppendEventOperation(options.EventGraph, assembly);
builderType.MethodFor(nameof(EventDocumentStorage.AppendEvent))
.Frames.Code($"return new Marten.Generated.AppendEventOperation(stream, e);");
var insertType = buildInsertStream(builderType, assembly, options.EventGraph);
var streamQueryHandlerType = buildStreamQueryHandlerType(options.EventGraph, assembly);
buildQueryForStreamMethod(options.EventGraph, builderType);
var updateType = buildUpdateStreamVersion(builderType, assembly, options.EventGraph);
var compiler = new AssemblyGenerator();
compiler.ReferenceAssembly(typeof(IMartenSession).Assembly);
compiler.Compile(assembly);
var writer = new StringWriter();
writer.WriteLine($" // {streamQueryHandlerType.TypeName}");
writer.WriteLine(streamQueryHandlerType.SourceCode);
writer.WriteLine();
writer.WriteLine($" // {insertType.TypeName}");
writer.WriteLine(insertType.SourceCode);
writer.WriteLine();
writer.WriteLine($" // {appendType.TypeName}");
writer.WriteLine(appendType.SourceCode);
writer.WriteLine();
writer.WriteLine($" // {updateType.TypeName}");
writer.WriteLine(updateType.SourceCode);
writer.WriteLine();
writer.WriteLine($" // {builderType.TypeName}");
writer.WriteLine(builderType.SourceCode);
writer.WriteLine();
var code = writer.ToString();
var storage = (EventDocumentStorage)Activator.CreateInstance(builderType.CompiledType, options);
return(storage, code);
}
public void GenerateResolver(GeneratedAssembly generatedAssembly)
{
if (_resolverType != null)
{
return; // got some kind of loop in here we need to short circuit
}
if (ErrorMessages.Any() || Dependencies.SelectMany(x => x.ErrorMessages).Any())
{
return;
}
var typeName = (ServiceType.FullNameInCode() + "_" + Name).Sanitize();
_resolverType = generatedAssembly.AddType(typeName, ResolverBaseType.MakeGenericType(ServiceType));
foreach (var relatedAssembly in relatedAssemblies())
{
generatedAssembly.ReferenceAssembly(relatedAssembly);
}
var method = _resolverType.MethodFor("Build");
var frame = CreateBuildFrame();
method.Frames.Add(frame);
}
public void should_not_be_using_service_provider()
{
var container = new Container(x => {
x.AddDbContext <InputDbContext>(builder =>
{
builder.UseSqlServer("some connection string");
}, optionsLifetime: ServiceLifetime.Singleton);
});
var rules = new GenerationRules();
var source = container.CreateServiceVariableSource();
var assembly = new GeneratedAssembly(rules);
var handler = assembly.AddType("SpecialHandler", typeof(Handler));
var handleMethod = handler.MethodFor(nameof(Handler.Handle));
var save = MethodCall.For <InputDbContext>(x => x.Add <Input>(null));
handleMethod.Frames.Add(save);
var code = assembly.GenerateCode(source);
code.ShouldNotContain("ServiceProvider");
}
public void generate_code_with_base_type_that_is_generic()
{
var assembly = new GeneratedAssembly(new GenerationRules());
var type = assembly.AddType("SomeClass", typeof(ClassWithGenericParameter <string>));
assembly.CompileAll();
}
private GeneratedType buildProviderType(GeneratedAssembly assembly, GeneratedType queryOnly,
GeneratedType bulkWriterType, GeneratedType lightweight, GeneratedType identityMap,
GeneratedType dirtyTracking)
{
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);
return(providerType);
}
/// <summary>
/// Generate a new method for the basic base class. The base class "TObject" should
/// only have a single declared method
/// </summary>
/// <param name="configuration"></param>
/// <param name="rules"></param>
/// <typeparam name="TObject"></typeparam>
/// <returns></returns>
public static CodegenResult <TObject> ForBaseOf <TObject>(Action <GeneratedType, GeneratedMethod> configuration, GenerationRules rules = null)
{
if (typeof(TObject).GetMethods().Length != 1)
{
throw new ArgumentOutOfRangeException(nameof(TObject), "The supplied base type or interface can only have exactly one declared method");
}
rules = rules ?? new GenerationRules("LamarCodegenScenario");
var assembly = new GeneratedAssembly(rules);
if (typeof(TObject).IsGenericType)
{
foreach (var genericTypeArgument in typeof(TObject).GenericTypeArguments)
{
rules.Assemblies.Fill(genericTypeArgument.Assembly);
}
}
var generatedType = assembly.AddType("GeneratedType", typeof(TObject));
var method = generatedType.Methods.Single();
configuration(generatedType, method);
new AssemblyGenerator().Compile(assembly);
return(new CodegenResult <TObject>(generatedType.CreateInstance <TObject>(), generatedType.SourceCode));
}
internal void Compile()
{
_assembly = new GeneratedAssembly(new GenerationRules("Marten.Generated"));
_assembly.Generation.Assemblies.Add(GetType().Assembly);
_assembly.Generation.Assemblies.AddRange(_projectMethods.ReferencedAssemblies());
_assembly.Generation.Assemblies.AddRange(_createMethods.ReferencedAssemblies());
_assembly.Namespaces.Add("System.Linq");
_isAsync = _createMethods.IsAsync || _projectMethods.IsAsync;
var baseType = _isAsync ? typeof(AsyncEventProjection <>) : typeof(SyncEventProjection <>);
baseType = baseType.MakeGenericType(GetType());
_inlineType = _assembly.AddType(GetType().Name.Sanitize() + "GeneratedInlineProjection", baseType);
var method = _inlineType.MethodFor("ApplyEvent");
method.DerivedVariables.Add(new Variable(GetType(), "Projection"));
var eventHandling = MethodCollection.AddEventHandling(null, null, _createMethods, _projectMethods);
method.Frames.Add(eventHandling);
var assemblyGenerator = new AssemblyGenerator();
assemblyGenerator.ReferenceAssembly(typeof(IMartenSession).Assembly);
assemblyGenerator.Compile(_assembly);
}
private static GeneratedType buildAppendEventOperation(EventGraph graph, GeneratedAssembly assembly)
{
var operationType = assembly.AddType("AppendEventOperation", typeof(AppendEventOperationBase));
var configure = operationType.MethodFor(nameof(AppendEventOperationBase.ConfigureCommand));
configure.DerivedVariables.Add(new Variable(typeof(IEvent), nameof(AppendEventOperationBase.Event)));
configure.DerivedVariables.Add(new Variable(typeof(StreamAction), nameof(AppendEventOperationBase.Stream)));
var columns = new EventsTable(graph).SelectColumns()
// Hokey, use an explicit model for writeable vs readable columns some day
.Where(x => !(x is IsArchivedColumn)).ToList();
var sql =
$"insert into {graph.DatabaseSchemaName}.mt_events ({columns.Select(x => x.Name).Join(", ")}) values ({columns.Select(_ => "?").Join(", ")})";
configure.Frames.Code($"var parameters = {{0}}.{nameof(CommandBuilder.AppendWithParameters)}(\"{sql}\");",
Use.Type <CommandBuilder>());
for (var i = 0; i < columns.Count; i++)
{
columns[i].GenerateAppendCode(configure, graph, i);
}
return(operationType);
}
/// <summary>
/// Generate a new method for the basic base class. The base class "TObject" should
/// only have a single declared method
/// </summary>
/// <param name="configuration"></param>
/// <param name="rules"></param>
/// <typeparam name="TObject"></typeparam>
/// <returns></returns>
private static CodegenResult <TObject> ForBaseOf <TObject>(Action <GeneratedType, GeneratedMethod> configuration)
{
if (typeof(TObject).GetMethods().Length != 1)
{
throw new ArgumentOutOfRangeException(nameof(TObject), "The supplied base type or interface can only have exactly one declared method");
}
var rules = Builder.Rules();
var assembly = new GeneratedAssembly(rules);
var generatedType = assembly.AddType("Tests", "GeneratedType", typeof(TObject));
var method = generatedType.Methods.Single();
configuration(generatedType, method);
var generator = new AssemblyGenerator(new NullLogger <AssemblyGenerator>(), new InMemoryOnlyCompileStrategy(new NullLogger <InMemoryOnlyCompileStrategy>()));
if (typeof(TObject).IsGenericType)
{
foreach (var genericTypeArgument in typeof(TObject).GenericTypeArguments)
{
generator.ReferenceAssembly(genericTypeArgument.Assembly);
}
}
assembly.CompileAll(generator);
return(new CodegenResult <TObject>(generatedType.CreateInstance <TObject>(), generatedType.SourceCode));
}
public void write_method()
{
// SAMPLE: write-new-method
// Configures the code generation rules
// and policies
var rules = new GenerationRules("GeneratedNamespace");
// Adds the "now : DateTime" variable rule to
// our generated code
rules.Sources.Add(new NowTimeVariableSource());
// Start the definition for a new generated assembly
var assembly = new GeneratedAssembly(rules);
// Add a new generated type called "WhatTimeIsIt" that will
// implement the
var type = assembly.AddType("WhatTimeIsIt", typeof(ISaySomething));
// Getting the definition for the method named "Speak"
var method = type.MethodFor(nameof(ISaySomething.Speak));
// Adding a frame that calls the NowSpeaker.Speak() method and
// adding it to the generated method
var @call = new MethodCall(typeof(NowSpeaker), nameof(NowSpeaker.Speak));
method.Frames.Add(@call);
// Compile the new code!
assembly.CompileAll();
// ENDSAMPLE
// Write the generated code to the console here
_output.WriteLine(type.SourceCode);
}
public void AssembleTypes(GeneratedAssembly assembly)
{
_type = assembly.AddType(TypeName, typeof(IGreeter));
var method = _type.MethodFor(nameof(IGreeter.Greetings));
method.Frames.Code($"return \"{FileName}\";");
}
public static EventDocumentStorage GenerateStorage(StoreOptions options)
{
var assembly = new GeneratedAssembly(new GenerationRules("Marten.Generated"));
assembly.ReferenceAssembly(typeof(EventGraph).Assembly);
var builderType = assembly.AddType("GeneratedEventDocumentStorage", typeof(EventDocumentStorage));
buildSelectorMethods(options, builderType);
buildAppendEventOperation(options.Events, assembly);
builderType.MethodFor(nameof(EventDocumentStorage.AppendEvent))
.Frames.Code($"return new Marten.Generated.AppendEventOperation(stream, e);");
buildInsertStream(builderType, assembly, options.Events);
var streamQueryHandlerType = buildStreamQueryHandlerType(options.Events, assembly);
buildQueryForStreamMethod(options.Events, builderType);
buildUpdateStreamVersion(builderType, assembly, options.Events);
var compiler = new AssemblyGenerator();
compiler.ReferenceAssembly(typeof(IMartenSession).Assembly);
compiler.Compile(assembly);
var code = streamQueryHandlerType.SourceCode;
return((EventDocumentStorage)Activator.CreateInstance(builderType.CompiledType, options));
}
public void GenerateResolver(GeneratedAssembly generatedAssembly)
{
if (_resolverType != null)
{
return; // got some kind of loop in here we need to short circuit
}
if (ErrorMessages.Any() || Dependencies.SelectMany(x => x.ErrorMessages).Any())
{
return;
}
var typeName = (ServiceType.FullNameInCode() + "_" + Name).Sanitize();
var buildType = ServiceType.MustBeBuiltWithFunc() || ImplementationType.MustBeBuiltWithFunc()
? typeof(object)
: ServiceType;
_resolverType = generatedAssembly.AddType(typeName, ResolverBaseType.MakeGenericType(buildType));
var method = _resolverType.MethodFor("Build");
var frame = CreateBuildFrame();
method.Frames.Add(frame);
}
private static GeneratedType buildStreamQueryHandlerType(EventGraph graph, GeneratedAssembly assembly)
{
var streamQueryHandlerType =
assembly.AddType(StreamStateSelectorTypeName, typeof(StreamStateQueryHandler));
streamQueryHandlerType.AllInjectedFields.Add(graph.StreamIdentity == StreamIdentity.AsGuid
? new InjectedField(typeof(Guid), "streamId")
: new InjectedField(typeof(string), "streamId"));
buildConfigureCommandMethodForStreamState(graph, streamQueryHandlerType);
var sync = streamQueryHandlerType.MethodFor("Resolve");
var async = streamQueryHandlerType.MethodFor("ResolveAsync");
sync.Frames.Add(new ConstructorFrame <StreamState>(() => new StreamState()));
async.Frames.Add(new ConstructorFrame <StreamState>(() => new StreamState()));
if (graph.StreamIdentity == StreamIdentity.AsGuid)
{
sync.AssignMemberFromReader <StreamState>(streamQueryHandlerType, 0, x => x.Id);
async.AssignMemberFromReaderAsync <StreamState>(streamQueryHandlerType, 0, x => x.Id);
}
else
{
sync.AssignMemberFromReader <StreamState>(streamQueryHandlerType, 0, x => x.Key);
async.AssignMemberFromReaderAsync <StreamState>(streamQueryHandlerType, 0, x => x.Key);
}
sync.AssignMemberFromReader <StreamState>(streamQueryHandlerType, 1, x => x.Version);
async.AssignMemberFromReaderAsync <StreamState>(streamQueryHandlerType, 1, x => x.Version);
sync.Frames.Call <StreamStateQueryHandler>(x => x.SetAggregateType(null, null, null), call =>
{
call.IsLocal = true;
});
#pragma warning disable 4014
async.Frames.Call <StreamStateQueryHandler>(
x => x.SetAggregateTypeAsync(null, null, null, CancellationToken.None), call =>
#pragma warning restore 4014
{
call.IsLocal = true;
});
sync.AssignMemberFromReader <StreamState>(streamQueryHandlerType, 3, x => x.LastTimestamp);
async.AssignMemberFromReaderAsync <StreamState>(streamQueryHandlerType, 3, x => x.LastTimestamp);
sync.AssignMemberFromReader <StreamState>(streamQueryHandlerType, 4, x => x.Created);
async.AssignMemberFromReaderAsync <StreamState>(streamQueryHandlerType, 4, x => x.Created);
sync.AssignMemberFromReader <StreamState>(streamQueryHandlerType, 5, x => x.IsArchived);
async.AssignMemberFromReaderAsync <StreamState>(streamQueryHandlerType, 5, x => x.IsArchived);
sync.Frames.Return(typeof(StreamState));
async.Frames.Return(typeof(StreamState));
return(streamQueryHandlerType);
}
private void buildInlineAggregationType()
{
var inlineBaseType =
typeof(AggregationRuntime <,>).MakeGenericType(typeof(T), _aggregateMapping.IdType);
_inlineType = _assembly.AddType(GetType().NameInCode().Sanitize() + "InlineHandler", inlineBaseType);
_createMethods.BuildCreateMethod(_inlineType, _aggregateMapping);
_inlineType.AllInjectedFields.Add(new InjectedField(GetType()));
buildApplyEventMethod();
_inlineType.Setters.AddRange(_applyMethods.Setters());
_inlineType.Setters.AddRange(_createMethods.Setters());
_inlineType.Setters.AddRange(_shouldDeleteMethods.Setters());
}
public void generate_code_with_base_type_that_is_generic_using_an_inner_type_as_the_parameter()
{
var assembly = new GeneratedAssembly(new GenerationRules());
var type = assembly.AddType("SomeClass", typeof(ClassWithGenericParameter <SomeInnerClass>));
assembly.CompileAll();
_output.WriteLine(type.SourceCode);
}
public void AssembleType(GeneratedAssembly generatedAssembly)
{
_generatedType = generatedAssembly.AddType(TypeName, typeof(MessageHandler));
var handleMethod = _generatedType.MethodFor(nameof(MessageHandler.Handle));
handleMethod.Sources.Add(new MessageHandlerVariableSource(MessageType));
handleMethod.Frames.AddRange(DetermineFrames());
handleMethod.DerivedVariables.Add(new Variable(typeof(Envelope), $"context.{nameof(IInvocationContext.Envelope)}"));
}
public void can_use_Task_as_the_class_name()
{
var assembly = new GeneratedAssembly(new GenerationRules());
var type = assembly.AddType("Task", typeof(Thing));
var method = type.MethodFor("Do").Frames.Code("// stuff");
assembly.CompileAll();
_output.WriteLine(type.SourceCode);
}
public void AssemblyType(GeneratedAssembly generatedAssembly, ConnegRules rules)
{
_generatedType = generatedAssembly.AddType(TypeName, typeof(RouteHandler));
var handleMethod = _generatedType.MethodFor(nameof(RouteHandler.Handle));
handleMethod.Frames.AddRange(DetermineFrames(rules));
handleMethod.Sources.Add(new ContextVariableSource());
handleMethod.DerivedVariables.AddRange(HttpContextVariables);
}
internal void AssembleType(GenerationRules rules, GeneratedAssembly generatedAssembly, IContainer container)
{
_generatedType = generatedAssembly.AddType(TypeName, typeof(MessageHandler));
var handleMethod = _generatedType.MethodFor(nameof(MessageHandler.Handle));
handleMethod.Sources.Add(new MessageHandlerVariableSource(MessageType));
handleMethod.Frames.AddRange(DetermineFrames(rules, container));
handleMethod.DerivedVariables.Add(new Variable(typeof(Envelope),
$"context.{nameof(IMessageContext.Envelope)}"));
}
public void AssembleType(GeneratedAssembly generatedAssembly, JasperGenerationRules rules)
{
_generatedType = generatedAssembly.AddType(TypeName, typeof(MessageHandler));
var handleMethod = _generatedType.MethodFor(nameof(MessageHandler.Handle));
handleMethod.Sources.Add(new MessageHandlerVariableSource(MessageType));
handleMethod.Frames.AddRange(DetermineFrames(rules));
handleMethod.DerivedVariables.Add(new Variable(typeof(Envelope), $"context.{nameof(IMessageContext.Envelope)}"));
handleMethod.DerivedVariables.Add(new Variable(typeof(IAdvancedMessagingActions), $"context.{nameof(IMessageContext.Advanced)}"));
}
public void do_not_do_a_stackoverflow_here()
{
var assembly = new GeneratedAssembly(new GenerationRules("Jasper.Generated"));
var type = assembly.AddType("MyGuy", typeof(IHandler));
var method = type.MethodFor("Go");
method.Frames.Add(new CustomFrame());
method.Frames.Add(new CustomFrame());
method.Frames.Add(new CustomFrame());
assembly.CompileAll();
}
internal static ILiveAggregator <T> Build <T>(StoreOptions options)
{
var mapping = options.Storage.MappingFor(typeof(T));
var assembly = new GeneratedAssembly(new GenerationRules("Marten.Generated"));
var applyMethods = new ApplyMethodCollection(typeof(T), typeof(T));
// TODO -- this doesn't do very much right now.
var createMethods = new CreateMethodCollection(typeof(T), typeof(T));
assembly.Generation.Assemblies.Add(typeof(IMartenSession).Assembly);
assembly.Generation.Assemblies.AddRange(applyMethods.ReferencedAssemblies());
assembly.Generation.Assemblies.AddRange(createMethods.ReferencedAssemblies());
var isAsync = applyMethods.IsAsync;
assembly.Namespaces.Add("System.Linq");
var liveBaseType = isAsync
? typeof(AsyncLiveAggregatorBase <>)
: typeof(SyncLiveAggregatorBase <>);
liveBaseType = liveBaseType.MakeGenericType(typeof(T));
var liveType = assembly.AddType(typeof(T).NameInCode().Sanitize() + "LiveAggregation", liveBaseType);
var overrideMethodName = isAsync ? "BuildAsync" : "Build";
var buildMethod = liveType.MethodFor(overrideMethodName);
// TODO -- use constructor functions later
// TODO -- use static Create() methods
// TODO -- validate that there is some way to create the aggregate
buildMethod.Frames.Code("if (!events.Any()) return null;");
buildMethod.Frames.Add(new CallCreateAggregateFrame(createMethods));
buildMethod.Frames.Add(new CallApplyAggregateFrame(applyMethods)
{
InsideForEach = true
});
buildMethod.Frames.Return(typeof(T));
createMethods.BuildCreateMethod(liveType, mapping);
applyMethods.BuildApplyMethod(liveType, mapping);
var assemblyGenerator = new AssemblyGenerator();
assemblyGenerator.ReferenceAssembly(typeof(IMartenSession).Assembly);
assemblyGenerator.Compile(assembly);
return((ILiveAggregator <T>)Activator.CreateInstance(liveType.CompiledType));
}
public void AssemblySelector(GeneratedAssembly assembly, RouteGraph routes)
{
_generatedType = assembly.AddType(HttpMethod + "Router", typeof(RouteSelector));
foreach (var route in routes.Where(x => x.RespondsToMethod(HttpMethod)))
{
route.WriteRouteMatchMethod(_generatedType);
}
var method = _generatedType.MethodFor(nameof(RouteSelector.Select));
method.Frames.Add(new FindRouteFrame(this, routes));
}
public void write_footer_into_source_code()
{
var assembly = new GeneratedAssembly(new GenerationRules());
var type = assembly.AddType("SomeClass", typeof(ClassWithGenericParameter <SomeInnerClass>));
type.Footer = new OneLineComment("Hey, look at this!");
assembly.CompileAll();
type.SourceCode.ReadLines()
.ShouldContain(" // Hey, look at this!");
_output.WriteLine(type.SourceCode);
}
public void Setup()
{
var generatedAssembly = new GeneratedAssembly(new GenerationRules {
AssemblyName = "Blueprint.Benchmarks.MethodCallBenchmarks"
});
var generatedType = generatedAssembly.AddType("Blueprint.Benchmarks", "MethodTester", typeof(object));
generatedMethod = generatedType.AddVoidMethod("Test");
sourceWriter = new SourceWriter
{
IndentationLevel = 1,
};
}
