@reinteractive/rails-insight 1.0.1

package/src/extractors/routes.js

@@ -0,0 +1,251 @@
+/**
+ * Routes Extractor (#3)
+ * Parses config/routes.rb with namespace/scope stack tracking.
+ */
+
+import { ROUTE_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Extract route information from routes file(s).
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @returns {object}
+ */
+export function extractRoutes(provider) {
+  const result = {
+    root: null,
+    resources: [],
+    standalone_routes: [],
+    mounted_engines: [],
+    concerns: [],
+    drawn_files: [],
+    nested_relationships: [],
+  }
+
+  const content = provider.readFile('config/routes.rb')
+  if (!content) return result
+
+  parseRouteContent(content, result, provider, [])
+  return result
+}
+
+/**
+ * @param {string} content
+ * @param {object} result
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {string[]} namespaceStack
+ */
+function parseRouteContent(content, result, provider, namespaceStack) {
+  const lines = content.split('\n')
+  const blockStack = [] // tracks do..end nesting for resources/member/collection
+  const resourceStack = []
+  let inMember = false
+  let inCollection = false
+
+  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
+
+    // Root
+    const rootMatch = trimmed.match(ROUTE_PATTERNS.root)
+    if (rootMatch) {
+      result.root = { controller: rootMatch[1], action: rootMatch[2] || null }
+      continue
+    }
+
+    // Draw (route splitting)
+    const drawMatch = trimmed.match(ROUTE_PATTERNS.draw)
+    if (drawMatch) {
+      const drawFile = drawMatch[1]
+      result.drawn_files.push(drawFile)
+      const drawContent = provider.readFile('config/routes/' + drawFile + '.rb')
+      if (drawContent) {
+        parseRouteContent(drawContent, result, provider, [...namespaceStack])
+      }
+      continue
+    }
+
+    // Mount
+    const mountMatch = trimmed.match(ROUTE_PATTERNS.mount)
+    if (mountMatch) {
+      result.mounted_engines.push({
+        engine: mountMatch[1],
+        path: mountMatch[2],
+      })
+      continue
+    }
+
+    // Concern definition
+    const concernMatch = trimmed.match(ROUTE_PATTERNS.concern)
+    if (concernMatch) {
+      result.concerns.push(concernMatch[1])
+      blockStack.push('concern')
+      continue
+    }
+
+    // Namespace
+    const nsMatch = trimmed.match(ROUTE_PATTERNS.namespace)
+    if (nsMatch) {
+      namespaceStack.push(nsMatch[1])
+      blockStack.push('namespace')
+      continue
+    }
+
+    // Scope
+    const scopeMatch = trimmed.match(ROUTE_PATTERNS.scope)
+    if (scopeMatch) {
+      const scopeName = scopeMatch[1] || scopeMatch[2] || ''
+      namespaceStack.push(scopeName)
+      blockStack.push('scope')
+      continue
+    }
+
+    // Resource (singular) - check before resources since resources? matches both
+    const resourceMatch = trimmed.match(ROUTE_PATTERNS.resource)
+    if (resourceMatch && /^\s*resource\s/.test(trimmed)) {
+      const name = resourceMatch[1]
+      const options = resourceMatch[2] || ''
+      const ns = namespaceStack.length > 0 ? namespaceStack.join('/') : null
+
+      let actions = ['show', 'new', 'create', 'edit', 'update', 'destroy']
+      const onlyMatch = options.match(ROUTE_PATTERNS.only)
+      if (onlyMatch) {
+        actions = onlyMatch[1].match(/:(\w+)/g)?.map((a) => a.slice(1)) || []
+      }
+
+      const entry = {
+        name,
+        namespace: ns,
+        controller: ns ? `${ns}/${name}` : name,
+        actions,
+        singular: true,
+      }
+
+      if (trimmed.includes('do')) {
+        blockStack.push('resource')
+        resourceStack.push(entry)
+      }
+
+      result.resources.push(entry)
+      continue
+    }
+
+    // Resources (plural)
+    const resourcesMatch = trimmed.match(ROUTE_PATTERNS.resources)
+    if (resourcesMatch) {
+      const name = resourcesMatch[1]
+      const options = resourcesMatch[2] || ''
+      const ns = namespaceStack.length > 0 ? namespaceStack.join('/') : null
+
+      // Determine actions
+      let actions = [
+        'index',
+        'show',
+        'new',
+        'create',
+        'edit',
+        'update',
+        'destroy',
+      ]
+      const onlyMatch = options.match(ROUTE_PATTERNS.only)
+      if (onlyMatch) {
+        actions = onlyMatch[1].match(/:(\w+)/g)?.map((a) => a.slice(1)) || []
+      }
+      const exceptMatch = options.match(ROUTE_PATTERNS.except)
+      if (exceptMatch) {
+        const except =
+          exceptMatch[1].match(/:(\w+)/g)?.map((a) => a.slice(1)) || []
+        actions = actions.filter((a) => !except.includes(a))
+      }
+
+      const entry = {
+        name,
+        namespace: ns,
+        controller: ns ? `${ns}/${name}` : name,
+        actions,
+        member_routes: [],
+        collection_routes: [],
+        nested: [],
+      }
+
+      // Track nesting relationship
+      const parentResource = resourceStack[resourceStack.length - 1] || null
+      if (parentResource) {
+        result.nested_relationships.push({
+          parent: parentResource.name,
+          child: name,
+          parent_controller: parentResource.controller,
+          child_controller: ns ? `${ns}/${name}` : name,
+        })
+        entry.parent_resource = parentResource.name
+        if (parentResource.nested) {
+          parentResource.nested.push(name)
+        }
+      }
+
+      if (trimmed.includes('do')) {
+        blockStack.push('resources')
+        resourceStack.push(entry)
+      }
+
+      result.resources.push(entry)
+      continue
+    }
+
+    // Member block
+    if (ROUTE_PATTERNS.member.test(trimmed)) {
+      inMember = true
+      blockStack.push('member')
+      continue
+    }
+
+    // Collection block
+    if (ROUTE_PATTERNS.collection.test(trimmed)) {
+      inCollection = true
+      blockStack.push('collection')
+      continue
+    }
+
+    // HTTP verb routes
+    const verbMatch = trimmed.match(ROUTE_PATTERNS.httpVerb)
+    if (verbMatch) {
+      const path = verbMatch[1]
+      const controller = verbMatch[2] || null
+      const action = verbMatch[3] || null
+      const method =
+        trimmed
+          .match(/^\s*(get|post|put|patch|delete)\s/)?.[1]
+          ?.toUpperCase() || 'GET'
+
+      if (inMember && resourceStack.length > 0) {
+        // Extract action name from path
+        const currentResource = resourceStack[resourceStack.length - 1]
+        const memberAction = path.replace(/^\//, '').split('/')[0]
+        currentResource.member_routes.push(memberAction)
+      } else if (inCollection && resourceStack.length > 0) {
+        const currentResource = resourceStack[resourceStack.length - 1]
+        const collAction = path.replace(/^\//, '').split('/')[0]
+        currentResource.collection_routes.push(collAction)
+      } else {
+        result.standalone_routes.push({ method, path, controller, action })
+      }
+      continue
+    }
+
+    // End
+    if (/^\s*end\b/.test(trimmed)) {
+      const popped = blockStack.pop()
+      if (popped === 'namespace' || popped === 'scope') {
+        namespaceStack.pop()
+      } else if (popped === 'member') {
+        inMember = false
+      } else if (popped === 'collection') {
+        inCollection = false
+      } else if (popped === 'resources' || popped === 'resource') {
+        resourceStack.pop()
+      }
+    }
+  }
+}

package/src/extractors/schema.js

@@ -0,0 +1,178 @@
+/**
+ * Schema Extractor (#4)
+ * Parses db/schema.rb for table definitions, columns, indexes, foreign keys.
+ */
+
+import { SCHEMA_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Extract schema information from db/schema.rb.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @returns {object}
+ */
+export function extractSchema(provider) {
+  const result = {
+    version: null,
+    extensions: [],
+    enums: {},
+    tables: [],
+    foreign_keys: [],
+  }
+
+  const content = provider.readFile('db/schema.rb')
+  if (!content) return result
+
+  // Schema version
+  const versionMatch =
+    content.match(SCHEMA_PATTERNS.schemaVersion) ||
+    content.match(SCHEMA_PATTERNS.schemaVersionAlt)
+  if (versionMatch) {
+    result.version = versionMatch[1]
+  }
+
+  // Extensions
+  const extRe = new RegExp(SCHEMA_PATTERNS.enableExtension.source, 'gm')
+  let m
+  while ((m = extRe.exec(content))) {
+    result.extensions.push(m[1])
+  }
+
+  // Enums (PostgreSQL)
+  const enumRe = new RegExp(SCHEMA_PATTERNS.createEnum.source, 'gm')
+  while ((m = enumRe.exec(content))) {
+    const values =
+      m[2].match(/['"](\w+)['"]/g)?.map((v) => v.replace(/['"]/g, '')) || []
+    result.enums[m[1]] = values
+  }
+
+  // Foreign keys (outside table blocks)
+  const fkRe = new RegExp(SCHEMA_PATTERNS.foreignKey.source, 'gm')
+  while ((m = fkRe.exec(content))) {
+    result.foreign_keys.push({
+      from_table: m[1],
+      to_table: m[2],
+      options: m[3] || null,
+    })
+  }
+
+  // Parse tables
+  const lines = content.split('\n')
+  let currentTable = null
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const trimmed = line.trim()
+
+    // Create table
+    const tableMatch = trimmed.match(SCHEMA_PATTERNS.createTable)
+    if (tableMatch) {
+      const options = tableMatch[2] || ''
+      let pkType = 'bigint'
+      let pkAuto = true
+
+      if (SCHEMA_PATTERNS.idFalse.test(options)) {
+        pkType = null
+        pkAuto = false
+      } else if (SCHEMA_PATTERNS.idUuid.test(options)) {
+        pkType = 'uuid'
+      } else {
+        const idTypeMatch = options.match(SCHEMA_PATTERNS.idType)
+        if (idTypeMatch) pkType = idTypeMatch[1]
+      }
+
+      const commentMatch = options.match(SCHEMA_PATTERNS.comment)
+
+      // Composite primary key detection
+      const compositePkMatch = options.match(
+        SCHEMA_PATTERNS.compositePrimaryKey,
+      )
+      if (compositePkMatch) {
+        const columns =
+          compositePkMatch[1]
+            .match(/['":]\w+/g)
+            ?.map((c) => c.replace(/['":]/, '')) || []
+        currentTable = {
+          name: tableMatch[1],
+          primary_key: { type: 'composite', columns },
+          columns: [],
+          indexes: [],
+          comment: commentMatch ? commentMatch[1] : null,
+        }
+      } else {
+        currentTable = {
+          name: tableMatch[1],
+          primary_key: pkType ? { type: pkType, auto: pkAuto } : null,
+          columns: [],
+          indexes: [],
+          comment: commentMatch ? commentMatch[1] : null,
+        }
+      }
+      result.tables.push(currentTable)
+      continue
+    }
+
+    if (!currentTable) continue
+
+    // End of table block
+    if (/^\s*end\b/.test(trimmed) && currentTable) {
+      currentTable = null
+      continue
+    }
+
+    // References/belongs_to
+    const refMatch = trimmed.match(SCHEMA_PATTERNS.references)
+    if (refMatch) {
+      currentTable.columns.push({
+        name: refMatch[1] + '_id',
+        type: 'references',
+        ref_name: refMatch[1],
+        constraints: refMatch[2] || null,
+      })
+      continue
+    }
+
+    // Timestamps
+    if (SCHEMA_PATTERNS.timestamps.test(trimmed)) {
+      currentTable.columns.push({
+        name: 'created_at',
+        type: 'datetime',
+        constraints: 'null: false',
+      })
+      currentTable.columns.push({
+        name: 'updated_at',
+        type: 'datetime',
+        constraints: 'null: false',
+      })
+      continue
+    }
+
+    // Index
+    const indexMatch = trimmed.match(SCHEMA_PATTERNS.index)
+    if (indexMatch) {
+      const columns = indexMatch[1]
+        ? indexMatch[1]
+            .match(/['"](\w+)['"]/g)
+            ?.map((c) => c.replace(/['"]/g, '')) || []
+        : [indexMatch[2]]
+      const opts = indexMatch[3] || ''
+      currentTable.indexes.push({
+        columns,
+        unique: /unique:\s*true/.test(opts),
+        name: opts.match(/name:\s*['"]([^'"]+)['"]/)?.[1] || null,
+      })
+      continue
+    }
+
+    // Regular column
+    const colMatch = trimmed.match(SCHEMA_PATTERNS.column)
+    if (colMatch) {
+      currentTable.columns.push({
+        name: colMatch[2],
+        type: colMatch[1],
+        constraints: colMatch[3] || null,
+      })
+    }
+  }
+
+  return result
+}

package/src/extractors/stimulus.js

@@ -0,0 +1,149 @@
+/**
+ * Stimulus Extractor (#6)
+ * Extracts Stimulus controller metadata from JavaScript files.
+ */
+
+import { STIMULUS_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Derive the Stimulus identifier from the file path.
+ * app/javascript/controllers/dropdown_controller.js → "dropdown"
+ * app/javascript/controllers/users/filter_controller.js → "users--filter"
+ * @param {string} filePath
+ * @returns {string}
+ */
+function deriveIdentifier(filePath) {
+  const controllersIdx = filePath.indexOf('controllers/')
+  if (controllersIdx === -1) return filePath
+  const rest = filePath.slice(controllersIdx + 'controllers/'.length)
+  return rest
+    .replace(/_controller\.\w+$/, '')
+    .replace(/\//g, '--')
+    .replace(/_/g, '-')
+}
+
+const LIFECYCLE_METHODS = new Set(['connect', 'disconnect', 'initialize'])
+
+/**
+ * Extract Stimulus controller information from a single JS file.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {string} filePath
+ * @returns {object|null}
+ */
+export function extractStimulusController(provider, filePath) {
+  const content = provider.readFile(filePath)
+  if (!content) return null
+
+  const classMatch = content.match(STIMULUS_PATTERNS.classDeclaration)
+  if (!classMatch) return null
+
+  const result = {
+    identifier: deriveIdentifier(filePath),
+    file: filePath,
+    targets: [],
+    values: {},
+    classes: [],
+    outlets: [],
+    actions: [],
+    imports: [],
+  }
+
+  // Targets
+  const targetsMatch = content.match(STIMULUS_PATTERNS.targets)
+  if (targetsMatch) {
+    result.targets =
+      targetsMatch[1]
+        .match(/['"](\w+)['"]/g)
+        ?.map((t) => t.replace(/['"]/g, '')) || []
+  }
+
+  // Values - extract the full block handling nested braces
+  const valuesStart = content.match(/static\s+values\s*=\s*\{/)
+  if (valuesStart) {
+    const startIdx = valuesStart.index + valuesStart[0].length
+    let depth = 1
+    let endIdx = startIdx
+    for (let ci = startIdx; ci < content.length && depth > 0; ci++) {
+      if (content[ci] === '{') depth++
+      else if (content[ci] === '}') depth--
+      if (depth === 0) endIdx = ci
+    }
+    const valStr = content.slice(startIdx, endIdx)
+    // Complex form: key: { type: Type, default: val }
+    const complexRe =
+      /(\w+):\s*\{\s*type:\s*(\w+)(?:,\s*default:\s*([^,}]+))?\s*\}/g
+    let vm
+    const processed = new Set()
+    while ((vm = complexRe.exec(valStr))) {
+      processed.add(vm[1])
+      result.values[vm[1]] = {
+        type: vm[2],
+        default: vm[3]?.trim() || null,
+      }
+    }
+    // Simple form: key: Type
+    const simpleRe = /(\w+):\s*(\w+)/g
+    while ((vm = simpleRe.exec(valStr))) {
+      if (!processed.has(vm[1]) && vm[1] !== 'type' && vm[1] !== 'default') {
+        result.values[vm[1]] = { type: vm[2], default: null }
+      }
+    }
+  }
+
+  // Classes
+  const classesMatch = content.match(STIMULUS_PATTERNS.classes)
+  if (classesMatch) {
+    result.classes =
+      classesMatch[1]
+        .match(/['"](\w[\w-]*)['"]/g)
+        ?.map((c) => c.replace(/['"]/g, '')) || []
+  }
+
+  // Outlets
+  const outletsMatch = content.match(STIMULUS_PATTERNS.outlets)
+  if (outletsMatch) {
+    result.outlets =
+      outletsMatch[1]
+        .match(/['"](\w[\w-]*)['"]/g)
+        ?.map((o) => o.replace(/['"]/g, '')) || []
+  }
+
+  // Actions (methods)
+  const actionRe = new RegExp(STIMULUS_PATTERNS.actionMethod.source, 'gm')
+  let am
+  while ((am = actionRe.exec(content))) {
+    const name = am[1]
+    if (
+      !LIFECYCLE_METHODS.has(name) &&
+      !name.endsWith('TargetConnected') &&
+      !name.endsWith('TargetDisconnected') &&
+      !name.endsWith('ValueChanged')
+    ) {
+      result.actions.push(name)
+    }
+  }
+
+  // Imports
+  const importRe = new RegExp(STIMULUS_PATTERNS.imports.source, 'g')
+  let im
+  while ((im = importRe.exec(content))) {
+    result.imports.push(im[3])
+  }
+
+  return result
+}
+
+/**
+ * Extract all Stimulus controllers from scanned entries.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {Array<{path: string}>} entries
+ * @returns {Array<object>}
+ */
+export function extractStimulusControllers(provider, entries) {
+  const controllers = []
+  for (const entry of entries) {
+    const ctrl = extractStimulusController(provider, entry.path)
+    if (ctrl) controllers.push(ctrl)
+  }
+  return controllers
+}

package/src/extractors/storage.js

@@ -0,0 +1,100 @@
+/**
+ * Storage Extractor (#12)
+ * Extracts Active Storage configuration, attachments, and variants.
+ */
+
+import { STORAGE_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Extract storage information.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {Array<{path: string, category: string}>} entries
+ * @param {{gems?: object}} gemInfo
+ * @returns {object}
+ */
+export function extractStorage(provider, entries, gemInfo = {}) {
+  const gems = gemInfo.gems || {}
+  const result = {
+    services: {},
+    attachments: [],
+    direct_uploads: false,
+    image_processing: null,
+    variants_detected: 0,
+  }
+
+  // Storage services from config/storage.yml
+  const storageYml = provider.readFile('config/storage.yml')
+  if (storageYml) {
+    const serviceRe = new RegExp(STORAGE_PATTERNS.storageService.source, 'g')
+    let m
+    while ((m = serviceRe.exec(storageYml))) {
+      result.services[m[1]] = { service: m[2] }
+    }
+
+    // Mirror service
+    if (STORAGE_PATTERNS.mirrorService.test(storageYml)) {
+      result.services.mirror = { service: 'Mirror' }
+    }
+
+    // Direct uploads
+    if (STORAGE_PATTERNS.directUpload.test(storageYml)) {
+      result.direct_uploads = true
+    }
+  }
+
+  // Attachments from model files
+  const modelEntries = entries.filter((e) => e.category === 'model')
+  for (const entry of modelEntries) {
+    const content = provider.readFile(entry.path)
+    if (!content) continue
+
+    const className = entry.path
+      .split('/')
+      .pop()
+      .replace('.rb', '')
+      .split('_')
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join('')
+
+    const oneRe = new RegExp(STORAGE_PATTERNS.hasOneAttached.source, 'gm')
+    let m
+    while ((m = oneRe.exec(content))) {
+      result.attachments.push({
+        model: className,
+        name: m[1],
+        type: 'has_one_attached',
+      })
+    }
+
+    const manyRe = new RegExp(STORAGE_PATTERNS.hasManyAttached.source, 'gm')
+    while ((m = manyRe.exec(content))) {
+      result.attachments.push({
+        model: className,
+        name: m[1],
+        type: 'has_many_attached',
+      })
+    }
+
+    // Variants
+    const varRe = new RegExp(STORAGE_PATTERNS.variant.source, 'g')
+    while (varRe.exec(content)) {
+      result.variants_detected++
+    }
+  }
+
+  // Image processing
+  if (gems.image_processing) {
+    result.image_processing = {
+      gem: 'image_processing',
+      backend: 'mini_magick',
+    }
+    // Check for vips backend
+    const envContent = provider.readFile('config/application.rb') || ''
+    const vipsMatch = envContent.match(STORAGE_PATTERNS.variantProcessor)
+    if (vipsMatch) {
+      result.image_processing.backend = vipsMatch[1]
+    }
+  }
+
+  return result
+}