@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/rust.ts

@@ -0,0 +1,243 @@
+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,
+  "form",
+  "form-string",
+  "max-redirs",
+  "location",
+  "no-location",
+  // "location-trusted",
+  // "no-location-trusted",
+]);
+
+const INDENTATION = " ".repeat(4);
+function indent(line: string, level = 1): string {
+  return INDENTATION.repeat(level) + line;
+}
+
+// https://doc.rust-lang.org/reference/tokens.html
+const regexEscape = /"|\\|\p{C}|[^ \P{Z}]/gu;
+export function reprStr(s: string): string {
+  return (
+    '"' +
+    s.replace(regexEscape, (c: string): string => {
+      switch (c) {
+        case "\n":
+          return "\\n";
+        case "\r":
+          return "\\r";
+        case "\t":
+          return "\\t";
+        case "\0":
+          return "\\0";
+        case "\\":
+          return "\\\\";
+        case '"':
+          return '\\"';
+      }
+      const hex = (c.codePointAt(0) as number).toString(16);
+      if (hex.length <= 2) {
+        return "\\x" + hex.padStart(2, "0");
+      }
+      return "\\u{" + hex + "}";
+    }) +
+    '"'
+  );
+}
+
+export function repr(w: Word, imports: Set<string>): string {
+  const ret: string[] = [];
+  for (const t of w.tokens) {
+    if (typeof t === "string") {
+      ret.push(reprStr(t));
+    } else if (t.type === "variable") {
+      ret.push("env::var(" + reprStr(t.value) + ').unwrap_or("")');
+      imports.add("std::env");
+    } else {
+      // TODO: tokenize subcommand
+      // .new() is only passed the command name, args are given with .arg().arg() or .args([])
+      ret.push("Command::new(" + reprStr(t.value) + ").output().stdout");
+      imports.add("std::process::Command");
+    }
+  }
+  if (ret.length === 1) {
+    return ret[0];
+  }
+  return "[" + ret.join(", ") + "].concat()";
+}
+
+export function _toRust(requests: Request[], warnings: Warnings = []): string {
+  const request = getFirst(requests, warnings);
+
+  const imports = new Set<string>();
+  const lines: string[] = [];
+  lines.push("", "fn main() -> Result<(), Box<dyn std::error::Error>> {");
+
+  if (request.headers.length) {
+    lines.push(indent("let mut headers = header::HeaderMap::new();"));
+    const headerEnum: { [key: string]: string } = {
+      cookie: "header::COOKIE",
+    };
+    for (const [headerName, headerValue] of request.headers) {
+      const enumValue = headerEnum[headerName.toLowerCase().toString()];
+      const name = enumValue || `"${headerName}"`;
+      if (headerValue !== null) {
+        lines.push(
+          indent(
+            `headers.insert(${name}, ${repr(
+              headerValue,
+              imports,
+            )}.parse().unwrap());`,
+          ),
+        );
+      }
+    }
+    lines.push("");
+  }
+
+  if (request.multipartUploads) {
+    lines.push(indent("let form = multipart::Form::new()"));
+    const parts = request.multipartUploads.map((m) => {
+      if ("contentFile" in m) {
+        return indent(
+          `.file(${repr(m.name, imports)}, ${repr(m.contentFile, imports)})?`,
+          2,
+        );
+      }
+      return indent(
+        `.text(${repr(m.name, imports)}, ${repr(m.content, imports)})`,
+        2,
+      );
+    });
+    parts[parts.length - 1] += ";";
+    lines.push(...parts, "");
+  }
+
+  if (!request.followRedirects) {
+    lines.push(indent("let client = reqwest::blocking::Client::builder()"));
+    lines.push(indent(".redirect(reqwest::redirect::Policy::none())", 2));
+    lines.push(indent(".build()", 2));
+    lines.push(indent(".unwrap();", 2));
+  } else if (typeof request.maxRedirects === "undefined") {
+    // Curl's default is following 50 redirects, reqwest's is 10
+    lines.push(indent("let client = reqwest::blocking::Client::new();"));
+  } else {
+    lines.push(indent("let client = reqwest::blocking::Client::builder()"));
+    if (eq(request.maxRedirects, "-1")) {
+      lines.push(
+        indent(
+          ".redirect(reqwest::redirect::Policy::custom(|attempt| { attempt.follow() }))",
+          2,
+        ),
+      );
+    } else {
+      // Insert the --max-redirs value as-is, hoping it's a valid integer
+      lines.push(
+        indent(
+          ".redirect(reqwest::redirect::Policy::limited(" +
+            request.maxRedirects.trim().toString() +
+            "))",
+          2,
+        ),
+      );
+    }
+    lines.push(indent(".build()", 2));
+    lines.push(indent(".unwrap();", 2));
+  }
+
+  const reqwestMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"];
+  if (reqwestMethods.includes(request.urls[0].method.toString())) {
+    lines.push(
+      indent(
+        `let res = client.${request.urls[0].method.toLowerCase()}(${repr(
+          request.urls[0].url,
+          imports,
+        )})`,
+      ),
+    );
+  } else {
+    lines.push(
+      indent(
+        `let res = client.request(${repr(
+          request.urls[0].method,
+          imports,
+        )}, ${repr(request.urls[0].url, imports)})`,
+      ),
+    );
+  }
+
+  if (request.urls[0].auth) {
+    const [user, password] = request.urls[0].auth;
+    lines.push(
+      indent(
+        `.basic_auth(${repr(user, imports)}, Some(${repr(password, imports)}))`,
+        2,
+      ),
+    );
+  }
+
+  if (request.headers.length) {
+    lines.push(indent(".headers(headers)", 2));
+  }
+
+  if (request.multipartUploads) {
+    lines.push(indent(".multipart(form)", 2));
+  } else if (request.data) {
+    if (request.data && request.data.indexOf("\n") !== -1) {
+      // Use raw strings for multiline content
+      lines.push(
+        indent('.body(r#"', 2),
+        request.data.toString(), // TODO: this is wrong
+        '"#',
+        indent(")", 2),
+      );
+    } else {
+      lines.push(indent(`.body(${repr(request.data, imports)})`, 2));
+    }
+  }
+
+  lines.push(
+    indent(".send()?", 2),
+    indent(".text()?;", 2),
+    indent('println!("{}", res);'),
+    "",
+    indent("Ok(())"),
+    "}",
+  );
+
+  const preambleLines = ["extern crate reqwest;"];
+  {
+    // Generate imports.
+    const imports = [
+      { want: "header", condition: !!request.headers.length },
+      { want: "blocking::multipart", condition: !!request.multipartUploads },
+    ]
+      .filter((i) => i.condition)
+      .map((i) => i.want);
+
+    if (imports.length > 1) {
+      preambleLines.push(`use reqwest::{${imports.join(", ")}};`);
+    } else if (imports.length) {
+      preambleLines.push(`use reqwest::${imports[0]};`);
+    }
+  }
+  for (const imp of Array.from(imports).sort()) {
+    preambleLines.push("use " + imp + ";");
+  }
+
+  return [...preambleLines, ...lines].join("\n") + "\n";
+}
+export function toRustWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const rust = _toRust(requests, warnings);
+  return [rust, warnings];
+}
+export function toRust(curlCommand: string | string[]): string {
+  return toRustWarn(curlCommand)[0];
+}

package/src/generators/swift.ts

@@ -0,0 +1,235 @@
+import { Word, eq, mergeWords } 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"]);
+
+// https://docs.swift.org/swift-book/documentation/the-swift-programming-language/stringsandcharacters/
+const regexEscape = /"|\\|\p{C}|[^ \P{Z}]/gu;
+export function reprStr(s: string): string {
+  return (
+    '"' +
+    s.replace(regexEscape, (c: string): string => {
+      switch (c) {
+        case "\x00":
+          return "\\0";
+        case "\\":
+          return "\\\\";
+        case "\t":
+          return "\\t";
+        case "\n":
+          return "\\n";
+        case "\r":
+          return "\\r";
+        case '"':
+          return '\\"';
+      }
+      const hex = (c.codePointAt(0) as number).toString(16);
+      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(
+        "(ProcessInfo.processInfo.environment[" + reprStr(t.value) + '] ?? "")',
+      );
+    } else {
+      args.push("exec(" + reprStr(t.value) + ")");
+      // TODO: add exec()
+    }
+  }
+  return args.join(" + ");
+}
+
+function reprJson(data: any, indent = 0): string {
+  if (typeof data === "string") {
+    return reprStr(data);
+  } else if (typeof data === "number") {
+    return data.toString();
+  } else if (typeof data === "boolean") {
+    return data ? "true" : "false";
+  } else if (data === null) {
+    return "nil";
+  } else if (Array.isArray(data)) {
+    if (data.length === 0) {
+      return "[]";
+    }
+    let code = "[\n";
+    for (const item of data) {
+      code += "    ".repeat(indent + 1) + reprJson(item, indent + 1) + ",\n";
+    }
+    if (code.endsWith(",\n")) {
+      code = code.slice(0, -2) + "\n";
+    }
+    code += "    ".repeat(indent) + "]";
+    return code;
+  } else if (typeof data === "object") {
+    const entries = Object.entries(data);
+    if (entries.length === 0) {
+      return "[:]";
+    }
+    let code = "[\n";
+    for (const [key, value] of entries) {
+      code +=
+        "    ".repeat(indent + 1) +
+        reprStr(key) +
+        ": " +
+        reprJson(value, indent + 1) +
+        ",\n";
+    }
+    if (code.endsWith(",\n")) {
+      code = code.slice(0, -2) + "\n";
+    }
+    code += "    ".repeat(indent) + "]";
+    return code;
+  } else {
+    throw new Error("Unsupported JSON type: " + typeof data);
+  }
+}
+
+function formatData(request: Request, data: Word): [string, string] {
+  const contentType = request.headers.getContentType();
+  if (contentType === "application/x-www-form-urlencoded" && data.isString()) {
+    const [first, ...rest] = data.split("&");
+    let code =
+      "let data = NSMutableData(data: " +
+      repr(first) +
+      ".data(using: .utf8)!)\n";
+    for (const part of rest) {
+      code +=
+        "data.append(" +
+        repr(mergeWords("&", part)) +
+        ".data(using: .utf8)!)\n";
+    }
+    return [code, "request.httpBody = data as Data\n"];
+  } else if (contentType === "application/json" && data.isString()) {
+    const dataStr = data.toString();
+    let parsed;
+    try {
+      parsed = JSON.parse(dataStr);
+      const roundtrips = JSON.stringify(parsed) === dataStr;
+      // Only convert arrays and {} to Swift types
+      if (
+        Array.isArray(parsed) ||
+        (typeof parsed === "object" && parsed !== null)
+      ) {
+        let code = "";
+        code += "let jsonData = " + reprJson(parsed);
+        if (Array.isArray(parsed)) {
+          // TODO: narrow type
+          code += " as [Any]\n";
+        } else {
+          code += " as [String : Any]\n";
+        }
+
+        code +=
+          "let data = try! JSONSerialization.data(withJSONObject: jsonData, options: [])\n";
+        if (!roundtrips) {
+          code += "// let data = " + repr(data) + ".data(using: .utf8)\n";
+        }
+        return [code, "request.httpBody = data as Data\n"];
+      }
+    } catch {}
+  }
+  return ["", "request.httpBody = " + repr(data) + ".data(using: .utf8)\n"];
+}
+
+export function _toSwift(requests: Request[], warnings: Warnings = []): string {
+  const request = getFirst(requests, warnings);
+
+  let code = "import Foundation\n\n";
+
+  let dataCode, dataArgCode;
+  if (request.data) {
+    [dataCode, dataArgCode] = formatData(request, request.data);
+    if (dataCode) {
+      code += dataCode + "\n";
+    }
+  }
+
+  code += "let url = URL(string: " + repr(request.urls[0].url) + ")!\n";
+  if (request.urls[0].auth) {
+    const [username, password] = request.urls[0].auth;
+    code += "\n";
+    code += "let username = " + repr(username) + "\n";
+    code += "let password = " + repr(password) + "\n";
+    code +=
+      'let loginString = String(format: "\\(username):\\(password)", username, password)\n';
+    code += "let loginData = loginString.data(using: String.Encoding.utf8)!\n";
+    code += "let base64LoginString = loginData.base64EncodedString()\n";
+    code += "\n";
+  }
+  if (request.headers.length || request.urls[0].auth) {
+    code += "let headers = [\n";
+    for (const [headerName, headerValue] of request.headers) {
+      if (headerValue === null) {
+        continue;
+      }
+      code += "    " + repr(headerName) + ": " + repr(headerValue) + ",\n";
+    }
+    if (request.urls[0].auth) {
+      const authHeader = request.headers.lowercase
+        ? "authorization"
+        : "Authorization";
+      code += '    "' + authHeader + '": "Basic \\(base64LoginString)",\n';
+    }
+    if (code.endsWith(",\n")) {
+      code = code.slice(0, -2) + "\n";
+    }
+    code += "]\n";
+  }
+  code += "\n";
+
+  code += "var request = URLRequest(url: url";
+  if (request.timeout && !eq(request.timeout, "60.0")) {
+    // TODO: must be double?
+    code += ", timeoutInterval: " + request.timeout.toString();
+  }
+  code += ")\n";
+
+  if (!eq(request.urls[0].method, "GET")) {
+    code += "request.httpMethod = " + repr(request.urls[0].method) + "\n";
+  }
+
+  if (request.headers.length) {
+    code += "request.allHTTPHeaderFields = headers\n";
+  }
+
+  if (dataArgCode) {
+    code += dataArgCode;
+  }
+
+  code += "\n";
+  code +=
+    "let task = URLSession.shared.dataTask(with: request) { (data, response, error) in\n";
+  code += "    if let error = error {\n";
+  code += "        print(error)\n";
+  code += "    } else if let data = data {\n";
+  code += "        let str = String(data: data, encoding: .utf8)\n";
+  code += '        print(str ?? "")\n';
+  code += "    }\n";
+  code += "}\n";
+  code += "\n";
+  code += "task.resume()\n";
+
+  return code;
+}
+
+export function toSwiftWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const code = _toSwift(requests, warnings);
+  return [code, warnings];
+}
+export function toSwift(curlCommand: string | string[]): string {
+  return toSwiftWarn(curlCommand)[0];
+}