@reinteractive/rails-insight 1.0.1

package/src/extractors/caching.js

@@ -0,0 +1,84 @@
+/**
+ * Caching Extractor (#13)
+ * Extracts cache store config, fragment caching, HTTP caching usage.
+ */
+
+import { CACHING_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Extract caching information.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {Array<{path: string, category: string}>} entries
+ * @returns {object}
+ */
+export function extractCaching(provider, entries) {
+  const result = {
+    store: {},
+    fragment_caching: { usage_count: 0, russian_doll_detected: false },
+    low_level_caching: { rails_cache_fetch_count: 0 },
+    http_caching: { stale_usage: 0, fresh_when_usage: 0, expires_in_usage: 0 },
+  }
+
+  // Cache store per environment
+  for (const env of ['production', 'development', 'test']) {
+    const content = provider.readFile(`config/environments/${env}.rb`)
+    if (content) {
+      const storeMatch = content.match(CACHING_PATTERNS.cacheStore)
+      if (storeMatch) {
+        result.store[env] = storeMatch[1]
+      }
+    }
+  }
+
+  // Scan views for fragment caching
+  const viewEntries = entries.filter(
+    (e) =>
+      e.path.startsWith('app/views/') || e.path.startsWith('app/components/'),
+  )
+  for (const entry of viewEntries) {
+    const content = provider.readFile(entry.path)
+    if (!content) continue
+
+    const fragRe = new RegExp(CACHING_PATTERNS.fragmentCache.source, 'g')
+    let m
+    while ((m = fragRe.exec(content))) {
+      result.fragment_caching.usage_count++
+    }
+
+    // Russian doll detection
+    const rdRe = new RegExp(CACHING_PATTERNS.russianDoll.source, 'g')
+    if (rdRe.test(content)) {
+      result.fragment_caching.russian_doll_detected = true
+    }
+  }
+
+  // Scan Ruby files for Rails.cache usage
+  const rbEntries = entries.filter((e) => e.path.endsWith('.rb'))
+  for (const entry of rbEntries) {
+    const content = provider.readFile(entry.path)
+    if (!content) continue
+
+    const fetchRe = new RegExp(CACHING_PATTERNS.railsCacheFetch.source, 'g')
+    while (fetchRe.exec(content)) {
+      result.low_level_caching.rails_cache_fetch_count++
+    }
+
+    // HTTP caching
+    const staleRe = new RegExp(CACHING_PATTERNS.stale.source, 'g')
+    while (staleRe.exec(content)) {
+      result.http_caching.stale_usage++
+    }
+
+    const freshRe = new RegExp(CACHING_PATTERNS.freshWhen.source, 'g')
+    while (freshRe.exec(content)) {
+      result.http_caching.fresh_when_usage++
+    }
+
+    const expiresRe = new RegExp(CACHING_PATTERNS.expiresIn.source, 'g')
+    while (expiresRe.exec(content)) {
+      result.http_caching.expires_in_usage++
+    }
+  }
+
+  return result
+}

package/src/extractors/component.js

@@ -0,0 +1,221 @@
+/**
+ * Component Extractor (#5)
+ * Extracts ViewComponent metadata from Ruby class files and sidecar templates.
+ */
+
+import { COMPONENT_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Determine component tier from class name / path.
+ * @param {string} className
+ * @returns {string}
+ */
+function detectTier(className) {
+  const lower = className.toLowerCase()
+  if (/^ui::/.test(lower) || /ui_component/.test(lower)) return 'ui'
+  if (/^layout/.test(lower) || /layout_component/.test(lower)) return 'layout'
+  if (/^page/.test(lower) || /page_component/.test(lower)) return 'page'
+  return 'feature'
+}
+
+/**
+ * Parse initialize params from the param string.
+ * @param {string} paramStr
+ * @returns {Array<{name: string, type: string, default: string|null, required: boolean}>}
+ */
+function parseInitializeParams(paramStr) {
+  const params = []
+  // Split by comma, handling nested defaults like [] and {}
+  const parts = paramStr.split(/,(?![^{[]*[}\]])/)
+  for (const part of parts) {
+    const trimmed = part.trim()
+    if (!trimmed) continue
+
+    // Keyword arg: name: default or name:
+    const kwMatch = trimmed.match(/^(\w+):\s*(.+)?$/)
+    if (kwMatch) {
+      const name = kwMatch[1]
+      const defaultVal = kwMatch[2]?.trim() || null
+      params.push({
+        name,
+        type: 'keyword',
+        default: defaultVal,
+        required: defaultVal === null,
+      })
+      continue
+    }
+
+    // Positional arg
+    const posMatch = trimmed.match(/^(\w+)$/)
+    if (posMatch) {
+      params.push({
+        name: posMatch[1],
+        type: 'positional',
+        default: null,
+        required: true,
+      })
+      continue
+    }
+
+    // Positional with default: name = value
+    const posDefMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/)
+    if (posDefMatch) {
+      params.push({
+        name: posDefMatch[1],
+        type: 'positional',
+        default: posDefMatch[2].trim(),
+        required: false,
+      })
+    }
+  }
+  return params
+}
+
+/**
+ * Extract component information from a single file.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {string} filePath
+ * @returns {object|null}
+ */
+export function extractComponent(provider, filePath) {
+  const content = provider.readFile(filePath)
+  if (!content) return null
+
+  const classMatch = content.match(COMPONENT_PATTERNS.classDeclaration)
+  if (!classMatch) return null
+
+  const className = classMatch[1]
+  const superclass = classMatch[2]
+
+  const result = {
+    class: className,
+    file: filePath,
+    superclass,
+    tier: detectTier(className),
+    initialize_params: [],
+    slots: { renders_one: [], renders_many: [] },
+    collection_parameter: null,
+    stimulus_controllers: [],
+    turbo_frames: [],
+    child_components: [],
+    uses_partials: false,
+    sidecar_template: null,
+    preview: null,
+  }
+
+  // Initialize params
+  const initMatch = content.match(COMPONENT_PATTERNS.initialize)
+  if (initMatch) {
+    result.initialize_params = parseInitializeParams(initMatch[1])
+  }
+
+  // Slots - renders_one
+  const rendersOneRe = new RegExp(COMPONENT_PATTERNS.rendersOne.source, 'gm')
+  let m
+  while ((m = rendersOneRe.exec(content))) {
+    result.slots.renders_one.push(m[1])
+  }
+
+  // Slots - renders_many
+  const rendersManyRe = new RegExp(COMPONENT_PATTERNS.rendersMany.source, 'gm')
+  while ((m = rendersManyRe.exec(content))) {
+    result.slots.renders_many.push(m[1])
+  }
+
+  // Collection parameter
+  const collMatch = content.match(COMPONENT_PATTERNS.collectionParam)
+  if (collMatch) {
+    result.collection_parameter = collMatch[1]
+  }
+
+  // Sidecar template detection
+  const baseName = filePath.replace(/\.rb$/, '')
+  const templateCandidates = [
+    baseName + '.html.erb',
+    baseName + '.html.haml',
+    baseName + '.html.slim',
+  ]
+  for (const candidate of templateCandidates) {
+    const templateContent = provider.readFile(candidate)
+    if (templateContent) {
+      result.sidecar_template = candidate
+      analyzeTemplate(templateContent, result)
+      break
+    }
+  }
+
+  // Also check sidecar directory style: component_name/component_name.html.erb
+  if (!result.sidecar_template) {
+    const parts = filePath.split('/')
+    const fileName = parts[parts.length - 1].replace(/\.rb$/, '')
+    const dirPath = filePath.replace(/\.rb$/, '')
+    const sidecarCandidates = [
+      dirPath + '/' + fileName + '.html.erb',
+      dirPath + '/' + fileName + '.html.haml',
+    ]
+    for (const candidate of sidecarCandidates) {
+      const templateContent = provider.readFile(candidate)
+      if (templateContent) {
+        result.sidecar_template = candidate
+        analyzeTemplate(templateContent, result)
+        break
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Analyze a sidecar template for Stimulus, Turbo, child components.
+ * @param {string} content
+ * @param {object} result
+ */
+function analyzeTemplate(content, result) {
+  // Stimulus controllers
+  const ctrlRe = new RegExp(COMPONENT_PATTERNS.stimulusController.source, 'g')
+  let m
+  while ((m = ctrlRe.exec(content))) {
+    const controllers = m[1].split(/\s+/)
+    for (const c of controllers) {
+      if (!result.stimulus_controllers.includes(c)) {
+        result.stimulus_controllers.push(c)
+      }
+    }
+  }
+
+  // Turbo frames
+  const frameRe = new RegExp(COMPONENT_PATTERNS.turboFrame.source, 'g')
+  while ((m = frameRe.exec(content))) {
+    result.turbo_frames.push(m[1])
+  }
+
+  // Child components
+  const compRe = new RegExp(COMPONENT_PATTERNS.componentRender.source, 'g')
+  while ((m = compRe.exec(content))) {
+    if (!result.child_components.includes(m[1])) {
+      result.child_components.push(m[1])
+    }
+  }
+
+  // Partial usage
+  const partialRe = new RegExp(COMPONENT_PATTERNS.partialRender.source, 'g')
+  if (partialRe.test(content)) {
+    result.uses_partials = true
+  }
+}
+
+/**
+ * Extract all components from scanned entries.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {Array<{path: string}>} entries - entries with category 'component'
+ * @returns {Array<object>}
+ */
+export function extractComponents(provider, entries) {
+  const components = []
+  for (const entry of entries) {
+    const comp = extractComponent(provider, entry.path)
+    if (comp) components.push(comp)
+  }
+  return components
+}

package/src/extractors/config.js

@@ -0,0 +1,81 @@
+/**
+ * Config Extractor (#17)
+ * Extracts Rails application configuration from config files.
+ */
+
+import { CONFIG_PATTERNS } from '../core/patterns.js'
+import { parseYaml } from '../utils/yaml-parser.js'
+
+/**
+ * Extract config information.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @returns {object}
+ */
+export function extractConfig(provider) {
+  const result = {
+    load_defaults: null,
+    api_only: false,
+    time_zone: null,
+    queue_adapter: null,
+    database: {},
+    environments: {},
+  }
+
+  // config/application.rb
+  const appContent = provider.readFile('config/application.rb')
+  if (appContent) {
+    const ldMatch = appContent.match(CONFIG_PATTERNS.loadDefaults)
+    if (ldMatch) result.load_defaults = ldMatch[1]
+
+    if (CONFIG_PATTERNS.apiOnly.test(appContent)) result.api_only = true
+
+    const tzMatch = appContent.match(CONFIG_PATTERNS.timeZone)
+    if (tzMatch) result.time_zone = tzMatch[1]
+
+    const qaMatch = appContent.match(CONFIG_PATTERNS.queueAdapter)
+    if (qaMatch) result.queue_adapter = qaMatch[1]
+  }
+
+  // config/database.yml
+  const dbContent = provider.readFile('config/database.yml')
+  if (dbContent) {
+    const parsed = parseYaml(dbContent)
+    // Extract production adapter
+    if (parsed.production) {
+      result.database.adapter = parsed.production.adapter || null
+      result.database.pool = parsed.production.pool || null
+    } else if (parsed.default) {
+      result.database.adapter = parsed.default.adapter || null
+      result.database.pool = parsed.default.pool || null
+    }
+
+    // Multi-DB detection: check for primary/secondary or multiple named DBs under production
+    const prodSection = parsed.production || {}
+    const prodKeys = Object.keys(prodSection)
+    const subDbs = prodKeys.filter(
+      (k) => typeof prodSection[k] === 'object' && prodSection[k] !== null,
+    )
+    if (subDbs.length > 1) {
+      result.database.multi_db = true
+      result.database.databases = subDbs
+    }
+  }
+
+  // config/environments/*.rb
+  for (const env of ['production', 'development', 'test']) {
+    const content = provider.readFile(`config/environments/${env}.rb`)
+    if (!content) continue
+
+    const envConfig = {}
+    const csMatch = content.match(CONFIG_PATTERNS.cacheStore)
+    if (csMatch) envConfig.cache_store = csMatch[1]
+
+    if (CONFIG_PATTERNS.forceSSL.test(content)) envConfig.force_ssl = true
+
+    if (Object.keys(envConfig).length > 0) {
+      result.environments[env] = envConfig
+    }
+  }
+
+  return result
+}

package/src/extractors/controller.js

@@ -0,0 +1,273 @@
+/**
+ * Controller Extractor (#2)
+ * Extracts all controller patterns from Ruby controller files.
+ */
+
+import { CONTROLLER_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Extract all controller information from a single controller file.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {string} filePath
+ * @returns {object|null}
+ */
+export function extractController(provider, filePath) {
+  const content = provider.readFile(filePath)
+  if (!content) return null
+
+  // Class declaration
+  const classMatch = content.match(CONTROLLER_PATTERNS.classDeclaration)
+  const className = classMatch ? classMatch[1] : null
+  const superclass = classMatch ? classMatch[2] : null
+
+  // Derive namespace from class name
+  let namespace = null
+  if (className && className.includes('::')) {
+    const parts = className.split('::')
+    parts.pop() // Remove controller name
+    namespace = parts.join('/').toLowerCase().replace(/::/g, '/')
+  }
+
+  // Concerns
+  const concerns = []
+  const includeRe = new RegExp(CONTROLLER_PATTERNS.include.source, 'gm')
+  let m
+  while ((m = includeRe.exec(content))) {
+    const mod = m[1]
+    if (mod !== 'ActionController::Live') {
+      concerns.push(mod)
+    }
+  }
+
+  // Filters — tag authorization guards
+  const filters = []
+  const filterRe = new RegExp(CONTROLLER_PATTERNS.filterType.source, 'gm')
+  while ((m = filterRe.exec(content))) {
+    const filterMethod = m[2]
+    const isAuthzGuard = /^require_\w+!$/.test(filterMethod)
+    filters.push({
+      type: m[1],
+      method: filterMethod,
+      ...(isAuthzGuard ? { authorization_guard: true } : {}),
+      options: m[3] || null,
+    })
+  }
+
+  // Actions (public methods before private/protected) with line ranges
+  const actions = []
+  const action_line_ranges = {}
+  const lines = content.split('\n')
+  let inPublic = true
+  let currentActionName = null
+  let currentActionStart = null
+  let methodDepth = 0
+  const visRe = /^\s*(private|protected)\s*$/
+  const methodRe = /^\s*def\s+(\w+)/
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const lineNumber = i + 1
+
+    if (visRe.test(line)) {
+      // Close current action if open
+      if (currentActionName && inPublic) {
+        action_line_ranges[currentActionName] = {
+          start: currentActionStart,
+          end: lineNumber - 1,
+        }
+      }
+      inPublic = false
+      currentActionName = null
+      methodDepth = 0
+      continue
+    }
+
+    const mm = line.match(methodRe)
+    if (mm) {
+      // Close previous action
+      if (currentActionName && inPublic) {
+        action_line_ranges[currentActionName] = {
+          start: currentActionStart,
+          end: lineNumber - 1,
+        }
+      }
+
+      if (inPublic) {
+        actions.push(mm[1])
+        currentActionName = mm[1]
+        currentActionStart = lineNumber
+        methodDepth = 1
+      } else {
+        currentActionName = null
+      }
+      continue
+    }
+
+    if (currentActionName && inPublic) {
+      if (
+        /\bdo\b|\bif\b(?!.*\bthen\b.*\bend\b)|\bcase\b|\bbegin\b/.test(line) &&
+        !/\bend\b/.test(line)
+      ) {
+        methodDepth++
+      }
+      if (/^\s*end\b/.test(line)) {
+        methodDepth--
+        if (methodDepth <= 0) {
+          action_line_ranges[currentActionName] = {
+            start: currentActionStart,
+            end: lineNumber,
+          }
+          currentActionName = null
+          methodDepth = 0
+        }
+      }
+    }
+  }
+
+  // Close final action
+  if (currentActionName && inPublic) {
+    action_line_ranges[currentActionName] = {
+      start: currentActionStart,
+      end: lines.length,
+    }
+  }
+
+  // Strong params
+  let strong_params = null
+  const spMatch = content.match(CONTROLLER_PATTERNS.paramsRequire)
+  if (spMatch) {
+    const methodMatch = content.match(CONTROLLER_PATTERNS.strongParamsMethod)
+    strong_params = {
+      method: methodMatch ? methodMatch[1] : null,
+      model: spMatch[1],
+      permitted: spMatch[2].split(',').map((p) => p.trim()),
+    }
+  }
+
+  // Rescue handlers
+  const rescue_handlers = []
+  const rescueRe = new RegExp(CONTROLLER_PATTERNS.rescueFrom.source, 'gm')
+  while ((m = rescueRe.exec(content))) {
+    rescue_handlers.push({
+      exception: m[1],
+      handler: m[2] || null,
+    })
+  }
+
+  // Layout
+  const layoutMatch = content.match(CONTROLLER_PATTERNS.layout)
+  const layout = layoutMatch ? layoutMatch[1] : null
+
+  // API controller detection
+  const api_controller =
+    CONTROLLER_PATTERNS.skipForgeryProtection.test(content) ||
+    /protect_from_forgery\s+with:\s*:null_session/.test(content) ||
+    (superclass && /Api|API/.test(superclass)) ||
+    (className && /Api::/.test(className))
+
+  // Streaming
+  const streaming = CONTROLLER_PATTERNS.actionControllerLive.test(content)
+
+  // Rails 8: rate_limit declarations
+  const rate_limits = []
+  const rateLimitRe =
+    /rate_limit\s+to:\s*(\d+),\s*within:\s*([^,\n]+?)(?:,\s*only:\s*(?:%i\[([^\]]+)\]|:(\w+)|\[([^\]]+)\]))?$/gm
+  let rl
+  while ((rl = rateLimitRe.exec(content))) {
+    rate_limits.push({
+      to: parseInt(rl[1], 10),
+      within: rl[2].trim(),
+      only: rl[3] || rl[4] || rl[5] || null,
+    })
+  }
+
+  // Rails 8: allow_unauthenticated_access
+  const unauthedMatch = content.match(
+    /allow_unauthenticated_access(?:\s+only:\s*(?:%i\[([^\]]+)\]|:(\w+)|\[([^\]]+)\]))?/,
+  )
+  const allow_unauthenticated_access = unauthedMatch
+    ? {
+        only: (unauthedMatch[1] || unauthedMatch[2] || unauthedMatch[3] || '')
+          .replace(/[:%\s]/g, ' ')
+          .trim()
+          .split(/\s+/)
+          .filter(Boolean),
+      }
+    : null
+
+  // Action key logic summaries — connected flow chain per action
+  const action_summaries = {}
+  for (const action of actions) {
+    const actionLines = content.split('\n')
+    let inAction = false
+    let depth = 0
+    const keyCalls = []
+    for (const line of actionLines) {
+      if (new RegExp(`^\\s*def\\s+${action}\\b`).test(line)) {
+        inAction = true
+        depth = 0
+        continue
+      }
+      if (!inAction) continue
+      if (/^\s*def\s+\w+/.test(line) && depth === 0) break
+      if (/\bdo\b|\bif\b|\bcase\b|\bbegin\b|\bblock\b/.test(line)) depth++
+      if (/^\s*end\b/.test(line)) {
+        if (depth === 0) break
+        depth--
+      }
+      const trimmed = line.trim()
+      // Capture all significant model calls, session helpers, and outcome calls
+      if (
+        /^(redirect_to|render\s|head\s|respond_to|@\w+\s*=\s*\w+[\.\w]+|User\.[a-z]|Session\.[a-z]|\w+\.(authenticate|find|create)|start_new_session|terminate_session|format\.)/.test(
+          trimmed,
+        )
+      ) {
+        // Collapse complex expressions to a short label
+        const label = trimmed
+          .replace(/\s+/g, ' ')
+          .replace(
+            /(redirect_to\s+)(root_path|after_authentication_url|new_session_path)\b.*/,
+            '$1$2',
+          )
+          .slice(0, 80)
+        keyCalls.push(label)
+        if (keyCalls.length >= 4) break
+      }
+    }
+    if (keyCalls.length > 0) action_summaries[action] = keyCalls.join(' → ')
+  }
+
+  return {
+    class: className,
+    file: filePath,
+    superclass,
+    namespace,
+    concerns,
+    filters,
+    actions,
+    action_line_ranges,
+    action_summaries:
+      Object.keys(action_summaries).length > 0 ? action_summaries : null,
+    strong_params,
+    rescue_handlers,
+    layout,
+    api_controller: !!api_controller,
+    streaming,
+    rate_limits: rate_limits.length > 0 ? rate_limits : null,
+    allow_unauthenticated_access,
+  }
+}
+
+/**
+ * Extract all controllers from a manifest.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {Array<{path: string}>} controllerEntries
+ * @returns {Array<object>}
+ */
+export function extractControllers(provider, controllerEntries) {
+  const results = []
+  for (const entry of controllerEntries) {
+    const ctrl = extractController(provider, entry.path)
+    if (ctrl) results.push(ctrl)
+  }
+  return results
+}