@dev-blinq/cucumber_client 1.0.1475-dev → 1.0.1475-stage

package/bin/client/codemod/find_harcoded_locators.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const ROOT = process.cwd();
+const ALLOWED_HARDCODE_RATIO = 0.2;
+const IGNORED_RATIO = 1.0;
+const PLACEHOLDER_REGEX = /{[^}]+}/;
+const IGNORE_DIRS = new Set(["node_modules", ".git", ".idea"]);
+
+const results = [];
+
+function hasPlaceholder(str) {
+  return PLACEHOLDER_REGEX.test(str);
+}
+
+function stringFromNode(node) {
+  if (!node) return undefined;
+  if (node.type === "StringLiteral") return node.value;
+  if (node.type === "TemplateLiteral") {
+    const raw = node.quasis.map((q) => q.value.cooked ?? q.value.raw).join("${}");
+    return raw;
+  }
+  return undefined;
+}
+
+function locatorIsParameterized(objNode) {
+  if (objNode.type !== "ObjectExpression") return false;
+  return objNode.properties.some((prop) => {
+    if (prop.type !== "ObjectProperty") return false;
+    const valueString = stringFromNode(prop.value);
+    return typeof valueString === "string" && hasPlaceholder(valueString);
+  });
+}
+
+function analyzeMjsFile(filePath, code) {
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript", "classProperties", "optionalChaining", "nullishCoalescingOperator", "topLevelAwait"],
+  });
+
+  const traverse = typeof traverseImport === "function" ? traverseImport : traverseImport.default;
+
+  traverse(ast, {
+    ObjectExpression(pathObj) {
+      const props = pathObj.node.properties;
+      const locatorProp = props.find(
+        (p) =>
+          p.type === "ObjectProperty" &&
+          ((p.key.type === "Identifier" && p.key.name === "locators") ||
+            (p.key.type === "StringLiteral" && p.key.value === "locators"))
+      );
+      if (!locatorProp || locatorProp.value.type !== "ArrayExpression") return;
+
+      const locators = locatorProp.value.elements.filter(Boolean);
+      if (locators.length === 0) return;
+
+      const total = locators.length;
+      const hardcoded = locators.filter((loc) => !locatorIsParameterized(loc)).length;
+      if (hardcoded / total === IGNORED_RATIO) return; // Skip if all locators are hardcoded (likely a non-locator object)
+      if (hardcoded / total <= ALLOWED_HARDCODE_RATIO) return;
+
+      const nameProp = props.find(
+        (p) =>
+          p.type === "ObjectProperty" &&
+          ((p.key.type === "Identifier" && (p.key.name === "element_name" || p.key.name === "element_key")) ||
+            (p.key.type === "StringLiteral" && (p.key.value === "element_name" || p.key.value === "element_key")))
+      );
+      const elementNameValue = nameProp ? stringFromNode(nameProp.value) : undefined;
+      const loc = pathObj.node.loc?.start;
+      results.push({
+        file: filePath,
+        line: loc?.line ?? 0,
+        element: elementNameValue ?? "<unknown>",
+        hardcoded,
+        total,
+      });
+    },
+  });
+}
+
+function locatorIsParameterizedJson(locator) {
+  if (locator && typeof locator === "object") {
+    return Object.values(locator).some((val) => typeof val === "string" && hasPlaceholder(val));
+  }
+  return false;
+}
+
+function findLineNumber(content, searchValue) {
+  const idx = content.indexOf(searchValue);
+  if (idx === -1) return 0;
+  return content.slice(0, idx).split("\n").length;
+}
+
+function analyzeJsonFile(filePath, content) {
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch (err) {
+    console.warn(`Skipping ${filePath}: invalid JSON`);
+    return;
+  }
+
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+
+    if (Array.isArray(node.locators) && node.locators.length > 0) {
+      const total = node.locators.length;
+      const hardcoded = node.locators.filter((loc) => !locatorIsParameterizedJson(loc)).length;
+
+      if (hardcoded / total > ALLOWED_HARDCODE_RATIO) {
+        if (hardcoded / total === IGNORED_RATIO) return; // Skip if all locators are hardcoded (likely a non-locator object)
+        const name = node.element_name || node.element_key || "<unknown>";
+        const line = findLineNumber(content, name);
+        results.push({ file: filePath, line, element: name, hardcoded, total });
+      }
+    }
+
+    Object.values(node).forEach(visit);
+  };
+
+  visit(data);
+}
+
+async function walk(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (IGNORE_DIRS.has(entry.name)) continue;
+    const resolved = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walk(resolved);
+    } else if (entry.isFile() && (entry.name.endsWith(".mjs") || entry.name.endsWith(".json"))) {
+      const content = await fs.readFile(resolved, "utf8");
+      try {
+        if (entry.name.endsWith(".mjs")) {
+          analyzeMjsFile(resolved, content);
+        } else {
+          analyzeJsonFile(resolved, content);
+        }
+      } catch (err) {
+        console.error(`Failed to analyze ${resolved}:`, err.message);
+      }
+    }
+  }
+}
+
+async function main() {
+  await walk(ROOT);
+  if (results.length === 0) {
+    console.log("No elements exceeded 20% hardcoded locator threshold.");
+    return;
+  }
+
+  for (const r of results) {
+    console.log(`${r.file}:${r.line} — ${r.element} (${r.hardcoded}/${r.total} hardcoded)`);
+  }
+  process.exitCode = 1;
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/bin/client/codemod/fix_hardcoded_locators.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+/**
+ * Codemod to drop hardcoded locators flagged by find_harcoded_locators.mjs.
+ * - Default: clones workspace to a temp dir, git init + baseline commit, applies fixes, prints diffs.
+ * - --inplace: modifies files in the current workspace.
+ *
+ * Behavior:
+ *   For each reported file, in every object with a `locators` array,
+ *   remove locator entries that contain no placeholders ({...}).
+ *   If all locators are hardcoded, the array is left unchanged to avoid emptying it.
+ *   JSON files are handled similarly.
+ *
+ * Usage:
+ *   node find_harcoded_locators.mjs | node fix-hardcoded-locators.mjs
+ *   node find_harcoded_locators.mjs | node fix-hardcoded-locators.mjs --inplace
+ */
+
+import fs from "node:fs";
+import { promises as fsPromises } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+import { spawnSync } from "node:child_process";
+
+const traverse = typeof traverseImport === "function" ? traverseImport : traverseImport.default;
+const PLACEHOLDER_REGEX = /{[^}]+}/;
+const ROOT = process.cwd();
+
+const INPUT = await readStdin();
+if (!INPUT.trim()) {
+  console.error("No input provided. Pipe find_harcoded_locators.mjs into this script.");
+  process.exit(1);
+}
+
+const filesToFix = parseInputLines(INPUT);
+if (filesToFix.size === 0) {
+  console.log("No actionable lines detected.");
+  process.exit(0);
+}
+
+const INPLACE = process.argv.includes("--inplace");
+const { cloneRoot, mapper } = INPLACE ? { cloneRoot: ROOT, mapper: (p) => p } : await cloneWorkspace(ROOT);
+if (!INPLACE) {
+  console.log(`Cloned workspace to: ${cloneRoot}`);
+  await initGitRepo(cloneRoot);
+} else {
+  console.log("Running in-place (original files will be modified).");
+}
+
+const changes = [];
+
+for (const originalPath of filesToFix) {
+  const clonedPath = mapper(originalPath);
+  const ext = path.extname(clonedPath).toLowerCase();
+  const original = await fsPromises.readFile(clonedPath, "utf8");
+  let fixed = original;
+
+  if (ext === ".json") {
+    fixed = fixJson(original);
+  } else if (ext === ".mjs" || ext === ".js") {
+    fixed = fixJs(original);
+  }
+
+  if (fixed === original) continue;
+
+  const diff = makeDiff(originalPath, clonedPath, fixed);
+  await fsPromises.writeFile(clonedPath, fixed, "utf8");
+  changes.push({ filePath: originalPath, diff });
+}
+
+if (changes.length === 0) {
+  console.log("No changes needed.");
+  process.exit(0);
+}
+
+for (const { filePath, diff } of changes) {
+  console.log(`\n=== ${filePath} (cloned) ===`);
+  console.log(diff.trimEnd());
+}
+
+process.exit(1);
+
+// ---------- helpers ----------
+
+function parseInputLines(text) {
+  const set = new Set();
+  for (const line of text.split(/\r?\n/)) {
+    const m = line.match(/^(.*?):\d+ — /);
+    if (m) set.add(m[1]);
+  }
+  return set;
+}
+
+function hasPlaceholder(str) {
+  return PLACEHOLDER_REGEX.test(str);
+}
+
+function locatorHasPlaceholderNode(node) {
+  if (!node || node.type !== "ObjectExpression") return false;
+  return node.properties.some((prop) => {
+    if (prop.type !== "ObjectProperty") return false;
+    const val = prop.value;
+    if (val.type === "StringLiteral") return hasPlaceholder(val.value);
+    if (val.type === "TemplateLiteral") {
+      const raw = val.quasis.map((q) => q.value.cooked ?? q.value.raw).join("${}");
+      return hasPlaceholder(raw);
+    }
+    return false;
+  });
+}
+
+function propName(prop) {
+  if (prop.type !== "ObjectProperty") return undefined;
+  const k = prop.key;
+  if (k.type === "Identifier") return k.name;
+  if (k.type === "StringLiteral") return k.value;
+  return undefined;
+}
+
+function leadingWhitespace(text, index) {
+  const lineStart = text.lastIndexOf("\n", index - 1) + 1;
+  const m = text.slice(lineStart, index).match(/^[ \t]*/);
+  return m ? m[0] : "";
+}
+
+function fixJs(code) {
+  let touched = false;
+  const replacements = [];
+
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript", "classProperties", "optionalChaining", "nullishCoalescingOperator", "topLevelAwait"],
+    ranges: true,
+  });
+
+  traverse(ast, {
+    ObjectExpression(pathObj) {
+      const props = pathObj.node.properties.filter((p) => p.type === "ObjectProperty");
+      if (!props.length) return;
+      const locProp = props.find((p) => propName(p) === "locators" && p.value.type === "ArrayExpression");
+      if (!locProp) return;
+      const elements = locProp.value.elements.filter(Boolean);
+      if (elements.length === 0) return;
+
+      const keep = elements.filter(locatorHasPlaceholderNode);
+      if (keep.length === elements.length) return;
+      if (keep.length === 0) return; // avoid emptying; leave as-is
+
+      if (typeof locProp.value.start !== "number" || typeof locProp.value.end !== "number") return;
+
+      const valueStart = locProp.value.start;
+      const valueEnd = locProp.value.end;
+      const indent = leadingWhitespace(code, valueStart) + "  ";
+      const keepTexts = keep.map((el) => code.slice(el.start, el.end));
+      const newArray =
+        "[\n" + keepTexts.map((t) => indent + t.trim()).join(",\n") + "\n" + leadingWhitespace(code, valueStart) + "]";
+
+      replacements.push({ start: valueStart, end: valueEnd, text: newArray });
+      touched = true;
+    },
+  });
+
+  if (!touched) return code;
+
+  let out = code;
+  replacements
+    .sort((a, b) => b.start - a.start)
+    .forEach(({ start, end, text }) => {
+      out = out.slice(0, start) + text + out.slice(end);
+    });
+  return out;
+}
+
+function locatorHasPlaceholderJson(locator) {
+  if (locator && typeof locator === "object") {
+    return Object.values(locator).some((val) => typeof val === "string" && hasPlaceholder(val));
+  }
+  return false;
+}
+
+function fixJson(content) {
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch {
+    return content;
+  }
+  let touched = false;
+
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) return node.forEach(visit);
+
+    if (Array.isArray(node.locators) && node.locators.length > 0) {
+      const keep = node.locators.filter(locatorHasPlaceholderJson);
+      if (keep.length > 0 && keep.length < node.locators.length) {
+        node.locators = keep;
+        touched = true;
+      }
+    }
+    Object.values(node).forEach(visit);
+  };
+
+  visit(data);
+  return touched ? JSON.stringify(data, null, 2) + "\n" : content;
+}
+
+async function cloneWorkspace(root) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "codemod-clone-"));
+  const cloneRoot = path.join(tmpDir, path.basename(root));
+
+  if (fsPromises.cp) {
+    await fsPromises.cp(root, cloneRoot, { recursive: true, force: true });
+  } else {
+    const res = spawnSync("cp", ["-R", ".", cloneRoot], { cwd: root, stdio: "inherit" });
+    if (res.status !== 0) throw new Error("Failed to clone workspace");
+  }
+
+  const mapper = (orig) => path.join(cloneRoot, path.relative(root, orig));
+  return { cloneRoot, mapper };
+}
+
+async function initGitRepo(cloneRoot) {
+  if (fs.existsSync(path.join(cloneRoot, ".git"))) return;
+  const run = (args) => spawnSync("git", args, { cwd: cloneRoot, stdio: "inherit" });
+  run(["init"]);
+  run(["add", "."]);
+  run(["commit", "-m", "chore: baseline before codemod"]);
+}
+
+function makeDiff(originalPath, clonedPath, fixed) {
+  const tmpOutDir = fs.mkdtempSync(path.join(os.tmpdir(), "codemod-out-"));
+  const fixedPath = path.join(tmpOutDir, path.basename(clonedPath));
+  fs.writeFileSync(fixedPath, fixed, "utf8");
+  const diff = spawnSync("diff", ["-u", originalPath, fixedPath], { encoding: "utf8" });
+  return diff.stdout || diff.stderr || "";
+}
+
+async function readStdin() {
+  return await new Promise((resolve) => {
+    let d = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => (d += c));
+    process.stdin.on("end", () => resolve(d));
+  });
+}

package/bin/client/codemod/index.js

@@ -0,0 +1,8 @@
+import { locatorObjectToArray } from "./locators_array/index.js";
+export const codeMods = [
+    {
+        name: "Locator Object to Array",
+        description: "Converts locator objects with numeric keys to arrays.",
+        apply: locatorObjectToArray,
+    },
+];

package/bin/client/codemod/locators_array/find_misstructured_elements.js

@@ -0,0 +1,148 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+import * as t from "@babel/types";
+// @babel/traverse may export the visitor function either as the module itself (CJS)
+// or under a `default` property (ESM). Normalize to a callable function to avoid
+// runtime "traverse is not a function" errors in bundled environments.
+const traverse = typeof traverseImport === "function"
+    ? traverseImport
+    : (traverseImport.default ?? traverseImport);
+const IGNORE_DIRS = new Set(["node_modules", ".git", ".idea"]);
+function propName(prop) {
+    if (!t.isObjectProperty(prop))
+        return undefined;
+    const key = prop.key;
+    if (t.isIdentifier(key))
+        return key.name;
+    if (t.isStringLiteral(key))
+        return key.value;
+    if (t.isNumericLiteral(key))
+        return String(key.value);
+    return undefined;
+}
+function isNumericKey(name) {
+    return typeof name === "string" && /^\d+$/.test(name);
+}
+function getElementLabel(props) {
+    const labelProp = props.find((p) => ["element_name", "element_key"].includes(propName(p) ?? ""));
+    if (!labelProp)
+        return undefined;
+    const value = labelProp.value;
+    if (t.isStringLiteral(value))
+        return value.value;
+    if (t.isTemplateLiteral(value)) {
+        return value.quasis.map((q) => q.value.cooked ?? q.value.raw).join("${}");
+    }
+    return undefined;
+}
+function analyzeAst(filePath, code, results) {
+    const ast = parse(code, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript", "classProperties", "optionalChaining", "nullishCoalescingOperator", "topLevelAwait"],
+    });
+    traverse(ast, {
+        ObjectExpression(pathObj) {
+            const props = pathObj.node.properties.filter(t.isObjectProperty);
+            if (props.length === 0)
+                return;
+            const names = props.map(propName).filter(Boolean);
+            const hasElementMeta = names.some((n) => n === "element_name" || n === "element_key");
+            if (!hasElementMeta)
+                return;
+            const hasLocators = names.includes("locators");
+            const numericProps = names.filter(isNumericKey);
+            if (!hasLocators && numericProps.length > 0) {
+                results.push({
+                    file: filePath,
+                    line: pathObj.node.loc?.start.line ?? 0,
+                    element: getElementLabel(props) ?? "<unknown>",
+                    numericCount: numericProps.length,
+                });
+            }
+        },
+    });
+}
+function findLineNumber(content, searchValue) {
+    if (!searchValue)
+        return 0;
+    const idx = content.indexOf(searchValue);
+    if (idx === -1)
+        return 0;
+    return content.slice(0, idx).split("\n").length;
+}
+function analyzeJson(filePath, content, results, logger) {
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch {
+        logger.warn(`Skipping ${filePath}: invalid JSON`);
+        return;
+    }
+    const visit = (node) => {
+        if (!node || typeof node !== "object")
+            return;
+        if (Array.isArray(node)) {
+            node.forEach(visit);
+            return;
+        }
+        const record = node;
+        const keys = Object.keys(record);
+        const hasElementMeta = "element_name" in record || "element_key" in record;
+        const hasLocators = "locators" in record;
+        const numericKeys = keys.filter(isNumericKey);
+        if (hasElementMeta && !hasLocators && numericKeys.length > 0) {
+            results.push({
+                file: filePath,
+                line: findLineNumber(content, record.element_name ?? record.element_key),
+                element: record.element_name ?? record.element_key ?? "<unknown>",
+                numericCount: numericKeys.length,
+            });
+        }
+        Object.values(record).forEach(visit);
+    };
+    visit(data);
+}
+async function walk(dir, results, logger) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (IGNORE_DIRS.has(entry.name))
+            continue;
+        const resolved = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walk(resolved, results, logger);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (entry.name.endsWith(".mjs") || entry.name.endsWith(".js")) {
+            const code = await fs.readFile(resolved, "utf8");
+            try {
+                analyzeAst(resolved, code, results);
+            }
+            catch (err) {
+                logger.error(`Failed to analyze ${resolved}: ${err.message}`);
+            }
+        }
+        else if (entry.name.endsWith(".json")) {
+            const content = await fs.readFile(resolved, "utf8");
+            try {
+                analyzeJson(resolved, content, results, logger);
+            }
+            catch (err) {
+                logger.error(`Failed to analyze ${resolved}: ${err.message}`);
+            }
+        }
+    }
+}
+/**
+ * Scans all JS/MJS/JSON files under `root` and returns an array of issues:
+ * [{ file, line, element, numericCount }]
+ */
+export async function findIssues(root, logger) {
+    const results = [];
+    await walk(root, results, logger);
+    return results;
+}