schema_reaper 1.0.12 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7e70e2066753282ad6757f3d73175a57b73b7026aa8879314f693dafc8547e7
-  data.tar.gz: d4b2ac7a4e6934e068d79ac32f694a5bffcd329bed689c23d0a080266b8bdb6b
+  metadata.gz: 6f169920afef1838471a418e29ad207b6c9d3193ef57caf6678cf68d675a3405
+  data.tar.gz: 3e5d507411e727278004def7a752db662620a01371625ce761af4495fd020f2e
 SHA512:
-  metadata.gz: '04943ff8915c5a809a9f81741f14e98712a6453dcf046441b7ae10d726031a994045e9490b5a8a62f948210c0e030825429bde387f35ffc15176a6b419e5f57a'
-  data.tar.gz: da080808761005f66096458968fc7c68d3c6f3251d2c97aa50a56020a37abb0d673129782244e880473ffb6287df191418f1142e1bc7632e4da05f49def17cc2
+  metadata.gz: 739b0cf29def40063c3a182ad5b9d207f7409f9277e134e76bd980bc3db276a333f225a1974bf5c30a3e14af769d0c8128efeb46961d084f1349fc17bddd6eca
+  data.tar.gz: 692ed7533e2553ebbc9085001f1d805519149fe988860e23da9902b941de60c292a8918e60f2fe9c2d0e558aaeacd182d31e6376570e7ea9e8551977d5856db8

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [1.0.13] - 2026-09-18
+
+### Fixed
+- **Expression key columns were silently dropped from an index's column
+  list.** `indexes_for` joined `pg_index.indkey` entries against
+  `pg_attribute` by `attnum`; an expression column's `indkey` entry is
+  `0`, which matches no real column, so the join dropped it instead of
+  erroring. An index on `((data ->> 'type')), ((data ->> 'id')), user_id,
+  created_at` came back as just `user_id,created_at`, which then made a
+  plain index on `:user_id` look like a genuine leading-edge duplicate of
+  a key it was not actually a prefix of -- `duplicate_index` recommended
+  dropping an index that ordinary `WHERE user_id = ?` lookups depended
+  on. Rewritten to use `pg_get_indexdef(indexrelid, column_no, pretty)`,
+  which is keyed by column position rather than table attnum and renders
+  a plain column and an expression the same way. Also switched the
+  internal column separator from `,` to a control byte, since an
+  expression can legitimately contain a comma (`COALESCE(a, b)`) that a
+  comma-delimited split would have cut in half. (#9, mitkush)
+- **A table a gem creates and owns outright could be reported as dead.**
+  `dead_table` never consulted `GemAwareness`, so a table only ever
+  referenced through a gem's own internal classes -- never named in app
+  code -- looked exactly like real dead weight. Confirmed on a real app:
+  all of that app's `dead_table` findings were gem-owned tables
+  (`active_admin_comments`, `devise_api_tokens`, `friendly_id_slugs`),
+  and `drop_table :devise_api_tokens` would have deleted its mobile
+  session storage. `GemAwareness.owned_tables` now feeds `dead_table` the
+  same way it already fed the `dead_column` exemption. Also added
+  `activeadmin` and `devise-api` to the gem map, verified against each
+  gem's own migration template. (#10, mitkush)
+
 ## [1.0.12] - 2026-09-15
 
 ### Fixed

data/lib/schema_reaper/analyzers/base.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
+require "set"
+
 module SchemaReaper
   module Analyzers
     # Context passed to every analyzer's #call.
-    #   schema       - DatabaseSchema
-    #   used_tokens  - Set<String> from the static scan
-    #   runtime      - Runtime::Report (may be empty)
-    #   gem_columns  - Hash{table_name => Set<column_name>} reserved by gems
-    #   config       - Config
-    Context = Struct.new(:schema, :used_tokens, :runtime, :gem_columns, :config, keyword_init: true) do
+    #   schema           - DatabaseSchema
+    #   used_tokens      - Set<String> from the static scan
+    #   runtime          - Runtime::Report (may be empty)
+    #   gem_columns      - Hash{table_name => Set<column_name>} reserved by gems
+    #   gem_owned_tables - Set<table_name> created and owned outright by a gem
+    #   config           - Config
+    Context = Struct.new(:schema, :used_tokens, :runtime, :gem_columns, :gem_owned_tables, :config,
+                         keyword_init: true) do
       def runtime
         self[:runtime] || Runtime::Report.empty
       end
@@ -16,6 +20,10 @@ module SchemaReaper
       def gem_columns
         self[:gem_columns] || {}
       end
+
+      def gem_owned_tables
+        self[:gem_owned_tables] || Set.new
+      end
     end
 
     # Shared plumbing for analyzers: schema access and token lookup helpers.
@@ -57,6 +65,10 @@ module SchemaReaper
         ctx.gem_columns.fetch(table, []).include?(column)
       end
 
+      def gem_owned_table?(table)
+        ctx.gem_owned_tables.include?(table)
+      end
+
       # Builds a Finding, filling in reclaimable_bytes from the row count.
       # An unknown row count leaves reclaimable_bytes nil: "we cannot say" is
       # not the same claim as "zero bytes", and reporters need to tell them

data/lib/schema_reaper/analyzers/dead_table.rb

@@ -24,7 +24,8 @@ module SchemaReaper
 
       def ignored?(table)
         config.ignore_tables.include?(table.name) ||
-          table.name.start_with?("active_storage_", "action_text_", "action_mailbox_")
+          table.name.start_with?("active_storage_", "action_text_", "action_mailbox_") ||
+          gem_owned_table?(table.name)
       end
 
       def dead(table)

data/lib/schema_reaper/analyzers/duplicate_index.rb

@@ -3,7 +3,8 @@
 module SchemaReaper
   module Analyzers
     # An index whose column list is a leading prefix of another index on the
-    # same table is redundant (the wider index serves both).
+    # same table is redundant (the wider index serves both), and two indexes
+    # with identical column lists are redundant with each other.
     class DuplicateIndex < Base
       Registry.register(self)
 
@@ -14,28 +15,79 @@ module SchemaReaper
 
       private
 
+      # A partial index only exists for rows matching its WHERE clause and is
+      # usually there on purpose (a smaller, faster index for one condition),
+      # so it is excluded entirely rather than reasoned about: not a
+      # candidate for removal, and not a stand-in for a full index either.
+      # Comparing WHERE clauses for implication is out of scope here, and a
+      # wrong guess in either direction is a real index gone from production.
       def dupes_in(table)
-        non_pk = table.indexes.reject(&:primary)
-        non_pk.filter_map do |ix|
-          covering = non_pk.find { |o| o != ix && !o.unique && o.covers?(ix) && o.columns != ix.columns }
-          next unless covering
-
-          finding(
-            type: :duplicate_index,
-            table: table.name,
-            index: ix.name,
-            column: ix.columns.join(","),
-            severity: :low,
-            confidence: 0.8,
-            bytes_per_row: 0,
-            evidence: [
-              "#{ix.name} (#{ix.columns.join(", ")}) is a prefix of " \
-              "#{covering.name} (#{covering.columns.join(", ")})"
-            ],
-            suggested_fix: "remove_index :#{table.name}, name: :#{ix.name}"
-          )
+        non_pk = table.indexes.reject { |index| index.primary || index.partial? }
+        by_columns = non_pk.group_by(&:columns)
+        non_pk.filter_map { |index| finding_for(table, index, non_pk, by_columns) }
+      end
+
+      def finding_for(table, index, non_pk, by_columns)
+        covering = covering_for(index, non_pk, by_columns)
+        return unless covering
+
+        finding(
+          type: :duplicate_index,
+          table: table.name,
+          index: index.name,
+          column: index.columns.join(","),
+          severity: :low,
+          confidence: 0.8,
+          bytes_per_row: 0,
+          evidence: [evidence_for(index, covering)],
+          suggested_fix: "remove_index :#{table.name}, name: :#{index.name}"
+        )
+      end
+
+      # Two indexes with the same column list have no natural wider/narrower
+      # direction, so comparing them pairwise would have each flag the other --
+      # applying both suggested fixes would then drop the column pair
+      # entirely. Instead, one designated survivor per exact-column group is
+      # chosen once; every other member of the group is redundant against it,
+      # and the survivor itself is only checked against a genuinely wider
+      # prefix elsewhere on the table.
+      def covering_for(index, non_pk, by_columns)
+        peers = by_columns[index.columns]
+        return prefix_covering_for(index, non_pk) if peers.size == 1
+
+        survivor = survivor_of(peers)
+        return survivor unless survivor == index
+
+        prefix_covering_for(index, non_pk)
+      end
+
+      # Keep a unique index over a non-unique one -- it enforces a guarantee
+      # the others don't -- breaking further ties by name for a stable,
+      # order-independent choice.
+      def survivor_of(peers)
+        unique_peers = peers.select(&:unique)
+        (unique_peers.empty? ? peers : unique_peers).min_by(&:name)
+      end
+
+      def prefix_covering_for(index, non_pk)
+        non_pk.find do |o|
+          o != index && o.columns != index.columns && o.covers?(index) && safe_to_drop?(index, against: o)
         end
       end
+
+      # A wider index does not make a narrower prefix unique: unique (a, b)
+      # says nothing about whether a alone is unique. So a unique index is
+      # only safe to drop in favour of another index that is itself unique on
+      # that exact same column list -- never a merely-wider or non-unique one.
+      def safe_to_drop?(index, against:)
+        !index.unique || (against.unique && against.columns == index.columns)
+      end
+
+      def evidence_for(index, covering)
+        relation = covering.columns == index.columns ? "duplicates" : "is a prefix of"
+        "#{index.name} (#{index.columns.join(", ")}) #{relation} " \
+          "#{covering.name} (#{covering.columns.join(", ")})"
+      end
     end
   end
 end

data/lib/schema_reaper/gem_awareness.rb

@@ -33,9 +33,38 @@ module SchemaReaper
       "ahoy_matey" => {
         "ahoy_visits" => %w[visit_token visitor_token],
         "ahoy_events" => %w[visit_id name properties]
+      },
+      "activeadmin" => {
+        "active_admin_comments" => %w[namespace body resource_type resource_id author_type author_id]
+      },
+      "devise-api" => {
+        "devise_api_tokens" => %w[
+          resource_owner_type resource_owner_id access_token refresh_token
+          expires_in revoked_at previous_refresh_token
+        ]
       }
     }.freeze
 
+    # Table names an installed gem creates and owns outright -- as opposed to
+    # columns a gem adds onto a table the app itself defines. DeadTable
+    # consults this: the static scanner only reads app code, so a table a
+    # gem's own internal classes reference (ActiveAdmin::Comment,
+    # Devise::Api::Token, FriendlyId::Slug, ...) looks unreferenced and gets
+    # suggested for `drop_table`, which for something like devise_api_tokens
+    # -- mobile session storage -- is actively destructive.
+    #
+    # Only exact table_glob entries qualify: a "*" entry means "this gem adds
+    # these columns to whatever table has them", not "this gem owns this
+    # table", so it says nothing about whole-table ownership.
+    def self.owned_tables(installed:)
+      installed = installed.to_set
+      MAP.each_with_object(Set.new) do |(gem_name, table_map), owned|
+        next unless installed.include?(gem_name)
+
+        table_map.each_key { |glob| owned << glob unless glob == "*" }
+      end
+    end
+
     # @param installed [Enumerable<String>] gem names present in the bundle
     # @param tables [Enumerable<#name,#column_names>] or Enumerable<String>
     # @return [Hash{String => Set<String>}]

data/lib/schema_reaper/introspect/postgres.rb

@@ -16,6 +16,12 @@ module SchemaReaper
                "database_url: in .schema_reaper.yml; the DATABASE_URL env var; " \
                "config/database.yml for RAILS_ENV (default: development, Postgres only)."
 
+      # A record separator that cannot appear inside a plain identifier and is
+      # exceedingly unlikely inside an expression, so splitting the aggregated
+      # column list back apart in Ruby cannot be fooled by a comma the
+      # expression itself contains: COALESCE(a, b), ROUND(x, 2), etc.
+      COLUMN_SEPARATOR = 31.chr
+
       def initialize(url)
         require "pg" # load first so the PG::Error rescue below can resolve
         raise Error, NO_URL if url.nil? || url.empty?
@@ -94,26 +100,31 @@ module SchemaReaper
         end
       end
 
-      # Columns must come back in index-key order, not table order: prefix
-      # comparisons (Index#covers?) are only meaningful on the real key order.
-      # unnest(indkey) WITH ORDINALITY preserves that; ORDER BY attnum does not.
+      # Columns come back in index-key order via pg_get_indexdef(indexrelid,
+      # column_no, pretty), keyed by column position rather than table attnum
+      # so it renders a plain column and an expression uniformly and never
+      # silently drops one. indnkeyatts excludes INCLUDE columns, which are
+      # payload only. partial (indpred IS NOT NULL) lets analyzers refuse to
+      # treat a conditional index as if it covered every row.
       def indexes_for(table)
         exec(<<~SQL, [table]).map do |r|
           SELECT i.relname AS name, ix.indisunique AS "unique", ix.indisprimary AS "primary",
-                 s.idx_scan AS scans,
-                 array_to_string(array_agg(a.attname ORDER BY k.ord), ',') AS cols
+                 (ix.indpred IS NOT NULL) AS partial, s.idx_scan AS scans,
+                 array_to_string(
+                   array_agg(pg_get_indexdef(ix.indexrelid, k.ord::int, true) ORDER BY k.ord),
+                   '#{COLUMN_SEPARATOR}'
+                 ) AS cols
           FROM pg_class t
           JOIN pg_index ix ON t.oid = ix.indrelid
           JOIN pg_class i ON i.oid = ix.indexrelid
-          JOIN LATERAL unnest(ix.indkey::int2[]) WITH ORDINALITY AS k(attnum, ord) ON TRUE
-          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+          JOIN LATERAL generate_series(1, ix.indnkeyatts) AS k(ord) ON TRUE
           LEFT JOIN pg_stat_user_indexes s ON s.indexrelid = i.oid
           WHERE t.relname = $1
-          GROUP BY i.relname, ix.indisunique, ix.indisprimary, s.idx_scan
+          GROUP BY i.relname, ix.indisunique, ix.indisprimary, ix.indpred, s.idx_scan
         SQL
           Index.new(
-            name: r["name"], columns: r["cols"].split(","),
-            unique: r["unique"] == "t", primary: r["primary"] == "t",
+            name: r["name"], columns: r["cols"].split(COLUMN_SEPARATOR),
+            unique: r["unique"] == "t", primary: r["primary"] == "t", partial: r["partial"] == "t",
             scans: r["scans"]&.to_i
           )
         end

data/lib/schema_reaper/runner.rb

@@ -23,6 +23,7 @@ module SchemaReaper
         used_tokens: Static::Scanner.new(@config, root: @root).call,
         runtime: runtime_report,
         gem_columns: gem_columns(db),
+        gem_owned_tables: gem_owned_tables,
         config: @config
       )
 
@@ -89,6 +90,12 @@ module SchemaReaper
       )
     end
 
+    def gem_owned_tables
+      return Set.new unless @config.gem_awareness?
+
+      GemAwareness.owned_tables(installed: GemAwareness.installed_gems)
+    end
+
     def load_plugins
       @config.require_paths.each do |path|
         require(File.expand_path(path, @root))

data/lib/schema_reaper/schema.rb

@@ -19,10 +19,18 @@ module SchemaReaper
     end
   end
 
-  Index = Struct.new(:name, :columns, :unique, :primary, :scans, keyword_init: true) do
+  Index = Struct.new(:name, :columns, :unique, :primary, :scans, :partial, keyword_init: true) do
     def covers?(other)
       columns.first(other.columns.length) == other.columns
     end
+
+    # A partial index only exists for rows matching its WHERE clause, so it
+    # cannot stand in for a full index for rows outside that condition.
+    # comparing WHERE clauses for implication is out of scope here, so a
+    # partial index is simply never treated as covering another.
+    def partial?
+      !!partial
+    end
   end
 
   Table = Struct.new(

data/lib/schema_reaper/static/scanner.rb

@@ -12,6 +12,16 @@ module SchemaReaper
       RUBY_GLOB  = "**/*.rb"
       WORD_RE    = /[a-z_][a-z0-9_]*/i.freeze
 
+      # Macros that generate a real column from a differently-named virtual
+      # attribute, so the literal column name never appears in application
+      # code. Missing this made dead_column flag has_secure_password's
+      # password_digest, and attr_encrypted/Lockbox/KMS ciphertext columns,
+      # as unused even though they're the live backing store.
+      DIGEST_MACROS = %w[has_secure_password].freeze
+      DIGEST_SUFFIXES = %w[_digest].freeze
+      ENCRYPTED_MACROS = %w[encrypts attr_encrypted lockbox_encrypts].freeze
+      ENCRYPTED_SUFFIXES = %w[_ciphertext _iv _tag _encrypted].freeze
+
       # Node classes whose #name (or #unescaped) is a bare identifier we treat
       # as a possible column/table reference.
       NAME_NODES = [
@@ -61,6 +71,7 @@ module SchemaReaper
         return unless node.is_a?(Prism::Node)
 
         out.merge(tokens_for(node))
+        out.merge(macro_derived_tokens(node)) if node.is_a?(Prism::CallNode)
         node.compact_child_nodes.each { |c| collect_from_node(c, out) }
       end
 
@@ -78,6 +89,34 @@ module SchemaReaper
         end
       end
 
+      # `has_secure_password` / `encrypts :field` / `attr_encrypted :field`
+      # never write their generated column name (password_digest,
+      # field_ciphertext, ...) anywhere in source -- only the virtual
+      # attribute name. Derive the column names a macro call implies so they
+      # count as "used" instead of looking dead.
+      def macro_derived_tokens(node)
+        call_name = node.name&.to_s
+        return [] unless call_name
+
+        if DIGEST_MACROS.include?(call_name)
+          attrs = macro_symbol_args(node)
+          attrs = ["password"] if attrs.empty?
+          attrs.flat_map { |a| DIGEST_SUFFIXES.map { |s| "#{a}#{s}" } }
+        elsif ENCRYPTED_MACROS.include?(call_name)
+          macro_symbol_args(node).flat_map { |a| ENCRYPTED_SUFFIXES.map { |s| "#{a}#{s}" } }
+        else
+          []
+        end
+      end
+
+      # Leading bare symbol arguments of a call, e.g. `encrypts :a, :b, purpose: :x`
+      # => ["a", "b"]. Stops at the first non-symbol (keyword args, etc).
+      def macro_symbol_args(node)
+        args = node.arguments&.arguments || []
+        args.take_while { |a| a.is_a?(Prism::SymbolNode) }
+            .map { |a| a.unescaped.to_s.downcase }
+      end
+
       def text_tokens(path)
         File.read(path).scan(WORD_RE).to_set(&:downcase)
       rescue StandardError

data/lib/schema_reaper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SchemaReaper
-  VERSION = "1.0.12"
+  VERSION = "1.0.14"
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: schema_reaper
 version: !ruby/object:Gem::Version
-  version: 1.0.12
+  version: 1.0.14
 platform: ruby
 authors:
 - aksshatt
 - mitkush
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -156,6 +157,7 @@ metadata:
   wiki_uri: https://github.com/aksshatt/schema_reaper/wiki
   funding_uri: https://github.com/sponsors/aksshatt
   rubygems_mfa_required: 'true'
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -170,7 +172,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.4.10
+signing_key: 
 specification_version: 4
 summary: Find and safely remove schema dead-weight in Rails + PostgreSQL apps.
 test_files: []