schema_reaper 1.0.13 → 1.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 920a3c80a9b99271cfb1152f9a4682dd42c03516934fbd6971c56ef0af06882f
-  data.tar.gz: 63567586bef79cb15f27be238def5882fe3119955bb45bea346b4f979599e8ff
+  metadata.gz: 6b327fade324c6f2e9a871da57ae46814c1b077a1aca3aec64ca6681f270ffe6
+  data.tar.gz: d63156d86d7dc44e92204475c3d23ffa7e6b87730d0a436dc9aefd041ea8b843
 SHA512:
-  metadata.gz: fa80aecb2dacdbf843f03734818d739b7d5d386ba4096fc69163dacbc55ef52fb92a1b93adc1c4f5f4bf14bb5a1dc3a449fab647101d5a4b43a9922fa7088469
-  data.tar.gz: 410917c5ece25227dbcfeb0b32128b8d0105770631c10a4175da273c3c36744b4bed428857db38b2b621fb4d5ffd03fce89e70d4599bae9c66676371ce42687f
+  metadata.gz: cb3fe82c18f9f198ec544089305b183f2a413123093edd6f437a04c8d0b32879c123d1e4d1c338a1e03539a8eb16847406bb21f4eab5932ed6b4aba4fcdf461e
+  data.tar.gz: 1c1cf99e43ff66383f5b3bb0c42d5cfec209cbc8dab3bb986e734b6dcf75706c5ed1ecbf09d61f116ce2883957630f0ceeff7a102fb49793fe73cd93cd8283ad

data/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## [1.0.15] - 2026-09-18
+
+### Fixed
+- **`dead_column` still missed the two gems its own macro-detection feature
+  named as motivation.** 1.0.14 added recognition for `has_secure_password`,
+  `attr_encrypted`, and Lockbox macro columns, but only the first actually
+  worked. `attr_encrypted`'s real default column naming is a *prefix*
+  (`encrypted_<attr>`), confirmed against the gem's own
+  `attr_encrypted_default_options`; the feature generated a suffix guess
+  that never matched it. Lockbox's real macro is `has_encrypted`; the
+  feature checked for `lockbox_encrypts`, which is not a method that
+  exists in the gem, so it never even fired for genuine Lockbox code.
+  Rewritten as a macro-name -> column-template table so each macro's real
+  naming shape is expressed explicitly, and dropped an unnecessary
+  suffix guess for Rails' native `encrypts` (which stores ciphertext in
+  the original column and creates no extra one). Eight new specs cover
+  all four macros -- this had no test coverage before. (#15, mitkush)
+
+## [1.0.14] - 2026-09-18
+
+Published directly without a version-bump commit or tag; this entry
+reconciles the record after the fact. Confirmed by diffing the
+published gem against `main` at the time -- the only difference was the
+version string.
+
+### Fixed
+- `duplicate_index` respecting uniqueness and partial `WHERE` clauses --
+  see 1.0.13's entry for the underlying issue; this release adds the fix.
+  (#12, mitkush)
+- `dead_column` missing `has_secure_password`, `encrypts`, and
+  `attr_encrypted` macro columns -- a virtual attribute like
+  `has_secure_password` never has its generated column name
+  (`password_digest`) written anywhere in application code, so it looked
+  unreferenced. (aksshatt)
+
+### Known issue
+- The `attr_encrypted`/Lockbox part of the macro-column fix above does
+  not work as intended: it derives a suffix-based column name
+  (`<attr>_encrypted`) that does not match `attr_encrypted`'s actual
+  default naming (`encrypted_<attr>`, a prefix), and it references a
+  `lockbox_encrypts` macro name that does not exist in Lockbox -- the
+  gem's real method is `has_encrypted`. `has_secure_password` and Rails'
+  native `encrypts` are unaffected and work correctly. Tracked for 1.0.15.
+
 ## [1.0.13] - 2026-09-18
 
 ### Fixed

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/introspect/postgres.rb

@@ -100,22 +100,16 @@ 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.
-      #
-      # pg_get_indexdef(indexrelid, column_no, pretty) is keyed by column
-      # *position* (1..indnkeyatts), not by table attnum, so it renders a
-      # plain column and an expression column uniformly. The previous query
-      # joined each indkey entry against pg_attribute by attnum; an expression
-      # column's indkey entry is 0, which matches no real column, so the join
-      # silently dropped it -- an index on (COALESCE(a, b), c) came back as
-      # just "c", which then looked like a genuine duplicate of any ordinary
-      # index on :c. indnkeyatts also excludes INCLUDE columns, which are
-      # payload only and never participate in Index#covers?'s prefix check.
+      # 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,
+                 (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}'
@@ -126,11 +120,11 @@ module SchemaReaper
           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(COLUMN_SEPARATOR),
-            unique: r["unique"] == "t", primary: r["primary"] == "t",
+            unique: r["unique"] == "t", primary: r["primary"] == "t", partial: r["partial"] == "t",
             scans: r["scans"]&.to_i
           )
         end

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,38 @@ module SchemaReaper
       RUBY_GLOB  = "**/*.rb"
       WORD_RE    = /[a-z_][a-z0-9_]*/i.freeze
 
+      # Macros whose generated column name differs from the virtual attribute
+      # declared in the call, so the real column name never appears anywhere
+      # in application code and would otherwise look dead. %s is replaced with
+      # the declared attribute.
+      #
+      # Several shapes are listed for some macros on purpose: getting the real
+      # default right matters most, but an extra guess that never matches a
+      # real column is harmless -- over-collecting is this scanner's stated
+      # design, and both attr_encrypted and Lockbox let a call override their
+      # naming, which a static scan cannot always evaluate.
+      #
+      # attr_encrypted's own default is a PREFIX (encrypted_<attr>), not a
+      # suffix -- confirmed against the gem's own attr_encrypted_default_options
+      # (prefix: "encrypted_", suffix: ""). The suffix form is kept as a
+      # fallback for calls that override it.
+      #
+      # Lockbox's real macro is has_encrypted, not lockbox_encrypts.
+      #
+      # Rails' own `encrypts` has no entry: it stores ciphertext in the
+      # original column, so the bare attribute name is what needs to be
+      # "used", and that is already picked up as a symbol literal by
+      # tokens_for below -- do not add a suffix pattern for it.
+      MACRO_COLUMN_TEMPLATES = {
+        "has_secure_password" => ["%s_digest"],
+        "attr_encrypted" => ["encrypted_%s", "%s_encrypted", "%s_ciphertext"],
+        "has_encrypted" => ["%s_ciphertext", "%s_iv", "%s_tag"]
+      }.freeze
+
+      # The attribute a macro implies when called with no explicit name, e.g.
+      # bare `has_secure_password` -> :password.
+      MACRO_DEFAULT_ATTR = { "has_secure_password" => "password" }.freeze
+
       # Node classes whose #name (or #unescaped) is a bare identifier we treat
       # as a possible column/table reference.
       NAME_NODES = [
@@ -61,6 +93,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 +111,24 @@ module SchemaReaper
         end
       end
 
+      def macro_derived_tokens(node)
+        call_name = node.name&.to_s
+        templates = call_name && MACRO_COLUMN_TEMPLATES[call_name]
+        return [] unless templates
+
+        attrs = macro_symbol_args(node)
+        attrs = [MACRO_DEFAULT_ATTR[call_name]].compact if attrs.empty?
+        attrs.product(templates).map { |attr, template| format(template, attr) }
+      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.13"
+  VERSION = "1.0.15"
 end

data/schema_reaper.gemspec

@@ -9,15 +9,17 @@ Gem::Specification.new do |spec|
   spec.email = ["akshatpegwar5@gmail.com", "mitanshukushwah@gmail.com"]
 
   spec.summary = "Find and safely remove schema dead-weight in Rails + PostgreSQL apps."
-  spec.description =
-    "schema_reaper finds schema dead-weight in Rails/ActiveRecord + PostgreSQL apps: " \
-    "dead columns and tables, unused, duplicate and missing foreign-key indexes, and " \
-    "always-NULL or single-value columns. It cross-references the live schema and pg_stats " \
-    "against a static scan of your code, with an optional production runtime signal for " \
-    "higher confidence. Each finding is scored, carries a reclaimable-bytes estimate, and " \
-    "ships with a staged, reversible migration. Reporters for terminal, JSON, Markdown and " \
-    "SARIF; a CI baseline gate; a trend log; a Rails railtie. PostgreSQL only for now; " \
-    "Ruby >= 2.7. See the README for full usage."
+  spec.description = <<~DESC.strip
+    schema_reaper scans a Rails + PostgreSQL app for schema debt that's easy to accumulate and hard to find by hand.
+
+    It checks your live database against your codebase and flags three kinds of problems: things nothing references anymore (dead columns and dead tables), index trouble (indexes nobody queries, indexes made redundant by a wider index that already covers them, and foreign-key columns with no index at all), and degenerate data (columns that are always NULL, or hold the exact same value in every row).
+
+    Every finding comes with a confidence score, an estimate of the disk space removing it would reclaim, and a concrete fix. For a column, that's a two-step migration: stop reading it first, then drop it once you've confirmed nothing broke. An optional runtime tracker can sample real production traffic to raise confidence further, for cases a static code scan alone can't settle.
+
+    Reports come as a colored terminal summary, JSON, Markdown for a PR comment, or SARIF for GitHub code scanning -- plus a CI baseline gate and a trend log to track progress release over release.
+
+    PostgreSQL only for now. Requires Ruby 2.7 or later. Full usage is in the README.
+  DESC
   spec.homepage = "https://github.com/aksshatt/schema_reaper"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.7.0"

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: schema_reaper
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 1.0.15
 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
@@ -78,14 +79,16 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
-description: 'schema_reaper finds schema dead-weight in Rails/ActiveRecord + PostgreSQL
-  apps: dead columns and tables, unused, duplicate and missing foreign-key indexes,
-  and always-NULL or single-value columns. It cross-references the live schema and
-  pg_stats against a static scan of your code, with an optional production runtime
-  signal for higher confidence. Each finding is scored, carries a reclaimable-bytes
-  estimate, and ships with a staged, reversible migration. Reporters for terminal,
-  JSON, Markdown and SARIF; a CI baseline gate; a trend log; a Rails railtie. PostgreSQL
-  only for now; Ruby >= 2.7. See the README for full usage.'
+description: |-
+  schema_reaper scans a Rails + PostgreSQL app for schema debt that's easy to accumulate and hard to find by hand.
+
+  It checks your live database against your codebase and flags three kinds of problems: things nothing references anymore (dead columns and dead tables), index trouble (indexes nobody queries, indexes made redundant by a wider index that already covers them, and foreign-key columns with no index at all), and degenerate data (columns that are always NULL, or hold the exact same value in every row).
+
+  Every finding comes with a confidence score, an estimate of the disk space removing it would reclaim, and a concrete fix. For a column, that's a two-step migration: stop reading it first, then drop it once you've confirmed nothing broke. An optional runtime tracker can sample real production traffic to raise confidence further, for cases a static code scan alone can't settle.
+
+  Reports come as a colored terminal summary, JSON, Markdown for a PR comment, or SARIF for GitHub code scanning -- plus a CI baseline gate and a trend log to track progress release over release.
+
+  PostgreSQL only for now. Requires Ruby 2.7 or later. Full usage is in the README.
 email:
 - akshatpegwar5@gmail.com
 - mitanshukushwah@gmail.com
@@ -156,6 +159,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 +174,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Find and safely remove schema dead-weight in Rails + PostgreSQL apps.
 test_files: []