@sun-asterisk/sungen 1.0.0

package/src/generators/scaffold-generator/index.ts

@@ -0,0 +1,524 @@
+/**
+ * Scaffold Generator
+ * Parses Gherkin feature files and generates selector YAML scaffolds
+ */
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import { glob } from 'glob';
+import { SelectorResolver } from '../test-generator/utils/selector-resolver';
+
+export interface ScaffoldElement {
+  selector: string;
+  type: 'placeholder' | 'role' | 'text';
+  value: string;
+  name?: string; // For role type (button name)
+  nth: number;
+}
+
+export interface ScaffoldResult {
+  [key: string]: ScaffoldElement;
+}
+
+export interface TestDataResult {
+  [key: string]: string | TestDataResult;
+}
+
+export interface MapResult {
+  featureFile: string;
+  selectorsPath: string;
+  testDataPath: string;
+  elementCount: number;
+  dataRefCount: number;
+  selectorsSkipped?: boolean;  // True if selectors file already existed
+  testDataSkipped?: boolean;   // True if test-data file already existed
+}
+
+interface ExtractedDataRef {
+  rawRef: string;         // Original ref e.g., "valid_login_email" or "valid.login_password"
+  lineText: string;       // Full line for context
+}
+
+interface ExtractedElement {
+  rawText: string;        // Original text in brackets e.g., "Email Address"
+  key: string;            // Converted key e.g., "email.address"
+  action: string;         // Action type: fill, click, see, open
+  lineText: string;       // Full line for context
+}
+
+export class ScaffoldGenerator {
+  /**
+   * Generate scaffold YAML from a feature file
+   */
+  generateFromFile(featureFilePath: string): ScaffoldResult {
+    const content = fs.readFileSync(featureFilePath, 'utf-8');
+    return this.generateFromContent(content);
+  }
+
+  /**
+   * Generate scaffold YAML from feature content
+   */
+  generateFromContent(content: string): ScaffoldResult {
+    const elements = this.extractElements(content);
+    return this.buildScaffold(elements);
+  }
+
+  /**
+   * Extract elements from Gherkin content with their actions
+   */
+  private extractElements(content: string): ExtractedElement[] {
+    const elements: ExtractedElement[] = [];
+    const lines = content.split('\n');
+
+    // Regex to match elements in brackets [...]
+    const elementRegex = /\[([^\]]+)\]/g;
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+
+      // Skip comments and empty lines
+      if (trimmedLine.startsWith('#') || !trimmedLine) {
+        continue;
+      }
+
+      // Determine action from the line
+      const action = this.detectAction(trimmedLine);
+
+      let match;
+      while ((match = elementRegex.exec(trimmedLine)) !== null) {
+        const rawText = match[1];
+        const key = SelectorResolver.generateKey(rawText);
+
+        elements.push({
+          rawText,
+          key,
+          action,
+          lineText: trimmedLine,
+        });
+      }
+    }
+
+    return elements;
+  }
+
+  /**
+   * Detect the action type from a Gherkin step line
+   */
+  private detectAction(line: string): string {
+    const lowerLine = line.toLowerCase();
+
+    // Check for specific action keywords
+    // Order matters: check "see" before "fill" because text like "fill in all fields" may appear in assertions
+    if (/\b(see|verify|check|expect|should see|visible|displayed)\b/.test(lowerLine)) {
+      return 'see';
+    }
+    if (/\b(fill|enter|type|input)\b/.test(lowerLine)) {
+      return 'fill';
+    }
+    if (/\b(click|press|tap|submit)\b/.test(lowerLine)) {
+      return 'click';
+    }
+    if (/\b(open|navigate|go to|visit)\b/.test(lowerLine)) {
+      return 'open';
+    }
+    if (/\b(select|choose|pick)\b/.test(lowerLine)) {
+      return 'select';
+    }
+
+    // Default to placeholder for unknown actions
+    return 'default';
+  }
+
+  /**
+   * Convert element text to YAML key format
+   * "Email Address" -> "email.address"
+   * "Your email or password is incorrect!" -> "your.email.or.password.is.incorrect"
+   */
+  /**
+   * Get action priority (higher number = higher priority)
+   */
+  private getActionPriority(action: string): number {
+    const priorities: { [key: string]: number } = {
+      'click': 4,    // Highest priority - most specific interaction
+      'fill': 3,     // Form input
+      'select': 3,   // Form select
+      'see': 2,      // Assertion
+      'open': 1,     // Navigation - lowest priority
+      'default': 0,
+    };
+    return priorities[action] ?? 0;
+  }
+
+  /**
+   * Build scaffold result from extracted elements
+   */
+  private buildScaffold(elements: ExtractedElement[]): ScaffoldResult {
+    const result: ScaffoldResult = {};
+    const elementActions: { [key: string]: ExtractedElement } = {};
+
+    for (const element of elements) {
+      const existingElement = elementActions[element.key];
+
+      // Keep element with higher priority action
+      if (!existingElement ||
+          this.getActionPriority(element.action) > this.getActionPriority(existingElement.action)) {
+        elementActions[element.key] = element;
+      }
+    }
+
+    // Build final scaffold from prioritized elements
+    for (const key of Object.keys(elementActions)) {
+      const element = elementActions[key];
+      const scaffoldElement = this.createScaffoldElement(element);
+      result[key] = scaffoldElement;
+    }
+
+    return result;
+  }
+
+  /**
+   * Create a scaffold element based on the action type
+   */
+  private createScaffoldElement(element: ExtractedElement): ScaffoldElement {
+    switch (element.action) {
+      case 'fill':
+        return {
+          selector: '',
+          type: 'placeholder',
+          value: element.rawText,
+          nth: 0,
+        };
+
+      case 'click':
+        return {
+          selector: '',
+          type: 'role',
+          value: 'button',
+          name: element.rawText,
+          nth: 0,
+        };
+
+      case 'see':
+        return {
+          selector: '',
+          type: 'text',
+          value: element.rawText,
+          nth: 0,
+        };
+
+      case 'select':
+        return {
+          selector: '',
+          type: 'role',
+          value: 'combobox',
+          name: element.rawText,
+          nth: 0,
+        };
+
+      case 'open':
+        // For page navigation, we typically don't need a selector
+        // But include it for reference
+        return {
+          selector: '',
+          type: 'text',
+          value: element.rawText,
+          nth: 0,
+        };
+
+      default:
+        // Default to placeholder type
+        return {
+          selector: '',
+          type: 'placeholder',
+          value: element.rawText,
+          nth: 0,
+        };
+    }
+  }
+
+  /**
+   * Generate YAML content from scaffold result
+   */
+  generateYamlContent(scaffold: ScaffoldResult, screenName?: string): string {
+    // For header, use name (for role type) or value (for other types)
+    const getDisplayValue = (e: ScaffoldElement) => e.name || e.value;
+
+    const header = screenName
+      ? `# ${this.capitalizeFirst(screenName)} Screen Selectors (Auto-generated)
+# Reference in features: ${Object.values(scaffold).map(e => `[${getDisplayValue(e)}]`).join(', ')}
+# Directory: qa/selectors/screens/
+
+`
+      : `# Screen Selectors (Auto-generated)
+
+`;
+
+    // Convert to YAML with proper formatting
+    const yamlContent = yaml.stringify(scaffold, {
+      indent: 2,
+      lineWidth: 100,
+      defaultKeyType: 'PLAIN',
+      defaultStringType: 'QUOTE_SINGLE',
+    });
+
+    return header + yamlContent;
+  }
+
+  /**
+   * Write scaffold to file
+   */
+  writeScaffold(
+    scaffold: ScaffoldResult,
+    outputPath: string,
+    screenName?: string
+  ): void {
+    const dir = path.dirname(outputPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    const content = this.generateYamlContent(scaffold, screenName);
+    fs.writeFileSync(outputPath, content, 'utf-8');
+  }
+
+  /**
+   * Process a feature file and write scaffold to output
+   */
+  processFeatureFile(
+    featureFilePath: string,
+    outputDir: string,
+    forceOverwrite: boolean = false
+  ): { outputPath: string; elementCount: number } {
+    // Extract screen name from feature file name
+    const featureFileName = path.basename(featureFilePath, '.feature');
+    const screenName = featureFileName;
+
+    // Generate scaffold
+    const scaffold = this.generateFromFile(featureFilePath);
+    const elementCount = Object.keys(scaffold).length;
+
+    // Write to output
+    const outputPath = path.join(outputDir, `${screenName}.yaml`);
+    
+    // Check if file exists and skip if not forcing overwrite
+    if (fs.existsSync(outputPath) && !forceOverwrite) {
+      return { outputPath, elementCount };
+    }
+    
+    this.writeScaffold(scaffold, outputPath, screenName);
+
+    return { outputPath, elementCount };
+  }
+
+  /**
+   * Process all feature files in a directory
+   */
+  processAllFeatures(
+    featuresDir: string,
+    outputDir: string
+  ): Array<{ file: string; outputPath: string; elementCount: number }> {
+    const featureFiles = glob.sync('**/*.feature', {
+      cwd: featuresDir,
+      absolute: true,
+    });
+
+    const results: Array<{ file: string; outputPath: string; elementCount: number }> = [];
+
+    for (const featureFile of featureFiles) {
+      const result = this.processFeatureFile(featureFile, outputDir);
+      results.push({
+        file: featureFile,
+        ...result,
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Helper to capitalize first letter
+   */
+  private capitalizeFirst(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+
+  /**
+   * Process a screen and generate both selectors and test-data YAML
+   * Folder structure: qa/screens/<screen>/features/, selectors/, test-data/
+   */
+  processScreen(screenName: string, screensDir: string = 'qa/screens', forceOverwrite: boolean = false): MapResult[] {
+    const screenDir = path.join(screensDir, screenName);
+    const featuresDir = path.join(screenDir, 'features');
+    const selectorsDir = path.join(screenDir, 'selectors');
+    const testDataDir = path.join(screenDir, 'test-data');
+
+    // Find all feature files in the screen's features directory
+    const featureFiles = glob.sync('**/*.feature', {
+      cwd: featuresDir,
+      absolute: true,
+    });
+
+    if (featureFiles.length === 0) {
+      throw new Error(`No feature files found in ${featuresDir}`);
+    }
+
+    // Ensure directories exist
+    fs.mkdirSync(selectorsDir, { recursive: true });
+    fs.mkdirSync(testDataDir, { recursive: true });
+
+    const results: MapResult[] = [];
+
+    // Process each feature file individually
+    for (const featureFile of featureFiles) {
+      const filename = path.basename(featureFile, '.feature');
+      const content = fs.readFileSync(featureFile, 'utf-8');
+
+      // Extract elements and data refs from this file
+      const elements = this.extractElements(content);
+      const dataRefs = this.extractDataRefs(content);
+
+      // Build scaffolds from this file
+      const selectorScaffold = this.buildScaffold(elements);
+      const testDataScaffold = this.buildTestData(dataRefs);
+
+      // Check if files exist
+      const selectorsPath = path.join(selectorsDir, `${filename}.yaml`);
+      const selectorsExists = fs.existsSync(selectorsPath);
+      
+      const testDataPath = path.join(testDataDir, `${filename}.yaml`);
+      const testDataExists = fs.existsSync(testDataPath);
+
+      // Write selectors YAML with filename (write if doesn't exist or force is true)
+      if (!selectorsExists || forceOverwrite) {
+        this.writeSelectorsYaml(selectorScaffold, selectorsPath, filename);
+      }
+
+      // Write test-data YAML with filename (write if doesn't exist or force is true)
+      if (!testDataExists || forceOverwrite) {
+        this.writeTestDataYaml(testDataScaffold, testDataPath, filename);
+      }
+
+      results.push({
+        featureFile: filename,
+        selectorsPath,
+        testDataPath,
+        elementCount: Object.keys(selectorScaffold).length,
+        dataRefCount: dataRefs.length,
+        selectorsSkipped: selectorsExists && !forceOverwrite,
+        testDataSkipped: testDataExists && !forceOverwrite,
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Extract data references {{...}} from Gherkin content
+   */
+  private extractDataRefs(content: string): ExtractedDataRef[] {
+    const dataRefs: ExtractedDataRef[] = [];
+    const lines = content.split('\n');
+    const seen = new Set<string>();
+
+    // Regex to match data refs {{...}}
+    const dataRefRegex = /\{\{([^}]+)\}\}/g;
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+
+      // Skip comments and empty lines
+      if (trimmedLine.startsWith('#') || !trimmedLine) {
+        continue;
+      }
+
+      let match;
+      while ((match = dataRefRegex.exec(trimmedLine)) !== null) {
+        const rawRef = match[1].trim();
+
+        // Skip duplicates
+        if (seen.has(rawRef)) {
+          continue;
+        }
+        seen.add(rawRef);
+
+        dataRefs.push({
+          rawRef,
+          lineText: trimmedLine,
+        });
+      }
+    }
+
+    return dataRefs;
+  }
+
+  /**
+   * Build test data structure from data refs
+   * Supports nested structure: "valid.login_password" -> { valid: { login_password: '' } }
+   */
+  private buildTestData(dataRefs: ExtractedDataRef[]): TestDataResult {
+    const result: TestDataResult = {};
+
+    for (const dataRef of dataRefs) {
+      const parts = dataRef.rawRef.split('.');
+
+      if (parts.length === 1) {
+        // Simple variable: "valid_login_email" -> { valid_login_email: '' }
+        result[parts[0]] = '';
+      } else {
+        // Nested variable: "valid.login_password" -> { valid: { login_password: '' } }
+        let current: TestDataResult = result;
+        for (let i = 0; i < parts.length - 1; i++) {
+          const part = parts[i];
+          if (!current[part] || typeof current[part] === 'string') {
+            current[part] = {};
+          }
+          current = current[part] as TestDataResult;
+        }
+        current[parts[parts.length - 1]] = '';
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Write selectors YAML file
+   */
+  private writeSelectorsYaml(scaffold: ScaffoldResult, outputPath: string, screenName: string): void {
+    const getDisplayValue = (e: ScaffoldElement) => e.name || e.value;
+
+    const header = `# ${this.capitalizeFirst(screenName)} Screen Selectors (Auto-generated)
+# Reference in features: ${Object.values(scaffold).map(e => `[${getDisplayValue(e)}]`).join(', ')}
+
+`;
+
+    const yamlContent = yaml.stringify(scaffold, {
+      indent: 2,
+      lineWidth: 100,
+      defaultKeyType: 'PLAIN',
+      defaultStringType: 'QUOTE_SINGLE',
+    });
+
+    fs.writeFileSync(outputPath, header + yamlContent, 'utf-8');
+  }
+
+  /**
+   * Write test-data YAML file
+   */
+  private writeTestDataYaml(testData: TestDataResult, outputPath: string, screenName: string): void {
+    const header = `# ${this.capitalizeFirst(screenName)} Screen Test Data (Auto-generated)
+# Reference in features using {{variable}} syntax
+
+`;
+
+    const yamlContent = yaml.stringify(testData, {
+      indent: 2,
+      lineWidth: 100,
+      defaultKeyType: 'PLAIN',
+      defaultStringType: 'QUOTE_SINGLE',
+    });
+
+    fs.writeFileSync(outputPath, header + yamlContent, 'utf-8');
+  }
+}