@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/matlab/webservices.ts

@@ -0,0 +1,263 @@
+import { Word, joinWords } from "../../shell/Word.js";
+import type { Request, Warnings } from "../../parse.js";
+
+import {
+  reprStr,
+  repr,
+  setVariableValue,
+  callFunction,
+  addCellArray,
+  structify,
+  containsBody,
+  prepareQueryString,
+  prepareCookies,
+  cookieString,
+  paramsString,
+} from "./common.js";
+
+function isSupportedByWebServices(request: Request): boolean {
+  return (
+    ["get", "post", "put", "delete", "patch"].includes(
+      request.urls[0].method.toLowerCase().toString(),
+    ) &&
+    !request.multipartUploads &&
+    !request.insecure
+  );
+}
+
+interface Options {
+  RequestMethod?: Word;
+
+  Username?: Word;
+  Password?: Word;
+
+  UserAgent?: Word;
+  MediaType?: Word;
+  ContentType?: string;
+  HeaderFields?: string;
+}
+
+function setHeader(
+  headers: [Word, Word][],
+  header: Word,
+  value: Word,
+  lowercase: boolean,
+) {
+  headers.push([lowercase ? header.toLowerCase() : header, value]);
+}
+
+function parseWebOptions(request: Request): Options {
+  const options: Options = {};
+
+  // MATLAB uses GET in `webread` and POST in `webwrite` by default
+  // thus, it is necessary to set the method for other requests
+  const method = request.urls[0].method.toLowerCase().toString();
+  if (method !== "get" && method !== "post") {
+    options.RequestMethod = request.urls[0].method.toLowerCase();
+  }
+
+  const headers: [Word, Word][] = [];
+  const preformattedHeaders: string[] = [];
+  if (request.urls[0].auth) {
+    const [username, password] = request.urls[0].auth;
+    if (username.length) {
+      options.Username = username;
+      options.Password = password;
+    } else {
+      const authHeader = `['Basic ' matlab.net.base64encode(${repr(
+        joinWords(request.urls[0].auth, ":"),
+      )})]`;
+      setHeader(
+        headers,
+        new Word("Authorization"),
+        new Word(authHeader),
+        request.headers.lowercase,
+      );
+      preformattedHeaders.push("authorization");
+    }
+  }
+
+  if (request.headers.length) {
+    for (const [header, value] of request.headers) {
+      if (value === null) {
+        continue;
+      }
+      // Doing this case insensitively probably makes MATLAB send title-cased headers
+      switch (header.toLowerCase().toString()) {
+        case "user-agent":
+          options.UserAgent = value;
+          break;
+        case "content-type":
+          options.MediaType = value;
+          break;
+        case "cookie":
+          if (request.cookies) {
+            setHeader(
+              headers,
+              new Word("Cookie"),
+              new Word(cookieString),
+              request.headers.lowercase,
+            );
+            preformattedHeaders.push("cookie");
+          } else {
+            setHeader(headers, header, value, request.headers.lowercase);
+          }
+          break;
+        case "accept":
+          switch (value.toLowerCase().toString()) {
+            case "application/json":
+              options.ContentType = "json";
+              break;
+            case "text/csv":
+              options.ContentType = "table";
+              break;
+            case "text/plain":
+            case "text/html":
+            case "application/javascript":
+            case "application/x-javascript":
+            case "application/x-www-form-urlencoded":
+              options.ContentType = "text";
+              break;
+            case "text/xml":
+            case "application/xml":
+              options.ContentType = "xmldom";
+              break;
+            case "application/octet-stream":
+              options.ContentType = "binary";
+              break;
+            default:
+              if (value.startsWith("image/")) {
+                options.ContentType = "image";
+              } else if (value.startsWith("audio/")) {
+                options.ContentType = "audio";
+              } else {
+                setHeader(headers, header, value, request.headers.lowercase);
+              }
+          }
+          break;
+        default:
+          setHeader(headers, header, value, request.headers.lowercase);
+      }
+    }
+  }
+
+  if (headers.length > 0) {
+    // If key is on the same line as 'weboptions', there is only one parameter
+    // otherwise keys are indented by one level in the next line.
+    // An extra indentation level is given to the values's new lines in cell array
+    const indentLevel = 1 + (Object.keys(options).length === 0 ? 0 : 1);
+    options.HeaderFields = addCellArray(
+      headers,
+      preformattedHeaders,
+      indentLevel,
+    );
+  }
+
+  return options;
+}
+
+function prepareOptions(request: Request, options: Options): string[] {
+  const lines: string[] = [];
+  if (Object.keys(options).length === 0) {
+    return lines;
+  }
+  const pairValues = addCellArray(
+    Object.entries(options),
+    ["headerfields"],
+    1,
+    true,
+  );
+  lines.push(callFunction("options", "weboptions", pairValues));
+
+  return lines;
+}
+
+function prepareBasicURI(request: Request): string[] {
+  const response: string[] = [];
+  if (request.urls[0].queryList) {
+    response.push(
+      setVariableValue("baseURI", repr(request.urls[0].urlWithoutQueryList)),
+    );
+    response.push(setVariableValue("uri", `[baseURI '?' ${paramsString}]`));
+  } else {
+    response.push(setVariableValue("uri", repr(request.urls[0].url)));
+  }
+  return response;
+}
+
+function prepareBasicData(request: Request): string | string[] {
+  if (request.data && request.data.length === 0) {
+    return setVariableValue("body", repr(new Word()));
+  }
+  if (!request.data) {
+    return [];
+  }
+  let response: string | string[] = [];
+  if (request.data.charAt(0) === "@") {
+    response.push(
+      callFunction("body", "fileread", repr(request.data.slice(1))),
+    );
+
+    if (!request.isDataBinary) {
+      response.push(setVariableValue("body(body==13 | body==10)", "[]"));
+    }
+  } else if (request.data.isString()) {
+    // if the data is in JSON, store it as struct in MATLAB
+    // otherwise just keep it as a char vector
+    try {
+      const jsonData = JSON.parse(request.data?.toString());
+      if (typeof jsonData === "object") {
+        let jsonText = structify(jsonData);
+        if (!jsonText.startsWith("struct")) jsonText = reprStr(jsonText);
+        response = setVariableValue("body", jsonText);
+      } else {
+        response = setVariableValue("body", repr(request.data));
+      }
+    } catch (e) {
+      response = setVariableValue("body", repr(request.data));
+    }
+  }
+  return response;
+}
+
+function prepareWebCall(request: Request, options: Options): string[] {
+  const lines: string[] = [];
+  const webFunction = containsBody(request) ? "webwrite" : "webread";
+
+  const params = ["uri"];
+  if (containsBody(request)) {
+    params.push("body");
+  }
+  if (Object.keys(options).length > 0) {
+    params.push("options");
+  }
+  lines.push(callFunction("response", webFunction, params));
+
+  return lines;
+}
+
+export function toWebServices(
+  request: Request,
+  warnings: Warnings,
+): [(string | string[] | null)[], Warnings] {
+  let lines: (string | string[] | null)[] = [
+    "%% Web Access using Data Import and Export API",
+  ];
+
+  if (!isSupportedByWebServices(request)) {
+    lines.push("% This is not possible with the webread/webwrite API");
+    return [lines, warnings];
+  }
+
+  const options = parseWebOptions(request);
+  lines = lines.concat([
+    prepareQueryString(request),
+    prepareCookies(request),
+    prepareBasicURI(request),
+    prepareBasicData(request),
+    prepareOptions(request, options),
+    prepareWebCall(request, options),
+  ]);
+
+  return [lines, warnings];
+}

package/src/generators/objectivec.ts

@@ -0,0 +1,297 @@
+import { Word, eq, mergeWords } from "../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../parse.js";
+import type { Request, Warnings } from "../parse.js";
+import type { DataParam } from "../Request.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  // TODO
+  // "form",
+  // "form-string",
+  "max-time",
+]);
+
+// Presumably the same as C strings
+// https://en.wikipedia.org/wiki/Escape_sequences_in_C#Table_of_escape_sequences
+const regexEscape = /"|\\|\p{C}|[^ \P{Z}]/gu;
+export function reprStr(s: string): string {
+  return (
+    '@"' +
+    s.replace(regexEscape, (c: string) => {
+      switch (c) {
+        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 "\\":
+          return "\\\\";
+        case '"':
+          return '\\"';
+      }
+      const hex = (c.codePointAt(0) as number).toString(16);
+      if (hex.length <= 2) {
+        return "\\x" + hex.padStart(2, "0");
+      }
+      if (hex.length <= 4) {
+        return "\\u" + hex.padStart(4, "0");
+      }
+      return "\\U" + hex.padStart(8, "0");
+    }) +
+    '"'
+  );
+}
+
+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") {
+      // TODO: turns into "(null)" if variable doesn't exist
+      args.push(
+        "[[[NSProcessInfo processInfo] environment] objectForKey:" +
+          reprStr(t.value) +
+          "]",
+      );
+    } else if (t.type === "command") {
+      // TODO: doesn't return the output
+      args.push("system(" + reprStr(t.value) + ")");
+    }
+  }
+  if (args.length === 1) {
+    return args[0];
+  }
+  // This is how you concatenate strings in Objective-C.
+  return (
+    '[NSString stringWithFormat:@"' +
+    "%@".repeat(args.length) +
+    '", ' +
+    args.join(", ") +
+    "]"
+  );
+}
+
+const reservedHeaders = [
+  "Content-Length",
+  "Authorization",
+  "Connection",
+  "Host",
+  "Proxy-Authenticate",
+  "Proxy-Authorization",
+  "WWW-Authenticate",
+].map((h) => h.toLowerCase());
+
+export function _toObjectiveC(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings, { dataReadsFile: true });
+  let code = "";
+  code += "#import <Foundation/Foundation.h>\n";
+  code += "\n";
+  code +=
+    "NSURL *url = [NSURL URLWithString:" + repr(request.urls[0].url) + "];\n";
+
+  if (request.urls[0].auth) {
+    const [user, password] = request.urls[0].auth;
+
+    code += "\n";
+    code +=
+      'NSString *credentials = [NSString stringWithFormat:@"%@:%@", ' +
+      repr(user) +
+      ", " +
+      repr(password) +
+      "];\n";
+    code +=
+      "NSData *credentialsData = [credentials dataUsingEncoding:NSUTF8StringEncoding];\n";
+    code +=
+      "NSString *base64Credentials = [credentialsData base64EncodedStringWithOptions:0];\n";
+  }
+
+  if (request.headers.length || request.urls[0].auth) {
+    const headerLines = [];
+    for (const [key, value] of request.headers) {
+      if (value === null) {
+        continue;
+      }
+      if (
+        key.isString() &&
+        reservedHeaders.includes(key.toLowerCase().toString())
+      ) {
+        warnings.push([
+          "reserved-header",
+          key.toString() + " is a reserved header",
+        ]);
+      }
+      headerLines.push("    " + repr(key) + ": " + repr(value));
+    }
+    if (request.urls[0].auth) {
+      warnings.push(["reserved-header", "Authorization is a reserved header"]);
+      headerLines.push(
+        '    @"Authorization": [NSString stringWithFormat:@"Basic %@", base64Credentials]',
+      );
+    }
+    if (headerLines.length) {
+      code += "NSDictionary *headers = @{\n";
+      code += headerLines.join(",\n") + "\n";
+      code += "};\n";
+      code += "\n";
+    }
+  }
+
+  let hasData = false;
+  let hasDataStream = false;
+  if (request.urls[0].uploadFile) {
+    code +=
+      "InputStream *dataStream = [InputStream fileAtPath:" +
+      // TODO: might need processing
+      repr(request.urls[0].uploadFile) +
+      "];";
+    hasDataStream = true;
+  } else if (request.multipartUploads) {
+    // TODO
+  } else if (request.dataArray && request.dataArray.length >= 1) {
+    if (
+      request.dataArray.length === 1 &&
+      !(request.dataArray[0] instanceof Word) &&
+      !request.dataArray[0].name
+    ) {
+      // TODO: urlencode if necessary
+      code +=
+        "InputStream *dataStream = [InputStream fileAtPath:" +
+        repr(request.dataArray[0].filename) +
+        "];";
+      hasDataStream = true;
+    } else {
+      const parts = [];
+      if (
+        request.dataArray.length === 1 &&
+        request.dataArray[0] instanceof Word
+      ) {
+        const entries = request.dataArray[0].split("&");
+        for (const [i, entry] of entries.entries()) {
+          const newEntry = i === 0 ? entry : entry.prepend("&");
+          parts.push(repr(newEntry));
+        }
+      } else {
+        // TODO: this can be better
+        const entries: DataParam[] = [];
+        for (const d of request.dataArray) {
+          if (d instanceof Word) {
+            entries.push(d);
+          } else {
+            if (d.name) {
+              const name = d.name.append("=");
+              const lastEntry = entries[entries.length - 1];
+              if (entries.length && lastEntry instanceof Word) {
+                entries[entries.length - 1] = mergeWords(lastEntry, name);
+              } else {
+                entries.push(name);
+              }
+            }
+            entries.push(d);
+          }
+        }
+        for (const entry of entries) {
+          if (entry instanceof Word) {
+            parts.push(repr(entry));
+          } else {
+            // TODO: handle file type
+            parts.push(
+              "[NSString stringWithContentsOfFile:" +
+                repr(entry.filename) +
+                " encoding:NSUTF8StringEncoding error:nil];",
+            );
+          }
+        }
+      }
+
+      const [firstPart, ...restParts] = parts;
+      code +=
+        "NSMutableData *data = [[NSMutableData alloc] initWithData:[" +
+        firstPart +
+        " dataUsingEncoding:NSUTF8StringEncoding]];\n";
+      for (const part of restParts) {
+        code +=
+          "[data appendData:[" +
+          part +
+          " dataUsingEncoding:NSUTF8StringEncoding]];\n";
+      }
+      code += "\n";
+      hasData = true;
+    }
+  }
+  if (
+    request.timeout &&
+    !eq(request.timeout, "60") &&
+    !eq(request.timeout, "60.0")
+  ) {
+    code +=
+      "NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url\n";
+    code +=
+      "                                                          cachePolicy:NSURLRequestUseProtocolCachePolicy\n";
+    code +=
+      "                                                      timeoutInterval:" +
+      // TODO: verify/escape or parse
+      request.timeout.toString() +
+      "];\n";
+  } else {
+    code +=
+      "NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];\n";
+  }
+
+  if (!eq(request.urls[0].method, "GET")) {
+    code += "[request setHTTPMethod:" + repr(request.urls[0].method) + "];\n";
+  }
+  if (request.headers.length || request.urls[0].auth) {
+    code += "[request setAllHTTPHeaderFields:headers];\n";
+  }
+  if (hasData) {
+    code += "[request setHTTPBody:data];\n";
+  } else if (hasDataStream) {
+    // TODO: does this work?
+    code += "[request setHTTPBodyStream:dataStream];\n";
+  }
+
+  code += "\n";
+  // TODO: TLSMinimumSupportedProtocolVersion
+  code +=
+    "NSURLSessionConfiguration *defaultSessionConfiguration = [NSURLSessionConfiguration defaultSessionConfiguration];\n";
+  code +=
+    "NSURLSession *session = [NSURLSession sessionWithConfiguration:defaultSessionConfiguration];\n";
+  code +=
+    "NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {\n";
+  code += "    if (error) {\n";
+  code += '        NSLog(@"%@", error);\n';
+  code += "    } else {\n";
+  code +=
+    "        NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;\n";
+  code += '        NSLog(@"%@", httpResponse);\n';
+  code += "    }\n";
+  code += "}];\n";
+  code += "[dataTask resume];\n";
+
+  return code;
+}
+
+export function toObjectiveCWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const code = _toObjectiveC(requests, warnings);
+  return [code, warnings];
+}
+export function toObjectiveC(curlCommand: string | string[]): string {
+  return toObjectiveCWarn(curlCommand)[0];
+}