@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/matlab/common.ts

@@ -0,0 +1,281 @@
+import { CCError } from "../../utils.js";
+import { Word } from "../../shell/Word.js";
+import type { Request } from "../../parse.js";
+
+// Wrap in brakets so that splitting keeps the characters to escape
+const regexEscape = /(\p{C}|[^ \P{Z}])/gu;
+// TODO: do we need to consider that some strings could be used
+// with sprintf() and have to have more stuff escaped?
+function strToParts(s: string): string[] {
+  if (!s) {
+    return ["''"];
+  }
+  const parts = s
+    .replace(/'/g, "''")
+    .split(regexEscape)
+    .filter((x) => x) // empty strings between consecutive matches
+    .flatMap((x) => {
+      if (x.match(regexEscape)) {
+        if (x.length === 1) {
+          switch (x) {
+            case "\x07":
+              return "sprintf('\\a')";
+            case "\b":
+              return "sprintf('\\b')";
+            case "\f":
+              return "sprintf('\\f')";
+            case "\n":
+              return "newline";
+            case "\r":
+              return "sprintf('\\r')";
+            case "\t":
+              return "sprintf('\\t')";
+            case "\v":
+              return "sprintf('\\v')";
+            default:
+              return `char(${x.charCodeAt(0)})`;
+          }
+        } else {
+          return [`char(${x.charCodeAt(0)})`, `char(${x.charCodeAt(1)})`];
+        }
+      }
+      return "'" + x + "'";
+    });
+  return parts;
+}
+function joinParts(parts: string[]): string {
+  if (parts.length > 1) {
+    return "[" + parts.join(" ") + "]";
+  }
+  if (parts.length === 0) {
+    return "''"; // shouldn't happen
+  }
+  return parts[0];
+}
+function reprStr(s: string): string {
+  return joinParts(strToParts(s));
+}
+function repr(w: Word | null) {
+  // In context of url parameters, don't accept nulls and such.
+  if (w === null || w.length === 0) {
+    return "''";
+  }
+
+  let parts: string[] = [];
+  for (const t of w.tokens) {
+    if (typeof t === "string") {
+      parts = parts.concat(strToParts(t));
+    } else if (t.type === "variable") {
+      // https://www.mathworks.com/help/matlab/ref/getenv.html
+      parts.push("getenv(" + reprStr(t.value) + ")");
+    } else {
+      // TODO: is this array access correct?
+      // https://www.mathworks.com/help/matlab/ref/system.html
+      parts.push("system(" + reprStr(t.value) + "){2}");
+    }
+  }
+  return joinParts(parts);
+}
+
+function setVariableValue(
+  outputVariable: string | null,
+  value: string,
+  termination?: string,
+): string {
+  let result = "";
+
+  if (outputVariable) {
+    result += outputVariable + " = ";
+  }
+
+  result += value;
+  result +=
+    typeof termination === "undefined" || termination === null
+      ? ";"
+      : termination;
+  return result;
+}
+
+function callFunction(
+  outputVariable: string | null,
+  functionName: string,
+  params: string | string[] | string[][],
+  termination?: string,
+) {
+  let functionCall = functionName + "(";
+  if (Array.isArray(params)) {
+    const singleLine = params
+      .map((x) => (Array.isArray(x) ? x.join(", ") : x))
+      .join(", ");
+    const indentLevel = 1;
+    const indent = " ".repeat(4 * indentLevel);
+    const skipToNextLine = "...\n" + indent;
+    let multiLine = skipToNextLine;
+    multiLine += params
+      .map((x) => (Array.isArray(x) ? x.join(", ") : x))
+      .join("," + skipToNextLine);
+    multiLine += "...\n";
+
+    // Split the params in multiple lines - if one line is not enough
+    const combinedSingleLineLength =
+      [outputVariable, functionName, singleLine]
+        .map((x) => (x ? x.length : 0))
+        .reduce((x, y) => x + y) +
+      (outputVariable ? 3 : 0) +
+      2 +
+      (termination ? termination.length : 1);
+    functionCall += combinedSingleLineLength < 120 ? singleLine : multiLine;
+  } else {
+    functionCall += params;
+  }
+  functionCall += ")";
+  return setVariableValue(outputVariable, functionCall, termination);
+}
+
+function addCellArray(
+  mapping: ([Word, Word] | [string, Word | string])[],
+  keysNotToQuote?: string[],
+  indentLevel = 1,
+  pairs?: boolean,
+) {
+  if (mapping.length === 0) return ""; // shouldn't happen
+
+  const indentUnit = " ".repeat(4);
+  const indent = indentUnit.repeat(indentLevel);
+  const indentPrevLevel = indentUnit.repeat(indentLevel - 1);
+  const separator = pairs ? ", " : " ";
+
+  let response = "";
+  if (!pairs) {
+    response += "{";
+  }
+  if (pairs && mapping.length > 1) {
+    response += "...";
+  }
+  for (const [counter, [key, value]] of mapping.entries()) {
+    const k = typeof key === "string" ? reprStr(key) : repr(key);
+    let val: string;
+    if (
+      keysNotToQuote &&
+      keysNotToQuote.includes(key.toLowerCase().toString())
+    ) {
+      val = value.toString();
+    } else {
+      val = typeof value === "string" ? reprStr(value) : repr(value);
+    }
+    if (mapping.length > 1) {
+      response += "\n" + indent;
+    }
+    response += k + separator + val;
+
+    if (pairs && mapping.length > 1) {
+      // Don't add trailing comma
+      if (counter !== mapping.length - 1) {
+        response += ",";
+      }
+      response += "...";
+    }
+  }
+  if (mapping.length > 1) {
+    response += "\n" + indentPrevLevel;
+  }
+  if (!pairs) {
+    response += "}";
+  }
+  return response;
+}
+
+function structify(
+  obj: number[] | string[] | { [key: string]: string } | string | number | null,
+  indentLevel?: number,
+) {
+  let response = "";
+  indentLevel = !indentLevel ? 1 : ++indentLevel;
+  const indent = " ".repeat(4 * indentLevel);
+  const prevIndent = " ".repeat(4 * (indentLevel - 1));
+
+  if (obj instanceof Array) {
+    const list: string[] = [];
+    let listContainsNumbers = true;
+    for (const k in obj) {
+      if (listContainsNumbers && typeof obj[k] !== "number") {
+        listContainsNumbers = false;
+      }
+      const value = structify(obj[k], indentLevel);
+      list.push(`${value}`);
+    }
+    if (listContainsNumbers) {
+      const listString = list.join(" ");
+      response += `[${listString}]`;
+    } else {
+      list.unshift("{{");
+      const listString = list.join(`\n${indent}`);
+      response += `${listString}\n${prevIndent}}}`;
+    }
+  } else if (obj instanceof Object) {
+    response += "struct(...";
+    let first = true;
+    for (const k in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, k)) {
+        if (!k[0].match(/[a-z]/i)) {
+          throw new CCError(
+            "MATLAB structs do not support keys starting with non-alphabet symbols",
+          );
+        }
+        // recursive call to scan property
+        if (first) {
+          first = false;
+        } else {
+          response += ",...";
+        }
+        response += `\n${indent}`;
+        response += `'${k}', `;
+        response += structify(obj[k], indentLevel);
+      }
+    }
+    response += "...";
+    response += `\n${prevIndent})`;
+  } else if (typeof obj === "number") {
+    // not an Object so obj[k] here is a value
+    response += obj.toString();
+  } else {
+    response += obj === null ? "string(nan)" : reprStr(obj);
+  }
+
+  return response;
+}
+
+function containsBody(request: Request): boolean {
+  return Boolean(request.data || request.multipartUploads);
+}
+
+function prepareQueryString(request: Request): string | null {
+  if (!request.urls[0].queryList) {
+    return null;
+  }
+  return setVariableValue("params", addCellArray(request.urls[0].queryList));
+}
+
+function prepareCookies(request: Request): string | null {
+  if (!request.cookies) {
+    return null;
+  }
+  return setVariableValue("cookies", addCellArray(request.cookies));
+}
+
+const cookieString = "char(join(join(cookies, '='), '; '))";
+const paramsString = "char(join(join(params, '='), '&'))";
+
+export {
+  reprStr,
+  repr,
+  setVariableValue,
+  callFunction,
+  addCellArray,
+  structify,
+  containsBody,
+  prepareQueryString,
+  prepareCookies,
+  cookieString,
+  paramsString,
+};

package/src/generators/matlab/httpinterface.ts

@@ -0,0 +1,284 @@
+import { Word } from "../../shell/Word.js";
+import type { Request, Warnings } from "../../parse.js";
+
+import {
+  reprStr,
+  repr,
+  setVariableValue,
+  callFunction,
+  structify,
+  containsBody,
+  prepareQueryString,
+  prepareCookies,
+} from "./common.js";
+
+function prepareHeaders(request: Request): string | null {
+  if (!request.headers.length) {
+    return null;
+  }
+
+  const headerStrs: string[] = [];
+  for (const [key, value] of request.headers) {
+    if (value === null) {
+      continue;
+    }
+    const keyStr = key.toLowerCase().toString();
+    if (keyStr === "cookie" && request.cookies) {
+      // TODO: curl -H 'Cookie: foo=bar' example.com
+      // adds an extra newline before the cookie
+      const cookieFieldParams = callFunction(
+        null,
+        "cellfun",
+        [
+          "@(x) Cookie(x{:})",
+          callFunction(null, "num2cell", ["cookies", "2"], ""),
+        ],
+        "",
+      );
+      headerStrs.push(
+        callFunction(null, "field.CookieField", cookieFieldParams, ""),
+      );
+    } else if (keyStr === "accept") {
+      const accepts = value.split(",");
+      if (accepts.length === 1) {
+        headerStrs.push(`field.AcceptField(MediaType(${repr(value)}))`);
+      } else {
+        let acceptheader = "field.AcceptField([";
+        for (const accept of accepts) {
+          acceptheader += `\n        MediaType(${repr(accept.trim())})`;
+        }
+        acceptheader += "\n    ])";
+        headerStrs.push(acceptheader);
+      }
+    } else {
+      headerStrs.push(`HeaderField(${repr(key)}, ${repr(value)})`);
+    }
+  }
+
+  if (headerStrs.length === 1) {
+    return setVariableValue("header", headerStrs[0]);
+  }
+
+  let header = "[\n";
+  header += "    " + headerStrs.join("\n    ") + "\n";
+  header += "]'";
+  return setVariableValue("header", header);
+}
+
+function prepareURI(request: Request) {
+  const uriParams: string[] = [];
+  if (request.urls[0].queryList) {
+    uriParams.push(repr(request.urls[0].urlWithoutQueryList));
+    uriParams.push("QueryParameter(params')");
+  } else {
+    uriParams.push(repr(request.urls[0].url));
+  }
+  return callFunction("uri", "URI", uriParams);
+}
+
+function prepareAuth(request: Request): string[] {
+  const options: string[] = [];
+  const optionsParams: string[] = [];
+  if (request.urls[0].auth) {
+    const [usr, pass] = request.urls[0].auth;
+    const userfield = `'Username', ${repr(usr)}`;
+    const passfield = `'Password', ${repr(pass)}`;
+    const authparams = (usr.length ? `${userfield}, ` : "") + passfield;
+    optionsParams.push(reprStr("Credentials"), "cred");
+    options.push(callFunction("cred", "Credentials", authparams));
+  }
+
+  if (request.insecure) {
+    optionsParams.push(reprStr("VerifyServerName"), "false");
+  }
+
+  if (optionsParams.length > 0) {
+    options.push(callFunction("options", "HTTPOptions", optionsParams));
+  }
+
+  return options;
+}
+
+function prepareMultipartUploads(request: Request): string | null {
+  if (!request.multipartUploads) {
+    return null;
+  }
+  const params: [string, string][] = [];
+  for (const m of request.multipartUploads) {
+    const readsFile = "contentFile" in m;
+    const value = readsFile ? m.contentFile.prepend("@") : m.content; // TODO: something nicer
+    const fileProvider = prepareDataProvider(
+      value,
+      null,
+      "",
+      1,
+      true,
+      !readsFile,
+    );
+    params.push([repr(m.name), fileProvider as string]); // TODO: can be a string[]
+  }
+  return callFunction("body", "MultipartFormProvider", params);
+}
+
+function isJsonString(str: string): boolean {
+  // Source: https://stackoverflow.com/a/3710226/5625738
+  try {
+    JSON.parse(str);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+// prepareDataProvider(value, null, "", 1, true, !readsFile);
+// prepareDataProvider(request.data, "body", ";", 0, request.isDataBinary, request.isDataRaw);
+function prepareDataProvider(
+  value: Word,
+  output: string | null,
+  termination: string,
+  indentLevel: number,
+  isDataBinary = true,
+  isDataRaw = false,
+): string | string[] {
+  if (!isDataRaw && value.charAt(0) === "@") {
+    const filename = value.slice(1);
+    if (!isDataBinary) {
+      return [
+        callFunction(output, "fileread", repr(filename)),
+        setVariableValue(`${output}(${output}==13 | ${output}==10)`, "[]"),
+      ];
+    }
+    // >> imformats % for seeing MATLAB supported image formats
+    const extension = (filename.split(".")[1] ?? "").toLowerCase().toString();
+    const isImage = ["jpeg", "jpg", "png", "tif", "gif"].includes(extension);
+    const provider = isImage ? "ImageProvider" : "FileProvider";
+    return callFunction(output, provider, repr(filename), termination);
+  }
+
+  if (!value.length) {
+    return callFunction(output, "FileProvider", "", termination);
+  }
+
+  if (value.isString() && isJsonString(value.toString())) {
+    const obj = JSON.parse(value.toString());
+    // If failed to create a struct for the JSON, then return a string
+    try {
+      const structure = structify(obj, indentLevel);
+      return callFunction(output, "JSONProvider", structure, termination);
+    } catch (e) {
+      return callFunction(output, "StringProvider", repr(value), termination);
+    }
+  }
+
+  // TODO: StringProvider should be the default
+  const formValue = value
+    .split("&")
+    .map((x) => x.split("=").map((x) => repr(x)));
+  return callFunction(output, "FormProvider", formValue, termination);
+}
+
+function prepareData(request: Request) {
+  if (!request.data || request.multipartUploads) {
+    return null;
+  }
+
+  if (request.data && request.data.split("&", 2).length > 1) {
+    const data = request.data.split("&").map((x: Word) =>
+      x.split("=").map((x) => {
+        let ans = repr(x);
+        if (x.isString()) {
+          try {
+            const jsonData = JSON.parse(x.toString());
+            if (typeof jsonData === "object") {
+              ans = callFunction(
+                null,
+                "JSONProvider",
+                structify(jsonData, 1),
+                "",
+              );
+            }
+          } catch (e) {}
+        }
+
+        return ans;
+      }),
+    );
+    return callFunction("body", "FormProvider", data);
+  }
+
+  let response = prepareDataProvider(
+    request.data,
+    "body",
+    ";",
+    0,
+    !!request.isDataBinary,
+    !!request.isDataRaw,
+  );
+  if (!response) {
+    response = setVariableValue("body", repr(request.data));
+  }
+  return response;
+}
+
+function prepareRequestMessage(request: Request): string {
+  const method = request.urls[0].method.toLowerCase();
+  let reqMessage: string[] | string = [repr(method)];
+  if (request.headers.length) {
+    reqMessage.push("header");
+  }
+  if (containsBody(request)) {
+    if (reqMessage.length === 1) {
+      reqMessage.push("[]");
+    }
+    reqMessage.push("body");
+  }
+
+  if (
+    !request.headers.length &&
+    !containsBody(request) &&
+    method.toString() === "get"
+  ) {
+    reqMessage = ""; // TODO: just empty array?
+  }
+
+  const params = ["uri.EncodedURI"];
+  if (request.urls[0].auth || request.insecure) {
+    params.push("options");
+  }
+
+  const response = [
+    callFunction(
+      "response",
+      "RequestMessage",
+      reqMessage,
+      callFunction(null, ".send", params),
+    ),
+  ];
+
+  return response.join("\n");
+}
+
+export function toHTTPInterface(
+  request: Request,
+  warnings: Warnings,
+): [(string | string[] | null)[], Warnings] {
+  return [
+    [
+      "%% HTTP Interface",
+      "import matlab.net.*",
+      "import matlab.net.http.*",
+      containsBody(request) ? "import matlab.net.http.io.*" : null,
+      "",
+      prepareQueryString(request),
+      prepareCookies(request),
+      prepareHeaders(request),
+      prepareURI(request),
+      prepareAuth(request),
+      prepareMultipartUploads(request),
+      prepareData(request),
+      prepareRequestMessage(request),
+      "",
+    ],
+    warnings,
+  ];
+}

package/src/generators/matlab/matlab.ts

@@ -0,0 +1,39 @@
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+
+import { toWebServices } from "./webservices.js";
+import { toHTTPInterface } from "./httpinterface.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "insecure",
+  "no-insecure",
+  "form",
+  "form-string",
+]);
+
+export function _toMATLAB(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+
+  const [webServicesLines] = toWebServices(request, warnings);
+  const [httpInterfaceLines] = toHTTPInterface(request, warnings);
+  const lines = webServicesLines.concat("", httpInterfaceLines);
+  return lines
+    .flat()
+    .filter((line) => line !== null)
+    .join("\n");
+}
+export function toMATLABWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const matlab = _toMATLAB(requests, warnings);
+  return [matlab, warnings];
+}
+export function toMATLAB(curlCommand: string | string[]): string {
+  return toMATLABWarn(curlCommand)[0];
+}