norn-cli 1.3.16 → 1.3.18

package/out/codeLensProvider.js

@@ -0,0 +1,254 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCodeLensProvider = void 0;
+exports.updateCodeLensCoverage = updateCodeLensCoverage;
+const vscode = __importStar(require("vscode"));
+const environmentProvider_1 = require("./environmentProvider");
+// Cached coverage percentage for CodeLens display
+let cachedCoveragePercentage = null;
+let cachedCoverageTotal = 0;
+let cachedCoverageCovered = 0;
+/**
+ * Update the cached coverage for CodeLens display
+ */
+function updateCodeLensCoverage(percentage, total, covered) {
+    cachedCoveragePercentage = percentage;
+    cachedCoverageTotal = total;
+    cachedCoverageCovered = covered;
+}
+/**
+ * Checks if a sequence declaration has only optional parameters (all have defaults).
+ * Returns true if no parameters or all parameters have defaults.
+ */
+function canRunSequenceWithoutArgs(line) {
+    // Check if there are parameters
+    const parenMatch = line.match(/\(([^)]*)\)/);
+    if (!parenMatch) {
+        // No parameters - can run
+        return true;
+    }
+    const paramsStr = parenMatch[1].trim();
+    if (!paramsStr) {
+        // Empty parens - can run
+        return true;
+    }
+    // Split by comma (simple split, not handling quoted strings with commas)
+    const params = paramsStr.split(',');
+    // Check each parameter has a default (contains =)
+    for (const param of params) {
+        const trimmed = param.trim();
+        if (!trimmed)
+            continue;
+        // Must contain = for a default value
+        if (!trimmed.includes('=')) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Checks for @data(...) or @theory(...) annotations directly above a sequence declaration.
+ * This allows CodeLens execution for parameterized sequences with required parameters.
+ */
+function hasTheoryAnnotationsAbove(document, sequenceLine) {
+    const dataOrTheoryPattern = /^@(data|theory)\s*\(/;
+    const decoratorPattern = /^@/;
+    for (let i = sequenceLine - 1; i >= 0; i--) {
+        const line = document.lineAt(i).text.trim();
+        // Allow blank lines between decorators and sequence declaration
+        if (!line) {
+            continue;
+        }
+        // Stop as soon as the decorator block ends
+        if (!decoratorPattern.test(line)) {
+            break;
+        }
+        if (dataOrTheoryPattern.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+class HttpCodeLensProvider {
+    _onDidChangeCodeLenses = new vscode.EventEmitter();
+    onDidChangeCodeLenses = this._onDidChangeCodeLenses.event;
+    constructor() {
+        // Refresh code lenses when environment changes
+        vscode.commands.registerCommand('norn.refreshCodeLenses', () => {
+            this._onDidChangeCodeLenses.fire();
+        });
+    }
+    /**
+     * Gets the environment display text for CodeLens
+     * Returns 'add' if no env file exists, environment name if it does
+     */
+    getEnvDisplay() {
+        const envFile = (0, environmentProvider_1.findEnvFile)();
+        if (!envFile) {
+            return { text: '+ Add env file', hasEnvFile: false };
+        }
+        const activeEnv = (0, environmentProvider_1.getActiveEnvironment)();
+        const availableEnvs = (0, environmentProvider_1.getAvailableEnvironments)();
+        if (availableEnvs.length === 0) {
+            return { text: 'env: (empty)', hasEnvFile: true };
+        }
+        return { text: activeEnv ? `env: ${activeEnv}` : 'env: none', hasEnvFile: true };
+    }
+    provideCodeLenses(document) {
+        const codeLenses = [];
+        const methodRegex = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+/;
+        // Match sequence (with optional test keyword) and optional parameters
+        const sequenceRegex = /^(?:test\s+)?sequence\s+([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*\([^)]*\))?$/;
+        // Match swagger statement with optional quotes around URL (only in .nornapi files)
+        const swaggerRegex = /^swagger\s+["']?(https?:\/\/[^\s"']+)["']?\s*$/;
+        // Match matchesSchema assertions: assert $1.body matchesSchema "./schema.json"
+        // Note: .+? is non-greedy to not consume matchesSchema
+        const matchesSchemaRegex = /^\s*assert\s+.+?\s+matchesSchema\s+["']?([^"']+)["']?/i;
+        const envInfo = this.getEnvDisplay();
+        const isNornApiFile = document.languageId === 'nornapi';
+        const isNornFile = document.languageId === 'norn';
+        // Track if we're inside a sequence
+        let insideSequence = false;
+        for (let i = 0; i < document.lineCount; i++) {
+            const line = document.lineAt(i);
+            const trimmedText = line.text.trim();
+            // Check for swagger statement (only in .nornapi files)
+            if (isNornApiFile) {
+                const swaggerMatch = trimmedText.match(swaggerRegex);
+                if (swaggerMatch) {
+                    const range = new vscode.Range(i, 0, i, line.text.length);
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(debug-start)   Import Endpoints',
+                        command: 'norn.importSwagger',
+                        arguments: [swaggerMatch[1], i],
+                        tooltip: `Parse OpenAPI spec and generate endpoints`
+                    }));
+                    // Add Generate Schemas CodeLens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(file-code) Generate Schemas',
+                        command: 'norn.generateSchemasFromSwagger',
+                        arguments: [swaggerMatch[1], document.uri.fsPath],
+                        tooltip: 'Generate JSON Schema files from OpenAPI response definitions'
+                    }));
+                    // Add coverage CodeLens if we have coverage data
+                    if (cachedCoveragePercentage !== null) {
+                        const coverageIcon = cachedCoveragePercentage >= 80 ? '$(pass)' :
+                            cachedCoveragePercentage >= 50 ? '$(warning)' : '$(error)';
+                        codeLenses.push(new vscode.CodeLens(range, {
+                            title: `${coverageIcon} Coverage: ${cachedCoveragePercentage}% (${cachedCoverageCovered}/${cachedCoverageTotal})`,
+                            command: 'norn.showCoverage',
+                            tooltip: `API Coverage: ${cachedCoverageCovered} of ${cachedCoverageTotal} response codes tested. Click to view details.`
+                        }));
+                    }
+                    continue;
+                }
+            }
+            // Check for matchesSchema assertions (in .norn files)
+            if (isNornFile) {
+                const schemaMatch = trimmedText.match(matchesSchemaRegex);
+                if (schemaMatch) {
+                    const schemaPath = schemaMatch[1];
+                    const range = new vscode.Range(i, 0, i, line.text.length);
+                    // Open Contract lens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(file-code) Open Contract',
+                        command: 'norn.openSchemaFile',
+                        arguments: [schemaPath, document.uri.fsPath],
+                        tooltip: `Open schema file: ${schemaPath}`
+                    }));
+                    // View Contract Report lens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '$(checklist) View Contract',
+                        command: 'norn.viewContractReport',
+                        arguments: [i, document.uri.fsPath, schemaPath],
+                        tooltip: 'Run validation and show contract comparison report'
+                    }));
+                    continue;
+                }
+            }
+            // Check for sequence start
+            const sequenceMatch = trimmedText.match(sequenceRegex);
+            if (sequenceMatch) {
+                insideSequence = true;
+                const range = new vscode.Range(i, 0, i, line.text.length);
+                // Show Run Sequence if parameters are all optional, or values are provided via @data/@theory.
+                const canRunWithoutArgs = canRunSequenceWithoutArgs(trimmedText);
+                const hasTheoryAnnotations = hasTheoryAnnotationsAbove(document, i);
+                if (canRunWithoutArgs || hasTheoryAnnotations) {
+                    // Run Sequence lens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: '▶ Run Sequence',
+                        command: 'norn.runSequence',
+                        arguments: [i],
+                        tooltip: `Run all requests in sequence "${sequenceMatch[1]}"`
+                    }));
+                    // Environment lens
+                    codeLenses.push(new vscode.CodeLens(range, {
+                        title: envInfo.text,
+                        command: envInfo.hasEnvFile ? 'norn.selectEnvironmentAndRefresh' : 'norn.createEnvFile',
+                        tooltip: envInfo.hasEnvFile ? 'Click to change environment' : 'Click to create .nornenv file'
+                    }));
+                }
+                continue;
+            }
+            // Check for sequence end
+            if (trimmedText === 'end sequence') {
+                insideSequence = false;
+                continue;
+            }
+            // Only show "Send Request" for requests OUTSIDE of sequences
+            if (!insideSequence && methodRegex.test(line.text)) {
+                const range = new vscode.Range(i, 0, i, line.text.length);
+                // Send Request lens
+                codeLenses.push(new vscode.CodeLens(range, {
+                    title: '▶ Send Request',
+                    command: 'norn.sendRequest',
+                    arguments: [i],
+                    tooltip: 'Send this HTTP request'
+                }));
+                // Environment lens
+                codeLenses.push(new vscode.CodeLens(range, {
+                    title: envInfo.text,
+                    command: envInfo.hasEnvFile ? 'norn.selectEnvironmentAndRefresh' : 'norn.createEnvFile',
+                    tooltip: envInfo.hasEnvFile ? 'Click to change environment' : 'Click to create .nornenv file'
+                }));
+            }
+        }
+        return codeLenses;
+    }
+}
+exports.HttpCodeLensProvider = HttpCodeLensProvider;
+//# sourceMappingURL=codeLensProvider.js.map

package/out/compareContentProvider.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Content provider for response comparison diff view
+ * Provides in-memory content for VS Code's built-in diff editor
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompareContentProvider = void 0;
+exports.getCompareContentProvider = getCompareContentProvider;
+exports.registerCompareContentProvider = registerCompareContentProvider;
+const vscode = __importStar(require("vscode"));
+class CompareContentProvider {
+    static scheme = 'norn-compare';
+    _content = new Map();
+    _onDidChange = new vscode.EventEmitter();
+    onDidChange = this._onDidChange.event;
+    /**
+     * Set content for a given path (e.g., 'baseline.json' or 'current.json')
+     */
+    setContent(path, content) {
+        this._content.set(path, content);
+        const uri = vscode.Uri.parse(`${CompareContentProvider.scheme}:${path}`);
+        this._onDidChange.fire(uri);
+        return uri;
+    }
+    /**
+     * Clear all stored content
+     */
+    clear() {
+        this._content.clear();
+    }
+    /**
+     * Provider implementation - returns content for the given URI
+     */
+    provideTextDocumentContent(uri) {
+        return this._content.get(uri.path) || '';
+    }
+}
+exports.CompareContentProvider = CompareContentProvider;
+// Singleton instance for use across the extension
+let _instance;
+function getCompareContentProvider() {
+    if (!_instance) {
+        _instance = new CompareContentProvider();
+    }
+    return _instance;
+}
+function registerCompareContentProvider(context) {
+    const provider = getCompareContentProvider();
+    const registration = vscode.workspace.registerTextDocumentContentProvider(CompareContentProvider.scheme, provider);
+    context.subscriptions.push(registration);
+}
+//# sourceMappingURL=compareContentProvider.js.map