@reinteractive/rails-insight 1.0.1

package/src/extractors/coverage-snapshot.js

@@ -0,0 +1,296 @@
+/**
+ * Coverage Snapshot Extractor
+ * Parses SimpleCov JSON output and cross-references with structural
+ * data to produce per-file, per-method coverage analysis.
+ *
+ * @module coverage-snapshot
+ */
+
+import { toOneDecimalPercent } from '../core/constants.js'
+
+/**
+ * Extract coverage snapshot from SimpleCov output.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {object} [modelExtractions] - Pre-extracted model data (for method line mapping)
+ * @param {object} [controllerExtractions] - Pre-extracted controller data
+ * @returns {object}
+ */
+export function extractCoverageSnapshot(
+  provider,
+  modelExtractions = {},
+  controllerExtractions = {},
+) {
+  const result = {
+    available: false,
+    tool: null,
+    overall: {
+      line_coverage: null,
+      branch_coverage: null,
+      files_tracked: 0,
+    },
+    per_file: {},
+    uncovered_methods: [],
+    timestamp: null,
+  }
+
+  // Try to read SimpleCov JSON output
+  const coverageRaw = provider.readFile('coverage/coverage.json')
+  if (!coverageRaw) {
+    // Also try .resultset.json (older SimpleCov format)
+    const resultsetRaw = provider.readFile('coverage/.resultset.json')
+    if (!resultsetRaw) return result
+    return parseResultSet(
+      resultsetRaw,
+      result,
+      modelExtractions,
+      controllerExtractions,
+    )
+  }
+
+  let coverageData
+  try {
+    coverageData = JSON.parse(coverageRaw)
+  } catch {
+    result.parse_error = true
+    return result
+  }
+
+  result.available = true
+  result.tool = 'simplecov'
+  result.timestamp = coverageData.timestamp || null
+
+  // SimpleCov coverage.json structure varies by version
+  // Modern: { "coverage": { "file_path": { "lines": [...], "branches": {...} } } }
+  // Legacy: { "RSpec": { "coverage": { "file_path": { "lines": [...] } } } }
+  let fileCoverage = {}
+
+  if (coverageData.coverage) {
+    fileCoverage = coverageData.coverage
+  } else {
+    // Legacy format: find first test suite key
+    for (const key of Object.keys(coverageData)) {
+      if (coverageData[key] && coverageData[key].coverage) {
+        fileCoverage = coverageData[key].coverage
+        break
+      }
+    }
+  }
+
+  let totalLines = 0
+  let coveredLines = 0
+  let totalBranches = 0
+  let coveredBranches = 0
+
+  for (const [filePath, fileData] of Object.entries(fileCoverage)) {
+    const relativePath = normaliseToRelative(filePath)
+    if (!relativePath) continue
+
+    // Extract line coverage data
+    const lineData = Array.isArray(fileData) ? fileData : fileData.lines || []
+
+    let fileTotal = 0
+    let fileCovered = 0
+    const uncoveredLineNumbers = []
+
+    for (let i = 0; i < lineData.length; i++) {
+      const val = lineData[i]
+      if (val === null) continue // Non-relevant line (comments, blanks)
+      fileTotal++
+      totalLines++
+      if (val > 0) {
+        fileCovered++
+        coveredLines++
+      } else {
+        uncoveredLineNumbers.push(i + 1) // 1-indexed
+      }
+    }
+
+    const fileCoveragePercent = toOneDecimalPercent(fileCovered, fileTotal)
+
+    result.per_file[relativePath] = {
+      line_coverage: fileCoveragePercent,
+      lines_total: fileTotal,
+      lines_covered: fileCovered,
+      uncovered_lines: uncoveredLineNumbers,
+    }
+
+    // Branch coverage if available
+    if (fileData.branches && typeof fileData.branches === 'object') {
+      for (const [, branchData] of Object.entries(fileData.branches)) {
+        if (typeof branchData === 'object') {
+          for (const count of Object.values(branchData)) {
+            totalBranches++
+            if (count > 0) coveredBranches++
+          }
+        }
+      }
+
+      const fileBranchTotal = Object.values(fileData.branches).reduce(
+        (sum, bd) => {
+          return sum + (typeof bd === 'object' ? Object.keys(bd).length : 0)
+        },
+        0,
+      )
+      const fileBranchCovered = Object.values(fileData.branches).reduce(
+        (sum, bd) => {
+          if (typeof bd !== 'object') return sum
+          return sum + Object.values(bd).filter((c) => c > 0).length
+        },
+        0,
+      )
+
+      if (fileBranchTotal > 0) {
+        result.per_file[relativePath].branch_coverage = toOneDecimalPercent(
+          fileBranchCovered,
+          fileBranchTotal,
+        )
+      }
+    }
+
+    // Cross-reference uncovered lines with method line ranges
+    mapUncoveredMethods(
+      relativePath,
+      uncoveredLineNumbers,
+      modelExtractions,
+      controllerExtractions,
+      result.uncovered_methods,
+    )
+  }
+
+  result.overall.line_coverage = toOneDecimalPercent(coveredLines, totalLines)
+  result.overall.branch_coverage = toOneDecimalPercent(
+    coveredBranches,
+    totalBranches,
+  )
+  result.overall.files_tracked = Object.keys(result.per_file).length
+
+  return result
+}
+
+/**
+ * Map uncovered line numbers to specific methods using extractor data.
+ * @param {string} filePath
+ * @param {number[]} uncoveredLines
+ * @param {object} modelExtractions
+ * @param {object} controllerExtractions
+ * @param {Array} outputArray - mutated, results pushed here
+ */
+function mapUncoveredMethods(
+  filePath,
+  uncoveredLines,
+  modelExtractions,
+  controllerExtractions,
+  outputArray,
+) {
+  if (uncoveredLines.length === 0) return
+
+  // Find the extraction for this file
+  let methodRanges = null
+  let entityName = null
+  let entityType = null
+
+  // Check models
+  for (const [name, model] of Object.entries(modelExtractions)) {
+    if (model.file === filePath && model.method_line_ranges) {
+      methodRanges = model.method_line_ranges
+      entityName = name
+      entityType = 'model'
+      break
+    }
+  }
+
+  // Check controllers
+  if (!methodRanges) {
+    for (const [name, ctrl] of Object.entries(controllerExtractions)) {
+      if (ctrl.file === filePath && ctrl.action_line_ranges) {
+        methodRanges = ctrl.action_line_ranges
+        entityName = name
+        entityType = 'controller'
+        break
+      }
+    }
+  }
+
+  if (!methodRanges) return
+
+  for (const [methodName, range] of Object.entries(methodRanges)) {
+    const uncoveredInMethod = uncoveredLines.filter(
+      (line) => line >= range.start && line <= range.end,
+    )
+    const totalMethodLines = range.end - range.start + 1
+
+    if (uncoveredInMethod.length > 0) {
+      outputArray.push({
+        file: filePath,
+        entity: entityName,
+        entity_type: entityType,
+        method: methodName,
+        uncovered_lines: uncoveredInMethod.length,
+        total_lines: totalMethodLines,
+        coverage: toOneDecimalPercent(
+          totalMethodLines - uncoveredInMethod.length,
+          totalMethodLines,
+        ),
+      })
+    }
+  }
+}
+
+/**
+ * Normalise an absolute file path to a project-relative path.
+ * @param {string} filePath
+ * @returns {string|null}
+ */
+function normaliseToRelative(filePath) {
+  if (filePath.startsWith('app/') || filePath.startsWith('lib/')) {
+    return filePath
+  }
+
+  const appIdx = filePath.lastIndexOf('/app/')
+  if (appIdx !== -1) return filePath.slice(appIdx + 1)
+
+  const libIdx = filePath.lastIndexOf('/lib/')
+  if (libIdx !== -1 && !filePath.includes('/gems/')) {
+    return filePath.slice(libIdx + 1)
+  }
+
+  return null
+}
+
+/**
+ * Parse legacy .resultset.json format.
+ * @param {string} raw
+ * @param {object} result
+ * @param {object} modelExtractions
+ * @param {object} controllerExtractions
+ * @returns {object}
+ */
+function parseResultSet(raw, result, modelExtractions, controllerExtractions) {
+  try {
+    const data = JSON.parse(raw)
+    // .resultset.json: { "SuiteName": { "coverage": { ... }, "timestamp": ... } }
+    for (const key of Object.keys(data)) {
+      if (data[key] && data[key].coverage) {
+        // Re-use the main parser by constructing a coverage.json-like structure
+        const syntheticRaw = JSON.stringify({
+          coverage: data[key].coverage,
+          timestamp: data[key].timestamp || null,
+        })
+        const provider = {
+          readFile(path) {
+            if (path === 'coverage/coverage.json') return syntheticRaw
+            return null
+          },
+        }
+        return extractCoverageSnapshot(
+          provider,
+          modelExtractions,
+          controllerExtractions,
+        )
+      }
+    }
+  } catch {
+    result.parse_error = true
+  }
+  return result
+}

package/src/extractors/email.js

@@ -0,0 +1,123 @@
+/**
+ * Email Extractor (#11)
+ * Extracts mailer metadata and Action Mailbox configuration.
+ */
+
+import { EMAIL_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Extract email/mailer information.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {Array<{path: string, category: string}>} entries
+ * @returns {object}
+ */
+export function extractEmail(provider, entries) {
+  const result = {
+    mailers: [],
+    delivery: {},
+    interceptors: [],
+    observers: [],
+    mailbox: null,
+  }
+
+  // Extract mailers
+  const mailerEntries = entries.filter(
+    (e) => e.path.startsWith('app/mailers/') && e.path.endsWith('.rb'),
+  )
+
+  for (const entry of mailerEntries) {
+    const content = provider.readFile(entry.path)
+    if (!content) continue
+
+    const classMatch = content.match(EMAIL_PATTERNS.mailerClass)
+    if (!classMatch) continue
+
+    const mailer = {
+      class: classMatch[1],
+      file: entry.path,
+      superclass: classMatch[2],
+      methods: [],
+      default_from: null,
+      layout: null,
+    }
+
+    // Default from
+    const fromMatch = content.match(EMAIL_PATTERNS.defaultFrom)
+    if (fromMatch) mailer.default_from = fromMatch[1]
+
+    // Layout
+    const layoutMatch = content.match(EMAIL_PATTERNS.mailerLayout)
+    if (layoutMatch) mailer.layout = layoutMatch[1]
+
+    // Methods (actions) - extract all def methods, filter out private
+    const lines = content.split('\n')
+    let inPrivate = false
+    for (const line of lines) {
+      if (/^\s*private\b/.test(line) || /^\s*protected\b/.test(line)) {
+        inPrivate = true
+        continue
+      }
+      if (!inPrivate) {
+        const methodMatch = line.match(/^\s*def\s+(\w+)/)
+        if (methodMatch && methodMatch[1] !== 'initialize') {
+          mailer.methods.push(methodMatch[1])
+        }
+      }
+    }
+
+    result.mailers.push(mailer)
+  }
+
+  // Delivery config from environment files
+  for (const env of ['production', 'development', 'test']) {
+    const config = provider.readFile(`config/environments/${env}.rb`)
+    if (config) {
+      const deliveryMatch = config.match(EMAIL_PATTERNS.deliveryMethod)
+      if (deliveryMatch) {
+        result.delivery[env] = deliveryMatch[1]
+      }
+    }
+  }
+
+  // Interceptors and observers from initializers
+  const initContent =
+    provider.readFile('config/initializers/email.rb') ||
+    provider.readFile('config/initializers/mailer.rb') ||
+    ''
+  const appContent = provider.readFile('config/application.rb') || ''
+  const combined = initContent + '\n' + appContent
+
+  const intMatch = combined.match(EMAIL_PATTERNS.interceptor)
+  if (intMatch) result.interceptors.push(intMatch[1])
+
+  const obsMatch = combined.match(EMAIL_PATTERNS.observer)
+  if (obsMatch) result.observers.push(obsMatch[1])
+
+  // Action Mailbox
+  const mailboxEntries = entries.filter(
+    (e) => e.path.startsWith('app/mailboxes/') && e.path.endsWith('.rb'),
+  )
+  if (mailboxEntries.length > 0) {
+    result.mailbox = { present: true, mailboxes: [], routing: {} }
+    for (const entry of mailboxEntries) {
+      const content = provider.readFile(entry.path)
+      if (!content) continue
+      const classMatch = content.match(EMAIL_PATTERNS.mailboxClass)
+      if (classMatch && classMatch[1] !== 'ApplicationMailbox') {
+        result.mailbox.mailboxes.push(classMatch[1])
+      }
+      // Routing
+      const routingRe = new RegExp(EMAIL_PATTERNS.mailboxRouting.source, 'g')
+      let m
+      while ((m = routingRe.exec(content))) {
+        const routeStr = m[1].trim()
+        const routeMatch = routeStr.match(/(.+)\s*=>\s*:(\w+)/)
+        if (routeMatch) {
+          result.mailbox.routing[routeMatch[1].trim()] = routeMatch[2]
+        }
+      }
+    }
+  }
+
+  return result
+}

package/src/extractors/factory-registry.js

@@ -0,0 +1,225 @@
+/**
+ * Factory Registry Extractor
+ * Parses FactoryBot factory definitions from spec/factories/ or test/factories/.
+ *
+ * @module factory-registry
+ */
+
+import { FACTORY_PATTERNS } from '../core/patterns.js'
+import { classify as inflectorClassify } from '../utils/inflector.js'
+
+/**
+ * Extract factory definitions from factory files.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {Array<{path: string, specCategory?: string}>} entries
+ * @returns {object}
+ */
+export function extractFactoryRegistry(provider, entries) {
+  const result = {
+    factories: {},
+    total_factories: 0,
+    total_traits: 0,
+    factory_files: [],
+    missing_factories: [],
+  }
+
+  // Find factory files
+  const factoryEntries = entries.filter(
+    (e) =>
+      e.specCategory === 'factories' ||
+      (e.path.includes('factories/') && e.path.endsWith('.rb')),
+  )
+
+  for (const entry of factoryEntries) {
+    const content = provider.readFile(entry.path)
+    if (!content) continue
+
+    result.factory_files.push(entry.path)
+    const factories = parseFactoryFile(content, entry.path)
+
+    for (const factory of factories) {
+      result.factories[factory.name] = factory
+      result.total_factories++
+      result.total_traits += factory.traits.length
+    }
+  }
+
+  return result
+}
+
+/**
+ * Parse a single factory file for factory definitions.
+ * Handles nested factories and multiple factories per file.
+ * @param {string} content
+ * @param {string} filePath
+ * @returns {Array<object>}
+ */
+function parseFactoryFile(content, filePath) {
+  const factories = []
+  const lines = content.split('\n')
+
+  let currentFactory = null
+  let inTransient = false
+  let depth = 0
+  let factoryDepth = 0
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const trimmed = line.trim()
+
+    // Skip comments and blanks
+    if (!trimmed || trimmed.startsWith('#')) continue
+
+    // Skip FactoryBot.define wrapper — don't track its depth
+    if (/FactoryBot\.define\s+do/.test(trimmed)) continue
+
+    // Factory definition
+    const factoryMatch = trimmed.match(FACTORY_PATTERNS.factoryDef)
+    if (factoryMatch) {
+      // If we're already in a factory, save it first (nested factory)
+      if (currentFactory) {
+        factories.push(currentFactory)
+      }
+
+      const name = factoryMatch[1]
+      const explicitClass = factoryMatch[2] || null
+
+      currentFactory = {
+        name,
+        class_name: explicitClass || classify(name),
+        file: filePath,
+        traits: [],
+        sequences: [],
+        associations: [],
+        attributes: [],
+        has_transient: false,
+        has_after_create: false,
+        has_after_build: false,
+      }
+      factoryDepth = depth
+      depth++
+      inTransient = false
+      continue
+    }
+
+    if (!currentFactory) {
+      if (/\bdo\b/.test(trimmed) && !/\bend\b/.test(trimmed)) depth++
+      if (/\bend\b/.test(trimmed)) depth--
+      continue
+    }
+
+    // Trait definition
+    const traitMatch = trimmed.match(FACTORY_PATTERNS.trait)
+    if (traitMatch) {
+      currentFactory.traits.push(traitMatch[1])
+      depth++
+      continue
+    }
+
+    // Transient block
+    if (FACTORY_PATTERNS.transient.test(trimmed)) {
+      inTransient = true
+      currentFactory.has_transient = true
+      depth++
+      continue
+    }
+
+    // After create callback
+    if (FACTORY_PATTERNS.afterCreate.test(trimmed)) {
+      currentFactory.has_after_create = true
+      if (/\bdo\b/.test(trimmed) && !/\bend\b/.test(trimmed)) depth++
+      continue
+    }
+
+    // After build callback
+    if (FACTORY_PATTERNS.afterBuild.test(trimmed)) {
+      currentFactory.has_after_build = true
+      if (/\bdo\b/.test(trimmed) && !/\bend\b/.test(trimmed)) depth++
+      continue
+    }
+
+    // Association
+    const assocMatch = trimmed.match(FACTORY_PATTERNS.association)
+    if (assocMatch) {
+      currentFactory.associations.push({
+        name: assocMatch[1],
+        options: assocMatch[2] || null,
+      })
+      continue
+    }
+
+    // Sequence
+    const seqMatch =
+      trimmed.match(FACTORY_PATTERNS.sequence) ||
+      trimmed.match(FACTORY_PATTERNS.sequenceBlock)
+    if (seqMatch) {
+      currentFactory.sequences.push(seqMatch[1])
+      if (/\bdo\b/.test(trimmed) && !/\bend\b/.test(trimmed)) depth++
+      continue
+    }
+
+    // Track do...end nesting
+    if (/\bdo\b/.test(trimmed) && !/\bend\b/.test(trimmed)) {
+      depth++
+    }
+
+    if (/\bend\b/.test(trimmed)) {
+      depth--
+      if (depth <= factoryDepth) {
+        // Factory closed
+        if (inTransient) {
+          inTransient = false
+        } else {
+          factories.push(currentFactory)
+          currentFactory = null
+        }
+      }
+    }
+
+    // Attribute with block
+    if (!inTransient) {
+      const attrBlockMatch = trimmed.match(FACTORY_PATTERNS.attributeBlock)
+      if (
+        attrBlockMatch &&
+        !FACTORY_PATTERNS.trait.test(trimmed) &&
+        !FACTORY_PATTERNS.transient.test(trimmed) &&
+        !FACTORY_PATTERNS.afterCreate.test(trimmed) &&
+        !FACTORY_PATTERNS.afterBuild.test(trimmed)
+      ) {
+        const attrName = attrBlockMatch[1]
+        // Filter out ruby keywords and control structures
+        if (
+          ![
+            'if',
+            'unless',
+            'do',
+            'end',
+            'def',
+            'class',
+            'module',
+            'factory',
+            'trait',
+          ].includes(attrName)
+        ) {
+          currentFactory.attributes.push(attrName)
+        }
+      }
+    }
+  }
+
+  // Handle unclosed factory
+  if (currentFactory) {
+    factories.push(currentFactory)
+  }
+
+  return factories
+}
+
+/**
+ * Convert a snake_case factory name to a PascalCase class name.
+ * @param {string} str
+ * @returns {string}
+ */
+function classify(str) {
+  return inflectorClassify(str)
+}