@reinteractive/rails-insight 1.0.1

package/src/extractors/gemfile.js

@@ -0,0 +1,440 @@
+/**
+ * Gemfile Extractor (#16)
+ * Parses Gemfile and Gemfile.lock, categorises gems.
+ */
+
+import { GEMFILE_PATTERNS } from '../core/patterns.js'
+
+/** @type {Record<string, string[]>} */
+const GEM_CATEGORIES = {
+  core: [
+    'rails',
+    'railties',
+    'activesupport',
+    'activerecord',
+    'actionpack',
+    'actionview',
+    'actionmailer',
+    'activejob',
+    'actioncable',
+    'activestorage',
+    'actiontext',
+    'actionmailbox',
+    'puma',
+    'unicorn',
+    'bootsnap',
+    'tzinfo-data',
+    'sprockets',
+    'sprockets-rails',
+  ],
+  frontend: [
+    'importmap-rails',
+    'jsbundling-rails',
+    'cssbundling-rails',
+    'tailwindcss-rails',
+    'sass-rails',
+    'webpacker',
+    'shakapacker',
+    'turbo-rails',
+    'stimulus-rails',
+    'hotwire-rails',
+    'propshaft',
+    'dartsass-rails',
+    'vite_rails',
+    'esbuild',
+    'rollup',
+  ],
+  auth: [
+    'devise',
+    'devise-jwt',
+    'devise_invitable',
+    'omniauth',
+    'omniauth-rails_csrf_protection',
+    'sorcery',
+    'clearance',
+    'rodauth-rails',
+    'doorkeeper',
+    'jwt',
+    'bcrypt',
+    'has_secure_password',
+    'warden',
+    'rack-attack',
+  ],
+  authorization: [
+    'pundit',
+    'cancancan',
+    'action_policy',
+    'rolify',
+    'authority',
+  ],
+  background: [
+    'sidekiq',
+    'sidekiq-pro',
+    'sidekiq-enterprise',
+    'resque',
+    'delayed_job',
+    'good_job',
+    'solid_queue',
+    'que',
+    'sneakers',
+    'shoryuken',
+    'mission_control-jobs',
+  ],
+  caching: [
+    'redis',
+    'redis-rails',
+    'redis-actionpack',
+    'hiredis',
+    'solid_cache',
+    'dalli',
+    'identity_cache',
+    'readthis',
+  ],
+  search: [
+    'searchkick',
+    'pg_search',
+    'meilisearch-rails',
+    'elasticsearch-rails',
+    'chewy',
+    'ransack',
+    'thinking-sphinx',
+  ],
+  payments: [
+    'pay',
+    'stripe',
+    'stripe-rails',
+    'braintree',
+    'shopify_api',
+    'solidus',
+    'spree',
+  ],
+  uploads: [
+    'image_processing',
+    'mini_magick',
+    'shrine',
+    'carrierwave',
+    'paperclip',
+    'aws-sdk-s3',
+    'google-cloud-storage',
+    'azure-storage-blob',
+  ],
+  monitoring: [
+    'sentry-ruby',
+    'sentry-rails',
+    'newrelic_rpm',
+    'honeybadger',
+    'bugsnag',
+    'rollbar',
+    'airbrake',
+    'scout_apm',
+    'skylight',
+    'datadog',
+    'lograge',
+    'ahoy_matey',
+  ],
+  deployment: [
+    'kamal',
+    'capistrano',
+    'capistrano-rails',
+    'capistrano-bundler',
+    'capistrano-rbenv',
+    'thruster',
+    'mina',
+    'sshkit',
+  ],
+  code_quality: [
+    'rubocop',
+    'rubocop-rails',
+    'rubocop-rspec',
+    'rubocop-performance',
+    'rubocop-minitest',
+    'rubocop-rails-omakase',
+    'standard',
+    'erb_lint',
+    'brakeman',
+    'bundler-audit',
+    'overcommit',
+    'annotate',
+    'reek',
+    'flog',
+    'flay',
+  ],
+  testing: [
+    'rspec-rails',
+    'factory_bot_rails',
+    'faker',
+    'capybara',
+    'selenium-webdriver',
+    'cuprite',
+    'capybara-playwright-driver',
+    'shoulda-matchers',
+    'simplecov',
+    'webmock',
+    'vcr',
+    'timecop',
+    'database_cleaner',
+    'parallel_tests',
+    'minitest',
+    'mocha',
+    'rspec-mocks',
+  ],
+  data: [
+    'pg',
+    'mysql2',
+    'sqlite3',
+    'trilogy',
+    'activerecord-import',
+    'scenic',
+    'strong_migrations',
+    'active_record_doctor',
+    'paranoia',
+    'discard',
+    'acts_as_paranoid',
+    'paper_trail',
+    'audited',
+    'aasm',
+    'statesman',
+    'state_machines-activerecord',
+    'friendly_id',
+    'acts_as_list',
+    'acts_as_tree',
+    'ancestry',
+    'closure_tree',
+  ],
+  admin: [
+    'activeadmin',
+    'administrate',
+    'avo',
+    'rails_admin',
+    'trestle',
+    'motor-admin',
+  ],
+  api: [
+    'grape',
+    'graphql',
+    'graphql-ruby',
+    'graphiql-rails',
+    'jbuilder',
+    'jsonapi-serializer',
+    'active_model_serializers',
+    'blueprinter',
+    'alba',
+    'fast_jsonapi',
+    'rack-cors',
+    'versionist',
+    'apipie-rails',
+    'rswag',
+  ],
+  realtime: ['actioncable', 'anycable-rails', 'hotwire-rails'],
+  mail: [
+    'letter_opener',
+    'letter_opener_web',
+    'premailer-rails',
+    'mailgun-ruby',
+    'postmark-rails',
+    'sendgrid-ruby',
+    'aws-sdk-ses',
+  ],
+  pdf: [
+    'wicked_pdf',
+    'grover',
+    'prawn',
+    'prawn-table',
+    'hexapdf',
+    'wkhtmltopdf-binary',
+  ],
+  spreadsheet: [
+    'caxlsx',
+    'axlsx_rails',
+    'roo',
+    'spreadsheet',
+    'rubyXL',
+    'creek',
+    'csv',
+  ],
+  image: ['ruby-vips', 'fastimage'],
+  i18n: ['i18n-tasks', 'rails-i18n', 'mobility', 'globalize', 'i18n-js'],
+  multi_tenancy: ['acts_as_tenant', 'apartment', 'ros-apartment', 'milia'],
+  dev_tools: [
+    'pry',
+    'pry-rails',
+    'pry-byebug',
+    'byebug',
+    'debug',
+    'better_errors',
+    'binding_of_caller',
+    'web-console',
+    'rack-mini-profiler',
+    'bullet',
+    'prosopite',
+    'pghero',
+    'spring',
+    'listen',
+    'foreman',
+  ],
+}
+
+/** Build reverse lookup: gem name → category */
+const GEM_TO_CATEGORY = {}
+for (const [category, gems] of Object.entries(GEM_CATEGORIES)) {
+  for (const gem of gems) {
+    GEM_TO_CATEGORY[gem] = category
+  }
+}
+
+/**
+ * Categorize a gem name.
+ * @param {string} name
+ * @returns {string}
+ */
+function categorizeGem(name) {
+  return GEM_TO_CATEGORY[name] || 'other'
+}
+
+/**
+ * Parse resolved versions from Gemfile.lock content.
+ * @param {string|null} lockContent
+ * @returns {Map<string, string>}
+ */
+function parseLockVersions(lockContent) {
+  const versions = new Map()
+  if (!lockContent) return versions
+
+  let inSpecs = false
+  for (const line of lockContent.split('\n')) {
+    const trimmed = line.trimEnd()
+    if (trimmed === '  specs:' || trimmed === '    specs:') {
+      inSpecs = true
+      continue
+    }
+    if (inSpecs && /^\S/.test(trimmed)) {
+      inSpecs = false
+      continue
+    }
+    if (inSpecs) {
+      // Lines like "    rails (7.1.3)" or "      activesupport (= 7.1.3)"
+      const match = trimmed.match(/^\s{4}(\S+)\s+\(([^)]+)\)/)
+      if (match) {
+        versions.set(match[1], match[2])
+      }
+    }
+  }
+  return versions
+}
+
+/**
+ * Parse Gemfile content into structured gem entries.
+ * @param {string|null} gemfileContent
+ * @param {Map<string, string>} lockVersions
+ * @returns {{ gems: Array<{name: string, version: string|null, resolved: string|null, category: string, group: string}>, source: string|null, rubyVersion: string|null, groups: string[] }}
+ */
+function parseGemfile(gemfileContent, lockVersions) {
+  const result = {
+    gems: [],
+    source: null,
+    rubyVersion: null,
+    groups: [],
+  }
+
+  if (!gemfileContent) return result
+
+  // Extract source
+  const sourceMatch = gemfileContent.match(GEMFILE_PATTERNS.source)
+  if (sourceMatch) {
+    result.source = sourceMatch[1]
+  }
+
+  // Extract ruby version
+  const rubyMatch = gemfileContent.match(GEMFILE_PATTERNS.ruby)
+  if (rubyMatch) {
+    result.rubyVersion = rubyMatch[1]
+  }
+
+  // Parse line by line, tracking group context
+  const lines = gemfileContent.split('\n')
+  const groupStack = []
+  const seenGroups = new Set()
+
+  for (const line of lines) {
+    // Detect group blocks
+    const groupMatch = line.match(GEMFILE_PATTERNS.group)
+    if (groupMatch) {
+      // Parse group symbols: :development, :test or :development, :test
+      const groupSymbols = groupMatch[1].match(/:(\w+)/g)
+      if (groupSymbols) {
+        const groups = groupSymbols.map((g) => g.slice(1))
+        groupStack.push(groups)
+        for (const g of groups) seenGroups.add(g)
+      }
+      continue
+    }
+
+    // Detect end of group block
+    if (/^\s*end\b/.test(line) && groupStack.length > 0) {
+      groupStack.pop()
+      continue
+    }
+
+    // Parse gem declarations
+    const gemMatch = line.match(GEMFILE_PATTERNS.gem)
+    if (gemMatch) {
+      const name = gemMatch[1]
+      const version = gemMatch[2] || null
+
+      // Determine group from context or inline group option
+      let group = 'default'
+      if (groupStack.length > 0) {
+        group = groupStack[groupStack.length - 1].join(', ')
+      } else if (gemMatch[3]) {
+        // Check for inline group: option
+        const inlineGroup = gemMatch[3].match(
+          /group:\s*(?::(\w+)|\[([^\]]+)\])/,
+        )
+        if (inlineGroup) {
+          group =
+            inlineGroup[1] ||
+            inlineGroup[2]
+              .replace(/:/g, '')
+              .replace(/\s/g, '')
+              .split(',')
+              .join(', ')
+        }
+      }
+
+      result.gems.push({
+        name,
+        version,
+        resolved: lockVersions.get(name) || null,
+        category: categorizeGem(name),
+        group,
+      })
+    }
+  }
+
+  result.groups = [...seenGroups]
+  return result
+}
+
+/**
+ * Extract Gemfile data from the project.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @returns {{ gems: Array<{name: string, version: string|null, resolved: string|null, category: string, group: string}>, source: string|null, rubyVersion: string|null, groups: string[], byCategory: Record<string, Array<{name: string, version: string|null, resolved: string|null, category: string, group: string}>> }}
+ */
+export function extractGemfile(provider) {
+  const gemfileContent = provider.readFile('Gemfile')
+  const lockContent = provider.readFile('Gemfile.lock')
+
+  const lockVersions = parseLockVersions(lockContent)
+  const result = parseGemfile(gemfileContent, lockVersions)
+
+  // Build byCategory index
+  const byCategory = {}
+  for (const gem of result.gems) {
+    if (!byCategory[gem.category]) {
+      byCategory[gem.category] = []
+    }
+    byCategory[gem.category].push(gem)
+  }
+
+  return { ...result, byCategory }
+}

package/src/extractors/helper.js

@@ -0,0 +1,55 @@
+/**
+ * Helper Extractor (#7 — Views sub-type)
+ * Extracts helper module names, public methods, and controller associations.
+ */
+
+import { HELPER_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Extract helper information from a single helper file.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {string} filePath
+ * @returns {object|null}
+ */
+export function extractHelper(provider, filePath) {
+  const content = provider.readFile(filePath)
+  if (!content) return null
+
+  const moduleMatch = content.match(HELPER_PATTERNS.moduleDeclaration)
+  if (!moduleMatch) return null
+
+  const moduleName = moduleMatch[1]
+
+  // Derive controller by convention: PostsHelper → PostsController
+  const controller = moduleName.endsWith('Helper')
+    ? moduleName.replace(/Helper$/, 'Controller')
+    : null
+
+  // Find where private section begins (if any)
+  const privateMatch = content.match(HELPER_PATTERNS.privateKeyword)
+  const privateIndex = privateMatch ? privateMatch.index : content.length
+
+  // Extract public methods (before private keyword)
+  const publicContent = content.slice(0, privateIndex)
+  const methods = []
+  const methodRe = new RegExp(HELPER_PATTERNS.methodDefinition.source, 'gm')
+  let m
+  while ((m = methodRe.exec(publicContent))) {
+    methods.push(m[1])
+  }
+
+  // Extract included helpers
+  const includes = []
+  const includeRe = new RegExp(HELPER_PATTERNS.includeHelper.source, 'g')
+  while ((m = includeRe.exec(content))) {
+    includes.push(m[1])
+  }
+
+  return {
+    module: moduleName,
+    file: filePath,
+    controller,
+    methods,
+    includes,
+  }
+}

package/src/extractors/jobs.js

@@ -0,0 +1,122 @@
+/**
+ * Jobs Extractor (#10)
+ * Extracts background job metadata from app/jobs/*.rb.
+ */
+
+import { JOB_PATTERNS } from '../core/patterns.js'
+
+/**
+ * Extract a single job's metadata.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {string} filePath
+ * @returns {object|null}
+ */
+export function extractJob(provider, filePath) {
+  const content = provider.readFile(filePath)
+  if (!content) return null
+
+  const classMatch = content.match(JOB_PATTERNS.classDeclaration)
+  if (!classMatch) return null
+
+  const superclass = classMatch[2]
+  if (
+    !superclass.includes('Job') &&
+    !superclass.includes('ApplicationJob') &&
+    superclass !== 'ActiveJob::Base'
+  ) {
+    return null
+  }
+
+  const result = {
+    class: classMatch[1],
+    file: filePath,
+    superclass,
+    queue: 'default',
+    retry_on: [],
+    discard_on: [],
+    sidekiq_options: null,
+  }
+
+  // Queue
+  const queueMatch = content.match(JOB_PATTERNS.queueAs)
+  if (queueMatch) {
+    result.queue = queueMatch[1]
+  }
+
+  // Retry on
+  const retryRe = new RegExp(JOB_PATTERNS.retryOn.source, 'gm')
+  let m
+  while ((m = retryRe.exec(content))) {
+    result.retry_on.push({
+      exception: m[1],
+      options: m[2]?.trim() || null,
+    })
+  }
+
+  // Discard on
+  const discardRe = new RegExp(JOB_PATTERNS.discardOn.source, 'gm')
+  while ((m = discardRe.exec(content))) {
+    result.discard_on.push(m[1])
+  }
+
+  // Sidekiq options
+  const sidekiqMatch = content.match(JOB_PATTERNS.sidekiqOptions)
+  if (sidekiqMatch) {
+    result.sidekiq_options = sidekiqMatch[1].trim()
+  }
+
+  return result
+}
+
+/**
+ * Extract all jobs and detect adapter/recurring config.
+ * @param {import('../providers/interface.js').FileProvider} provider
+ * @param {Array<{path: string}>} entries
+ * @param {{gems?: object}} gemInfo
+ * @returns {object}
+ */
+export function extractJobs(provider, entries, gemInfo = {}) {
+  const gems = gemInfo.gems || {}
+  const result = {
+    adapter: null,
+    jobs: [],
+    queues_detected: new Set(),
+    recurring_jobs: null,
+  }
+
+  // Detect adapter
+  if (gems.solid_queue) result.adapter = 'solid_queue'
+  else if (gems.sidekiq) result.adapter = 'sidekiq'
+  else if (gems.delayed_job) result.adapter = 'delayed_job'
+  else if (gems.resque) result.adapter = 'resque'
+  else if (gems.good_job) result.adapter = 'good_job'
+
+  for (const entry of entries) {
+    const job = extractJob(provider, entry.path)
+    if (job) {
+      result.jobs.push(job)
+      result.queues_detected.add(job.queue)
+    }
+  }
+
+  // Recurring jobs from config/recurring.yml (Solid Queue)
+  const recurringContent = provider.readFile('config/recurring.yml')
+  if (recurringContent) {
+    const jobNames = []
+    const classRe = /class:\s*(\w+)/g
+    let m
+    while ((m = classRe.exec(recurringContent))) {
+      jobNames.push(m[1])
+    }
+    if (jobNames.length > 0) {
+      result.recurring_jobs = {
+        source: 'config/recurring.yml',
+        jobs: jobNames,
+      }
+    }
+  }
+
+  result.queues_detected = [...result.queues_detected]
+
+  return result
+}