@fromeroc9/testform 1.0.2 → 1.0.4

package/dist/core/utils.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * @fileoverview Pure utility functions shared across TestForm commands.
+ *
+ * Small, stateless helpers that eliminate common one-liner duplications
+ * found across command files.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHclValue = void 0;
+exports.elapsedSeconds = elapsedSeconds;
+exports.formatIdentityDisplay = formatIdentityDisplay;
+exports.formatResourceAddress = formatResourceAddress;
+/**
+ * Calculates seconds elapsed since a given timestamp and returns a
+ * human-readable string (e.g. `"3"`).
+ *
+ * @param startTime - The start timestamp as returned by `Date.now()`.
+ * @returns Elapsed seconds as a fixed-point string with no decimals.
+ *
+ * @example
+ * const start = Date.now();
+ * // ... async work ...
+ * console.log(`Done in ${elapsedSeconds(start)}s`);
+ */
+function elapsedSeconds(startTime) {
+    return ((Date.now() - startTime) / 1000).toFixed(0);
+}
+function formatIdentityDisplay(identity) {
+    const parts = identity.split('::');
+    if (parts.length > 0) {
+        let filePath = parts[0];
+        const lastSlash = Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\'));
+        if (lastSlash !== -1) {
+            filePath = filePath.substring(lastSlash + 1);
+        }
+        const lastDot = filePath.lastIndexOf('.');
+        if (lastDot !== -1) {
+            filePath = filePath.substring(0, lastDot);
+        }
+        parts[0] = filePath;
+        return parts.join('::');
+    }
+    return identity;
+}
+/**
+ * Formats a resource address string.
+ *
+ * @param type     - The resource type (e.g. `'github_testcase'`).
+ * @param identity - The resource identity (e.g. `'tc1.case.feature::@[tc1]'`).
+ * @returns A formatted address like `"github_testcase.tc1::@[tc1]"`.
+ */
+function formatResourceAddress(type, identity) {
+    return `${type}.${formatIdentityDisplay(identity)}`;
+}
+const formatHclValue = (value, indentLevel) => {
+    const indent = '    '.repeat(indentLevel);
+    if (value === null || value === undefined)
+        return 'null';
+    if (typeof value === 'string') {
+        if (value.includes('\n')) {
+            const paddedValue = value.split('\n').map(line => line ? `${indent}    ${line}` : `${indent}    `).join('\n');
+            return `<<-EOT\n${paddedValue}\n${indent}EOT`;
+        }
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const items = value.map(v => (0, exports.formatHclValue)(v, indentLevel + 1));
+        return `[\n${indent}    ${items.join(`,\n${indent}    `)},\n${indent}]`;
+    }
+    if (typeof value === 'object') {
+        const keys = Object.keys(value);
+        if (keys.length === 0)
+            return '{}';
+        let maxKeyLen = 0;
+        for (const k of keys) {
+            const strK = JSON.stringify(k);
+            if (strK.length > maxKeyLen)
+                maxKeyLen = strK.length;
+        }
+        let out = `{\n`;
+        for (const k of keys) {
+            const strK = JSON.stringify(k);
+            const padding = ' '.repeat(maxKeyLen - strK.length);
+            const val = Object.prototype.hasOwnProperty.call(value, k) ? value[k] : undefined;
+            out += `${indent}    ${strK}${padding} = ${(0, exports.formatHclValue)(val, indentLevel + 1)}\n`;
+        }
+        out += `${indent}}`;
+        return out;
+    }
+    return JSON.stringify(value);
+};
+exports.formatHclValue = formatHclValue;

package/dist/core/variables.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableParser = void 0;
+const fs_1 = require("fs");
+const notify_1 = require("../notify");
+class VariableParser {
+    vars = {};
+    workDir;
+    constructor(varArgs, varFileArgs, workDir = '.') {
+        this.workDir = workDir;
+        this.parseVarFiles(varFileArgs);
+        this.parseVars(varArgs);
+    }
+    parseVars(varArgs) {
+        if (!varArgs)
+            return;
+        const items = Array.isArray(varArgs) ? varArgs : [varArgs];
+        for (const item of items) {
+            const idx = item.indexOf('=');
+            if (idx === -1) {
+                notify_1.notify.push({
+                    type: 'warning',
+                    title: `Invalid variable format: ${item}`,
+                    detail: ['Variables must be in the format key=value']
+                });
+                continue;
+            }
+            const key = item.substring(0, idx).trim();
+            const value = item.substring(idx + 1).trim();
+            this.vars[key] = value;
+        }
+    }
+    parseVarFiles(varFileArgs) {
+        if (!varFileArgs)
+            return;
+        const items = Array.isArray(varFileArgs) ? varFileArgs : [varFileArgs];
+        for (let filePath of items) {
+            const path = require('path');
+            filePath = path.resolve(this.workDir, filePath);
+            if (!(0, fs_1.existsSync)(filePath)) {
+                notify_1.notify.push({
+                    type: 'error',
+                    title: `Variable file not found: ${filePath}`,
+                    detail: [],
+                    close: true
+                });
+                process.exit(1);
+            }
+            try {
+                const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+                let fileVars = {};
+                if (filePath.endsWith('.json')) {
+                    fileVars = JSON.parse(content);
+                }
+                else {
+                    // Simple tfvars format parser (key = "value")
+                    const lines = content.split('\n');
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//'))
+                            continue;
+                        const idx = trimmed.indexOf('=');
+                        if (idx !== -1) {
+                            const key = trimmed.substring(0, idx).trim();
+                            let value = trimmed.substring(idx + 1).trim();
+                            // Remove surrounding quotes if present
+                            if (value.startsWith('"') && value.endsWith('"')) {
+                                value = value.substring(1, value.length - 1);
+                            }
+                            else if (value.startsWith("'") && value.endsWith("'")) {
+                                value = value.substring(1, value.length - 1);
+                            }
+                            fileVars[key] = value;
+                        }
+                    }
+                }
+                // Merge into existing vars
+                this.vars = { ...this.vars, ...fileVars };
+            }
+            catch (error) {
+                notify_1.notify.push({
+                    type: 'error',
+                    title: `Failed to parse variable file: ${filePath}`,
+                    detail: [error.message],
+                    close: true
+                });
+                process.exit(1);
+            }
+        }
+    }
+    getVars() {
+        return this.vars;
+    }
+    /**
+     * Replaces ${var.name} in the given template string
+     * with the corresponding values from the variables.
+     */
+    applyToTemplate(template) {
+        let result = template;
+        // Match ${var.NAME}
+        const regex = /\$\{var\.([a-zA-Z0-9_-]+)\}/g;
+        result = result.replace(regex, (match, key) => {
+            return this.vars[key] !== undefined ? this.vars[key] : match;
+        });
+        return result;
+    }
+}
+exports.VariableParser = VariableParser;

package/dist/core/workspace.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceManager = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+class WorkspaceManager {
+    envPath;
+    statePath;
+    constructor(dir) {
+        const testformDir = (0, path_1.join)(dir, '.testform');
+        if (!(0, fs_1.existsSync)(testformDir)) {
+            (0, fs_1.mkdirSync)(testformDir, { recursive: true });
+        }
+        this.envPath = (0, path_1.join)(testformDir, 'environment');
+        this.statePath = (0, path_1.join)(testformDir, 'testform.state');
+    }
+    getCurrentWorkspace() {
+        if ((0, fs_1.existsSync)(this.envPath) && (0, fs_1.statSync)(this.envPath).isFile()) {
+            const content = (0, fs_1.readFileSync)(this.envPath, 'utf8').trim();
+            if (content.length > 0) {
+                return content;
+            }
+        }
+        return 'default';
+    }
+    setCurrentWorkspace(name) {
+        (0, fs_1.writeFileSync)(this.envPath, name, 'utf8');
+    }
+    getActiveBackend() {
+        if ((0, fs_1.existsSync)(this.statePath) && (0, fs_1.statSync)(this.statePath).isFile()) {
+            try {
+                const content = (0, fs_1.readFileSync)(this.statePath, 'utf8');
+                const parsed = JSON.parse(content);
+                return parsed.backend || null;
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    setActiveBackend(backend) {
+        let stateObj = { version: 3 };
+        if ((0, fs_1.existsSync)(this.statePath) && (0, fs_1.statSync)(this.statePath).isFile()) {
+            try {
+                stateObj = JSON.parse((0, fs_1.readFileSync)(this.statePath, 'utf8'));
+            }
+            catch {
+                // Ignore parse errors, just overwrite
+            }
+        }
+        stateObj.backend = backend;
+        (0, fs_1.writeFileSync)(this.statePath, JSON.stringify(stateObj, null, 2), 'utf8');
+    }
+}
+exports.WorkspaceManager = WorkspaceManager;