コード例 #1
0
 public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
 {
     writer.Write($"BLOCK:using (var {_session.Usage} = {_store.Usage}.OpenSession())");
     Next?.GenerateCode(method, writer);
     writer.Write($"{_session.Usage}.{nameof(IFakeSession.SaveChanges)}();");
     writer.FinishBlock();
 }
コード例 #2
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            var arguments = _arguments.Select(x => x.Usage).Join(", ");
            var implementationTypeName = ImplementationType.FullName.Replace("+", ".");

            var declaration = $"var {Variable.Usage} = new {implementationTypeName}({arguments})";

            if (IsDisposable)
            {
                if (Next is ConstructorFrame && Next.As <ConstructorFrame>().IsDisposable)
                {
                    writer.Write($"using ({declaration})");
                    Next?.GenerateCode(method, writer);
                }
                else
                {
                    writer.UsingBlock(declaration, w => Next?.GenerateCode(method, w));
                }
            }
            else
            {
                writer.Write(declaration + ";");
                Next?.GenerateCode(method, writer);
            }
        }
コード例 #3
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            if (_sagaIdProperty.PropertyType == typeof(string))
            {
                writer.Write(
                    $"{_sagaIdProperty.PropertyType.NameInCode()} {SagaFramePolicy.SagaIdVariableName} = {_envelope.Usage}.{nameof(Envelope.SagaId)} ?? {_message.Usage}.{_sagaIdProperty.Name};");
                writer.Write(
                    $"if (string.{nameof(string.IsNullOrEmpty)}({SagaFramePolicy.SagaIdVariableName})) throw new {typeof(IndeterminateSagaStateIdException).FullName}({_envelope.Usage});");
            }
            else
            {
                var typeNameInCode = _sagaIdProperty.PropertyType == typeof(Guid)
                    ? typeof(Guid).FullName
                    : _sagaIdProperty.PropertyType.NameInCode();


                writer.Write(
                    $"if (!{typeNameInCode}.TryParse({_envelope.Usage}.{nameof(Envelope.SagaId)}, out {typeNameInCode} sagaId)) sagaId = {_message.Usage}.{_sagaIdProperty.Name};");

                if (_sagaIdProperty.PropertyType == typeof(Guid))
                {
                    writer.Write(
                        $"if ({SagaId.Usage} == System.Guid.Empty) throw new {typeof(IndeterminateSagaStateIdException).FullName}({_envelope.Usage});");
                }
                else
                {
                    writer.Write(
                        $"if ({SagaId.Usage} == 0) throw new {typeof(IndeterminateSagaStateIdException).FullName}({_envelope.Usage});");
                }
            }


            // TODO -- set the SagaId on message context?
            Next?.GenerateCode(method, writer);
        }
コード例 #4
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            if (_createsSession)
            {
                writer.Write($"BLOCK:using (var {Session.Usage} = {_store.Usage}.{nameof(IDocumentStore.LightweightSession)}())");
            }

            if (_context != null && _isUsingPersistence)
            {
                writer.Write($"await {typeof(MessageContextExtensions).FullName}.{nameof(MessageContextExtensions.EnlistInTransaction)}({_context.Usage}, {Session.Usage});");
            }

            foreach (var loaded in _loadedDocs)
            {
                loaded.Write(writer, Session);
            }

            Next?.GenerateCode(method, writer);


            foreach (var saved in _saved)
            {
                writer.Write($"{Session.Usage}.{nameof(IDocumentSession.Store)}({saved.Usage});");
            }

            writer.Write($"await {Session.Usage}.{nameof(IDocumentSession.SaveChangesAsync)}();");

            if (_createsSession)
            {
                writer.FinishBlock();
            }
        }
コード例 #5
0
        public void WriteMethod(ISourceWriter writer)
        {
            var returnValue = AsyncMode == AsyncMode.AsyncTask
                ? "async Task"
                : "Task";

            if (Overrides)
            {
                returnValue = "override " + returnValue;
            }

            var arguments = Arguments.Select(x => x.Declaration).Join(", ");

            writer.Write($"BLOCK:public {returnValue} {MethodName}({arguments})");


            Top.GenerateCode(this, writer);

            if (AsyncMode == AsyncMode.ReturnCompletedTask)
            {
                writer.Write("return Task.CompletedTask;");
            }

            writer.FinishBlock();
        }
コード例 #6
0
 public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
 {
     writer.Write($"BLOCK:using (var {Session.Usage} = {_store.Usage}.{nameof(IDocumentStore.OpenSession)}())");
     Next?.GenerateCode(method, writer);
     writer.Write($"await {Session.Usage}.{nameof(IDocumentSession.SaveChangesAsync)}();");
     writer.FinishBlock();
 }
コード例 #7
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            var arguments = _arguments.Select(x => x.Usage).Join(", ");

            if (ReturnCreated)
            {
                writer.Write($"return {_func.Usage}({arguments});");
                Next?.GenerateCode(method, writer);
                return;
            }

            var declaration = $"var {Variable.Usage} = {_func.Usage}({arguments})";

            switch (Disposal)
            {
            case DisposeTracking.None:
                writer.Write(declaration + ";");
                Next?.GenerateCode(method, writer);
                break;

            case DisposeTracking.WithUsing:
                writer.UsingBlock(declaration, w => Next?.GenerateCode(method, w));

                break;

            case DisposeTracking.RegisterWithScope:
                writer.Write(declaration + ";");
                writer.Write($"{_scope.Usage}.{nameof(Scope.TryAddDisposable)}({Variable.Usage});");
                Next?.GenerateCode(method, writer);
                break;
            }
        }
コード例 #8
0
        private void writeDeclaration(ISourceWriter writer)
        {
            var implemented = implements().ToArray();

            if (implemented.Any())
                writer.Write(
                    $"BLOCK:public class {TypeName} : {implemented.Select(x => x.FullNameInCode()).Join(", ")}");
            else
                writer.Write($"BLOCK:public class {TypeName}");
        }
コード例 #9
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            writer.Write($"BLOCK:if ({_handler.Usage}.{nameof(StatefulSagaOf<string>.IsCompleted)})");
            writer.Write($"{_session.Usage}.{nameof(IDocumentSession.Delete)}({_document.Usage});");
            writer.FinishBlock();
            writer.Write("BLOCK:else");
            writer.Write($"{_session.Usage}.{nameof(IDocumentSession.Store)}({_document.Usage});");
            writer.FinishBlock();

            Next?.GenerateCode(method, writer);
        }
コード例 #10
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            writer.Write($"BLOCK:if ({_handler.Usage}.{nameof(StatefulSagaOf<string>.IsCompleted)})");
            writer.Write($"{_persistor.Usage}.{nameof(InMemorySagaPersistor.Delete)}<{_document.VariableType.FullNameInCode()}>({_document.Usage}.Id);");
            writer.FinishBlock();
            writer.Write("BLOCK:else");
            writer.Write($"{_persistor.Usage}.{nameof(InMemorySagaPersistor.Store)}({_document.Usage});");
            writer.FinishBlock();

            Next?.GenerateCode(method, writer);
        }
コード例 #11
0
 /// <summary>
 /// Writes the declaration of a new class to the source writer
 /// </summary>
 /// <param name="writer"></param>
 /// <param name="className"></param>
 /// <param name="inheritsOrImplements"></param>
 public static void StartClass(this ISourceWriter writer, string className, params Type[] inheritsOrImplements)
 {
     if (inheritsOrImplements.Length == 0)
     {
         writer.Write($"BLOCK:public class {className}");
     }
     else
     {
         writer.Write($"BLOCK:public class {className} : {inheritsOrImplements.Select(x => x.FullNameInCode()).Join(", ")}");
     }
 }
コード例 #12
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            writer.Write($"var {Persistor.Usage} = new {typeof(InMemoryEnvelopeTransaction).FullNameInCode()}();");
            writer.Write($"await {_context.Usage}.{nameof(IMessageContext.EnlistInTransaction)}({Persistor.Usage});");


            if (_existence == SagaStateExistence.Existing)
            {
                writer.Write($"var {Document.Usage} = {_persistor.Usage}.{nameof(InMemorySagaPersistor.Load)}<{Document.VariableType.FullNameInCode()}>({_sagaId.Usage});");
            }

            Next?.GenerateCode(method, writer);
        }
コード例 #13
0
        public override void GenerateCode(IGenerationModel generationModel, ISourceWriter writer)
        {
            var callingCode = $"{Method.Name}({_variables.Select(x => x.Usage).Join(", ")})";
            var target      = Method.IsStatic
                ? HandlerType.NameInCode()
                : _target.Usage;

            var returnValue = "";
            var suffix      = "";

            if (IsAsync)
            {
                if (generationModel.AsyncMode == AsyncMode.ReturnFromLastNode)
                {
                    returnValue = "return ";
                }
                else
                {
                    returnValue = "await ";
                    suffix      = ".ConfigureAwait(false)";
                }
            }

            if (ReturnVariable != null)
            {
                returnValue = $"var {ReturnVariable.Usage} = {returnValue}";
            }

            // TODO -- will need to see if it's IDisposable too

            writer.Write($"{returnValue}{target}.{callingCode}{suffix};");

            Next?.GenerateCode(generationModel, writer);
        }
コード例 #14
0
 public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
 {
     writer.BlankLine();
     writer.WriteComment($"From {nameof(BuildClientFrame)}");
     writer.Write($"var {Client.Usage} = {_factory.Usage}.{nameof(IHttpClientFactory.CreateClient)}(\"{_interfaceType.Name}\");");
     Next?.GenerateCode(method, writer);
 }
コード例 #15
0
 public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
 {
     writer.BlankLine();
     writer.WriteComment($"From {nameof(FillUrlFrame)}");
     writer.Write($"var {Url.Usage} = $\"{Pattern}\";");
     Next?.GenerateCode(method, writer);
 }
コード例 #16
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            var invokeMethod = invocationCode();

            var returnValue = "";

            if (IsAsync)
            {
                returnValue = method.AsyncMode == AsyncMode.ReturnFromLastNode ? "return " : "await ";
            }

            var isDisposable = false;

            if (shouldAssignVariableToReturnValue(method))
            {
                returnValue  = ReturnVariable.VariableType.IsValueTuple() ? $"{ReturnVariable.Usage} = {returnValue}" : $"var {ReturnVariable.Usage} = {returnValue}";
                isDisposable = ReturnVariable.VariableType.CanBeCastTo <IDisposable>();
            }

            if (isDisposable && DisposalMode == DisposalMode.UsingBlock)
            {
                writer.UsingBlock($"{returnValue}{invokeMethod}", w => Next?.GenerateCode(method, writer));
            }
            else
            {
                writer.Write($"{returnValue}{invokeMethod};");

                Next?.GenerateCode(method, writer);
            }
        }
コード例 #17
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            var declaration = $"{typeof(List<>).Namespace}.List<{ElementType.FullNameInCode()}>";

            var elements = Elements.Select(x => x.Usage).Join(", ");

            if (ReturnCreated)
            {
                writer.Write($"return new {declaration}{{{elements}}};");
            }
            else
            {
                writer.Write($"var {Variable.Usage} = new {declaration}{{{elements}}};");
            }
            Next?.GenerateCode(method, writer);
        }
コード例 #18
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            writer.WriteComment("Check if the saga has been completed");
            writer.Write($"BLOCK:if ({_handler.Usage}.{nameof(StatefulSagaOf<string>.IsCompleted)})");
            writer.WriteComment("Delete the saga state entity");
            writer.Write($"{_context.Usage}.{nameof(DbContext.Remove)}({_state.Usage});");
            writer.FinishBlock();
//            writer.Write("BLOCK:else");
//            writer.WriteComment("Persist the saga state entity");
//            writer.Write($"{_context.Usage}.{nameof(DbContext.Add)}({_state.Usage});");
//            writer.FinishBlock();

            writer.BlankLine();

            Next?.GenerateCode(method, writer);
        }
コード例 #19
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            writer.Write($"case {SpecificEvent.VariableType.FullNameInCode()} {SpecificEvent.Usage}:");
            // TODO -- fix this with LamarCodeGeneration
            writer.As <SourceWriter>().IndentionLevel++;

            foreach (var frame in _inner)
            {
                frame.GenerateCode(method, writer);
            }

            writer.Write("break;");
            writer.As <SourceWriter>().IndentionLevel--;

            Next?.GenerateCode(method, writer);
        }
コード例 #20
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            var elements = Elements.Select(x => x.Usage).Join(", ");

            writer.Write($"var {Variable.Usage} = new {ElementType.FullNameInCode()}[]{{{elements}}};");
            Next?.GenerateCode(method, writer);
        }
コード例 #21
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            if (InsideForEach)
            {
                writer.Write("BLOCK:foreach (var @event in events)");
            }

            if (IsAsync)
            {
                writer.WriteLine(
                    $"{_aggregate.Usage} = await {ApplyMethodCollection.MethodName}(@event, {_aggregate.Usage}, {_session.Usage}, {_cancellation.Usage});");
            }
            else
            {
                writer.WriteLine(
                    $"{_aggregate.Usage} = {ApplyMethodCollection.MethodName}(@event, {_aggregate.Usage}, {_session.Usage});");
            }

            if (InsideForEach)
            {
                writer.FinishBlock();
            }

            Next?.GenerateCode(method, writer);
        }
コード例 #22
0
 public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
 {
     writer.Write(
         $"BLOCK:using (var {Session.Usage} = {_store.Usage}.{nameof(IDocumentStore.LightweightSession)}())");
     Next?.GenerateCode(method, writer);
     writer.FinishBlock();
 }
コード例 #23
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            if (SagaId.VariableType == typeof(string))
            {
                writer.Write($"var {SagaId.Usage} = {_envelope.Usage}.{nameof(Envelope.SagaId)};");
                writer.Write($"if (string.{nameof(string.IsNullOrEmpty)}({SagaFramePolicy.SagaIdVariableName})) throw new {typeof(IndeterminateSagaStateIdException).FullName}({_envelope.Usage});");
            }
            else
            {
                var typeNameInCode = SagaId.VariableType == typeof(Guid) ? typeof(Guid).FullName : SagaId.VariableType.NameInCode();

                writer.Write($"if (!{typeNameInCode}.TryParse({_envelope.Usage}.{nameof(Envelope.SagaId)}, out {typeNameInCode} sagaId)) throw new {typeof(IndeterminateSagaStateIdException).FullName}({_envelope.Usage});");
            }

            Next?.GenerateCode(method, writer);
        }
コード例 #24
0
 public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
 {
     writer.Write(
         $"BLOCK:using ({_instance.ServiceType.FullNameInCode()} {Connection.Usage} = new {typeof(SqlConnection).FullName}({_settings.Usage}.{nameof(SqlServerSettings.ConnectionString)}))");
     Next?.GenerateCode(method, writer);
     writer.FinishBlock();
 }
コード例 #25
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            if (CommentText.IsNotEmpty())
            {
                writer.WriteComment(CommentText);
            }

            var invokeMethod = InvocationCode(method);

            if (shouldWriteInUsingBlock(method))
            {
                writer.UsingBlock($"{returnActionCode(method)}{invokeMethod}", w => Next?.GenerateCode(method, writer));
            }
            else
            {
                writer.Write($"{returnActionCode(method)}{invokeMethod};");

                // This is just to make the generated code a little
                // easier to read
                if (CommentText.IsNotEmpty())
                {
                    writer.BlankLine();
                }

                Next?.GenerateCode(method, writer);
            }
        }
コード例 #26
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            writer.Write($"BLOCK:foreach (var @event in {EventIteration})");
            _inner.GenerateCode(method, writer);
            writer.FinishBlock();

            Next?.GenerateCode(method, writer);
        }
コード例 #27
0
            public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
            {
                writer.WriteComment("Enroll the DbContext & IMessagingContext in the outgoing Jasper outbox transaction");
                writer.Write(
                    $"await {typeof(JasperEnvelopeEntityFrameworkCoreExtensions).FullName}.{nameof(JasperEnvelopeEntityFrameworkCoreExtensions.EnlistInTransaction)}({_context.Usage}, {_dbContext.Usage});");

                Next?.GenerateCode(method, writer);
            }
コード例 #28
0
        public static void UsingBlock(this ISourceWriter writer, string declaration, Action <ISourceWriter> inner)
        {
            writer.Write($"BLOCK:using ({declaration})");

            inner(writer);

            writer.FinishBlock();
        }
コード例 #29
0
ファイル: CodeFrame.cs プロジェクト: vlisovych/lamar
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            var substitutions = _values.Select(CodeFormatter.Write).ToArray();
            var code          = string.Format(_format, substitutions);

            // TODO -- It's important to use Write() and not WriteLine() here.
            writer.Write(code);
            Next?.GenerateCode(method, writer);
        }
コード例 #30
0
        public override void GenerateCode(GeneratedMethod method, ISourceWriter writer)
        {
            Maybe.GenerateCode(method, writer);
            writer.Write($"BLOCK:if ({Maybe.ReturnVariable.Usage})");

            writer.WriteLine($"return null;");

            writer.FinishBlock();
        }