();
+ errorContext.put("code", statusCode);
+ errorContext.put("message", rsp.getDescription());
+ return context().error(evaluationContext, errorContext);
+ }
+
+ private ResponseExt response() {
+ if (statusCode == null) {
+ return operation.getDefaultResponse();
+ } else {
+ var rsp = operation.getResponses().get(Integer.toString(statusCode));
+ if (rsp == null) {
+ if (statusCode >= 200 && statusCode <= 299) {
+ // override default response
+ return operation.getDefaultResponse();
+ }
+ }
+ return (ResponseExt) rsp;
+ }
+ }
+
+ public StatusCode getStatusCode() {
+ if (statusCode == null) {
+ return Optional.ofNullable(response())
+ .map(it -> StatusCode.valueOf(Integer.parseInt(it.getCode())))
+ .orElse(StatusCode.OK);
+ }
+ return StatusCode.valueOf(statusCode);
+ }
+
+ private Schema getBody(ResponseExt response) {
+ return Optional.ofNullable(response)
+ .map(it -> toSchema(it.getContent(), List.of()))
+ .map(context()::resolveSchema)
+ .orElse(null);
+ }
+
+ @NonNull @Override
+ public String toString() {
+ return operation.getMethod() + " " + operation.getPath();
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/Lookup.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/Lookup.java
new file mode 100644
index 0000000000..46feb364f6
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/Lookup.java
@@ -0,0 +1,267 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc;
+
+import java.util.*;
+import java.util.stream.Stream;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+import io.jooby.StatusCode;
+import io.pebbletemplates.pebble.extension.Function;
+import io.pebbletemplates.pebble.template.EvaluationContext;
+import io.pebbletemplates.pebble.template.PebbleTemplate;
+
+/**
+ * GET("path") | table GET("path") | parameters | table
+ *
+ * schema("Book") | json schema("Book.type") | yaml
+ *
+ *
GET("path") | response | json
+ *
+ *
GET("path") | response(200) | json
+ *
+ *
GET("path") | request | json
+ *
+ *
GET("path") | request | http
+ *
+ *
GET("path") | request | body | http
+ */
+public enum Lookup implements Function {
+ operation {
+ @Override
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ var method = args.get("method").toString();
+ var path = args.get("path").toString();
+ var asciidoc = AsciiDocContext.from(context);
+ return asciidoc.getOpenApi().findOperation(method, path);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("method", "path");
+ }
+ },
+ GET {
+ @Override
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ return operation.execute(appendMethod(args), self, context, lineNumber);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("path");
+ }
+ },
+ POST {
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ return operation.execute(appendMethod(args), self, context, lineNumber);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("path");
+ }
+ },
+ PUT {
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ return operation.execute(appendMethod(args), self, context, lineNumber);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("path");
+ }
+ },
+ PATCH {
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ return operation.execute(appendMethod(args), self, context, lineNumber);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("path");
+ }
+ },
+ DELETE {
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ return operation.execute(appendMethod(args), self, context, lineNumber);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("path");
+ }
+ },
+ schema {
+ @Override
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ var path = args.get("path").toString();
+ var asciidoc = AsciiDocContext.from(context);
+ return asciidoc.resolveSchema(path);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("path");
+ }
+
+ @Override
+ public List alias() {
+ return List.of("schema", "model");
+ }
+ },
+ tag {
+ @Override
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ var asciidoc = AsciiDocContext.from(context);
+ var name = args.get("name").toString();
+ return asciidoc.getOpenApi().getTags().stream()
+ .filter(tag -> tag.getName().equalsIgnoreCase(name))
+ .findFirst()
+ .map(
+ it ->
+ new TagExt(
+ it,
+ asciidoc.getOpenApi().findOperationByTag(it.getName()).stream()
+ .map(op -> new HttpRequest(asciidoc, op, Map.of()))
+ .toList()))
+ .orElseThrow(() -> new NoSuchElementException("Tag not found: " + name));
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("name");
+ }
+ },
+ error {
+ @Override
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ var asciidoc = AsciiDocContext.from(context);
+ return asciidoc.error(context, args);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("code");
+ }
+ },
+ routes {
+ @Override
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ var asciidoc = AsciiDocContext.from(context);
+ var operations = asciidoc.getOpenApi().getOperations();
+ var list =
+ operations.stream()
+ .filter(
+ it -> {
+ var includes = (String) args.get("includes");
+ return includes == null || it.getPath().matches(includes);
+ })
+ .map(it -> new HttpRequest(asciidoc, it, args))
+ .toList();
+ return new HttpRequestList(asciidoc, list);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("includes");
+ }
+
+ @Override
+ public List alias() {
+ return List.of("routes", "operations");
+ }
+ },
+ statusCode {
+ @Override
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ var code = args.get("code");
+ if (code instanceof List codes) {
+ return new StatusCodeList(codes.stream().flatMap(this::toMap).toList());
+ }
+ return new StatusCodeList(toMap(code).toList());
+ }
+
+ @NonNull private Stream> toMap(Object candidate) {
+ if (candidate instanceof Number code) {
+ Map map = new LinkedHashMap<>();
+ map.put("code", code.intValue());
+ map.put("reason", StatusCode.valueOf(code.intValue()).reason());
+ return Stream.of(map);
+ } else if (candidate instanceof Map codeMap) {
+ var codes = new ArrayList>();
+ for (var entry : new TreeMap<>(codeMap).entrySet()) {
+ var value = entry.getKey();
+ if (value instanceof Number code) {
+ Map map = new LinkedHashMap<>();
+ map.put("code", code.intValue());
+ map.put("reason", entry.getValue());
+ codes.add(map);
+ } else {
+ throw new ClassCastException("Must be Map: " + candidate);
+ }
+ }
+ return codes.stream();
+ }
+ throw new ClassCastException("Not a number: " + candidate);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("code");
+ }
+ },
+ server {
+ @Override
+ public Object execute(
+ Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+ var asciidoc = AsciiDocContext.from(context);
+ var servers = asciidoc.getOpenApi().getServers();
+ if (servers == null || servers.isEmpty()) {
+ throw new NoSuchElementException("No servers");
+ }
+ var nameOrIndex = args.get("name");
+ if (nameOrIndex instanceof Number index) {
+ if (index.intValue() >= 0 && index.intValue() < servers.size()) {
+ return servers.get(index.intValue());
+ } else {
+ throw new NoSuchElementException("Server not found: [" + nameOrIndex + "]");
+ }
+ } else {
+ return servers.stream()
+ .filter(it -> nameOrIndex.equals(it.getDescription()))
+ .findFirst()
+ .orElseThrow(() -> new NoSuchElementException("Server not found: " + nameOrIndex));
+ }
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("name");
+ }
+ };
+
+ public List alias() {
+ return List.of(name());
+ }
+
+ protected Map appendMethod(Map args) {
+ Map result = new LinkedHashMap<>(args);
+ result.put("method", name());
+ return result;
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/Mutator.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/Mutator.java
new file mode 100644
index 0000000000..3d85d4b458
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/Mutator.java
@@ -0,0 +1,188 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import io.jooby.internal.openapi.OperationExt;
+import io.pebbletemplates.pebble.error.PebbleException;
+import io.pebbletemplates.pebble.extension.Filter;
+import io.pebbletemplates.pebble.template.EvaluationContext;
+import io.pebbletemplates.pebble.template.PebbleTemplate;
+import io.swagger.v3.oas.models.media.Schema;
+
+public enum Mutator implements Filter {
+ example {
+ @Override
+ public Object apply(
+ Object input,
+ Map args,
+ PebbleTemplate self,
+ EvaluationContext context,
+ int lineNumber)
+ throws PebbleException {
+ if (input instanceof Schema schema) {
+ var asciidoc = AsciiDocContext.from(context);
+ return asciidoc.schemaExample(schema);
+ }
+ return input;
+ }
+ },
+ truncate {
+ @Override
+ public Object apply(
+ Object input,
+ Map args,
+ PebbleTemplate self,
+ EvaluationContext context,
+ int lineNumber)
+ throws PebbleException {
+ if (input instanceof Schema schema) {
+ var asciidoc = AsciiDocContext.from(context);
+ return asciidoc.reduceSchema(schema);
+ }
+ return input;
+ }
+ },
+ request {
+ @Override
+ public Object apply(
+ Object input,
+ Map args,
+ PebbleTemplate self,
+ EvaluationContext context,
+ int lineNumber)
+ throws PebbleException {
+ return new HttpRequest(AsciiDocContext.from(context), toOperation(input), args);
+ }
+ },
+ response {
+ @Override
+ public Object apply(
+ Object input,
+ Map args,
+ PebbleTemplate self,
+ EvaluationContext context,
+ int lineNumber)
+ throws PebbleException {
+ return new HttpResponse(
+ context,
+ toOperation(input),
+ Optional.ofNullable(args.get("code"))
+ .map(Number.class::cast)
+ .map(Number::intValue)
+ .orElse(null),
+ args);
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("code");
+ }
+ },
+ parameters {
+ @Override
+ public Object apply(
+ Object input,
+ Map args,
+ PebbleTemplate self,
+ EvaluationContext context,
+ int lineNumber)
+ throws PebbleException {
+ var in = normalizeList(args.getOrDefault("in", "*"));
+ var includes = normalizeList(args.getOrDefault("includes", List.of()));
+ return toHttpRequest(context, input, args).getParameters(in, includes);
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ private List normalizeList(Object value) {
+ if (value instanceof List valueList) {
+ return valueList;
+ }
+ return value == null ? List.of() : List.of(value.toString());
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of("in", "includes");
+ }
+ },
+ body {
+ @Override
+ public Object apply(
+ Object input,
+ Map args,
+ PebbleTemplate self,
+ EvaluationContext context,
+ int lineNumber)
+ throws PebbleException {
+ var bodyType = args.getOrDefault("type", "full");
+ // Handle response a bit different
+ if (input instanceof HttpResponse rsp) {
+ // success or error
+ return rsp.getSucessOrError();
+ }
+ return toHttpMessage(context, input, Map.of("body", bodyType)).getBody();
+ }
+ },
+ form {
+ @Override
+ public Object apply(
+ Object input,
+ Map args,
+ PebbleTemplate self,
+ EvaluationContext context,
+ int lineNumber)
+ throws PebbleException {
+ return toHttpRequest(context, input, args).getForm();
+ }
+ };
+
+ protected OperationExt toOperation(Object input) {
+ return switch (input) {
+ case OperationExt op -> op;
+ case HttpRequest req -> req.operation();
+ case HttpResponse rsp -> rsp.operation();
+ case null -> throw new NullPointerException(name() + ": requires a request/response input");
+ default ->
+ throw new ClassCastException(
+ name() + ": requires a request/response input: " + input.getClass());
+ };
+ }
+
+ protected HttpMessage toHttpMessage(
+ EvaluationContext context, Object input, Map options) {
+ return switch (input) {
+ // default to http request
+ case OperationExt op -> new HttpRequest(AsciiDocContext.from(context), op, options);
+ case HttpMessage msg -> msg;
+ case null -> throw new NullPointerException(name() + ": requires a request/response input");
+ default ->
+ throw new ClassCastException(
+ name() + ": requires a request/response input: " + input.getClass());
+ };
+ }
+
+ protected HttpRequest toHttpRequest(
+ EvaluationContext context, Object input, Map options) {
+ return switch (input) {
+ // default to http request
+ case OperationExt op -> new HttpRequest(AsciiDocContext.from(context), op, options);
+ case HttpRequest msg -> msg;
+ case null -> throw new NullPointerException(name() + ": requires a request/response input");
+ default ->
+ throw new ClassCastException(
+ name() + ": requires a request/response input: " + input.getClass());
+ };
+ }
+
+ @Override
+ public List getArgumentNames() {
+ return List.of();
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/ParameterList.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/ParameterList.java
new file mode 100644
index 0000000000..9cf432b560
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/ParameterList.java
@@ -0,0 +1,51 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc;
+
+import java.util.AbstractList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import io.swagger.v3.oas.models.parameters.Parameter;
+
+@JsonIgnoreProperties({"includes"})
+public class ParameterList extends AbstractList {
+ public static final List NAME_DESC = List.of("name", "description");
+ public static final List NAME_TYPE_DESC = List.of("name", "type", "description");
+ public static final List PARAM = List.of("name", "type", "in", "description");
+ private final List parameters;
+ private final List includes;
+
+ public ParameterList(List parameters, List includes) {
+ this.parameters = parameters;
+ this.includes = includes;
+ }
+
+ public List parameters() {
+ return parameters;
+ }
+
+ public List includes() {
+ return includes;
+ }
+
+ @Override
+ public int size() {
+ return parameters.size();
+ }
+
+ @NonNull @Override
+ public String toString() {
+ return parameters.stream().map(Parameter::getName).collect(Collectors.joining(", "));
+ }
+
+ @Override
+ public Parameter get(int index) {
+ return parameters.get(index);
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/StatusCodeList.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/StatusCodeList.java
new file mode 100644
index 0000000000..6b4adebeb8
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/StatusCodeList.java
@@ -0,0 +1,49 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import com.fasterxml.jackson.annotation.JsonIncludeProperties;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import io.jooby.internal.openapi.asciidoc.display.MapToAsciiDoc;
+
+@JsonIncludeProperties({"codes"})
+public record StatusCodeList(List> codes)
+ implements Iterable>, ToAsciiDoc {
+ @NonNull @Override
+ public String toString() {
+ return codes.toString();
+ }
+
+ @NonNull @Override
+ public Iterator> iterator() {
+ return codes.iterator();
+ }
+
+ @Override
+ public String list(Map options) {
+ var sb = new StringBuilder();
+ codes.forEach(
+ (row) ->
+ sb.append("* `+")
+ .append(row.get("code"))
+ .append("+`: ")
+ .append(row.get("reason"))
+ .append('\n'));
+ if (!sb.isEmpty()) {
+ sb.setLength(sb.length() - 1);
+ }
+ return sb.toString();
+ }
+
+ @Override
+ public String table(Map options) {
+ return new MapToAsciiDoc(codes).table(options);
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/TagExt.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/TagExt.java
new file mode 100644
index 0000000000..7655775d00
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/TagExt.java
@@ -0,0 +1,31 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc;
+
+import java.util.List;
+
+import io.swagger.v3.oas.models.tags.Tag;
+
+public class TagExt extends Tag {
+
+ private final List operations;
+
+ public TagExt(Tag tag, List operations) {
+ setDescription(tag.getDescription());
+ setName(tag.getName());
+ setExternalDocs(tag.getExternalDocs());
+ setExtensions(tag.getExtensions());
+ this.operations = operations;
+ }
+
+ public List getOperations() {
+ return operations;
+ }
+
+ public List getRoutes() {
+ return operations;
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/ToAsciiDoc.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/ToAsciiDoc.java
new file mode 100644
index 0000000000..435ead5f3e
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/ToAsciiDoc.java
@@ -0,0 +1,14 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc;
+
+import java.util.Map;
+
+public interface ToAsciiDoc {
+ String list(Map options);
+
+ String table(Map options);
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/ToSnippet.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/ToSnippet.java
new file mode 100644
index 0000000000..d3e0a82fd0
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/ToSnippet.java
@@ -0,0 +1,12 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc;
+
+import java.util.Map;
+
+public interface ToSnippet {
+ String render(Map options);
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/MapToAsciiDoc.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/MapToAsciiDoc.java
new file mode 100644
index 0000000000..2f1511fd84
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/MapToAsciiDoc.java
@@ -0,0 +1,55 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc.display;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import io.jooby.internal.openapi.asciidoc.ToAsciiDoc;
+
+public record MapToAsciiDoc(List> rows) implements ToAsciiDoc {
+
+ public String list(Map options) {
+ var sb = new StringBuilder();
+ rows.forEach(
+ (row) -> {
+ row.forEach(
+ (name, value) -> {
+ sb.append("* ").append(name).append(": ").append(value).append('\n');
+ });
+ });
+ if (!sb.isEmpty()) {
+ sb.setLength(sb.length() - 1);
+ }
+ return sb.toString();
+ }
+
+ public String table(Map options) {
+ var sb = new StringBuilder();
+ if (!options.isEmpty()) {
+ sb.append(
+ options.entrySet().stream()
+ .map(it -> it.getKey() + "=\"" + it.getValue() + "\"")
+ .collect(Collectors.joining(", ", "[", "]")))
+ .append('\n');
+ }
+ sb.append("|===").append('\n');
+ if (!rows.isEmpty()) {
+ sb.append(rows.getFirst().keySet().stream().collect(Collectors.joining("|", "|", "")))
+ .append("\n\n");
+ rows.forEach(
+ row -> {
+ row.values().forEach(value -> sb.append("|").append(value).append("\n"));
+ sb.append("\n");
+ });
+ sb.append("\n");
+ }
+ sb.setLength(sb.length() - 1);
+ sb.append("|===");
+ return sb.toString();
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/OpenApiToAsciiDoc.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/OpenApiToAsciiDoc.java
new file mode 100644
index 0000000000..22185430cc
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/OpenApiToAsciiDoc.java
@@ -0,0 +1,211 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc.display;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import com.google.common.base.CaseFormat;
+import io.jooby.internal.openapi.EnumSchema;
+import io.jooby.internal.openapi.asciidoc.AsciiDocContext;
+import io.jooby.internal.openapi.asciidoc.ParameterList;
+import io.jooby.internal.openapi.asciidoc.ToAsciiDoc;
+import io.swagger.v3.oas.models.media.Schema;
+
+public record OpenApiToAsciiDoc(
+ AsciiDocContext context,
+ Map> properties,
+ List columns,
+ Map additionalProperties)
+ implements ToAsciiDoc {
+ private static final String ROOT = "___root__";
+
+ public static OpenApiToAsciiDoc schema(AsciiDocContext context, Schema schema) {
+ var columns =
+ schema instanceof EnumSchema
+ ? List.of("name", "description")
+ : List.of("name", "type", "description");
+ var properties = new LinkedHashMap>();
+ properties.put(OpenApiToAsciiDoc.ROOT, schema);
+ context.traverseSchema(schema, properties::put);
+ return new OpenApiToAsciiDoc(context, properties, columns, Map.of());
+ }
+
+ public static OpenApiToAsciiDoc parameters(AsciiDocContext context, ParameterList parameters) {
+ var properties = new LinkedHashMap>();
+ parameters.forEach(p -> properties.put(p.getName(), p.getSchema()));
+ Map additionalProperties = new LinkedHashMap<>();
+ parameters.forEach(
+ p -> {
+ additionalProperties.put(p.getName() + ".in", p.getIn());
+ additionalProperties.put(p.getName() + ".description", p.getDescription());
+ });
+ return new OpenApiToAsciiDoc(context, properties, parameters.includes(), additionalProperties);
+ }
+
+ public String list(Map options) {
+ var isEnum = properties.get(ROOT) instanceof EnumSchema;
+ var sb = new StringBuilder();
+ if (isEnum) {
+ var enumSchema = (EnumSchema) properties.remove(ROOT);
+ for (var enumName : enumSchema.getEnum()) {
+ sb.append(boldCell(enumName)).append("::").append('\n');
+ var enumDesc = enumSchema.getDescription(enumName);
+ if (enumDesc != null) {
+ sb.append("* ").append(enumDesc);
+ }
+ sb.append('\n');
+ }
+ } else {
+ properties.remove(ROOT);
+ properties.forEach(
+ (name, value) -> {
+ sb.append(name).append("::").append('\n');
+ sb.append("* ")
+ .append("type")
+ .append(": ")
+ .append(monospaceCell(context.schemaType(value)))
+ .append('\n');
+ var in = additionalProperties.get(name + ".in");
+ if (in != null) {
+ sb.append("* ")
+ .append("in")
+ .append(": ")
+ .append(monospaceCell((String) in))
+ .append('\n');
+ }
+ var isEnumProperty = value instanceof EnumSchema;
+ var description =
+ isEnumProperty ? ((EnumSchema) value).getSummary() : value.getDescription();
+ if (isEnumProperty) {
+ sb.append("* ").append("description").append(":");
+ if (description != null) {
+ sb.append(" ").append(description);
+ }
+ sb.append('\n');
+ var enumSchema = (EnumSchema) value;
+ for (var enumName : enumSchema.getEnum()) {
+ sb.append("** ").append(boldCell(enumName));
+ var enumDesc = enumSchema.getDescription(enumName);
+ if (enumDesc != null) {
+ sb.append(": ").append(enumDesc);
+ }
+ sb.append('\n');
+ }
+ } else {
+ if (description != null) {
+ sb.append("* ").append("description").append(": ").append(description).append('\n');
+ }
+ }
+ });
+ }
+ if (!sb.isEmpty()) {
+ sb.setLength(sb.length() - 1);
+ }
+ return sb.toString();
+ }
+
+ @SuppressWarnings({"unchecked"})
+ public String table(Map options) {
+ var isEnum = properties.get(ROOT) instanceof EnumSchema;
+ var columns = (List) options.getOrDefault("columns", this.columns);
+ options.remove("columns");
+ var colList = colList(columns);
+ var sb = new StringBuilder();
+ sb.append("|===").append('\n');
+ sb.append(header(columns)).append('\n');
+ if (isEnum) {
+ var enumSchema = (EnumSchema) properties.remove(ROOT);
+ for (var enumName : enumSchema.getEnum()) {
+ sb.append("| ").append(boldCell(enumName)).append('\n');
+ var enumDesc = enumSchema.getDescription(enumName);
+ if (enumDesc != null) {
+ sb.append("| ").append(enumDesc);
+ }
+ sb.append('\n');
+ }
+ } else {
+ properties.remove(ROOT);
+ properties.forEach(
+ (name, value) -> {
+ var isPropertyEnum = value instanceof EnumSchema;
+ for (int i = 0; i < columns.size(); i++) {
+ var column = columns.get(i);
+ sb.append("|").append(row(column, name, value)).append("\n");
+ if (isPropertyEnum && column.equals("description")) {
+ colList.set(i, colList.get(i) + "a");
+ var enumSchema = (EnumSchema) value;
+ for (var enumValue : enumSchema.getEnum()) {
+ sb.append("\n* ").append(boldCell(enumValue));
+ var enumDesc = enumSchema.getDescription(enumValue);
+ if (enumDesc != null) {
+ sb.append(": ").append(enumDesc);
+ }
+ }
+ sb.append('\n');
+ }
+ }
+ sb.append('\n');
+ });
+ }
+ sb.append("|===");
+ options.putIfAbsent("cols", colsToString(colList));
+ if (options.size() == 1) {
+ options.put("options", "header");
+ }
+ return options.entrySet().stream()
+ .map(e -> e.getKey() + "=\"" + e.getValue() + "\"")
+ .collect(Collectors.joining(", ", "[", "]"))
+ + "\n"
+ + sb;
+ }
+
+ private String colsToString(List cols) {
+ return String.join(",", cols);
+ }
+
+ private List colList(List names) {
+ return names.stream()
+ .map(it -> it.equals("description") ? "3" : "1")
+ .collect(Collectors.toList());
+ }
+
+ private String header(List names) {
+ return names.stream()
+ .map(it -> CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, it))
+ .collect(Collectors.joining("|", "|", ""));
+ }
+
+ private static String monospaceCell(String value) {
+ return value == null || value.trim().isEmpty() ? "" : "`+" + value + "+`";
+ }
+
+ private String boldCell(String value) {
+ return value == null || value.trim().isEmpty() ? "" : "*" + value + "*";
+ }
+
+ private String nullSafe(String value) {
+ return value == null || value.trim().isEmpty() ? "" : value;
+ }
+
+ private String row(String col, String property, Schema schema) {
+ return nullSafe(
+ switch (col) {
+ case "name" -> monospaceCell(property);
+ case "type" -> monospaceCell(context.schemaType(schema));
+ case "in" -> monospaceCell((String) additionalProperties.get(property + "." + col));
+ case "description" ->
+ (schema instanceof EnumSchema enumSchema
+ ? enumSchema.getSummary()
+ : (String)
+ additionalProperties.getOrDefault(
+ property + "." + col, schema.getDescription()));
+ default -> throw new IllegalArgumentException("Unknown property: " + col);
+ });
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/RequestToCurl.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/RequestToCurl.java
new file mode 100644
index 0000000000..9da8674661
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/RequestToCurl.java
@@ -0,0 +1,180 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc.display;
+
+import java.util.*;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Multimap;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import io.jooby.Router;
+import io.jooby.internal.openapi.asciidoc.*;
+
+public class RequestToCurl implements ToSnippet {
+ private static final CharSequence Accept = new HeaderName("Accept");
+ private static final CharSequence ContentType = new HeaderName("Content-Type");
+
+ private final AsciiDocContext context;
+ private final HttpRequest request;
+
+ public RequestToCurl(AsciiDocContext context, HttpRequest request) {
+ this.context = context;
+ this.request = request;
+ }
+
+ @Override
+ public String render(Map args) {
+ var language = (String) args.remove("language");
+ var options = args(args);
+ var method = removeOption(options, "-X", request.getMethod()).toUpperCase();
+ /* Accept/Content-Type: */
+ var addAccept = true;
+ var addContentType = true;
+ if (options.containsKey("-H")) {
+ var headers = parseHeaders(options.get("-H"));
+ addAccept = !headers.containsKey(Accept);
+ addContentType = !headers.containsKey(ContentType);
+ }
+ if (addAccept) {
+ request.getProduces().forEach(value -> options.put("-H", "'Accept: " + value + "'"));
+ }
+ if (addContentType
+ && Set.of(Router.PATCH, Router.PUT, Router.POST, Router.DELETE).contains(method)) {
+ request.getConsumes().forEach(value -> options.put("-H", "'Content-Type: " + value + "'"));
+ }
+ /* Body */
+ var formUrlEncoded =
+ request.formUrlEncoded(
+ (schema, field) -> {
+ var option = "--data-urlencode";
+ var value = field.getValue();
+ if ("binary".equals(schema.getFormat())) {
+ option = "-F";
+ value = "@/file%1$s.extension";
+ }
+ return Map.entry(option, "\"" + field.getKey() + "=" + value + "\"");
+ });
+ if (formUrlEncoded.isEmpty()) {
+ var body = request.getBody();
+ if (body != null) {
+ options.put("-d", "'" + context.toJson(context.schemaProperties(body), false) + "'");
+ }
+ } else {
+ formUrlEncoded.forEach(options::put);
+ }
+
+ /* Method */
+ var url = request.getPath() + request.getQueryString();
+ options.put("-X", method + " '" + url + "'");
+ return toString(options, language);
+ }
+
+ private String toString(Multimap options, String language) {
+ var curl = "curl";
+ var sb = new StringBuilder();
+ sb.append("[source");
+ if (language != null) {
+ sb.append(", ").append(language);
+ }
+ sb.append("]\n----\n").append(curl);
+ var separator = "\\\n";
+ var tabSize = 1;
+ for (var entry : options.entries()) {
+ var k = entry.getKey();
+ var v = entry.getValue();
+ sb.append(" ".repeat(tabSize));
+ sb.append(k);
+ if (v != null && !v.isEmpty()) {
+ sb.append(" ").append(v);
+ }
+ sb.append(separator);
+ tabSize = curl.length() + 1;
+ }
+ sb.setLength(sb.length() - separator.length());
+ sb.append("\n----");
+ return sb.toString();
+ }
+
+ private Multimap parseHeaders(Collection headers) {
+ Multimap result = LinkedHashMultimap.create();
+ for (var line : headers) {
+ if (line.startsWith("'") && line.endsWith("'")) {
+ line = line.substring(1, line.length() - 1);
+ }
+ var header = Splitter.on(':').trimResults().omitEmptyStrings().splitToList(line);
+ if (header.size() != 2) {
+ throw new IllegalArgumentException("Invalid header: " + line);
+ }
+ result.put(new HeaderName(header.get(0)), header.get(1));
+ }
+ return result;
+ }
+
+ @NonNull private static String removeOption(
+ Multimap options, String name, String defaultValue) {
+ return Optional.of(options.removeAll(name))
+ .map(Collection::iterator)
+ .filter(Iterator::hasNext)
+ .map(Iterator::next)
+ .orElse(defaultValue);
+ }
+
+ private Multimap args(Map args) {
+ Multimap result = LinkedHashMultimap.create();
+ var optionList = new ArrayList<>(args.values());
+ for (int i = 0; i < optionList.size(); ) {
+ var key = optionList.get(i).toString();
+ String value = null;
+ if (i + 1 < optionList.size()) {
+ var next = optionList.get(i + 1);
+ if (next.toString().startsWith("-")) {
+ i += 1;
+ } else {
+ value = next.toString();
+ i += 2;
+ }
+ } else {
+ i += 1;
+ }
+ result.put(key, value == null ? "" : value);
+ }
+ return result;
+ }
+
+ private record HeaderName(String value) implements CharSequence {
+
+ @Override
+ public int length() {
+ return value.length();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return value.equalsIgnoreCase(obj.toString());
+ }
+
+ @Override
+ public int hashCode() {
+ return value.toLowerCase().hashCode();
+ }
+
+ @Override
+ public char charAt(int index) {
+ return value.charAt(index);
+ }
+
+ @NonNull @Override
+ public CharSequence subSequence(int start, int end) {
+ return value.subSequence(start, end);
+ }
+
+ @Override
+ @NonNull public String toString() {
+ return value;
+ }
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/RequestToHttp.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/RequestToHttp.java
new file mode 100644
index 0000000000..387e11de7c
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/RequestToHttp.java
@@ -0,0 +1,50 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc.display;
+
+import java.util.Map;
+
+import io.jooby.SneakyThrows;
+import io.jooby.internal.openapi.ParameterExt;
+import io.jooby.internal.openapi.asciidoc.AsciiDocContext;
+import io.jooby.internal.openapi.asciidoc.HttpRequest;
+import io.jooby.internal.openapi.asciidoc.ToSnippet;
+
+/**
+ * [source,http,options="nowrap"] ---- ${method} ${path} HTTP/1.1 {% for h in headers -%} ${h.name}:
+ * ${h.value} {% endfor -%} ${requestBody -} ----
+ *
+ * @param context
+ * @param request
+ */
+public record RequestToHttp(AsciiDocContext context, HttpRequest request) implements ToSnippet {
+ @Override
+ public String render(Map options) {
+ try {
+ var sb = new StringBuilder();
+ sb.append("[source,http,options=\"nowrap\"]").append('\n');
+ sb.append("----").append('\n');
+ sb.append(request.getMethod())
+ .append(" ")
+ .append(request.getPath())
+ .append(" HTTP/1.1")
+ .append('\n');
+ for (var header : request.getHeaders()) {
+ sb.append(header.getName())
+ .append(": ")
+ .append(((ParameterExt) header).getDefaultValue())
+ .append('\n');
+ }
+ var schema = request.getBody();
+ if (schema != null) {
+ sb.append(context.toJson(context.schemaProperties(schema), false)).append('\n');
+ }
+ return sb.append("----").toString();
+ } catch (Exception x) {
+ throw SneakyThrows.propagate(x);
+ }
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/ResponseToHttp.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/ResponseToHttp.java
new file mode 100644
index 0000000000..545572c473
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/asciidoc/display/ResponseToHttp.java
@@ -0,0 +1,39 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.asciidoc.display;
+
+import java.util.Map;
+
+import io.jooby.SneakyThrows;
+import io.jooby.internal.openapi.ParameterExt;
+import io.jooby.internal.openapi.asciidoc.*;
+
+public record ResponseToHttp(AsciiDocContext context, HttpResponse response) implements ToSnippet {
+ @Override
+ public String render(Map options) {
+ try {
+ var sb = new StringBuilder();
+ sb.append("[source,http,options=\"nowrap\"]").append('\n');
+ sb.append("----").append('\n');
+ sb.append("HTTP/1.1 ")
+ .append(response.getStatusCode().value())
+ .append(" ")
+ .append(response.getStatusCode().reason())
+ .append('\n');
+ for (var header : response.getHeaders()) {
+ var value = ((ParameterExt) header).getDefaultValue();
+ sb.append(header.getName()).append(": ").append(value).append('\n');
+ }
+ var schema = response.getBody();
+ if (schema != null) {
+ sb.append(context.toJson(context.schemaProperties(schema), false)).append('\n');
+ }
+ return sb.append("----").toString();
+ } catch (Exception x) {
+ throw SneakyThrows.propagate(x);
+ }
+ }
+}
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/javadoc/ClassDoc.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/javadoc/ClassDoc.java
index 35d7c04bda..7fb1c6136f 100644
--- a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/javadoc/ClassDoc.java
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/javadoc/ClassDoc.java
@@ -88,6 +88,16 @@ public String getEnumDescription(String text) {
return text;
}
+ public String getEnumItemDescription(String name) {
+ if (isEnum()) {
+ var field = fields.get(name);
+ if (field != null) {
+ return field.getText();
+ }
+ }
+ return null;
+ }
+
private void defaultRecordMembers() {
JavaDocTag.javaDocTag(
javadoc,
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/javadoc/ContentSplitter.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/javadoc/ContentSplitter.java
new file mode 100644
index 0000000000..12e7e80b60
--- /dev/null
+++ b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/javadoc/ContentSplitter.java
@@ -0,0 +1,158 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.openapi.javadoc;
+
+public class ContentSplitter {
+
+ public record ContentResult(String summary, String description) {}
+
+ public static ContentResult split(String text) {
+ if (text == null || text.isEmpty()) {
+ return new ContentResult("", "");
+ }
+
+ int len = text.length();
+ int splitIndex = -1;
+
+ // State trackers
+ int parenDepth = 0; // ( )
+ int bracketDepth = 0; // [ ]
+ int braceDepth = 0; // { }
+ boolean inHtmlDef = false; // < ... >
+ boolean inCodeBlock = false; //