public static ApplicationTransport createDefaultHttpApplicationTransport()

in codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/ApplicationTransport.java [77:174]
86 lines of code
2 McCabe index (conditional complexity)

    public static ApplicationTransport createDefaultHttpApplicationTransport() {

        ClientConfig endpoint = (new ClientConfig.Builder())
                .name("endpoint")
                .type("string")
                .documentation("Endpoint of the service")
                .build();

        ClientFragment request = (new ClientFragment.Builder())
                .addConfig(endpoint)
                .render((self, ctx) -> "Seahorse::HTTP::Request.new(url: options.fetch(:endpoint, @endpoint))")
                .build();

        ClientFragment response = (new ClientFragment.Builder())
                .render((self, ctx) -> "Seahorse::HTTP::Response.new(body: output_stream(options, &block))")
                .build();

        ClientConfig wireTrace = (new ClientConfig.Builder())
                .name("http_wire_trace")
                .type("bool")
                .defaultValue("false")
                .documentation("Enable debug wire trace on http requests.")
                .build();

        ClientConfig logger = (new ClientConfig.Builder())
                .name("logger")
                .type("Logger")
                .defaultValue("stdout")
                .initializationCustomization(
                        "@logger = options.fetch(:logger, Logger.new($stdout, level: @log_level))")
                .documentation("Logger to use for output")
                .build();

        ClientConfig logLevel = (new ClientConfig.Builder())
                .name("log_level")
                .type("symbol")
                .defaultValue(":info")
                .documentation("Default log level to use")
                .build();

        ClientFragment client = (new ClientFragment.Builder())
                .addConfig(wireTrace)
                .addConfig(logger)
                .addConfig(logLevel)
                .render((self, ctx) -> "Seahorse::HTTP::Client.new(logger: @logger, http_wire_trace: "
                        + "options.fetch(:http_wire_trace, @http_wire_trace))")
                .build();

        MiddlewareList defaultMiddleware = (transport, context) -> {
            List<Middleware> middleware = new ArrayList();
            middleware.add((new Middleware.Builder())
                    .klass("Seahorse::HTTP::Middleware::ContentLength")
                    .step(MiddlewareStackStep.BUILD)
                    .build()
            );

            middleware.add((new Middleware.Builder())
                    .klass("Seahorse::Middleware::Parse")
                    .step(MiddlewareStackStep.DESERIALIZE)
                    .operationParams((ctx, operation) -> {
                        SymbolProvider symbolProvider =
                                new RubySymbolProvider(ctx.getModel(), ctx.getRubySettings(), "Client", false);

                        Map<String, String> params = new HashMap<>();
                        params.put("data_parser",
                                "Parsers::" + symbolProvider.toSymbol(operation).getName());
                        String successCode = "200";
                        Optional<HttpTrait> httpTrait = operation.getTrait(HttpTrait.class);
                        if (httpTrait.isPresent()) {
                            successCode = "" + httpTrait.get().getCode();
                        }
                        String errors =
                                operation.getErrors().stream().map((error) -> "Errors::"
                                        + symbolProvider.toSymbol(ctx.getModel().expectShape(error)).getName()).collect(
                                        Collectors.joining(", "));
                        params.put("error_parser",
                                "Seahorse::HTTP::ErrorParser.new("
                                        + "error_module: Errors, error_code_fn: "
                                        + "Errors.method(:error_code), "
                                        + "success_status: "
                                        + successCode + ", errors: [" + errors + "]"
                                        + ")"
                        );
                        return params;
                    })
                    .build()
            );

            return middleware;
        };

        return new ApplicationTransport(
                "http",
                request,
                response,
                client,
                defaultMiddleware);
    }