@zxyycom/vibe-check 0.0.1 → 0.0.2

package/src/package-checks/function-metrics/analyzer/extension-output.ts

@@ -0,0 +1,261 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard.py OutputScheme and extension output lifecycle.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: Apache-2.0
+ * Modified: private extension reporting compatibility isolated from analysis execution.
+ */
+
+import { extensionMetadata, invokeExtensionPrintResult } from "./extensions/protocol.ts";
+import type { FunctionInfoDefinition } from "./extensions/protocol.ts";
+import type { AnalyzerProcessor } from "./contracts.ts";
+import { AttributeError, FileInformation, FunctionInfo } from "./analysis-model.ts";
+import { isPythonWhitespace } from "./shared/code-reader.ts";
+
+export interface OutputSchemeItem {
+  caption?: string;
+  value: string;
+  avg_caption?: string;
+}
+
+/**
+ * Lizard's extension-owned output schema. The class remains analyzer-internal:
+ * report invocation stays in the separately excluded CLI/report entry surface.
+ */
+export class OutputScheme {
+  public extensions: readonly AnalyzerProcessor[];
+  public items: OutputSchemeItem[];
+
+  public constructor(ext: readonly AnalyzerProcessor[]) {
+    this.extensions = ext;
+    this.items = [
+      { caption: "  NLOC  ", value: "nloc", avg_caption: " Avg.NLOC " },
+      { caption: "  CCN  ", value: "cyclomatic_complexity", avg_caption: " AvgCCN " },
+      { caption: " token ", value: "token_count", avg_caption: " Avg.token " },
+      { caption: " PARAM ", value: "parameter_count" },
+      { caption: " length ", value: "length" },
+      ...Array.from(this._ext_member_info(), ([caption, value, averageCaption]) => ({
+        caption,
+        value,
+        // The source owns the key even when its value is None. That key controls
+        // `patch_for_extensions`, so keep the JavaScript property present too.
+        avg_caption: averageCaption
+      }))
+    ];
+    this.items.push({ caption: " location  ", value: "location" });
+  }
+
+  public patch_for_extensions(): void {
+    for (const item of this.items) {
+      if (!("avg_caption" in item)) continue;
+      const name = item.value;
+      Object.defineProperty(FileInformation.prototype, `average_${name}`, {
+        configurable: true,
+        get(this: FileInformation): number {
+          return this.functions_average(name);
+        }
+      });
+    }
+  }
+
+  public patchForExtensions(): void {
+    this.patch_for_extensions();
+  }
+
+  public any_silent(): boolean {
+    return this.extensions.some(
+      (extension) => extensionMetadata(extension).silent_all_others !== undefined
+    );
+  }
+
+  public anySilent(): boolean {
+    return this.any_silent();
+  }
+
+  public value_columns(): string[] {
+    return this.items.map((item) => item.value);
+  }
+
+  public valueColumns(): string[] {
+    return this.value_columns();
+  }
+
+  public *_ext_member_info(): Generator<[string | undefined, string, string | undefined]> {
+    for (const extension of this.extensions) {
+      const functionInfo = extensionMetadata(extension).FUNCTION_INFO;
+      if (functionInfo === undefined) continue;
+      for (const [name, definition] of Object.entries(functionInfo)) {
+        yield [definition.caption, name, definition.average_caption];
+      }
+    }
+  }
+
+  public *extMemberInfo(): Generator<[string | undefined, string, string | undefined]> {
+    yield* this._ext_member_info();
+  }
+
+  public captions(): string {
+    return this.items.flatMap((item) => (item.caption ? [item.caption] : [])).join("");
+  }
+
+  public static _head(captions: string): string {
+    const width = Array.from(captions).length;
+    return ["=".repeat(width), captions, "-".repeat(width)].join("\n");
+  }
+
+  public function_info_head(): string {
+    return OutputScheme._head(this.captions());
+  }
+
+  public functionInfoHead(): string {
+    return this.function_info_head();
+  }
+
+  public function_info(functionInfo: FunctionInfo): string {
+    let rendered = "";
+    for (const item of this.items) {
+      if (!item.caption) continue;
+      rendered += pythonRightJustify(
+        pythonString(readFunctionInfoAttribute(functionInfo, item.value)),
+        Array.from(item.caption).length
+      );
+    }
+    return rendered;
+  }
+
+  public functionInfo(functionInfo: FunctionInfo): string {
+    return this.function_info(functionInfo);
+  }
+
+  public average_captions(): string {
+    return this.items.flatMap((item) => (item.avg_caption ? [item.avg_caption] : [])).join("");
+  }
+
+  public averageCaptions(): string {
+    return this.average_captions();
+  }
+
+  public average_formatter(): string {
+    return this.items
+      .flatMap((item) => {
+        if (!item.avg_caption) return [];
+        return [`{module.average_${item.value}:${Array.from(item.avg_caption).length}.1f}`];
+      })
+      .join("");
+  }
+
+  public averageFormatter(): string {
+    return this.average_formatter();
+  }
+
+  public clang_warning_format(): string {
+    return (
+      "{f.filename}:{f.start_line}: warning: {f.name} has {f.nloc} NLOC, " +
+      "{f.cyclomatic_complexity} CCN, {f.token_count} token, {f.parameter_count} PARAM, " +
+      "{f.length} length, {f.max_nesting_depth} ND"
+    );
+  }
+
+  public clangWarningFormat(): string {
+    return this.clang_warning_format();
+  }
+
+  public msvs_warning_format(): string {
+    return (
+      "{f.filename}({f.start_line}): warning: {f.name} ({f.long_name}) has " +
+      this.items
+        .slice(0, -1)
+        .map((item) => `{f.${item.value}} ${outputCaption(item.caption)}`)
+        .join(", ")
+    );
+  }
+
+  public msvsWarningFormat(): string {
+    return this.msvs_warning_format();
+  }
+}
+
+/** Compatibility bridge for existing internal callers of OutputScheme metadata. */
+export function collectFunctionInfoDefinitions(
+  processors: readonly AnalyzerProcessor[]
+): readonly FunctionInfoDefinitionEntry[] {
+  const definitions: FunctionInfoDefinitionEntry[] = [];
+  for (const processor of processors) {
+    const functionInfo = extensionMetadata(processor).FUNCTION_INFO;
+    if (functionInfo === undefined) continue;
+    for (const [name, definition] of Object.entries(functionInfo)) {
+      definitions.push({ name, definition });
+    }
+  }
+  return definitions;
+}
+
+/** Compatibility bridge for the source `OutputScheme.patch_for_extensions` lifecycle. */
+export function patchFunctionInfoAverages(processors: readonly AnalyzerProcessor[]): void {
+  new OutputScheme(processors).patch_for_extensions();
+}
+
+/** Compatibility bridge for the source `OutputScheme.any_silent` lifecycle. */
+export function hasSilentAllOthers(processors: readonly AnalyzerProcessor[]): boolean {
+  return new OutputScheme(processors).any_silent();
+}
+
+/** Invoke extension result hooks in source registration order. */
+export function printExtensionResults(processors: readonly AnalyzerProcessor[]): void {
+  for (const processor of processors) {
+    invokeExtensionPrintResult(processor);
+  }
+}
+
+/** Source `print_extension_results` spelling for the retained hook lifecycle. */
+export function print_extension_results(processors: readonly AnalyzerProcessor[]): void {
+  printExtensionResults(processors);
+}
+
+/** One entry from an extension's source-aligned FUNCTION_INFO mapping. */
+export interface FunctionInfoDefinitionEntry {
+  readonly name: string;
+  readonly definition: FunctionInfoDefinition;
+}
+
+function readFunctionInfoAttribute(functionInfo: FunctionInfo, attribute: string): unknown {
+  if (!(attribute in functionInfo)) throw new AttributeError("FunctionInfo", attribute);
+  return Reflect.get(functionInfo, attribute);
+}
+
+function pythonString(value: unknown): string {
+  if (value === null) return "None";
+  if (value === true) return "True";
+  if (value === false) return "False";
+  // oxlint-disable-next-line typescript/no-base-to-string -- Python's str() deliberately dispatches dynamic extension metric values.
+  return String(value);
+}
+
+function pythonRightJustify(value: string, width: number): string {
+  const characterCount = Array.from(value).length;
+  return characterCount >= width ? value : `${" ".repeat(width - characterCount)}${value}`;
+}
+
+function outputCaption(caption: string | undefined): string {
+  if (caption === undefined) throw new AttributeError("NoneType", "strip");
+  return stripPythonWhitespace(caption);
+}
+
+function stripPythonWhitespace(value: string): string {
+  const characters = Array.from(value);
+  let firstCharacter = 0;
+  while (
+    firstCharacter < characters.length &&
+    isPythonWhitespace(characters[firstCharacter] ?? "")
+  ) {
+    firstCharacter += 1;
+  }
+  let lastCharacter = characters.length;
+  while (
+    lastCharacter > firstCharacter &&
+    isPythonWhitespace(characters[lastCharacter - 1] ?? "")
+  ) {
+    lastCharacter -= 1;
+  }
+  return characters.slice(firstCharacter, lastCharacter).join("");
+}

package/src/package-checks/function-metrics/analyzer/extensions/extension-base.ts

@@ -0,0 +1,33 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_ext/extension_base.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining the extension token-state
+ * lifecycle and per-reader context assignment.
+ */
+
+import { FileInfoBuilder } from "../analysis-context.ts";
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import { CodeStateMachine } from "../shared/code-reader.ts";
+import type { LizardExtension } from "./protocol.ts";
+
+/** Base state machine for translated extension bodies. */
+export class ExtensionBase extends CodeStateMachine implements LizardExtension {
+  public constructor(context?: FileInfoBuilder) {
+    // Upstream extension constructors commonly pass None and receive the real
+    // context at __call__ time. The placeholder is never observed after that
+    // source-aligned handoff.
+    super(context ?? new FileInfoBuilder(""));
+  }
+
+  public *__call__(tokens: TokenStream, reader: AnalyzerReader): Generator<string> {
+    this.context = reader.context;
+    for (const token of tokens) {
+      // ExtensionBase invokes its current state directly, unlike CodeReader's
+      // full state-machine call path; retain that distinction from upstream.
+      this.invokeCurrentState(token);
+      yield token;
+    }
+  }
+}

package/src/package-checks/function-metrics/analyzer/extensions/lizardcomplextags.ts

@@ -0,0 +1,27 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_ext/lizardcomplextags.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: mechanically translated to the Check-private TypeScript port.
+ */
+
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { LizardExtension as LizardExtensionProtocol } from "./protocol.ts";
+
+/** Records every source reader condition token with its current source line. */
+export class LizardExtension implements LizardExtensionProtocol {
+  public *__call__(tokens: TokenStream, reader: AnalyzerReader): Generator<string> {
+    const context = reader.context;
+    const conditions = reader.conditions;
+    for (const token of tokens) {
+      yield token;
+      if (context.current_function.complex_tags === undefined) {
+        context.current_function.complex_tags = [];
+      }
+      if (conditions.has(token)) {
+        context.current_function.complex_tags.push([token, context.current_line]);
+      }
+    }
+  }
+}

package/src/package-checks/function-metrics/analyzer/extensions/lizardnd.ts

@@ -0,0 +1,144 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_ext/lizardnd.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the Check-private TypeScript port. Python's
+ * import-time FileInfoBuilder/FunctionInfo monkey patches are represented by
+ * typed private members on those host classes in analysis-context.ts and analysis-model.ts.
+ */
+
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type {
+  ExtensionArgumentRegistrar,
+  LizardExtension as LizardExtensionProtocol
+} from "./protocol.ts";
+
+export const DEFAULT_ND_THRESHOLD = 7;
+
+const DEFAULT_LOOPS = new Set([
+  "if",
+  "foreach",
+  "for",
+  "while",
+  "&&",
+  "||",
+  "?",
+  "catch",
+  "case",
+  "try",
+  "def"
+]);
+
+/** Source lizardnd.py processor and its FUNCTION_INFO/set_args lifecycle. */
+export class LizardExtension implements LizardExtensionProtocol {
+  public static readonly FUNCTION_INFO = {
+    max_nesting_depth: { caption: "  ND  ", average_caption: " Avg.ND " }
+  };
+
+  public static set_args(parser: ExtensionArgumentRegistrar): void {
+    parser.add_argument("-N", "--ND", {
+      default: DEFAULT_ND_THRESHOLD,
+      dest: "ND",
+      help: `Threshold for nesting depth number\n            warning. The default value is ${DEFAULT_ND_THRESHOLD}.\n            Functions with ND bigger than it will generate warning\n            `,
+      type: "int"
+    });
+  }
+
+  public *__call__(tokens: TokenStream, reader: AnalyzerReader, lDepth = 0): Generator<string> {
+    const loops = reader.loops === undefined ? DEFAULT_LOOPS : new Set(reader.loops);
+    const bracket = reader.bracket ?? "}";
+    const loopIndicator = reader.loop_indicator ?? "{";
+    const indentIndicator = reader.indent_indicator ?? ";";
+    let nestingDepth = lDepth;
+
+    for (const token of tokens) {
+      if (token === "else") {
+        reader.context.set_prev_was_else(true);
+      } else if (token === loopIndicator || token === indentIndicator) {
+        reader.context.clear_prev_was_else();
+      } else if (token === "if" && loops.has(token) && reader.context.get_prev_was_else()) {
+        reader.context.clear_prev_was_else();
+      } else if (token === "(") {
+        reader.context.set_in_condition(true);
+        reader.context.increment_condition_depth();
+        reader.context.set_logical_operator_added(false);
+      } else if (token === ")") {
+        reader.context.decrement_condition_depth();
+        if (reader.context.get_condition_depth() === 0) {
+          reader.context.set_in_condition(false);
+          reader.context.set_logical_operator_added(false);
+        }
+      } else if (token === "&&" || token === "||") {
+        if (reader.context.get_in_condition()) {
+          if (!reader.context.get_logical_operator_added()) {
+            nestingDepth = reader.context.add_nd_condition();
+            if (!reader.context.get_loop_status()) {
+              reader.context.add_hidden_bracket_condition();
+              reader.context.loop_bracket_status();
+            }
+            reader.context.set_logical_operator_added(true);
+          }
+        } else {
+          nestingDepth = reader.context.add_nd_condition();
+          if (!reader.context.get_loop_status()) {
+            reader.context.add_hidden_bracket_condition();
+            reader.context.loop_bracket_status();
+          }
+        }
+      } else if (loops.has(token) && token !== "&&" && token !== "||") {
+        nestingDepth = reader.context.add_nd_condition();
+        if (!reader.context.get_loop_status()) {
+          reader.context.add_hidden_bracket_condition();
+          reader.context.loop_bracket_status();
+        }
+      }
+
+      if (token === loopIndicator) reader.context.loop_bracket_status();
+      if (token === bracket) nestingDepth = reader.context.add_nd_condition(-1);
+      if (token === indentIndicator) {
+        check_loop_brackets(reader.context, nestingDepth, reader.context.get_hidden_bracket());
+      }
+      if (nestingDepth < 0) {
+        nestingDepth = 0;
+        reader.context.reset_nd_complexity();
+      }
+      yield token;
+    }
+  }
+}
+
+/** Source lizardnd.py's FileInfoBuilder patch target, supplied by analysis-context.ts. */
+export type NDFileInfoAddition = Pick<
+  FileInfoBuilder,
+  | "add_nd_condition"
+  | "reset_nd_complexity"
+  | "add_hidden_bracket_condition"
+  | "get_hidden_bracket"
+  | "loop_bracket_status"
+  | "get_loop_status"
+  | "set_in_condition"
+  | "get_in_condition"
+  | "increment_condition_depth"
+  | "decrement_condition_depth"
+  | "get_condition_depth"
+  | "reset_condition_tracking"
+  | "set_logical_operator_added"
+  | "get_logical_operator_added"
+  | "set_prev_was_else"
+  | "get_prev_was_else"
+  | "clear_prev_was_else"
+>;
+
+/** Source check_loop_brackets; TypeScript returns no value like Python. */
+export function check_loop_brackets(
+  context: FileInfoBuilder,
+  lDepth: number,
+  hiddenBrackets: number
+): void {
+  if (hiddenBrackets > 0) {
+    context.add_hidden_bracket_condition(-1);
+    context.add_nd_condition(-1);
+  }
+}