@ohos-ports/curlconverter 4.12.0-beta.0

package/src/shell/Word.ts

@@ -0,0 +1,531 @@
+// Words act like strings. They're lists of characters, except some
+// characters can be shell variables or expressions.
+// They're implemented like this:
+// ["foobar", {type: "variable", value: "baz", text: "$baz"}, "qux"]
+// Except for the empty string [""], there should be no empty strings in the array.
+
+import type { Parser } from "./Parser.js";
+import { CCError } from "../utils.js";
+
+export interface ShellToken {
+  type: "variable" | "command";
+  value: string;
+  text: string;
+  syntaxNode: Parser.SyntaxNode; // For error reporting
+}
+export type Token = string | ShellToken;
+
+// TODO: Words should keep a list of operations that happened to them
+// like .replace() so that we can generate code that also does that operation
+// on the contents of the environment variable or the output of the command.
+export class Word implements Iterable<Token> {
+  readonly tokens: Token[];
+
+  constructor(tokens?: string);
+  constructor(tokens?: Token[]);
+  constructor(tokens?: string | Token[]) {
+    if (typeof tokens === "string") {
+      tokens = [tokens];
+    }
+    if (tokens === undefined || tokens.length === 0) {
+      tokens = [""];
+    }
+
+    this.tokens = [];
+    for (const t of tokens) {
+      if (typeof t === "string") {
+        if (
+          this.tokens.length > 0 &&
+          typeof this.tokens[this.tokens.length - 1] === "string"
+        ) {
+          // If we have 2+ strings in a row, merge them
+          this.tokens[this.tokens.length - 1] += t;
+        } else if (t) {
+          // skip empty strings
+          this.tokens.push(t);
+        }
+      } else {
+        this.tokens.push(t);
+      }
+    }
+    if (this.tokens.length === 0) {
+      this.tokens.push("");
+    }
+  }
+
+  get length(): number {
+    let len = 0;
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        len += t.length;
+      } else {
+        len += 1;
+      }
+    }
+    return len;
+  }
+
+  *[Symbol.iterator](): Iterator<Token> {
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        for (const c of t) {
+          yield c;
+        }
+      } else {
+        yield t;
+      }
+    }
+  }
+
+  // TODO: do we need this function?
+  get(index: number): Token {
+    let i = 0;
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        if (i + t.length > index) {
+          return t[index - i];
+        }
+        i += t.length;
+      } else {
+        if (i === index) {
+          return t;
+        }
+        i += 1;
+      }
+    }
+    throw new CCError("Index out of bounds");
+  }
+
+  charAt(index = 0): Token {
+    try {
+      return this.get(index);
+    } catch {}
+    return "";
+  }
+
+  indexOf(search: string, start?: number): number {
+    if (start === undefined) {
+      start = 0;
+    }
+    let i = 0;
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        if (i + t.length > start) {
+          const index = t.indexOf(search, start - i);
+          if (index !== -1) {
+            return i + index;
+          }
+        }
+        i += t.length;
+      } else {
+        i += 1;
+      }
+    }
+    return -1;
+  }
+
+  // Like indexOf() but accepts a string of characters and returns the index of the first one
+  // it finds
+  indexOfFirstChar(search: string): number {
+    let i = 0;
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        for (const c of t) {
+          if (search.includes(c)) {
+            return i;
+          }
+          i += 1;
+        }
+      } else {
+        i += 1;
+      }
+    }
+    return -1;
+  }
+
+  removeFirstChar(c: string): Word {
+    if (this.length === 0) {
+      return new Word();
+    }
+    if (this.charAt(0) === c) {
+      return this.slice(1);
+    }
+    return this.copy();
+  }
+
+  copy(): Word {
+    return new Word(this.tokens);
+  }
+
+  slice(indexStart?: number, indexEnd?: number): Word {
+    if (indexStart === undefined) {
+      indexStart = this.length;
+    }
+    if (indexEnd === undefined) {
+      indexEnd = this.length;
+    }
+    if (indexStart >= this.length) {
+      return new Word();
+    }
+    if (indexStart < 0) {
+      indexStart = Math.max(indexStart + this.length, 0);
+    }
+    if (indexEnd < 0) {
+      indexEnd = Math.max(indexEnd + this.length, 0);
+    }
+    if (indexEnd <= indexStart) {
+      return new Word();
+    }
+
+    const ret = [];
+    let i = 0;
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        if (i + t.length > indexStart) {
+          if (i < indexEnd) {
+            ret.push(t.slice(Math.max(indexStart - i, 0), indexEnd - i));
+          }
+        }
+        i += t.length;
+      } else {
+        if (i >= indexStart && i < indexEnd) {
+          ret.push(t);
+        }
+        i += 1;
+      }
+    }
+    return new Word(ret);
+  }
+
+  // TODO: check
+  includes(search: string, start?: number): boolean {
+    if (start === undefined) {
+      start = 0;
+    }
+    let i = 0;
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        if (i + t.length > start) {
+          if (t.includes(search, start - i)) {
+            return true;
+          }
+        }
+        i += t.length;
+      } else {
+        i += 1;
+      }
+    }
+    return false;
+  }
+
+  test(search: RegExp): boolean {
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        if (search.test(t)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  prepend(c: string): Word {
+    const ret = this.copy();
+    if (ret.tokens.length && typeof ret.tokens[0] === "string") {
+      ret.tokens[0] = c + ret.tokens[0];
+    } else {
+      ret.tokens.unshift(c);
+    }
+    return ret;
+  }
+
+  append(c: string): Word {
+    const ret = this.copy();
+    if (
+      ret.tokens.length &&
+      typeof ret.tokens[ret.tokens.length - 1] === "string"
+    ) {
+      ret.tokens[ret.tokens.length - 1] += c;
+    } else {
+      ret.tokens.push(c);
+    }
+    return ret;
+  }
+
+  // Merges two Words
+  add(other: Word): Word {
+    return new Word([...this.tokens, ...other.tokens]);
+  }
+
+  // Returns the first match, searches each string independently
+  // TODO: improve this
+  match(regex: RegExp): RegExpMatchArray | null {
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        const match = t.match(regex);
+        if (match) {
+          return match;
+        }
+      }
+    }
+    return null;
+  }
+
+  search(regex: RegExp): number {
+    let offset = 0;
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        const match = t.search(regex);
+        if (match !== -1) {
+          return offset + match;
+        }
+        offset += t.length;
+      }
+    }
+    return -1;
+  }
+
+  // .replace() is called per-string, so it won't work through shell variables
+  replace(search: string | RegExp, replacement: string): Word {
+    const ret: Token[] = [];
+    for (const t of this.tokens) {
+      if (typeof t === "string") {
+        ret.push(t.replace(search, replacement));
+      } else {
+        ret.push(t);
+      }
+    }
+    return new Word(ret);
+  }
+
+  // splits correctly, not like String.split()
+  // The last entry can contain the separator if limit entries has been reached
+  split(separator: string, limit?: number): Word[] {
+    const ret: Word[] = [];
+    let i = 0;
+    let start = 0;
+    while (i < this.length) {
+      let match = true;
+      for (let j = 0; j < separator.length; j++) {
+        if (this.get(i + j) !== separator.charAt(j)) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        ret.push(this.slice(start, i));
+        i += separator.length;
+        start = i;
+        if (limit !== undefined && ret.length === limit - 1) {
+          break;
+        }
+      } else {
+        i += 1;
+      }
+    }
+    if (start <= this.length) {
+      ret.push(this.slice(start));
+    }
+    return ret;
+  }
+
+  toLowerCase(): Word {
+    return new Word(
+      this.tokens.map((t) => (typeof t === "string" ? t.toLowerCase() : t)),
+    );
+  }
+
+  toUpperCase(): Word {
+    return new Word(
+      this.tokens.map((t) => (typeof t === "string" ? t.toUpperCase() : t)),
+    );
+  }
+
+  trimStart(): Word {
+    const ret: Token[] = [];
+    let i, t;
+    for ([i, t] of this.tokens.entries()) {
+      if (typeof t === "string") {
+        if (i === 0) {
+          t = t.trimStart();
+        }
+        if (t) {
+          ret.push(t);
+        }
+      } else {
+        ret.push(t);
+      }
+    }
+    if (ret.length === 0) {
+      return new Word();
+    }
+    return new Word(ret);
+  }
+
+  trimEnd(): Word {
+    const ret: Token[] = [];
+    let i, t;
+    for ([i, t] of this.tokens.entries()) {
+      if (typeof t === "string") {
+        if (i === this.tokens.length - 1) {
+          t = t.trimEnd();
+        }
+        if (t) {
+          ret.push(t);
+        }
+      } else {
+        ret.push(t);
+      }
+    }
+    if (ret.length === 0) {
+      return new Word();
+    }
+    return new Word(ret);
+  }
+
+  trim(): Word {
+    const ret: Token[] = [];
+    let i, t;
+    for ([i, t] of this.tokens.entries()) {
+      if (typeof t === "string") {
+        if (i === 0) {
+          t = t.trimStart();
+        }
+        if (i === this.tokens.length - 1) {
+          t = t.trimEnd();
+        }
+        if (t) {
+          ret.push(t);
+        }
+      } else {
+        ret.push(t);
+      }
+    }
+    if (ret.length === 0) {
+      return new Word();
+    }
+    return new Word(ret);
+  }
+
+  isEmpty(): boolean {
+    if (this.tokens.length === 0) {
+      return true;
+    }
+    if (this.tokens.length === 1 && typeof this.tokens[0] === "string") {
+      return this.tokens[0].length === 0;
+    }
+    return false;
+  }
+
+  toBool(): boolean {
+    return !this.isEmpty();
+  }
+
+  // Returns true if .tokens contains no variables/commands
+  isString(): boolean {
+    for (const t of this.tokens) {
+      if (typeof t !== "string") {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  firstShellToken(): ShellToken | null {
+    for (const t of this.tokens) {
+      if (typeof t !== "string") {
+        return t;
+      }
+    }
+    return null;
+  }
+
+  startsWith(prefix: string): boolean {
+    if (this.tokens.length === 0) {
+      return false;
+    }
+    if (typeof this.tokens[0] === "string") {
+      return this.tokens[0].startsWith(prefix);
+    }
+    return false;
+  }
+
+  endsWith(suffix: string): boolean {
+    if (this.tokens.length === 0) {
+      return false;
+    }
+    const lastToken = this.tokens[this.tokens.length - 1];
+    if (typeof lastToken === "string") {
+      return lastToken.endsWith(suffix);
+    }
+    return false;
+  }
+
+  // This destroys the information about the original tokenization
+  toString() {
+    return this.tokens
+      .map((t) => (typeof t === "string" ? t : t.text))
+      .join("");
+  }
+  valueOf = Word.toString;
+}
+
+export function eq(
+  it: Word | undefined | null,
+  other: string | Word | undefined | null,
+): boolean {
+  if (
+    it === undefined ||
+    it === null ||
+    other === undefined ||
+    other === null
+  ) {
+    return it === other;
+  }
+  if (typeof other === "string") {
+    return (
+      it.tokens.length === 1 &&
+      typeof it.tokens[0] === "string" &&
+      it.tokens[0] === other
+    );
+  }
+  return (
+    it.tokens.length === other.tokens.length &&
+    it.tokens.every((itToken, i) => {
+      const otherToken = other.tokens[i];
+      if (typeof itToken === "string") {
+        return itToken === otherToken;
+      } else if (typeof otherToken !== "string") {
+        return itToken.text === otherToken.text;
+      }
+      return false;
+    })
+  );
+}
+export function firstShellToken(word: string | Word): ShellToken | null {
+  if (typeof word === "string") {
+    return null;
+  }
+  return word.firstShellToken();
+}
+export function mergeWords(...words: (Word | string)[]): Word {
+  const ret: Token[] = [];
+  for (const w of words) {
+    if (w instanceof Word) {
+      ret.push(...w.tokens);
+    } else {
+      ret.push(w);
+    }
+  }
+  return new Word(ret);
+}
+export function joinWords(words: Word[], joinChar: string): Word {
+  const ret: Token[] = [];
+  for (const w of words) {
+    if (ret.length) {
+      ret.push(joinChar);
+    }
+    ret.push(...w.tokens);
+  }
+  return new Word(ret);
+}