schema_reaper 1.0.14 → 1.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f169920afef1838471a418e29ad207b6c9d3193ef57caf6678cf68d675a3405
-  data.tar.gz: 3e5d507411e727278004def7a752db662620a01371625ce761af4495fd020f2e
+  metadata.gz: df6a3127bc5e379e183a6f525870c5726bbf016223b6c8531b1be8cb97da8ca5
+  data.tar.gz: 2810a69e8b382c10ecf52bc35717efd53fc9b826b8aae580b15773f4ffb8e246
 SHA512:
-  metadata.gz: 739b0cf29def40063c3a182ad5b9d207f7409f9277e134e76bd980bc3db276a333f225a1974bf5c30a3e14af769d0c8128efeb46961d084f1349fc17bddd6eca
-  data.tar.gz: 692ed7533e2553ebbc9085001f1d805519149fe988860e23da9902b941de60c292a8918e60f2fe9c2d0e558aaeacd182d31e6376570e7ea9e8551977d5856db8
+  metadata.gz: f4dc2789fcdd897e213a4b050ef98a05d94f6c213e145bdc6ac6e8a5168d355b7fc86a2b18aa0799b76ff1183255e64b5d6bbc2789c9d5a063dac91c9fcabdf9
+  data.tar.gz: f8026dcfb27f4a9a828f519bef9a78f8e626522f8cadb5082ee39b393652d5ff0224a669fc8a4b7d109f20f5b6bc910bcea336971de0603a85af4d1c4ad2280a

data/.rubocop.yml

@@ -44,7 +44,7 @@ Metrics/MethodLength:
   Max: 20
 
 Metrics/ClassLength:
-  Max: 130
+  Max: 135
 
 Metrics/CyclomaticComplexity:
   Max: 12

data/CHANGELOG.md

@@ -1,5 +1,89 @@
 # Changelog
 
+## [1.0.16] - 2026-09-22
+
+### Fixed
+- **A bare index on a polymorphic `*_id` column alone silently suppressed the
+  `missing_fk_index` finding it should have raised.** The check tested the
+  generic "is this column indexed at all" before checking whether the column
+  was part of a polymorphic pair, so an index on `commentable_id` by itself
+  — never sufficient, since Rails always queries the pair together — read as
+  "covered" and the analyzer's own doc comment went unenforced. Now gates on
+  the composite `(type, id)` check whenever a `*_type` column is present.
+  (#17, mitkush)
+- **`Postgres#indexes_for` was the one introspection query missing the
+  `public`-schema filter** every sibling query (`columns_for`,
+  `foreign_keys_for`, `table_names`) already has. In a database with more
+  than one schema containing a same-named table, it could pull in and union
+  indexes from the wrong table. Verified live against a two-schema database
+  with a colliding table name and a planted bogus index. (#17, mitkush)
+- **The `SCHEMA_REAPER_TRACK=1` runtime-tracker initializer could crash a
+  host app's entire boot**, not just disable the optional feature, on a
+  malformed `.schema_reaper.yml` or an unwritable log directory — nothing
+  in the initializer was rescued. Now rescues and logs a warning instead.
+  (#18, mitkush)
+- **`schema_reaper scan --format json` could not distinguish a genuinely
+  zero-byte reclaim estimate from an unmeasured one.** `Finding#to_h` read
+  the zero-defaulted accessor instead of the raw value, silently flattening
+  "unknown" into `0` for every CI/tooling consumer of the JSON output, even
+  though every other reporter already preserves that distinction. The
+  payload now carries the raw value plus an explicit `reclaim_known` flag.
+  Verified live: an unmeasured finding now serializes `reclaimable_bytes`
+  as `null` with `reclaim_known: false`. (#18, mitkush)
+- **A query-time Postgres error (anything past the initial connection)
+  propagated as a raw `PG::Error`** instead of the wrapped `SchemaReaper::Error`
+  every other failure path produces, leaking a Ruby backtrace instead of a
+  clean CLI error message. `primary_key_for`'s existing fallback-to-nil
+  rescue is updated to match. (#18, mitkush)
+- Cosmetic: `MigrationGenerator#model` mangled irregular plural table names
+  (`addresses` → "Addresse") in the generated migration's comment text;
+  `Reporters::Trend#bytes` printed `-0.0 B` instead of `+0.0 B` for a zero
+  delta. (#17, mitkush)
+
+## [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/missing_fk_index.rb

@@ -32,11 +32,15 @@ module SchemaReaper
 
       def missing_in(table)
         fk_columns(table).filter_map do |col|
-          next if indexed?(table, col)
-          next if empty_column?(table, col) # never advise indexing a column with no data
-
           type_col = polymorphic_type_for(table, col)
-          next if type_col && polymorphic_indexed?(table, type_col, col)
+
+          # A bare index on the id alone doesn't cover a polymorphic pair --
+          # only the composite (type, id) index satisfies it. Check that
+          # instead of the generic `indexed?`, or a bare id-only index would
+          # wrongly suppress this finding.
+          covered = type_col ? polymorphic_indexed?(table, type_col, col) : indexed?(table, col)
+          next if covered
+          next if empty_column?(table, col) # never advise indexing a column with no data
 
           finding_for(table, col, type_col, declared: table.foreign_keys.include?(col))
         end

data/lib/schema_reaper/finding.rb

@@ -50,8 +50,12 @@ module SchemaReaper
       parts.empty? ? nil : parts.join(" · ")
     end
 
+    # Keeps the raw (possibly nil) reclaimable_bytes from Struct#to_h rather
+    # than the zero-defaulted accessor above, so JSON/SARIF consumers can tell
+    # "genuinely zero" apart from "unknown" the same way every other reporter
+    # does -- reclaim_known? makes that distinction explicit in the payload.
     def to_h
-      super.merge(id: id, reclaimable_bytes: reclaimable_bytes)
+      super.merge(id: id, reclaim_known: reclaim_known?)
     end
   end
 end

data/lib/schema_reaper/introspect/postgres.rb

@@ -8,13 +8,12 @@ module SchemaReaper
       AVG_TYPE_BYTES = {
         "boolean" => 1, "smallint" => 2, "integer" => 4, "bigint" => 8,
         "real" => 4, "double precision" => 8, "numeric" => 8,
-        "date" => 4, "timestamp without time zone" => 8,
-        "timestamp with time zone" => 8, "uuid" => 16
+        "date" => 4, "timestamp without time zone" => 8, "timestamp with time zone" => 8, "uuid" => 16
       }.freeze
 
       NO_URL = "no database connection found. schema_reaper looks, in order, for: " \
-               "database_url: in .schema_reaper.yml; the DATABASE_URL env var; " \
-               "config/database.yml for RAILS_ENV (default: development, Postgres only)."
+               "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
@@ -119,7 +118,7 @@ module SchemaReaper
           JOIN pg_class i ON i.oid = ix.indexrelid
           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
+          WHERE t.relname = $1 AND t.relnamespace = 'public'::regnamespace
           GROUP BY i.relname, ix.indisunique, ix.indisprimary, ix.indpred, s.idx_scan
         SQL
           Index.new(
@@ -142,7 +141,7 @@ module SchemaReaper
           WHERE i.indrelid = $1::regclass AND i.indisprimary
           ORDER BY k.ord
         SQL
-      rescue PG::Error
+      rescue Error, PG::Error
         nil
       end
 
@@ -172,6 +171,8 @@ module SchemaReaper
 
       def exec(sql, params = nil)
         (params ? @conn.exec_params(sql, params) : @conn.exec(sql)).to_a
+      rescue PG::Error => e
+        raise Error, "query against the database failed: #{e.message.strip}"
       end
     end
   end

data/lib/schema_reaper/migration_generator.rb

@@ -5,6 +5,14 @@ require "fileutils"
 module SchemaReaper
   # Emits a two-step, reversible migration pair for a dead column.
   class MigrationGenerator
+    # Enough of Rails' inflector for table names in this comment text -- a
+    # wrong guess doesn't break anything functional, just reads oddly.
+    SINGULAR_RULES = [
+      [/ies\z/, "y"],               # activities -> activity
+      [/(ss|sh|ch|x|z)es\z/, '\1'], # addresses  -> address, boxes -> box
+      [/s\z/, ""]                   # employees  -> employee
+    ].freeze
+
     def initialize(table:, column:, dir: "db/migrate")
       @table = table
       @column = column
@@ -77,7 +85,12 @@ module SchemaReaper
     end
 
     def model
-      @table.split("_").map(&:capitalize).join.sub(/s$/, "")
+      singular.split("_").map(&:capitalize).join
+    end
+
+    def singular
+      rule = SINGULAR_RULES.find { |pattern, _| @table.match?(pattern) }
+      rule ? @table.sub(rule[0], rule[1]) : @table
     end
   end
 end

data/lib/schema_reaper/railtie.rb

@@ -12,10 +12,17 @@ module SchemaReaper
     initializer "schema_reaper.runtime_tracker" do
       next unless ENV["SCHEMA_REAPER_TRACK"] == "1"
 
-      config = SchemaReaper::Config.load
-      store = SchemaReaper::Runtime::Store.new(path: config.runtime_log)
-      rate = (ENV["SCHEMA_REAPER_SAMPLE"] || "0.05").to_f
-      SchemaReaper::Runtime::Tracker.install!(store: store, sample_rate: rate)
+      begin
+        config = SchemaReaper::Config.load
+        store = SchemaReaper::Runtime::Store.new(path: config.runtime_log)
+        rate = (ENV["SCHEMA_REAPER_SAMPLE"] || "0.05").to_f
+        SchemaReaper::Runtime::Tracker.install!(store: store, sample_rate: rate)
+      rescue StandardError => e
+        # Optional instrumentation must never take the host app down with it --
+        # a bad config file or an unwritable log directory disables tracking,
+        # it does not abort boot.
+        Rails.logger&.warn("[schema_reaper] runtime tracker disabled: #{e.class}: #{e.message}")
+      end
     end
   end
 end

data/lib/schema_reaper/reporters/trend.rb

@@ -47,7 +47,7 @@ module SchemaReaper
 
       def bytes
         delta = @d[:bytes_change_total].to_i
-        sign = delta.positive? ? "+" : "-"
+        sign = delta.negative? ? "-" : "+"
         @c.row("reclaimable", Bytes.human(@d.fetch(:latest_bytes, 0)),
                "#{sign}#{Bytes.human(delta.abs)} since first run")
       end

data/lib/schema_reaper/static/scanner.rb

@@ -12,15 +12,37 @@ 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
+      # 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.
@@ -89,24 +111,14 @@ 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
+        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`

data/lib/schema_reaper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SchemaReaper
-  VERSION = "1.0.14"
+  VERSION = "1.0.16"
 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,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: schema_reaper
 version: !ruby/object:Gem::Version
-  version: 1.0.14
+  version: 1.0.16
 platform: ruby
 authors:
 - aksshatt
 - mitkush
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-18 00:00:00.000000000 Z
+date: 2026-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -79,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
@@ -157,7 +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: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -172,8 +174,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Find and safely remove schema dead-weight in Rails + PostgreSQL apps.
 test_files: []