@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/elixir.ts

@@ -0,0 +1,349 @@
+import { warnIfPartsIgnored } from "../Warnings.js";
+import { Word, joinWords } from "../shell/Word.js";
+import { parse, COMMON_SUPPORTED_ARGS } from "../parse.js";
+import type { Request, Warnings } from "../parse.js";
+import { parseQueryString } from "../Query.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "form",
+  "form-string",
+  "insecure",
+  "no-insecure",
+  "next",
+]);
+
+const regexEscape = /"|\\|\p{C}|[^ \P{Z}]|#\{/gu;
+
+export function reprStr(s: string): string {
+  return (
+    '"' +
+    s.replace(regexEscape, (c: string): string => {
+      switch (c[0]) {
+        case "\x00":
+          return "\\0";
+        case "\x07":
+          return "\\a";
+        case "\b":
+          return "\\b";
+        case "\f":
+          return "\\f";
+        case "\n":
+          return "\\n";
+        case "\r":
+          return "\\r";
+        case "\t":
+          return "\\t";
+        case "\v":
+          return "\\v";
+        case "\x1B":
+          return "\\e";
+        case "\\":
+          return "\\\\";
+        case '"':
+          return '\\"';
+        case "#":
+          return "\\" + c;
+      }
+      const hex = (c.codePointAt(0) as number).toString(16);
+      if (hex.length <= 4) {
+        return "\\u" + hex.padStart(4, "0");
+      }
+      return "\\u{" + hex + "}";
+    }) +
+    '"'
+  );
+}
+
+export function repr(w: Word): 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.get_env(" + reprStr(t.value) + ', "")');
+    } else {
+      // TODO: strip newline?
+      // TODO: use System.cmd(), which needs to be two arguments the command name + list of args
+      args.push("elem(System.shell(" + reprStr(t.value) + "), 0)");
+    }
+  }
+  return args.join(" <> ");
+}
+
+function addIndent(value: string): string {
+  // split on new lines and add 2 spaces of indentation to each line, except empty lines
+  return value
+    .split("\n")
+    .map((line) => (line ? "  " + line : line))
+    .join("\n");
+}
+
+function getCookies(request: Request): string {
+  if (!request.cookies || !request.cookies.length) {
+    return "";
+  }
+
+  // TODO: this duplicates work, just get it from request.headers
+  const cookies = joinWords(
+    request.cookies.map((c) => joinWords(c, "=")),
+    "; ",
+  );
+  return `cookie: [${repr(cookies)}]`;
+}
+
+function getOptions(request: Request, params: string): [string, string] {
+  const hackneyOptions: string[] = [];
+
+  const auth = getBasicAuth(request);
+  if (auth) {
+    hackneyOptions.push(auth);
+  }
+
+  if (request.insecure) {
+    hackneyOptions.push(":insecure");
+  }
+
+  const cookies = getCookies(request);
+  if (cookies) {
+    hackneyOptions.push(cookies);
+  }
+
+  let hackneyOptionsString = "";
+  if (hackneyOptions.length > 1) {
+    hackneyOptionsString = `hackney: [\n    ${hackneyOptions.join(
+      ",\n    ",
+    )}\n  ]`;
+  } else if (hackneyOptions.length) {
+    hackneyOptionsString = `hackney: [${hackneyOptions[0]}]`;
+  }
+
+  const optionsWithoutParams = `[${hackneyOptionsString}]`;
+  let options = optionsWithoutParams;
+  if (params !== "[]") {
+    options = "";
+    options += "[\n";
+    options += "    params: " + addIndent(params).trim();
+    if (hackneyOptionsString) {
+      options += ",\n";
+      options += "    " + addIndent(hackneyOptionsString).trim();
+    }
+    options += "\n";
+    options += "  ]";
+  }
+  return [options, optionsWithoutParams];
+}
+
+function getBasicAuth(request: Request): string {
+  if (!request.urls[0].auth) {
+    return "";
+  }
+
+  const [user, password] = request.urls[0].auth;
+  return `basic_auth: {${repr(user)}, ${repr(password)}}`;
+}
+
+function getQueryDict(request: Request): string {
+  if (!request.urls[0].queryList || !request.urls[0].queryList.length) {
+    return "[]";
+  }
+  let queryDict = "[\n";
+  const queryDictLines: string[] = [];
+  for (const [paramName, rawValue] of request.urls[0].queryList) {
+    queryDictLines.push(`    {${repr(paramName)}, ${repr(rawValue)}}`);
+  }
+  queryDict += queryDictLines.join(",\n");
+  queryDict += "\n  ]";
+  return queryDict;
+}
+
+function getHeadersDict(request: Request): string {
+  if (!request.headers.length) {
+    return "[]";
+  }
+  let dict = "[\n";
+  const dictLines: string[] = [];
+  for (const [headerName, headerValue] of request.headers) {
+    dictLines.push(
+      `    {${repr(headerName)}, ${repr(headerValue ?? new Word())}}`,
+    );
+  }
+  dict += dictLines.join(",\n");
+  dict += "\n  ]";
+  return dict;
+}
+
+function getBody(request: Request): string {
+  const formData = getFormDataString(request);
+  return formData ? formData : '""';
+}
+
+function getFormDataString(request: Request): string {
+  if (request.multipartUploads) {
+    if (!request.multipartUploads.length) {
+      return `{:multipart, []}`;
+    }
+
+    const formParams: string[] = [];
+    for (const m of request.multipartUploads) {
+      if ("contentFile" in m) {
+        formParams.push(
+          `    {:file, ${repr(m.contentFile)}, {"form-data", [{:name, ${repr(
+            m.name,
+          )}}, {:filename, Path.basename(${repr(
+            m.filename ?? m.contentFile,
+          )})}]}, []}`,
+        );
+      } else {
+        formParams.push(`    {${repr(m.name)}, ${repr(m.content)}}`);
+      }
+    }
+
+    const formStr = formParams.join(",\n");
+    if (formStr) {
+      return `{:multipart, [
+${formStr}
+  ]}`;
+    }
+  }
+
+  if (request.data) {
+    return getDataString(request);
+  }
+
+  return "";
+}
+
+function getDataString(request: Request): string {
+  if (!request.data) {
+    return "";
+  }
+
+  // TODO: JSON with Poison
+
+  if (!request.isDataRaw && request.data.startsWith("@")) {
+    const filePath = request.data.slice(1);
+    if (request.isDataBinary) {
+      return `File.read!(${repr(filePath)})`;
+    } else {
+      return `{:file, ${repr(filePath)}}`;
+    }
+  }
+
+  const [parsedQuery] = parseQueryString(request.data);
+  if (parsedQuery && parsedQuery.length) {
+    const data = parsedQuery.map((p) => {
+      const [key, value] = p;
+      return `    {${repr(key)}, ${repr(value)}}`;
+    });
+    return `{:form, [\n${data.join(",\n")}\n  ]}`;
+  }
+
+  if (
+    request.data.isString() &&
+    !request.data.includes("|") &&
+    request.data.split("\n", 4).length > 3 &&
+    // No trailing whitespace, except possibly on the last line
+    !request.data.match(/[^\S\r\n]\n/)
+  ) {
+    return "~s|" + request.data.toString() + "|";
+  }
+  return repr(request.data);
+}
+
+function requestToElixir(request: Request, warnings: Warnings = []): string {
+  warnIfPartsIgnored(request, warnings);
+  if (request.cookies) {
+    request.headers.delete("cookie");
+  }
+
+  // delete!(url, headers \\ [], options \\ [])
+  // get!(url, headers \\ [], options \\ [])
+  // head!(url, headers \\ [], options \\ [])
+  // options!(url, headers \\ [], options \\ [])
+  // patch!(url, body, headers \\ [], options \\ [])
+  // post!(url, body, headers \\ [], options \\ [])
+  // put!(url, body \\ "", headers \\ [], options \\ [])
+  const methods = ["DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT"];
+  const bodyMethods = ["PATCH", "POST", "PUT"];
+  const method = request.urls[0].method;
+  const methodStr = method.toString();
+  if (!methods.includes(methodStr)) {
+    warnings.push([
+      "bad-method",
+      "Unsupported method " + JSON.stringify(methodStr),
+    ]);
+  }
+
+  const isBodyMethod = bodyMethods.includes(methodStr);
+  const body = getBody(request);
+  const headers = getHeadersDict(request);
+  const params = getQueryDict(request);
+  // params can go in the options argument, but if we're using the full
+  // form, put them as a separate argument.
+  const [options, optionsWithoutParams] = getOptions(request, params);
+
+  if (isBodyMethod || (body === '""' && methods.includes(methodStr))) {
+    // Add args backwards. As soon as we see a non-default value, we have to
+    // add all preceding arguments.
+    let args: string[] = [];
+    let keepArgs = false;
+    keepArgs ||= options !== "[]";
+    if (keepArgs) {
+      args.push(options);
+    }
+    keepArgs ||= headers !== "[]";
+    if (keepArgs) {
+      args.push(headers);
+    }
+    keepArgs ||= body !== '""';
+    if (keepArgs && isBodyMethod) {
+      args.push(body);
+    }
+    args.push(repr(request.urls[0].urlWithoutQueryList));
+    args = args.reverse();
+
+    let s = "response = HTTPoison." + methodStr.toLowerCase() + "!(";
+    if (args.length === 1) {
+      // If we just need the method+URL, keep it all on one line
+      s += args[0];
+    } else {
+      s += "\n";
+      s += "  " + args.join(",\n  ");
+      s += "\n";
+    }
+    return s + ")\n";
+  }
+
+  return `request = %HTTPoison.Request{
+  method: :${method.toLowerCase().toString()},
+  url: ${repr(request.urls[0].urlWithoutQueryList)},
+  body: ${body},
+  headers: ${headers},
+  options: ${optionsWithoutParams},
+  params: ${params}
+}
+
+response = HTTPoison.request(request)
+`;
+}
+
+export function _toElixir(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  return requests.map((r) => requestToElixir(r, warnings)).join("\n");
+}
+
+export function toElixirWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const elixir = _toElixir(requests, warnings);
+  return [elixir, warnings];
+}
+
+export function toElixir(curlCommand: string | string[]): string {
+  return toElixirWarn(curlCommand)[0];
+}

package/src/generators/go.ts

@@ -0,0 +1,269 @@
+import { CCError } from "../utils.js";
+import { Word } from "../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../parse.js";
+import type { Request, Warnings } from "../parse.js";
+
+import { reprStr as pyreprStr } from "./python/python.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "insecure",
+  "no-insecure",
+  "compressed",
+  "no-compressed",
+  "max-time",
+  "form",
+  "form-string",
+]);
+
+const IF_ERR = "\tif err != nil {\n" + "\t\tlog.Fatal(err)\n" + "\t}\n";
+
+// https://go.dev/ref/spec#String_literals
+function reprMaybeBacktick(s: Word, vars: Vars, imports: Set<string>): string {
+  return s.isString() && s.includes('"')
+    ? reprBacktick(s, vars, imports)
+    : repr(s, vars, imports);
+}
+function reprBacktick(s: Word, vars: Vars, imports: Set<string>): string {
+  return s.isString() && !s.includes("`") && !s.includes("\r")
+    ? "`" + s.toString() + "`"
+    : repr(s, vars, imports);
+}
+function reprStr(s: string): string {
+  return pyreprStr(s, '"');
+}
+type Vars = { [key: string]: string };
+function repr(w: Word, vars: Vars, 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("os.Getenv(" + reprStr(t.value) + ")");
+      imports.add("os");
+    } else {
+      // TODO: Command takes a list of arguments .Command("ls", "-l", "-a")
+      // TODO: if there's only one command, it would be nice to name the variable "cmd"
+      const execCall = "exec.Command(" + reprStr(t.value) + ").Output()";
+      let i = 1;
+      let varName = "cmd" + i;
+      // We need to check because we often try to represent the same
+      // token twice and discard one of the attempts.
+      // This is linear time but hopefully there's not that many subcommands.
+      while (varName in vars && vars[varName] !== execCall) {
+        i++;
+        varName = "cmd" + i;
+        if (i > Number.MAX_SAFE_INTEGER) {
+          throw new CCError("lol");
+        }
+      }
+      vars[varName] = execCall;
+      args.push(varName);
+      imports.add("os/exec");
+    }
+  }
+  return args.join(" + ");
+}
+
+function timeoutAtoi(w: Word, vars: Vars, imports: Set<string>): string {
+  if (w.isString()) {
+    const asStr = w.toString();
+    // TODO: check using curl's syntax and convert to Go's float syntax
+    if (/^\d+\.?\d*$/.test(asStr)) {
+      return asStr;
+    }
+  }
+  vars["timeout"] = "strconv.Atoi(" + repr(w, vars, imports) + ")";
+  imports.add("strconv");
+  return "timeout";
+}
+
+export function _toGo(requests: Request[], warnings: Warnings = []): string {
+  const request = getFirst(requests, warnings);
+
+  const imports = new Set<string>(["fmt", "io", "log", "net/http"]);
+  const vars: Vars = {};
+
+  let goCode = "";
+  if (request.multipartUploads) {
+    goCode += "\tform := new(bytes.Buffer)\n";
+    goCode += "\twriter := multipart.NewWriter(form)\n";
+    imports.add("bytes");
+    imports.add("mime/multipart");
+
+    let firstFile = true;
+    let firstField = true;
+    for (const m of request.multipartUploads) {
+      if ("contentFile" in m) {
+        const op = firstFile ? ":=" : "=";
+        firstFile = false;
+        // TODO: Go sends name=<filename> but curl always sends name="data"
+        goCode += `\tfw, err ${op} writer.CreateFormFile(${repr(
+          m.name,
+          vars,
+          imports,
+        )}, filepath.Base(${repr(
+          m.filename ?? m.contentFile,
+          vars,
+          imports,
+        )}))\n`;
+        goCode += IF_ERR;
+        imports.add("path/filepath");
+
+        goCode += `\tfd, err ${op} os.Open(${repr(
+          m.contentFile,
+          vars,
+          imports,
+        )})\n`;
+        goCode += IF_ERR;
+        imports.add("os");
+        goCode += "\tdefer fd.Close()\n";
+        goCode += "\t_, err = io.Copy(fw, fd)\n";
+        goCode += IF_ERR;
+      } else {
+        const op = firstField ? ":=" : "=";
+        firstField = false;
+        goCode += `\tformField, err ${op} writer.CreateFormField(${repr(
+          m.name,
+          vars,
+          imports,
+        )})\n`;
+        goCode += IF_ERR;
+        goCode += `\t_, err = formField.Write([]byte(${reprMaybeBacktick(
+          m.content,
+          vars,
+          imports,
+        )}))\n`;
+      }
+      goCode += "\n";
+    }
+    goCode += "\twriter.Close()\n";
+    goCode += "\n";
+
+    request.headers.delete("content-type");
+  }
+
+  if (request.insecure || request.compressed === false) {
+    goCode += "\ttr := &http.Transport{\n";
+    if (request.insecure) {
+      goCode += "\t\tTLSClientConfig: &tls.Config{InsecureSkipVerify: true},\n";
+      imports.add("crypto/tls");
+    }
+    if (request.compressed === false) {
+      goCode += "\t\tDisableCompression: true,\n";
+    }
+    goCode += "\t}\n";
+  }
+
+  goCode += "\tclient := &http.Client{";
+  if (request.timeout) {
+    goCode += "\n";
+    if (request.insecure || request.compressed === false) {
+      goCode += "\t\tTransport: tr,\n";
+    }
+    goCode +=
+      "\t\tTimeout: " +
+      timeoutAtoi(request.timeout, vars, imports) +
+      " * time.Second,\n";
+    goCode += "\t";
+    imports.add("time");
+  } else if (request.insecure || request.compressed === false) {
+    goCode += "Transport: tr";
+  }
+  goCode += "}\n";
+
+  if (request.data && !request.multipartUploads) {
+    goCode +=
+      "\tvar data = strings.NewReader(" +
+      reprBacktick(request.data, vars, imports) +
+      ")\n";
+    imports.add("strings");
+  }
+
+  goCode +=
+    "\treq, err := http.NewRequest(" +
+    repr(request.urls[0].method, vars, imports) +
+    ", " +
+    repr(request.urls[0].url, vars, imports);
+  goCode +=
+    ", " +
+    (request.multipartUploads ? "form" : request.data ? "data" : "nil") +
+    ")\n";
+  goCode += IF_ERR;
+
+  if (request.headers.length) {
+    for (const [headerName, headerValue] of request.headers) {
+      let start = "\t";
+      if (
+        headerName.toLowerCase().toString() === "accept-encoding" &&
+        // By default Go will automatically decompress gzip,
+        // unless you set DisableCompression to true on the Transport
+        // or pass a custom Accept-Encoding header.
+        // By default curl won't automatically decompress gzip unless
+        // you pass --compressed, but we comment out the header in that
+        // case (request.compressed = undefined) too.
+        request.compressed !== false
+      ) {
+        start += "// ";
+      }
+      goCode +=
+        start +
+        "req.Header.Set(" +
+        repr(headerName, vars, imports) +
+        ", " +
+        reprMaybeBacktick(headerValue || new Word(), vars, imports) +
+        ")\n";
+    }
+  }
+  if (request.multipartUploads) {
+    goCode +=
+      '\treq.Header.Set("Content-Type", writer.FormDataContentType())\n';
+  }
+
+  if (request.urls[0].auth && request.authType === "basic") {
+    const [user, password] = request.urls[0].auth;
+    goCode +=
+      "\treq.SetBasicAuth(" +
+      repr(user, vars, imports) +
+      ", " +
+      repr(password, vars, imports) +
+      ")\n";
+  }
+
+  goCode += "\tresp, err := client.Do(req)\n";
+  goCode += IF_ERR;
+  goCode += "\tdefer resp.Body.Close()\n";
+  goCode += "\tbodyText, err := io.ReadAll(resp.Body)\n";
+  goCode += IF_ERR;
+  goCode += '\tfmt.Printf("%s\\n", bodyText)\n';
+  goCode += "}";
+
+  let preamble = "package main\n\n";
+  preamble += "import (\n";
+  for (const imp of Array.from(imports).sort()) {
+    preamble += '\t"' + imp + '"\n';
+  }
+  preamble += ")\n\n";
+  preamble += "func main() {\n";
+  // TODO: sorts wrong when >9 commands
+  for (const [name, expr] of Array.from(Object.entries(vars)).sort()) {
+    preamble += "\t" + name + ", err := " + expr + "\n";
+    preamble += IF_ERR;
+  }
+  if (Object.values(vars).length) {
+    preamble += "\n";
+  }
+
+  return preamble + goCode + "\n";
+}
+export function toGoWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const go = _toGo(requests, warnings);
+  return [go, warnings];
+}
+export function toGo(curlCommand: string | string[]): string {
+  return toGoWarn(curlCommand)[0];
+}