@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/java/java.ts

@@ -0,0 +1,280 @@
+import { Word, eq } from "../../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "max-time",
+  "connect-timeout",
+  "location",
+  // "location-trusted",
+  "upload-file",
+  // TODO
+  // "form",
+  // "form-string",
+  "http2",
+]);
+
+// https://docs.oracle.com/javase/specs/jls/se7/html/jls-3.html#jls-3.10.6
+// https://docs.oracle.com/javase/specs/jls/se7/html/jls-3.html#jls-3.3
+// Also used for Clojure
+const regexEscape = /"|\\|\p{C}|[^ \P{Z}]/gu;
+const regexDigit = /[0-9]/; // it's 0-7 actually but that would generate confusing code
+export function reprStr(s: string): string {
+  return (
+    '"' +
+    s.replace(regexEscape, (c: string, index: number, string: string) => {
+      switch (c) {
+        case "\\":
+          return "\\\\";
+        case "\b":
+          return "\\b";
+        case "\f":
+          return "\\f";
+        case "\n":
+          return "\\n";
+        case "\r":
+          return "\\r";
+        case "\t":
+          return "\\t";
+        case '"':
+          return '\\"';
+      }
+
+      if (c.length === 2) {
+        const first = c.charCodeAt(0);
+        const second = c.charCodeAt(1);
+        return (
+          "\\u" +
+          first.toString(16).padStart(4, "0") +
+          "\\u" +
+          second.toString(16).padStart(4, "0")
+        );
+      }
+
+      if (c === "\0" && !regexDigit.test(string.charAt(index + 1))) {
+        return "\\0";
+      }
+      return "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0");
+    }) +
+    '"'
+  );
+}
+
+export function repr(w: Word, imports: Set<string>): string {
+  const args: string[] = [];
+  for (const t of w.tokens) {
+    if (typeof t === "string") {
+      args.push(reprStr(t));
+    } else if (t.type === "variable") {
+      args.push("System.getenv(" + reprStr(t.value) + ")");
+      imports.add("java.lang.System");
+    } else {
+      args.push("exec(" + reprStr(t.value) + ")");
+      imports.add("java.lang.Runtime");
+      imports.add("java.util.Scanner");
+    }
+  }
+  return args.join(" + ");
+}
+
+export function _toJava(requests: Request[], warnings: Warnings = []): string {
+  const request = getFirst(requests, warnings);
+  const url = request.urls[0];
+
+  const imports = new Set<string>([
+    "java.net.URI",
+    "java.net.http.HttpClient",
+    "java.net.http.HttpRequest",
+    "java.net.http.HttpResponse",
+    "java.io.IOException",
+  ]);
+
+  let javaCode = "";
+
+  javaCode += "HttpClient client = ";
+
+  const clientLines = [];
+  if (request.followRedirects) {
+    // .NEVER is the default
+    // .ALWAYS will follow redirect from HTTPS to HTTP, which isn't what --location-trusted does
+    clientLines.push("    .followRedirects(HttpClient.Redirect.NORMAL)\n");
+  } else if (request.followRedirects === false) {
+    clientLines.push("    .followRedirects(HttpClient.Redirect.NEVER)\n");
+  }
+  if (request.connectTimeout) {
+    // TODO: won't work if it's a float
+    clientLines.push(
+      "    .connectTimeout(Duration.ofSeconds(" +
+        request.connectTimeout.toString() +
+        "))\n",
+    );
+    imports.add("java.time.Duration");
+  }
+  // TODO: Proxy
+  if (clientLines.length) {
+    javaCode += "HttpClient.newBuilder()\n";
+    for (const line of clientLines) {
+      javaCode += line;
+    }
+    javaCode += "    .build()";
+  } else {
+    javaCode += "HttpClient.newHttpClient()";
+  }
+  javaCode += ";\n";
+  javaCode += "\n";
+
+  const methodCallArgs = [];
+  if (url.uploadFile) {
+    if (eq(url.uploadFile, "-") || eq(url.uploadFile, ".")) {
+      warnings.push(["upload-stdin", "uploading from stdin isn't supported"]);
+    }
+    methodCallArgs.push(
+      "BodyPublishers.ofFile(Paths.get(" + repr(url.uploadFile, imports) + "))",
+    );
+    imports.add("java.net.http.HttpRequest.BodyPublishers");
+    imports.add("java.nio.file.Paths");
+  } else if (
+    request.dataArray &&
+    request.dataArray.length === 1 &&
+    !(request.dataArray[0] instanceof Word) &&
+    !request.dataArray[0].name
+  ) {
+    // TODO: surely --upload-file and this can't be identical,
+    // doesn't this ignore url encoding?
+    methodCallArgs.push(
+      "BodyPublishers.ofFile(Paths.get(" +
+        repr(request.dataArray[0].filename, imports) +
+        "))",
+    );
+    imports.add("java.net.http.HttpRequest.BodyPublishers");
+    imports.add("java.nio.file.Paths");
+  } else if (request.data) {
+    methodCallArgs.push(
+      "BodyPublishers.ofString(" + repr(request.data, imports) + ")",
+    );
+    imports.add("java.net.http.HttpRequest.BodyPublishers");
+  }
+
+  if (url.auth) {
+    const [name, password] = url.auth;
+    javaCode +=
+      "String credentials = " +
+      repr(name, imports) +
+      ' + ":" + ' +
+      repr(password, imports) +
+      ";\n";
+    javaCode +=
+      'String auth = "Basic " + Base64.getEncoder().encodeToString(credentials.getBytes());\n\n';
+    imports.add("java.util.Base64");
+
+    if (request.authType !== "basic") {
+      warnings.push([
+        "unsupported-auth-type",
+        `"${request.authType}" authentication is not supported`,
+      ]);
+    }
+  }
+
+  javaCode += "HttpRequest request = HttpRequest.newBuilder()\n";
+  javaCode += "    .uri(URI.create(" + repr(url.url, imports) + "))\n";
+  const methods = ["DELETE", "GET", "POST", "PUT"];
+  const dataMethods = ["POST", "PUT"];
+  const method = url.method;
+  let methodCall = "method";
+  if (
+    !method.isString() ||
+    !methods.includes(method.toString()) ||
+    // If we appended something to methodCallArgs it means we need to send data
+    (methodCallArgs.length && !dataMethods.includes(method.toString()))
+  ) {
+    if (!methodCallArgs.length) {
+      methodCallArgs.push("HttpRequest.BodyPublishers.noBody()");
+    }
+    methodCallArgs.unshift(repr(method, imports));
+  } else {
+    if (!methodCallArgs.length && dataMethods.includes(method.toString())) {
+      methodCallArgs.push("HttpRequest.BodyPublishers.noBody()");
+    }
+    methodCall = method.toString();
+  }
+  javaCode += "    ." + methodCall + "(" + methodCallArgs.join(", ") + ")\n";
+
+  if (request.headers.length) {
+    for (const [headerName, headerValue] of request.headers) {
+      if (headerValue === null) {
+        continue;
+      }
+      javaCode +=
+        "    .setHeader(" +
+        repr(headerName, imports) +
+        ", " +
+        repr(headerValue, imports) +
+        ")\n";
+    }
+  }
+  if (url.auth) {
+    const authHeader = request.headers.lowercase
+      ? "authorization"
+      : "Authorization";
+    javaCode += '    .setHeader("' + authHeader + '", auth)\n';
+  }
+
+  if (request.http2) {
+    javaCode += "    .version(HttpClient.Version.HTTP_2)\n";
+    // TODO: more granular control
+  }
+  if (request.timeout) {
+    // TODO: won't work if it's a float
+    javaCode +=
+      "    .timeout(Duration.ofSeconds(" + request.timeout.toString() + "))\n";
+    imports.add("java.time.Duration");
+  }
+
+  javaCode += "    .build();\n";
+  javaCode += "\n";
+  javaCode +=
+    "HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());\n";
+
+  let preambleCode = "";
+  for (const imp of Array.from(imports).sort()) {
+    preambleCode += "import " + imp + ";\n";
+  }
+  if (imports.size) {
+    preambleCode += "\n";
+  }
+
+  // preambleCode += "class Main {\n";
+  if (imports.has("java.lang.Runtime")) {
+    // Helper function that runs a bash command and always returns a string
+    preambleCode += "public static String exec(String cmd) {\n";
+    preambleCode += "    try {\n";
+    preambleCode += "        Process p = Runtime.getRuntime().exec(cmd);\n";
+    preambleCode += "        p.waitFor();\n";
+    preambleCode +=
+      '        Scanner s = new Scanner(p.getInputStream()).useDelimiter("\\\\A");\n';
+    preambleCode += '        return s.hasNext() ? s.next() : "";\n';
+    preambleCode += "    } catch (Exception e) {\n";
+    preambleCode += '        return "";\n';
+    preambleCode += "    }\n";
+    preambleCode += "}\n";
+    preambleCode += "\n";
+  }
+  // preambleCode +=
+  //   "    public static void main(String[] args) throws Exception {\n";
+
+  // return preambleCode + javaCode + "    }\n" + "}" + "\n";
+  return preambleCode + javaCode;
+}
+export function toJavaWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const java = _toJava(requests, warnings);
+  return [java, warnings];
+}
+
+export function toJava(curlCommand: string | string[]): string {
+  return toJavaWarn(curlCommand)[0];
+}

package/src/generators/java/jsoup.ts

@@ -0,0 +1,172 @@
+import { joinWords, eq } from "../../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+
+import { repr } from "./java.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+
+  "form",
+  "form-string",
+
+  "max-time",
+]);
+
+export const _toJavaJsoup = (
+  requests: Request[],
+  warnings: Warnings = [],
+): string => {
+  const request = getFirst(requests, warnings);
+
+  const imports = new Set<string>([
+    "java.io.IOException",
+    "java.io.File",
+    "java.io.FileInputStream",
+    "org.jsoup.Jsoup",
+    "org.jsoup.Connection",
+  ]);
+
+  let javaCode = "";
+
+  javaCode += "\nclass Main {\n\n";
+
+  javaCode += "\tpublic static void main(String[] args) throws IOException {\n";
+
+  if (request.urls[0].auth) {
+    javaCode +=
+      "\t\tbyte[] message = (" +
+      repr(joinWords(request.urls[0].auth, ":"), imports) +
+      ').getBytes("UTF-8");\n';
+    javaCode +=
+      "\t\tString basicAuth = DatatypeConverter.printBase64Binary(message);\n";
+    javaCode += "\n";
+    imports.add("javax.xml.bind.DatatypeConverter");
+  }
+
+  javaCode +=
+    "\t\tConnection.Response response = Jsoup.connect(" +
+    repr(request.urls[0].url, imports) +
+    ")\n";
+
+  if (request.headers) {
+    for (const [headerName, headerValue] of request.headers) {
+      if (headerValue === null) {
+        continue;
+      }
+
+      if (eq(headerName.toLowerCase(), "user-agent")) {
+        javaCode +=
+          "\t\t\t.userAgent" + "(" + repr(headerValue, imports) + ")\n";
+      } else if (eq(headerName.toLowerCase(), "cookie")) {
+        const cookieValues = headerValue.split(";");
+        for (const index in cookieValues) {
+          javaCode +=
+            "\t\t\t.cookie(" +
+            repr(cookieValues[index].split("=")[0].trim(), imports) +
+            ", " +
+            repr(cookieValues[index].split("=")[1].trim(), imports) +
+            ")\n";
+        }
+      } else {
+        javaCode +=
+          "\t\t\t.header(" +
+          repr(headerName, imports) +
+          ", " +
+          repr(headerValue, imports) +
+          ")\n";
+      }
+    }
+  }
+  if (request.urls[0].auth) {
+    javaCode += '\t\t\t.header("Authorization", "Basic " + basicAuth)\n';
+  }
+
+  if (request.multipartUploads) {
+    javaCode += "\t\t\t.data(";
+
+    for (const m of request.multipartUploads) {
+      const name = m.name;
+      const fileInputStream = "new FileInputStream(new File(";
+      const fileName = "filename";
+      if ("contentFile" in m) {
+        if (eq(m.contentFile, "-")) {
+          if (request.stdinFile) {
+            javaCode +=
+              repr(name, imports) +
+              '", "' +
+              fileName +
+              '", ' +
+              fileInputStream +
+              repr(request.stdinFile, imports);
+          } else if (request.stdin) {
+            javaCode +=
+              repr(name, imports) +
+              '", "' +
+              fileName +
+              '", ' +
+              fileInputStream +
+              repr(request.stdin, imports);
+          }
+        } else {
+          javaCode +=
+            repr(name, imports) +
+            '", "' +
+            fileName +
+            '", ' +
+            fileInputStream +
+            repr(m.contentFile, imports);
+        }
+      } else {
+        javaCode +=
+          repr(name, imports) +
+          '", "' +
+          fileName +
+          '",' +
+          fileInputStream +
+          repr(m.content, imports);
+      }
+    }
+    javaCode += ")))\n";
+  } else if (request.data) {
+    javaCode += "\t\t\t.requestBody(" + repr(request.data, imports) + ")\n";
+  }
+
+  // TODO: check method const exists
+  javaCode +=
+    "\t\t\t.method(org.jsoup.Connection.Method." +
+    request.urls[0].method.toString() +
+    ")\n";
+  javaCode += "\t\t\t.ignoreContentType(true)\n";
+  if (request.timeout) {
+    // TODO: multiply by 1000
+    javaCode += "\t\t\t.timeout(" + request.timeout.toString() + " * 1000)\n";
+  }
+  javaCode += "\t\t\t.execute();\n\n";
+  javaCode += "\t\tSystem.out.println(response.parse());\n";
+
+  javaCode += "\t}\n";
+  javaCode += "}";
+
+  let preambleCode = "";
+  for (const imp of Array.from(imports).sort()) {
+    preambleCode += "import " + imp + ";\n";
+  }
+  if (imports.size) {
+    preambleCode += "\n";
+  }
+
+  return preambleCode + javaCode + "\n";
+};
+export const toJavaJsoupWarn = (
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] => {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const java = _toJavaJsoup(requests, warnings);
+  return [java, warnings];
+};
+
+export const toJavaJsoup = (curlCommand: string | string[]): string => {
+  return toJavaJsoupWarn(curlCommand)[0];
+};

package/src/generators/java/okhttp.ts

@@ -0,0 +1,257 @@
+import { Word, eq } from "../../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+import { parseQueryString } from "../../Query.js";
+
+import { repr } from "./java.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "max-time",
+  "connect-timeout",
+  "location",
+  "location-trusted",
+  "upload-file",
+  "form",
+  "form-string",
+]);
+
+export function _toJavaOkHttp(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+  const url = request.urls[0];
+
+  const imports = new Set<string>([
+    "java.io.IOException",
+    "okhttp3.OkHttpClient",
+    "okhttp3.Request",
+    "okhttp3.Response",
+  ]);
+
+  let javaCode = "";
+
+  javaCode += "OkHttpClient client = new OkHttpClient()";
+  const clientLines = [];
+  if (request.timeout) {
+    clientLines.push(
+      "    .callTimeout(" +
+        request.timeout.toString() +
+        ", TimeUnit.SECONDS)\n",
+    );
+    imports.add("java.util.concurrent.TimeUnit");
+  }
+  if (request.connectTimeout) {
+    clientLines.push(
+      "    .connectTimeout(" +
+        request.connectTimeout.toString() +
+        ", TimeUnit.SECONDS)\n",
+    );
+    imports.add("java.util.concurrent.TimeUnit");
+  }
+  if (request.followRedirects === false) {
+    clientLines.push("    .followRedirects(false)\n");
+    clientLines.push("    .followSslRedirects(false)\n");
+  }
+  // TODO: Proxy
+  if (clientLines.length) {
+    javaCode += ".newBuilder()\n";
+    for (const line of clientLines) {
+      javaCode += line;
+    }
+    javaCode += "    .build()";
+  }
+  javaCode += ";\n";
+  javaCode += "\n";
+
+  if (url.auth) {
+    const [name, password] = url.auth;
+    javaCode +=
+      "String credential = Credentials.basic(" +
+      repr(name, imports) +
+      ", " +
+      repr(password, imports) +
+      ");\n\n";
+    imports.add("okhttp3.Credentials");
+
+    if (request.authType !== "basic") {
+      warnings.push([
+        "okhttp-unsupported-auth-type",
+        "OkHttp doesn't support auth type " + request.authType,
+      ]);
+    }
+  }
+
+  const methodCallArgs = [];
+  if (url.uploadFile) {
+    if (eq(url.uploadFile, "-") || eq(url.uploadFile, ".")) {
+      warnings.push(["upload-stdin", "uploading from stdin isn't supported"]);
+    }
+    methodCallArgs.push("file");
+    javaCode +=
+      "File file = new File(" + repr(url.uploadFile, imports) + ");\n\n";
+    imports.add("java.io.File");
+  } else if (request.multipartUploads) {
+    methodCallArgs.push("requestBody");
+    javaCode += "RequestBody requestBody = new MultipartBody.Builder()\n";
+    javaCode += "    .setType(MultipartBody.FORM)\n";
+    for (const m of request.multipartUploads) {
+      const args = [repr(m.name, imports)];
+      if ("content" in m) {
+        args.push(repr(m.content, imports));
+      } else {
+        if ("filename" in m && m.filename) {
+          if (!eq(m.filename, m.contentFile)) {
+            args.push(repr(m.filename, imports));
+          }
+          args.push(
+            "RequestBody.create(" +
+              '"", ' + // TODO: this is the media type
+              "new File(" +
+              repr(m.contentFile, imports) +
+              "))",
+          );
+          imports.add("java.io.File");
+        } else {
+          // TODO: import
+          // TODO: probably doesn't work
+          args.push("Files.readAllBytes(" + repr(m.contentFile, imports) + ")");
+        }
+      }
+      javaCode += "    .addFormDataPart(" + args.join(", ") + ")\n";
+    }
+    javaCode += "    .build();\n\n";
+    imports.add("okhttp3.RequestBody");
+    imports.add("okhttp3.MultipartBody");
+  } else if (
+    request.dataArray &&
+    request.dataArray.length === 1 &&
+    !(request.dataArray[0] instanceof Word) &&
+    !request.dataArray[0].name
+  ) {
+    // TODO: surely --upload-file and this can't be identical,
+    // doesn't this ignore url encoding?
+    methodCallArgs.push("file");
+    javaCode +=
+      "File file = new File(" +
+      repr(request.dataArray[0].filename, imports) +
+      ");\n\n";
+    imports.add("java.io.File");
+  } else if (request.data) {
+    const contentType = request.headers.getContentType();
+    if (contentType === "application/x-www-form-urlencoded") {
+      const [queryList] = parseQueryString(request.data);
+      if (!queryList) {
+        methodCallArgs.push("requestBody");
+        javaCode +=
+          "String requestBody = " + repr(request.data, imports) + ";\n\n";
+      } else {
+        methodCallArgs.push("formBody");
+        javaCode += "RequestBody formBody = new FormBody.Builder()\n";
+        for (const [name, value] of queryList) {
+          javaCode +=
+            "    .add(" +
+            repr(name, imports) +
+            ", " +
+            repr(value, imports) +
+            ")\n";
+        }
+        javaCode += "    .build();\n\n";
+        imports.add("okhttp3.FormBody");
+        imports.add("okhttp3.RequestBody");
+      }
+    } else {
+      methodCallArgs.push("requestBody");
+      javaCode +=
+        "String requestBody = " + repr(request.data, imports) + ";\n\n";
+    }
+  }
+
+  javaCode += "Request request = new Request.Builder()\n";
+  javaCode += "    .url(" + repr(url.url, imports) + ")\n";
+  const methods = ["DELETE", "GET", "HEAD", "PATCH", "POST", "PUT"];
+  const dataMethods = ["DELETE", "PATCH", "POST", "PUT"];
+  const method = url.method;
+  let methodCall = "method";
+  if (
+    !method.isString() ||
+    !methods.includes(method.toString()) ||
+    // If we appended something to methodCallArgs it means we need to send data
+    (methodCallArgs.length && !dataMethods.includes(method.toString()))
+  ) {
+    methodCallArgs.unshift(repr(method, imports));
+  } else {
+    methodCall = method.toString().toLowerCase();
+  }
+  if (methodCall !== "get") {
+    javaCode += "    ." + methodCall + "(" + methodCallArgs.join(", ") + ")\n";
+  }
+
+  if (request.headers.length) {
+    for (const [headerName, headerValue] of request.headers) {
+      if (headerValue === null) {
+        continue;
+      }
+      javaCode +=
+        "    .header(" +
+        repr(headerName, imports) +
+        ", " +
+        repr(headerValue, imports) +
+        ")\n";
+    }
+  }
+  if (url.auth) {
+    const authHeader = request.headers.lowercase
+      ? "authorization"
+      : "Authorization";
+    javaCode += '    .header("' + authHeader + '", credential)\n';
+  }
+
+  javaCode += "    .build();\n";
+
+  javaCode += "\n";
+  javaCode += "try (Response response = client.newCall(request).execute()) {\n";
+  javaCode +=
+    '    if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);\n';
+  javaCode += "    response.body().string();\n";
+  javaCode += "}\n";
+
+  let preambleCode = "";
+  for (const imp of Array.from(imports).sort()) {
+    preambleCode += "import " + imp + ";\n";
+  }
+  if (imports.size) {
+    preambleCode += "\n";
+  }
+
+  if (imports.has("java.lang.Runtime")) {
+    // Helper function that runs a bash command and always returns a string
+    preambleCode += "public static String exec(String cmd) {\n";
+    preambleCode += "    try {\n";
+    preambleCode += "        Process p = Runtime.getRuntime().exec(cmd);\n";
+    preambleCode += "        p.waitFor();\n";
+    preambleCode +=
+      '        Scanner s = new Scanner(p.getInputStream()).useDelimiter("\\\\A");\n';
+    preambleCode += '        return s.hasNext() ? s.next() : "";\n';
+    preambleCode += "    } catch (Exception e) {\n";
+    preambleCode += '        return "";\n';
+    preambleCode += "    }\n";
+    preambleCode += "}\n";
+    preambleCode += "\n";
+  }
+
+  return preambleCode + javaCode + "\n";
+}
+export function toJavaOkHttpWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const java = _toJavaOkHttp(requests, warnings);
+  return [java, warnings];
+}
+
+export function toJavaOkHttp(curlCommand: string | string[]): string {
+  return toJavaOkHttpWarn(curlCommand)[0];
+}