@zxyycom/vibe-check 0.0.1 → 0.0.2

package/src/package-checks/function-metrics/analyzer/readers/ruby.ts

@@ -0,0 +1,88 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/ruby.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript for the product-owned analyzer.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { js_style_regex_expression } from "../shared/js-style-regex.ts";
+import { RubylikeReader } from "../shared/rubylike.ts";
+import { ScriptLanguageMixIn } from "../shared/script-language.ts";
+
+const RUBY_TOKEN_ADDITION = String.raw`|^=begin|^=end|%[qQrwiI]?\{(?:\\.|[^\}\\])*?\}|%[qQrwiI]?\[(?:\\.|[^\]\\])*?\]|%[qQrwiI]?\<(?:\\.|[^\>\\])*?\>|%[qQrwiI]?\((?:\\.|[^\>\\])*?\)|\w+:|\$\w+|\.+|:?@{0,2}\w+\??\!?`;
+
+/** Python ruby.py's str subclass keeps the token's source-relative start. */
+class MyToken {
+  public readonly value: string;
+  public readonly begin: number;
+
+  public constructor(value: string, begin: number) {
+    this.value = value;
+    this.begin = begin;
+  }
+}
+
+export class RubyReader extends RubylikeReader {
+  public static override ext: readonly string[] = ["rb"];
+  public static override languageNames: readonly string[] = ["ruby"];
+  public static override generateTokens = js_style_regex_expression(rubyTokens);
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return ScriptLanguageMixIn.get_comment_from_token(token);
+  }
+}
+
+/**
+ * Direct translation of ruby.py's MyToken/restart loop. The restart keeps the
+ * original token offset semantics around `#{...}` without introducing a
+ * separate Ruby lexer.
+ */
+function* rubyTokens(sourceCode: string, addition = ""): Generator<string> {
+  const bracketStack: string[] = [];
+  let source: string | undefined = sourceCode;
+
+  while (source !== undefined) {
+    const currentSource: string = source;
+    let tokenOffset = 0;
+    let restarted = false;
+
+    for (const tokenValue of ScriptLanguageMixIn.generate_common_tokens(
+      currentSource,
+      RUBY_TOKEN_ADDITION + addition
+    )) {
+      const token = new MyToken(tokenValue, tokenOffset);
+      tokenOffset += tokenValue.length;
+
+      if (token.value === "{") {
+        bracketStack.push("{");
+      } else if (token.value === "}") {
+        if (bracketStack.pop() === "#{") {
+          source = `"${currentSource.slice(token.begin + 1)}`;
+          yield token.value;
+          restarted = true;
+          break;
+        }
+      } else if (token.value.startsWith('"')) {
+        const interpolationStart = token.value.indexOf("#{");
+        if (interpolationStart >= 0) {
+          yield `${token.value.slice(0, interpolationStart)}"`;
+          yield "${";
+          bracketStack.push("#{");
+          source = currentSource.slice(token.begin + interpolationStart + 2);
+          restarted = true;
+          break;
+        }
+      }
+
+      yield token.value;
+    }
+
+    if (!restarted) source = undefined;
+  }
+}

package/src/package-checks/function-metrics/analyzer/readers/rust.ts

@@ -0,0 +1,47 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/rust.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CCppCommentsMixin } from "../shared/clike.ts";
+import { CodeReader, type TokenFactory } from "../shared/code-reader.ts";
+import { GoLikeStates } from "../shared/golike.ts";
+export class RustReader extends CodeReader {
+  public static override ext = ["rs"];
+  public static override languageNames = ["rust"];
+  public static override controlFlowKeywords = new Set([
+    "if",
+    "for",
+    "while",
+    "catch",
+    "match",
+    "where"
+  ]);
+  public static override logicalOperators = new Set(["&&", "||"]);
+  public static override caseKeywords = new Set<string>();
+  public static override ternaryOperators = new Set(["?"]);
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new RustStates(context)];
+  }
+
+  public static override generateTokens(
+    sourceCode: string,
+    _addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    return CodeReader.generateTokens(sourceCode, String.raw`|(?:'\w+\b)`, tokenFactory);
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return CCppCommentsMixin.get_comment_from_token(token);
+  }
+}
+
+class RustStates extends GoLikeStates {
+  protected static override readonly FUNC_KEYWORD = "fn";
+}

package/src/package-checks/function-metrics/analyzer/readers/scala.ts

@@ -0,0 +1,60 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/scala.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CCppCommentsMixin } from "../shared/clike.ts";
+import { CodeReader } from "../shared/code-reader.ts";
+import { GoLikeStates } from "../shared/golike.ts";
+
+export const __author__ = "David Baum";
+
+export class ScalaReader extends CodeReader {
+  public static override ext = ["scala"];
+  public static override languageNames = ["scala"];
+  public static override controlFlowKeywords = new Set(["if", "for", "while", "catch", "do"]);
+  public static override logicalOperators = new Set(["&&", "||"]);
+  public static override caseKeywords = new Set(["case"]);
+  public static override ternaryOperators = new Set(["?"]);
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new ScalaStates(context)];
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return CCppCommentsMixin.get_comment_from_token(token);
+  }
+}
+
+class ScalaStates extends GoLikeStates {
+  protected static override readonly FUNC_KEYWORD = "def";
+
+  public override _state_global(token: string): void {
+    super._state_global(token);
+  }
+
+  protected override _expect_function_impl(token: string): void {
+    if (token === "=") {
+      this.next(this._expect_function_body);
+    } else {
+      super._expect_function_impl(token);
+    }
+  }
+
+  public override statemachine_before_return(): void {
+    if (this.state === this._expect_function_body) this.context.endOfFunction();
+  }
+
+  private readonly _expect_function_body = (token: string): void => {
+    if (this.context.newline) {
+      this.context.endOfFunction();
+      this.next(this.globalState, token);
+    } else if (token === "{") {
+      this.subState(this.cloneState());
+    }
+  };
+}

package/src/package-checks/function-metrics/analyzer/readers/solidity.ts

@@ -0,0 +1,32 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/solidity.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CCppCommentsMixin } from "../shared/clike.ts";
+import { CodeReader } from "../shared/code-reader.ts";
+import { GoLikeStates } from "../shared/golike.ts";
+export class SolidityReader extends CodeReader {
+  public static override ext = ["sol"];
+  public static override languageNames = ["solidity"];
+  public static override controlFlowKeywords = new Set(["if", "for", "while"]);
+  public static override logicalOperators = new Set(["&&", "||"]);
+  public static override caseKeywords = new Set<string>();
+  public static override ternaryOperators = new Set(["?"]);
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new SolidityStates(context)];
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return CCppCommentsMixin.get_comment_from_token(token);
+  }
+}
+
+class SolidityStates extends GoLikeStates {
+  protected static override readonly FUNC_KEYWORD = "function";
+}

package/src/package-checks/function-metrics/analyzer/readers/st.ts

@@ -0,0 +1,161 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/st.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { TokenStream } from "../contracts.ts";
+import {
+  CodeReader,
+  CodeStateMachine,
+  isPythonWhitespace,
+  splitPythonLines,
+  type TokenFactory
+} from "../shared/code-reader.ts";
+
+/** Source mixin retained as a constructable class despite TypeScript's single inheritance. */
+export class StCommentsMixin {
+  public static get_comment_from_token(token: string): string | undefined {
+    return token.startsWith("(*") || token.startsWith("//") ? token.slice(2) : undefined;
+  }
+
+  public static getCommentFromToken(token: string): string | undefined {
+    return this.get_comment_from_token(token);
+  }
+}
+
+export class StReader extends CodeReader {
+  public static override ext = ["st"];
+  public static override languageNames = ["st"];
+  public static override controlFlowKeywords = new Set([
+    "if",
+    "elsif",
+    "for",
+    "while",
+    "repeat",
+    "IF",
+    "ELSIF",
+    "FOR",
+    "WHILE",
+    "REPEAT"
+  ]);
+  public static override logicalOperators = new Set(["and", "or", "AND", "OR"]);
+  public static override caseKeywords = new Set(["case", "CASE"]);
+  public static override ternaryOperators = new Set<string>();
+  public static readonly macro_pattern = /#\s*(\w+)\s*(.*)/msu;
+  public static readonly _functions = new Set(["FUNCTION_BLOCK", "FUNCTION", "ACTION"]);
+  public static readonly _blocks = new Set(["IF", "FOR", "WHILE", "CASE", "REPEAT"]);
+  public static readonly _ends = new Set(["END"]);
+  /** Source `loops` class attribute consumed by the deferred nesting extension. */
+  public static readonly loops = [
+    "if",
+    "case",
+    "for",
+    "while",
+    "repeat",
+    "IF",
+    "CASE",
+    "FOR",
+    "WHILE",
+    "REPEAT"
+  ] as const;
+  /** Source `bracket` class attribute consumed by the deferred nesting extension. */
+  public static readonly bracket = "END";
+  public readonly loops = StReader.loops;
+  public readonly bracket = StReader.bracket;
+
+  public constructor(context: FileInfoBuilder) {
+    super(context, StReader);
+    this.parallelStates = [new StStates(context, this)];
+  }
+
+  public static override *generateTokens(
+    sourceCode: string,
+    addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    const untilEnd = String.raw`(?:\\\n|[^\n])*`;
+    const endings = [...StReader._blocks].map((block) => `END_${block}`).join("|");
+    const sourceAddition = String.raw`(?i)//${untilEnd}|\(\*${untilEnd}|OR|AND|XOR|NOT|ELSE\s+IF|${endings}${addition}`;
+    yield* CodeReader.generateTokens(sourceCode, sourceAddition, tokenFactory);
+  }
+
+  public *preprocess(tokens: TokenStream): Generator<string> {
+    for (const token of tokens) {
+      const macro = StReader.macro_pattern.exec(token);
+      if (macro) {
+        const directive = macro[1]?.toLowerCase();
+        const remainder = macro[2] ?? "";
+        if (["if", "ifdef", "ifndef", "elif"].includes(directive ?? "")) {
+          this.context.addCondition();
+        } else if (directive === "include") {
+          yield "#include";
+          yield remainder || '""';
+        }
+        for (const _line of splitPythonLines(remainder).slice(1)) yield "\n";
+      } else if (token.toUpperCase().startsWith("END_")) {
+        yield "END";
+      } else if (!isPythonWhitespace(token) || token === "\n") {
+        yield token;
+      }
+    }
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return StCommentsMixin.get_comment_from_token(token);
+  }
+}
+
+/* Source state callbacks retain their method identity; CodeStateMachine supplies the owning receiver. */
+/* oxlint-disable typescript/unbound-method */
+class StStates extends CodeStateMachine {
+  private readonly reader: StReader;
+
+  public constructor(context: FileInfoBuilder, reader: StReader) {
+    super(context);
+    this.reader = reader;
+    this.last_token = undefined;
+  }
+
+  public override consume(token: string): boolean {
+    // st.py defines its own `__call__`; retain its reader-local callback slot
+    // lifecycle instead of inheriting the shared CodeStateMachine variant.
+    if (this.invokeCurrentState(token)) {
+      this.next(this.saved_state);
+      this.callback?.();
+    }
+    this.last_token = token;
+    return this.to_exit;
+  }
+
+  public override _state_global(token: string): void {
+    const upper = token.toUpperCase();
+    if (StReader._functions.has(upper) && this.context.currentFunction.topNestingLevel < 0) {
+      this._state = this._function_name;
+    } else if (StReader._blocks.has(upper)) {
+      this.context.addBareNesting();
+    } else if (StReader._ends.has(token)) {
+      this.context.popNesting();
+    }
+  }
+
+  private readonly _function_name = (token: string): void => {
+    this.context.restartNewFunction(token);
+    this._state = this._function;
+  };
+
+  private readonly _function = (token: string): void => {
+    this.context.addBareNesting();
+    this.reset_state(token);
+  };
+
+  /** Source `reset_state`, retained for the local Structured Text state machine. */
+  private reset_state(token?: string): void {
+    this._state = this._state_global;
+    if (token !== undefined) this._state_global(token);
+  }
+}
+/* oxlint-enable typescript/unbound-method */

package/src/package-checks/function-metrics/analyzer/readers/swift.ts

@@ -0,0 +1,116 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/swift.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { TokenStream } from "../contracts.ts";
+import { CCppCommentsMixin } from "../shared/clike.ts";
+import { CodeReader, isPythonWhitespace, type TokenFactory } from "../shared/code-reader.ts";
+import { GoLikeStates } from "../shared/golike.ts";
+
+/** TypeScript composition equivalent of SwiftReplaceLabel's Python mixin. */
+export class SwiftReplaceLabel {
+  private readonly conditions: ReadonlySet<string>;
+
+  public constructor(conditions: ReadonlySet<string>) {
+    this.conditions = conditions;
+  }
+
+  public *preprocess(tokens: TokenStream): Generator<string> {
+    function replaceLabel(
+      source: string[],
+      target: readonly string[],
+      replacement: readonly string[]
+    ): string[] {
+      for (let index = 0; index < source.length - target.length; index += 1) {
+        if (target.every((token, offset) => source[index + offset] === token)) {
+          replacement.forEach((token, offset) => {
+            source[index + offset] = token;
+          });
+        }
+      }
+      return source;
+    }
+
+    let source = Array.from(tokens).filter((token) => !isPythonWhitespace(token) || token === "\n");
+
+    for (const condition of this.conditions) {
+      if (!/^\p{L}+$/u.test(condition)) continue;
+      source = replaceLabel(source, ["(", condition, ":"], ["(", `_${condition}`, ":"]);
+      source = replaceLabel(source, [",", condition, ":"], [",", `_${condition}`, ":"]);
+    }
+    yield* source;
+  }
+}
+
+export class SwiftReader extends CodeReader {
+  public static readonly FUNC_KEYWORD = "def";
+  public static override ext = ["swift"];
+  public static override languageNames = ["swift"];
+  public static override controlFlowKeywords = new Set(["if", "for", "while", "catch", "guard"]);
+  public static override logicalOperators = new Set(["&&", "||"]);
+  public static override caseKeywords = new Set(["case"]);
+  public static override ternaryOperators = new Set(["?"]);
+
+  private readonly replaceLabel: SwiftReplaceLabel;
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.parallelStates = [new SwiftStates(context)];
+    this.replaceLabel = new SwiftReplaceLabel(this.conditions);
+  }
+
+  public static override generateTokens(
+    sourceCode: string,
+    addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    return CodeReader.generateTokens(
+      sourceCode,
+      String.raw`|\`\w+\`|\w+\?|\w+\!|\?\?${addition}`,
+      tokenFactory
+    );
+  }
+
+  public *preprocess(tokens: TokenStream): Generator<string> {
+    yield* this.replaceLabel.preprocess(tokens);
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return CCppCommentsMixin.get_comment_from_token(token);
+  }
+}
+
+/* oxlint-disable typescript/unbound-method -- CodeStateMachine invokes stored source methods with this state. */
+class SwiftStates extends GoLikeStates {
+  public override _state_global(token: string): void {
+    if (token === "init" || token === "subscript") {
+      this.context.pushNewFunction("");
+      this.next(this._function_name, token);
+    } else if (["get", "set", "willSet", "didSet", "deinit"].includes(token)) {
+      this.context.pushNewFunction(token);
+      this.next(this._expect_function_impl);
+    } else if (token === "protocol") {
+      this.next(this._protocol);
+    } else if (["let", "var", "case", ","].includes(token)) {
+      this.next(this._expect_declaration_name);
+    } else {
+      super._state_global(token);
+    }
+  }
+
+  private readonly _expect_declaration_name = (_token: string): void => {
+    this.next(this.globalState);
+  };
+
+  private readonly _protocol = (token: string): void => {
+    this.readInsideBracketsThen("{}", token, (endToken) => {
+      if (endToken === "}") this.next(this.globalState);
+    });
+  };
+}
+/* oxlint-enable typescript/unbound-method */

package/src/package-checks/function-metrics/analyzer/readers/tsx.ts

@@ -0,0 +1,165 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/tsx.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeReader, isPythonWhitespace, type TokenFactory } from "../shared/code-reader.ts";
+import { js_style_regex_expression } from "../shared/js-style-regex.ts";
+import { JSTokenizer, Tokenizer, TypeScriptReader } from "./typescript.ts";
+
+export class TSXReader extends TypeScriptReader {
+  public static override ext = ["tsx", "jsx"];
+  public static override languageNames = ["tsx", "jsx"];
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+  }
+
+  public static override generateTokens = js_style_regex_expression(function* (
+    sourceCode: string,
+    addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    const tsxAddition = `${addition}|(?:<[A-Za-z][A-Za-z0-9]*(?:\\.[A-Za-z][A-Za-z0-9]*)*>)|(?:<\\/[A-Za-z][A-Za-z0-9]*(?:\\.[A-Za-z][A-Za-z0-9]*)*>)|(?:#\\w+)|(?:\\$\\w+)|(?:<\\/\\w+>)|(?:=>)|\`.*?\``;
+    const tokenizer = new TSXTokenizer();
+    for (const token of CodeReader.generateTokens(sourceCode, tsxAddition, tokenFactory)) {
+      yield* tokenizer.__call__(token);
+    }
+  });
+}
+
+class TSXTokenizer extends JSTokenizer {
+  public constructor() {
+    super();
+  }
+
+  public override *process_token(token: string): Generator<string> {
+    if (token === "<") {
+      this.sub_tokenizer = new XMLTagWithAttrTokenizer();
+      return;
+    }
+    if (token === "=>") {
+      yield token;
+      return;
+    }
+    yield* super.process_token(token);
+  }
+}
+
+class XMLTagWithAttrTokenizer extends Tokenizer {
+  private tag: string | undefined;
+  private cache = ["<"];
+  private state: (token: string) => readonly string[] | undefined;
+  private _attr_expr_active = false;
+
+  public constructor() {
+    super();
+    this.state = this._global_state;
+  }
+
+  public override *__call__(token: string): Generator<string> {
+    if (this.sub_tokenizer) {
+      yield* this.sub_tokenizer.__call__(token);
+      if (this.sub_tokenizer._ended) {
+        this.sub_tokenizer = undefined;
+        if (this._attr_expr_active) {
+          this._attr_expr_active = false;
+          yield ";";
+        }
+      }
+      return;
+    }
+    yield* this.process_token(token);
+  }
+
+  public override *process_token(token: string): Generator<string> {
+    this.cache.push(token);
+    if (isPythonWhitespace(token)) return;
+    const result = this.state(token);
+    if (result) yield* result;
+  }
+
+  private abort(): readonly string[] {
+    this.stop();
+    return this.cache;
+  }
+
+  private flush(): readonly string[] {
+    const tokens = [this.cache.join("")];
+    this.cache = [];
+    return tokens;
+  }
+
+  private readonly _global_state = (token: string): readonly string[] | undefined => {
+    if (!isidentifier(token)) return this.abort();
+    this.tag = token;
+    this.state = this._after_tag;
+    return undefined;
+  };
+
+  private readonly _after_tag = (token: string): readonly string[] | undefined => {
+    if (token === ">") {
+      this.state = this._body;
+      return undefined;
+    }
+    if (token === "/") {
+      this.state = this._expecting_self_closing;
+      return undefined;
+    }
+    if (isidentifier(token)) {
+      this.state = this._expecting_equal_sign;
+      return undefined;
+    }
+    return this.abort();
+  };
+
+  private readonly _expecting_self_closing = (token: string): readonly string[] | undefined => {
+    if (token === ">") {
+      this.stop();
+      return this.flush();
+    }
+    return this.abort();
+  };
+
+  private readonly _expecting_equal_sign = (token: string): readonly string[] | undefined => {
+    if (token === "=") this.state = this._expecting_value;
+    else return this.abort();
+    return undefined;
+  };
+
+  private readonly _expecting_value = (token: string): readonly string[] | undefined => {
+    if (token.startsWith("'") || token.startsWith('"')) this.state = this._after_tag;
+    else if (token === "{") {
+      this.state = this._after_tag;
+      this.sub_tokenizer = new TSXTokenizer();
+      this._attr_expr_active = true;
+    }
+    return undefined;
+  };
+
+  private readonly _body = (token: string): readonly string[] | undefined => {
+    if (["=", "=>", ";", ")"].includes(token)) return this.abort();
+    if (token === "<") {
+      this.sub_tokenizer = new XMLTagWithAttrTokenizer();
+      this.cache.pop();
+      return this.flush();
+    }
+    if (token.startsWith("</")) {
+      this.stop();
+      return this.flush();
+    }
+    if (token === "{") {
+      this.sub_tokenizer = new TSXTokenizer();
+      return this.flush();
+    }
+    return undefined;
+  };
+}
+
+function isidentifier(token: string): boolean {
+  return /^\p{ID_Start}\p{ID_Continue}*$/u.test(token);
+}