@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/php/guzzle.ts

@@ -0,0 +1,368 @@
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import { eq } from "../../shell/Word.js";
+import type { Request, Warnings } from "../../parse.js";
+import { parseQueryString } from "../../Query.js";
+
+import { reprStr, repr } from "./php.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "form",
+  "form-string",
+
+  "digest",
+  "no-digest",
+  "ntlm",
+  "no-ntlm",
+  "ntlm-wb",
+  "no-ntlm-wb",
+
+  "http3",
+  "http3-only",
+  "http2",
+  "http2-prior-knowledge",
+
+  "max-time",
+  "connect-timeout",
+
+  "insecure",
+  "no-insecure",
+  "cacert",
+  "capath",
+  "cert",
+  "key",
+
+  "compressed", // TODO: check behavior
+  "no-compressed",
+
+  "location",
+  "no-location",
+
+  "proxy",
+  "noproxy",
+]);
+
+function removeTrailingComma(str: string): string {
+  if (str.endsWith(",\n")) {
+    return str.slice(0, -2) + "\n";
+  }
+  return str;
+}
+
+function jsonToPhp(obj: any, indent = 0): string {
+  if (obj === null) {
+    return "null";
+  }
+  if (typeof obj === "boolean") {
+    return obj ? "true" : "false";
+  }
+  if (typeof obj === "number") {
+    return obj.toString();
+  }
+  if (typeof obj === "string") {
+    return reprStr(obj);
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return "[]";
+    }
+    let str = "[\n";
+    for (const item of obj) {
+      str += " ".repeat(indent + 4);
+      str += jsonToPhp(item, indent + 4);
+      str += ",\n";
+    }
+    str = removeTrailingComma(str);
+    str += " ".repeat(indent);
+    str += "]";
+    return str;
+  }
+  if (typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) {
+      return "new stdClass()";
+    }
+    let str = "[\n";
+    for (const [key, value] of entries) {
+      str += " ".repeat(indent + 4);
+      str += reprStr(key);
+      str += " => ";
+      str += jsonToPhp(value, indent + 4);
+      str += ",\n";
+    }
+    str = removeTrailingComma(str);
+    str += " ".repeat(indent);
+    str += "]";
+    return str;
+  }
+  throw new Error("Unknown type");
+}
+
+function jsonStrToPhp(obj: string, indent = 0): [string, boolean] {
+  const json = JSON.parse(obj);
+  if (json === null) {
+    throw new Error("null as a top level JSON object doesn't work");
+  }
+  const jsonAsPhp = jsonToPhp(json, indent);
+  const roundtrips = JSON.stringify(json) === obj;
+  return [jsonAsPhp, roundtrips];
+}
+
+export function _toPhpGuzzle(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+  const url = request.urls[0].queryDict
+    ? request.urls[0].urlWithoutQueryList
+    : request.urls[0].url;
+  const method = request.urls[0].method;
+
+  const imports = new Set<string>(["GuzzleHttp\\Client"]);
+
+  let guzzleCode = "$client = new Client();\n\n";
+  guzzleCode += "$response = $client->";
+
+  const methods = ["GET", "DELETE", "HEAD", "OPTIONS", "PATCH", "POST", "PUT"];
+  if (method.isString() && methods.includes(method.toString())) {
+    guzzleCode += method.toString().toLowerCase() + "(";
+  } else {
+    guzzleCode += "request(" + repr(method) + ", ";
+  }
+
+  let options = "";
+
+  if (request.urls[0].queryDict) {
+    options += "    'query' => [\n";
+    for (const [name, value] of request.urls[0].queryDict) {
+      options += `        ${repr(name)} => `;
+      if (Array.isArray(value)) {
+        options += "[\n";
+        for (const v of value) {
+          options += `            ${repr(v)},\n`;
+        }
+        options = removeTrailingComma(options);
+        options += "        ],\n";
+      } else {
+        options += `${repr(value)},\n`;
+      }
+    }
+    options = removeTrailingComma(options);
+    options += "    ],\n";
+  }
+
+  if (request.headers.length) {
+    const headerReprs = [];
+    for (const [name, value] of request.headers) {
+      if (value === null) {
+        continue;
+      }
+      headerReprs.push([repr(name), repr(value)]);
+    }
+
+    if (headerReprs.length) {
+      const longestHeader = Math.max(...headerReprs.map((h) => h[0].length));
+      options += "    'headers' => [\n";
+      for (const [name, value] of headerReprs) {
+        options += `        ${name.padEnd(longestHeader)} => ${value},\n`;
+      }
+      options = removeTrailingComma(options);
+      options += "    ],\n";
+    }
+  }
+
+  if (request.urls[0].auth) {
+    const [user, password] = request.urls[0].auth;
+    options += `    'auth' => [${repr(user)}, ${repr(password)}`;
+    switch (request.authType) {
+      case "basic":
+      case "none": // shouldn't happen?
+        break;
+      case "digest":
+        options += ", 'digest'";
+        break;
+      case "ntlm":
+      case "ntlm-wb":
+        options += ", 'ntlm'";
+        break;
+      default:
+        warnings.push([
+          "unsupported-auth-type",
+          "Guzzle does not support ${request.authType} authentication",
+        ]);
+        break;
+    }
+
+    options += "],\n";
+  }
+
+  // TODO: \GuzzleHttp\Cookie\CookieJar::fromArray
+
+  if (request.urls[0].uploadFile) {
+    options += `    'body' => Psr7\\Utils::tryFopen(${repr(
+      request.urls[0].uploadFile,
+    )}, 'r')\n`;
+    imports.add("GuzzleHttp\\Psr7");
+  } else if (request.multipartUploads) {
+    options += "    'multipart' => [\n";
+    for (const m of request.multipartUploads) {
+      options += "        [\n";
+      options += `            'name' => ${repr(m.name)},\n`;
+
+      if ("content" in m) {
+        options += `            'contents' => ${repr(m.content)},\n`;
+      } else {
+        if (m.filename && !eq(m.filename, m.contentFile)) {
+          options += `            'filename' => ${repr(m.filename)},\n`;
+        }
+        options += `            'contents' => Psr7\\Utils::tryFopen(${repr(
+          m.contentFile,
+        )}, 'r'),\n`;
+        imports.add("GuzzleHttp\\Psr7");
+        // TODO: set content type from file extension
+      }
+
+      options = removeTrailingComma(options);
+      options += "        ],\n";
+    }
+
+    options = removeTrailingComma(options);
+    options += "    ],\n";
+    // TODO: remove some headers?
+  } else if (request.data) {
+    const contentType = request.headers.getContentType();
+    if (contentType === "application/x-www-form-urlencoded") {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const [_, queryAsDict] = parseQueryString(request.data);
+      if (queryAsDict) {
+        options += "    'form_params' => [\n";
+        for (const [name, value] of queryAsDict) {
+          options += `        ${repr(name)} => `;
+          if (Array.isArray(value)) {
+            options += "[\n";
+            for (const v of value) {
+              options += `            ${repr(v)},\n`;
+            }
+            options = removeTrailingComma(options);
+            options += "        ],\n";
+          } else {
+            options += `${repr(value)},\n`;
+          }
+        }
+
+        options = removeTrailingComma(options);
+        options += "    ],\n";
+        // TODO: remove some headers?
+      } else {
+        options += `    'body' => ${repr(request.data)},\n`;
+      }
+    } else if (contentType === "application/json" && request.data.isString()) {
+      // TODO: parse JSON into PHP
+      try {
+        const [json, roundtrips] = jsonStrToPhp(request.data.toString(), 4);
+        if (!roundtrips) {
+          options += `    // 'body' => ${repr(request.data)},\n`;
+        }
+        options += `    'json' => ${json},\n`;
+        // TODO: remove some headers?
+      } catch {
+        options += `    'body' => ${repr(request.data)},\n`;
+      }
+    } else {
+      options += `    'body' => ${repr(request.data)},\n`;
+    }
+  }
+
+  // TODO: put --proxy-user in proxy URL
+  if (request.noproxy) {
+    options += `    'proxy' => [\n`;
+    if (request.proxy) {
+      options += `        'http' => ${repr(request.proxy)},\n`;
+      options += `        'https' => ${repr(request.proxy)},\n`;
+    }
+    const noproxies = request.noproxy.split(",").map((s) => s.trim());
+    options += `        'no' => [${noproxies
+      .map((np) => repr(np))
+      .join(", ")}]\n`;
+    options += "    ],\n";
+  } else if (request.proxy) {
+    // TODO: is this right for SOCKS proxies?
+    options += `    'proxy' => ${repr(request.proxy)},\n`;
+  }
+
+  if (request.timeout) {
+    options += `    'timeout' => ${
+      parseFloat(request.timeout.toString()) || 0
+    },\n`;
+  }
+  if (request.connectTimeout) {
+    options += `    'connect_timeout' => ${
+      parseFloat(request.connectTimeout.toString()) || 0
+    },\n`;
+  }
+
+  if (request.followRedirects === false) {
+    options += "    'allow_redirects' => false,\n";
+  }
+
+  if (request.insecure) {
+    options += "    'verify' => false,\n";
+  } else if (request.cacert) {
+    options += `    'verify' => ${repr(request.cacert)},\n`;
+  } else if (request.capath) {
+    options += `    'verify' => ${repr(request.capath)},\n`;
+  }
+  if (request.cert) {
+    const [cert, password] = request.cert;
+    if (password) {
+      options += `    'cert' => [${repr(cert)}, ${repr(password)}],\n`;
+    } else {
+      options += `    'cert' => ${repr(cert)},\n`;
+    }
+  }
+  if (request.key) {
+    options += `    'ssl_key' => ${repr(request.key)},\n`;
+  }
+
+  if (request.http3) {
+    options += "    'http_version' => 3.0,\n";
+  } else if (request.http2) {
+    options += "    'http_version' => 2.0,\n";
+  }
+
+  options = removeTrailingComma(options);
+
+  guzzleCode += repr(url);
+  if (options) {
+    guzzleCode += ", [\n";
+    guzzleCode += options;
+
+    guzzleCode += "]";
+  }
+  guzzleCode += ");";
+
+  return (
+    "<?php\n" +
+    "require 'vendor/autoload.php';\n\n" +
+    Array.from(imports)
+      .sort()
+      .map((i) => "use " + i + ";\n")
+      .join("") +
+    "\n" +
+    guzzleCode +
+    "\n"
+  );
+}
+
+export function toPhpGuzzleWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const guzzle = _toPhpGuzzle(requests, warnings);
+  return [guzzle, warnings];
+}
+
+export function toPhpGuzzle(curlCommand: string | string[]): string {
+  return toPhpGuzzleWarn(curlCommand)[0];
+}

package/src/generators/php/php.ts

@@ -0,0 +1,239 @@
+import { Word, eq, joinWords } 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",
+  "insecure",
+  "no-insecure",
+  "compressed",
+  "no-compressed",
+  "digest",
+  "no-digest",
+  "location",
+  "no-location",
+  // "location-trusted",
+  // "no-location-trusted",
+  "form",
+  "form-string",
+  "proxy",
+  "proxy-user",
+  "unix-socket",
+]);
+
+// https://www.php.net/manual/en/language.types.string.php
+// https://www.php.net/manual/en/language.types.string.php#language.types.string.details
+// https://www.unicode.org/reports/tr44/#GC_Values_Table
+// https://unicode.org/Public/UNIDATA/UnicodeData.txt
+// https://en.wikipedia.org/wiki/Plane_(Unicode)#Overview
+const regexSingleEscape = /'|\\/gu;
+const regexDoubleEscape = /"|\$|\\|\p{C}|[^ \P{Z}]/gu;
+export function reprStr(s: string): string {
+  let [quote, regex] = ["'", regexSingleEscape];
+  if ((s.includes("'") && !s.includes('"')) || /[^\x20-\x7E]/.test(s)) {
+    [quote, regex] = ['"', regexDoubleEscape];
+  }
+
+  return (
+    quote +
+    s.replace(regex, (c: string) => {
+      switch (c) {
+        // https://www.php.net/manual/en/language.types.string.php#language.types.string.syntax.double
+        case "$":
+          return quote === "'" ? "$" : "\\$";
+        case "\\":
+          return "\\\\";
+        case "'":
+        case '"':
+          return c === quote ? "\\" + c : c;
+        // The rest of these should not appear in single quotes
+        case "\n":
+          return "\\n";
+        case "\r":
+          return "\\r";
+        case "\t":
+          return "\\t";
+        case "\v":
+          return "\\v";
+        case "\x1B":
+          return "\\e";
+        case "\f":
+          return "\\f";
+      }
+
+      const hex = (c.codePointAt(0) as number).toString(16);
+      if (hex.length > 2) {
+        return "\\u{" + hex + "}";
+      }
+      return "\\x" + hex.padStart(2, "0");
+    }) +
+    quote
+  );
+}
+
+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("getenv(" + reprStr(t.value) + ") ?? " + reprStr(""));
+    } else if (t.type === "command") {
+      // TODO: use backticks instead
+      args.push("shell_exec(" + reprStr(t.value) + ")");
+    }
+  }
+  return args.join(" . ");
+}
+
+export function _toPhp(requests: Request[], warnings: Warnings = []): string {
+  // TODO: only reading one file is supported
+  const request = getFirst(requests, warnings, { dataReadsFile: true });
+
+  let cookieString;
+  if (request.headers.has("cookie")) {
+    cookieString = request.headers.get("cookie");
+    request.headers.delete("cookie");
+  }
+
+  let phpCode = "<?php\n";
+  phpCode += "$ch = curl_init();\n";
+  phpCode +=
+    "curl_setopt($ch, CURLOPT_URL, " + repr(request.urls[0].url) + ");\n";
+  phpCode += "curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);\n";
+  phpCode +=
+    "curl_setopt($ch, CURLOPT_CUSTOMREQUEST, " +
+    repr(request.urls[0].method) +
+    ");\n";
+
+  if (request.compressed) {
+    request.headers.setIfMissing("Accept-Encoding", "gzip");
+  }
+  if (request.headers.length) {
+    let headersArrayCode = "[\n";
+
+    for (const [headerName, headerValue] of request.headers) {
+      if (headerValue === null) {
+        continue;
+      }
+      headersArrayCode +=
+        "    " + repr(joinWords([headerName, headerValue], ": ")) + ",\n";
+    }
+
+    headersArrayCode += "]";
+    phpCode +=
+      "curl_setopt($ch, CURLOPT_HTTPHEADER, " + headersArrayCode + ");\n";
+  }
+
+  if (cookieString) {
+    phpCode +=
+      "curl_setopt($ch, CURLOPT_COOKIE, " + repr(cookieString) + ");\n";
+  }
+
+  if (request.urls[0].auth && ["basic", "digest"].includes(request.authType)) {
+    const authType =
+      request.authType === "digest" ? "CURLAUTH_DIGEST" : "CURLAUTH_BASIC";
+    phpCode += "curl_setopt($ch, CURLOPT_HTTPAUTH, " + authType + ");\n";
+    phpCode +=
+      "curl_setopt($ch, CURLOPT_USERPWD, " +
+      repr(joinWords(request.urls[0].auth, ":")) +
+      ");\n";
+  }
+
+  if (request.data || request.multipartUploads) {
+    let requestDataCode = "";
+    if (request.multipartUploads) {
+      requestDataCode = "[\n";
+      for (const m of request.multipartUploads) {
+        requestDataCode += "    " + repr(m.name) + " => ";
+        if ("contentFile" in m) {
+          requestDataCode += "new CURLFile(" + repr(m.contentFile);
+          if (m.contentType) {
+            requestDataCode += ", " + repr(m.contentType);
+          }
+          if (m.filename && !eq(m.filename, m.contentFile)) {
+            if (!m.contentType) {
+              // This actually sets it to the default, application/octet-stream
+              requestDataCode += ", null";
+            }
+            requestDataCode += ", " + repr(m.filename);
+          }
+          requestDataCode += ")";
+        } else {
+          if ("filename" in m && m.filename) {
+            requestDataCode += "new CURLStringFile(" + repr(m.content);
+            requestDataCode += ", " + repr(m.filename);
+            if (m.contentType) {
+              requestDataCode += ", " + repr(m.contentType);
+            }
+            requestDataCode += ")";
+          } else {
+            requestDataCode += repr(m.content);
+          }
+        }
+        requestDataCode += ",\n";
+      }
+      requestDataCode += "]";
+    } else if (request.isDataBinary && request.data!.charAt(0) === "@") {
+      // TODO: do this properly with .dataArray
+      requestDataCode =
+        "file_get_contents(" + repr(request.data!.slice(1)) + ")";
+    } else {
+      requestDataCode = repr(request.data!);
+    }
+    phpCode +=
+      "curl_setopt($ch, CURLOPT_POSTFIELDS, " + requestDataCode + ");\n";
+  }
+
+  if (request.proxy) {
+    phpCode +=
+      "curl_setopt($ch, CURLOPT_PROXY, " + repr(request.proxy) + ");\n";
+    if (request.proxyAuth) {
+      phpCode +=
+        "curl_setopt($ch, CURLOPT_PROXYUSERPWD, " +
+        repr(request.proxyAuth) +
+        ");\n";
+    }
+  }
+
+  if (request.timeout) {
+    phpCode +=
+      "curl_setopt($ch, CURLOPT_TIMEOUT, " +
+      (parseInt(request.timeout.toString(), 10) || 0) +
+      ");\n";
+  }
+
+  if (request.unixSocket) {
+    phpCode +=
+      "curl_setopt($ch, CURLOPT_UNIX_SOCKET_PATH, " +
+      repr(request.unixSocket) +
+      ");\n";
+  }
+
+  if (request.followRedirects) {
+    phpCode += "curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);\n";
+  }
+
+  if (request.insecure) {
+    phpCode += "curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);\n";
+    phpCode += "curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);\n";
+  }
+
+  phpCode += "\n$response = curl_exec($ch);\n\n";
+
+  phpCode += "curl_close($ch);\n";
+  return phpCode;
+}
+
+export function toPhpWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const php = _toPhp(requests, warnings);
+  return [php, warnings];
+}
+export function toPhp(curlCommand: string | string[]): string {
+  return toPhpWarn(curlCommand)[0];
+}

package/src/generators/php/requests.ts

@@ -0,0 +1,103 @@
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+import { parseQueryString } from "../../Query.js";
+
+import { repr } from "./php.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  // "form",
+  // "form-string",
+]);
+
+export function _toPhpRequests(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+
+  let headerString: string;
+  if (request.headers.length) {
+    headerString = "$headers = array(\n";
+    let i = 0;
+    for (const [headerName, headerValue] of request.headers) {
+      if (headerValue === null) {
+        continue; // TODO: this could miss not adding a trailing comma
+      }
+      headerString += "    " + repr(headerName) + " => " + repr(headerValue);
+      if (i < request.headers.length - 1) {
+        headerString += ",\n";
+      }
+      i++;
+    }
+    headerString += "\n);";
+  } else {
+    headerString = "$headers = array();";
+  }
+
+  let optionsString;
+  if (request.urls[0].auth) {
+    const [user, password] = request.urls[0].auth;
+    optionsString =
+      "$options = array('auth' => array(" +
+      repr(user) +
+      ", " +
+      repr(password) +
+      "));";
+  }
+
+  let dataString;
+  if (request.data) {
+    const [parsedQueryString] = parseQueryString(request.data);
+    dataString = "$data = array(\n";
+    if (!parsedQueryString || !parsedQueryString.length) {
+      dataString = "$data = " + repr(request.data) + ";";
+    } else {
+      const terms: string[] = [];
+      for (const q of parsedQueryString) {
+        const [key, value] = q;
+        terms.push("    " + repr(key) + " => " + repr(value));
+      }
+      dataString += terms.join(",\n") + "\n);";
+    }
+  }
+  let requestLine =
+    "$response = Requests::" +
+    request.urls[0].method.toLowerCase().toString() +
+    "(" +
+    repr(request.urls[0].url);
+  requestLine += ", $headers";
+  if (dataString) {
+    requestLine += ", $data";
+  }
+  if (optionsString) {
+    requestLine += ", $options";
+  }
+  requestLine += ");";
+
+  let phpCode = "<?php\n";
+  phpCode += "include('vendor/rmccue/requests/library/Requests.php');\n";
+  phpCode += "Requests::register_autoloader();\n";
+  phpCode += headerString + "\n";
+  if (dataString) {
+    phpCode += dataString + "\n";
+  }
+  if (optionsString) {
+    phpCode += optionsString + "\n";
+  }
+
+  phpCode += requestLine;
+
+  return phpCode + "\n";
+}
+export function toPhpRequestsWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const php = _toPhpRequests(requests, warnings);
+  return [php, warnings];
+}
+export function toPhpRequests(curlCommand: string | string[]): string {
+  return toPhpRequestsWarn(curlCommand)[0];
+}