@zxyycom/vibe-check 0.0.1 → 0.0.3

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

@@ -0,0 +1,340 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/perl.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 type { TokenStream } from "../contracts.ts";
+import { CodeReader, CodeStateMachine, isPythonWhitespace } from "../shared/code-reader.ts";
+import { ScriptLanguageMixIn } from "../shared/script-language.ts";
+
+/** Source mixin retained even though PerlReader composes ScriptLanguageMixIn instead. */
+export class PerlCommentsMixin {
+  public static get_comment_from_token(token: string): string | undefined {
+    return token.startsWith("#") ? token : undefined;
+  }
+
+  public static getCommentFromToken(token: string): string | undefined {
+    return this.get_comment_from_token(token);
+  }
+}
+
+export class PerlReader extends CodeReader {
+  public static override ext: readonly string[] = ["pl", "pm"];
+  public static override languageNames: readonly string[] = ["perl"];
+  public static override controlFlowKeywords = new Set([
+    "if",
+    "elsif",
+    "unless",
+    "while",
+    "until",
+    "for",
+    "foreach",
+    "when",
+    "given",
+    "default",
+    "do"
+  ]);
+  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, PerlReader);
+    this.parallelStates = [new PerlStates(context)];
+  }
+
+  public _state(token: string): boolean | void {
+    const currentState = this.parallel_states.at(-1);
+    if (token === "\n") return undefined;
+    return currentState?.consume(token);
+  }
+
+  public *preprocess(tokens: TokenStream): Generator<string> {
+    let comment: string | undefined;
+    for (const token of tokens) {
+      if (comment !== undefined) {
+        if (token === "\n") {
+          yield comment;
+          comment = undefined;
+          yield token;
+        } else {
+          comment += token;
+        }
+      } else if (token === "#") {
+        comment = token;
+      } else {
+        yield token;
+      }
+    }
+    if (comment !== undefined) yield comment;
+  }
+
+  public static override generateTokens(sourceCode: string): Generator<string> {
+    return ScriptLanguageMixIn.generate_common_tokens(sourceCode, "");
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    if (!token.startsWith("#")) return undefined;
+    const stripped = token.replace(/^#+/u, "").trim();
+    if (stripped.startsWith("lizard forgives") || stripped.startsWith("#lizard forgives")) {
+      return "#lizard forgives";
+    }
+    return stripped;
+  }
+}
+
+class PerlStates extends CodeStateMachine {
+  private function_name = "";
+  private package_name = "";
+  private variable_name = "";
+  private brace_count = 0;
+  private paren_count = 0;
+  private in_attribute = false;
+  private anonymous_count = 0;
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.next(this._state_global);
+  }
+
+  public override readonly _state_global = (token: string): void => {
+    if (token === "package") {
+      this.next(this._state_package_dec);
+    } else if (token === "sub") {
+      this.function_name = "";
+      this.next(this._state_function_dec);
+    } else if (token === "{") {
+      this.brace_count += 1;
+    } else if (token === "}") {
+      this.brace_count -= 1;
+    } else if (token === "(") {
+      this.paren_count += 1;
+      this.next(this._state_function_call);
+    } else if (["$", "my", "our", "local"].includes(token)) {
+      this.variable_name = "";
+      this.next(this._state_variable);
+    }
+  };
+
+  private readonly _state_package_dec = (token: string): void => {
+    if (!isPythonWhitespace(token)) {
+      this.package_name = token;
+      this.next(this._state_global);
+    }
+  };
+
+  private readonly _state_variable = (token: string): void => {
+    if (token === "$") {
+      return;
+    }
+    if (token === "=") {
+      this.next(this._state_assignment);
+    } else if (token === ";") {
+      this.variable_name = "";
+      this.next(this._state_global);
+    } else if (!isPythonWhitespace(token) && this.variable_name === "") {
+      this.variable_name = token;
+    }
+  };
+
+  private readonly _state_assignment = (token: string): void => {
+    if (token === "sub") {
+      this.next(this._state_anon_sub);
+    } else if (token === ";") {
+      this.variable_name = "";
+      this.next(this._state_global);
+    }
+  };
+
+  private readonly _state_function_call = (token: string): void => {
+    if (token === "sub") {
+      this.anonymous_count += 1;
+      let full_name = "<anonymous>";
+      if (this.package_name) full_name = `${this.package_name}::${full_name}`;
+      this.context.tryNewFunction(full_name);
+      this.context.confirmNewFunction();
+      this.next(this._state_anon_brace_search);
+    } else if (token === ")") {
+      this.paren_count -= 1;
+      if (this.paren_count === 0) this.next(this._state_global);
+    } else if (token === "(") {
+      this.paren_count += 1;
+    }
+  };
+
+  private readonly _state_anon_sub = (token: string): void => {
+    if (token !== "{") return;
+    this.brace_count = 1;
+    let full_name = "<anonymous>";
+    if (this.variable_name) full_name = `$${this.variable_name}`;
+    if (this.package_name) full_name = `${this.package_name}::${full_name}`;
+    this.context.tryNewFunction(full_name);
+    this.context.confirmNewFunction();
+    this.next(this._state_function_body);
+  };
+
+  private readonly _state_function_dec = (token: string): void => {
+    if (token === "{") {
+      this.brace_count = 1;
+      if (this.function_name) {
+        let full_name = this.function_name;
+        if (this.package_name) full_name = `${this.package_name}::${this.function_name}`;
+        this.context.tryNewFunction(full_name);
+        this.context.confirmNewFunction();
+      }
+      this.next(this._state_function_body);
+    } else if (token === ":") {
+      this.in_attribute = true;
+    } else if (token === ";") {
+      if (this.function_name) {
+        let full_name = this.function_name;
+        if (this.package_name) full_name = `${this.package_name}::${this.function_name}`;
+        this.context.tryNewFunction(full_name);
+        this.context.confirmNewFunction();
+        this.context.endOfFunction();
+      }
+      this.next(this._state_global);
+    } else if (token === "(") {
+      this.paren_count = 1;
+      this.next(this._state_function_prototype);
+    } else if (token === "sub") {
+      this.anonymous_count += 1;
+      let full_name = "<anonymous>";
+      if (this.package_name) full_name = `${this.package_name}::${full_name}`;
+      this.context.tryNewFunction(full_name);
+      this.context.confirmNewFunction();
+      this.next(this._state_anon_brace_search);
+    } else if (!isPythonWhitespace(token)) {
+      if (!this.in_attribute) this.function_name = token;
+      else this.in_attribute = false;
+    }
+  };
+
+  private readonly _state_function_prototype = (token: string): void => {
+    if (token === ")") {
+      this.paren_count -= 1;
+      if (this.paren_count === 0) this.next(this._state_function_dec);
+    } else if (token === "(") {
+      this.paren_count += 1;
+    }
+  };
+
+  private readonly _state_anon_brace_search = (token: string): void => {
+    if (token === "{") {
+      this.brace_count = 1;
+      this.next(this._state_function_body);
+    } else if (token === "(") {
+      this.paren_count += 1;
+    } else if (token === ")") {
+      this.paren_count -= 1;
+      if (this.paren_count === 0) this.next(this._state_global);
+    }
+  };
+
+  private readonly _state_function_body = (token: string): void => {
+    if (token === "{") {
+      this.brace_count += 1;
+    } else if (token === "}") {
+      this.brace_count -= 1;
+      if (this.brace_count === 0) {
+        this.context.endOfFunction();
+        this.next(this._state_global);
+      }
+    } else if (token === "?") {
+      this.context.addCondition();
+    } else if (token === ":") {
+      this.context.addCondition();
+    } else if (token === "sub") {
+      this.next(this._state_nested_sub_dec);
+    } else if (token === "(") {
+      this.paren_count += 1;
+      this.next(this._state_nested_call);
+    }
+  };
+
+  private readonly _state_nested_sub_dec = (token: string): void => {
+    if (isPythonWhitespace(token)) return;
+    if (token === "{") {
+      this.brace_count += 1;
+      this.anonymous_count += 1;
+      this.context.addCondition();
+      this.next(this._state_function_body);
+      return;
+    }
+    let full_name = token;
+    if (this.package_name) full_name = `${this.package_name}::${token}`;
+    this.context.tryNewFunction(full_name);
+    this.context.confirmNewFunction();
+    this.next(this._state_nested_named_sub_brace_search);
+  };
+
+  private readonly _state_nested_named_sub_brace_search = (token: string): void => {
+    if (token === "{") {
+      this.brace_count = 1;
+      this.next(this._state_nested_sub_body);
+    } else if (isPythonWhitespace(token)) {
+      return;
+    } else if (token === ":") {
+      this.in_attribute = true;
+    } else if (token === ";") {
+      this.context.endOfFunction();
+      this.next(this._state_function_body);
+    }
+  };
+
+  private readonly _state_nested_sub_body = (token: string): void => {
+    if (token === "{") {
+      this.brace_count += 1;
+    } else if (token === "}") {
+      this.brace_count -= 1;
+      if (this.brace_count === 0) {
+        this.context.endOfFunction();
+        this.next(this._state_function_body);
+      }
+    }
+  };
+
+  private readonly _state_nested_call = (token: string): void => {
+    if (token === "sub") {
+      this.anonymous_count += 1;
+      let full_name = "<anonymous>";
+      if (this.package_name) full_name = `${this.package_name}::${full_name}`;
+      this.context.tryNewFunction(full_name);
+      this.context.confirmNewFunction();
+      this.next(this._state_nested_anon_search);
+    } else if (token === ")") {
+      this.paren_count -= 1;
+      if (this.paren_count === 0) this.next(this._state_function_body);
+    } else if (token === "(") {
+      this.paren_count += 1;
+    }
+  };
+
+  private readonly _state_nested_anon_search = (token: string): void => {
+    if (token === "{") {
+      this.brace_count += 1;
+      this.next(this._state_nested_anon_body);
+    } else if (token === "(") {
+      this.paren_count += 1;
+    } else if (token === ")") {
+      this.paren_count -= 1;
+      if (this.paren_count === 0) this.next(this._state_function_body);
+    }
+  };
+
+  private readonly _state_nested_anon_body = (token: string): void => {
+    if (token === "{") {
+      this.brace_count += 1;
+    } else if (token === "}") {
+      this.brace_count -= 1;
+      if (this.brace_count === 1) {
+        this.context.endOfFunction();
+        this.next(this._state_function_body);
+      }
+    }
+  };
+}

package/src/package-checks/function-metrics/analyzer/readers/php-states.ts

@@ -0,0 +1,253 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/php_states.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer while
+ * retaining the source PHP function/class/match state machine.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeStateMachine, isPythonWhitespace } from "../shared/code-reader.ts";
+
+/* Source state callbacks retain their method identity; CodeStateMachine supplies the owning receiver. */
+/* oxlint-disable typescript/unbound-method */
+export class PHPLanguageStates extends CodeStateMachine {
+  private function_name = "";
+  private short_function_name = "";
+  private class_name: string | undefined;
+  private trait_name: string | undefined;
+  private in_class = false;
+  private in_trait = false;
+  private bracket_level = 0;
+  private brace_level = 0;
+  private started_function = false;
+  private last_tokens = "";
+  private is_function_declaration = false;
+  private readonly assignments: string[] = [];
+  private in_match = false;
+  private match_case_count = 0;
+
+  public constructor(context: FileInfoBuilder) {
+    super(context);
+    this.last_token = "";
+  }
+
+  public override _state_global(token: string): void {
+    if (token === "use") {
+      this._state = this._state_use;
+    } else if (token === "class") {
+      this._state = this._class_declaration;
+    } else if (token === "trait") {
+      this._state = this._trait_declaration;
+    } else if (token === "function") {
+      this.is_function_declaration = true;
+      this._state = this._function_name;
+    } else if (token === "fn") {
+      // Source deliberately does not count PHP 7.4 arrow functions.
+    } else if (token === "match") {
+      this.in_match = true;
+      this.match_case_count = 0;
+      this.next(this._match_expression);
+    } else if (["if", "switch", "for", "foreach", "while", "catch"].includes(token)) {
+      this.next(this._condition_expected);
+    } else if (["public", "private", "protected", "static"].includes(token)) {
+      // Visibility modifiers do not alter this source state machine.
+    } else if (token === "=>" && this.in_match) {
+      this.match_case_count += 1;
+    } else if (token === "}" && this.in_match) {
+      this.in_match = false;
+      for (let count = 0; count < this.match_case_count - 1; count += 1) {
+        this.context.addCondition();
+      }
+      this.match_case_count = 0;
+    } else if (token === "=") {
+      this.function_name = this.last_tokens.trim();
+      this.assignments.push(this.function_name);
+    } else if (token === "{") {
+      this.brace_level += 1;
+    } else if (token === "}") {
+      this.brace_level -= 1;
+      if (this.brace_level === 0) {
+        if (this.in_class) {
+          this.in_class = false;
+          this.class_name = undefined;
+        }
+        if (this.in_trait) {
+          this.in_trait = false;
+          this.trait_name = undefined;
+        }
+      }
+    }
+
+    this.last_token = token;
+    if (![" ", "\t", "\n"].includes(token)) {
+      if (!["=", ";", "{", "}", "(", ")", ","].includes(token)) {
+        this.last_tokens = token;
+      } else if (token !== "=" || !this.last_tokens) {
+        this.last_tokens = "";
+      }
+    }
+  }
+
+  private readonly _state_use = (token: string): void => {
+    if (token === ";") this._state = this._state_global;
+  };
+
+  private readonly _trait_declaration = (token: string): void => {
+    if (token.length > 0 && !isPythonWhitespace(token) && !["{", "("].includes(token)) {
+      this.trait_name = token;
+      this.in_trait = true;
+      this._state = this._state_global;
+    } else if (token === "{") {
+      this.brace_level += 1;
+      this._state = this._state_global;
+    }
+  };
+
+  private readonly _class_declaration = (token: string): void => {
+    if (
+      token.length > 0 &&
+      !isPythonWhitespace(token) &&
+      !["{", "(", "extends", "implements"].includes(token)
+    ) {
+      this.class_name = token;
+      this.in_class = true;
+      this._state = this._state_global;
+    } else if (token === "{") {
+      this.brace_level += 1;
+      this._state = this._state_global;
+    }
+  };
+
+  private readonly _function_name = (token: string): void => {
+    if (token && !isPythonWhitespace(token) && token !== "(") {
+      const methodName = token;
+      if (this.in_class && this.class_name !== undefined && this.class_name.length > 0) {
+        this.function_name = `${this.class_name}::${methodName}`;
+        this.short_function_name = methodName;
+      } else if (this.in_trait && this.trait_name !== undefined && this.trait_name.length > 0) {
+        this.function_name = `${this.trait_name}::${methodName}`;
+        this.short_function_name = methodName;
+      } else {
+        this.function_name = methodName;
+        this.short_function_name = methodName;
+      }
+      this._state = this._function_args;
+    } else if (token === "(") {
+      if (this.in_class) {
+        this.function_name = `${this.class_name}::(anonymous)`;
+      } else if (this.in_trait) {
+        this.function_name = `${this.trait_name}::(anonymous)`;
+      } else {
+        const assignment = this.assignments.at(-1);
+        this.function_name =
+          assignment !== undefined && assignment.length > 0 ? assignment : "(anonymous)";
+        if (assignment !== undefined && assignment.length > 0) this.assignments.pop();
+      }
+      this.bracket_level = 1;
+      this._state = this._function_args_continue;
+      this.context.pushNewFunction(this.function_name);
+      this.started_function = true;
+    }
+  };
+
+  private readonly _function_args = (token: string): void => {
+    if (token !== "(") return;
+    this.bracket_level = 1;
+    if (
+      this.in_class &&
+      this.class_name !== undefined &&
+      this.class_name.length > 0 &&
+      !this.is_function_declaration
+    ) {
+      this.context.pushNewFunction(this.short_function_name);
+    } else {
+      this.context.pushNewFunction(this.function_name);
+    }
+    this.started_function = true;
+    this._state = this._function_args_continue;
+  };
+
+  private readonly _function_args_continue = (token: string): void => {
+    if (token === "(") {
+      this.bracket_level += 1;
+    } else if (token === ")") {
+      this.bracket_level -= 1;
+      if (this.bracket_level === 0) this._state = this._function_return_type_or_body;
+    } else if (token.startsWith("$") && this.started_function) {
+      this.context.addToLongFunctionName(` ${token}`);
+      this.context.parameter(token);
+    }
+  };
+
+  private readonly _function_return_type_or_body = (token: string): void => {
+    if (token === ":") {
+      this._state = this._function_body_or_return_type;
+    } else if (token === "{") {
+      this.brace_level += 1;
+      this._state = this._function_body;
+    } else if (token === ";") {
+      if (this.started_function) {
+        this.context.endOfFunction();
+        this.started_function = false;
+      }
+      this._state = this._state_global;
+    }
+  };
+
+  private readonly _function_body_or_return_type = (token: string): void => {
+    if (token === "{") {
+      this.brace_level += 1;
+      this._state = this._function_body;
+    }
+  };
+
+  private readonly _function_body = (token: string): void => {
+    if (token === "{") {
+      this.brace_level += 1;
+    } else if (token === "}") {
+      this.brace_level -= 1;
+      if (this.brace_level === Number(this.in_class)) {
+        if (this.started_function) {
+          this.context.endOfFunction();
+          this.started_function = false;
+        }
+        this._state = this._state_global;
+      }
+    }
+  };
+
+  private readonly _condition_expected = (token: string): void => {
+    if (token === "(") {
+      this.bracket_level = 1;
+      this._state = this._condition_continue;
+    }
+  };
+
+  private readonly _condition_continue = (token: string): void => {
+    if (token === "(") {
+      this.bracket_level += 1;
+    } else if (token === ")") {
+      this.bracket_level -= 1;
+      if (this.bracket_level === 0) this._state = this._state_global;
+    }
+  };
+
+  private readonly _match_expression = (token: string): void => {
+    if (token === "(") {
+      this.bracket_level = 1;
+      this._state = this._match_expression_continue;
+    }
+  };
+
+  private readonly _match_expression_continue = (token: string): void => {
+    if (token === "(") {
+      this.bracket_level += 1;
+    } else if (token === ")") {
+      this.bracket_level -= 1;
+      if (this.bracket_level === 0) this._state = this._state_global;
+    }
+  };
+}
+/* oxlint-enable typescript/unbound-method */

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

@@ -0,0 +1,63 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/php.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer while
+ * retaining the source reader's PHP block tokenizer and state transitions.
+ */
+
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CCppCommentsMixin } from "../shared/clike.ts";
+import { CodeReader, type TokenFactory } from "../shared/code-reader.ts";
+import { PHPLanguageStates } from "./php-states.ts";
+
+const PHP_CODE_BLOCK_PATTERN = /<\?(?:php)?(.*?)(?:(\?>)|(?![\s\S]))/gmsu;
+const PHP_TOKEN_ADDITION =
+  String.raw`|(?:\$\w+)` +
+  String.raw`|(?:<{3}(?<quote>\w+).*?\k<quote>)` +
+  String.raw`|(?:\?\?=)|(?:\?\?)|(?:\?->)|(?:\?:)`;
+
+/** PHP reader with the source module's code-block-only tokenizer boundary. */
+export class PHPReader extends CodeReader {
+  public static override ext = ["php"];
+  public static override languageNames = ["php"];
+  public static override controlFlowKeywords = new Set([
+    "if",
+    "elseif",
+    "for",
+    "foreach",
+    "while",
+    "catch",
+    "match"
+  ]);
+  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, PHPReader);
+    this.parallelStates = [new PHPLanguageStates(context)];
+  }
+
+  public static override *generateTokens(
+    sourceCode: string,
+    addition = "",
+    tokenFactory?: TokenFactory
+  ): Generator<string> {
+    let currentPosition = 0;
+    for (const match of sourceCode.matchAll(PHP_CODE_BLOCK_PATTERN)) {
+      const matchStart = match.index ?? 0;
+      if (sourceCode.slice(currentPosition, matchStart)) {
+        yield `"${sourceCode.slice(currentPosition, matchStart)}"`;
+      }
+      yield* CodeReader.generateTokens(match[1] ?? "", addition + PHP_TOKEN_ADDITION, tokenFactory);
+      currentPosition = matchStart + (match[0]?.length ?? 0);
+    }
+    if (sourceCode.slice(currentPosition)) yield `"${sourceCode.slice(currentPosition)}"`;
+  }
+
+  public override get_comment_from_token(token: string): string | undefined {
+    return CCppCommentsMixin.get_comment_from_token(token);
+  }
+}