coatepec 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cbcec579a7904ef50c8d8227036bbb0dd45f05bd664ffa2fceb2d210f5171be
-  data.tar.gz: 672092f99f2bfab2de7ad832572e6f16b5aeea8613860f0456fc81f7abaf25f4
+  metadata.gz: 161aafede82c7279701f75a51cc7976a6ef7bbbadff7bc22a7bc04dc050e1780
+  data.tar.gz: 2b867df0d495bb573e1e00ad9a94f9aca800fa7045bbf6965fb0825acfc2683f
 SHA512:
-  metadata.gz: f065ef0f83fbf5796d8e333326d9cf852a7322de12a12f77ece713df6cf00d29f167ea3ca2001830cb70e1e770a4533e3b111956390da1d0968c682cdeb8335a
-  data.tar.gz: 62d2d70afe6f5554c4e40fd83572384161f1819b228e65baa5c3a9c048716632e47c126356810e0c5aeb1e2ca1e9a79ed30fe0d10e97e773d6f1b6527a373d38
+  metadata.gz: d93777d12dac89c55450377259fc7d206bd6ef077766395f1397045372a58a7203bf986bbb9a525fc89b8510159a7fd9d0c3a057c321219edd95d6f23caa7acf
+  data.tar.gz: 3e580288a7c4ef9b0e707909967c28293ce8bc8b749e8c11d03903faef69ef80587c4a8307e13e769633d521b6245a05f806859d124a40346a9a0120b56e3e9b

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.5.1
+
+- Fix `rails_model` crashing outright for a model with a `has_one`/
+  `has_many :through` association that goes through a polymorphic
+  `belongs_to` (e.g. `has_one :x, through: :notable, source: :y` where
+  `belongs_to :notable, polymorphic: true`). `foreign_key` on that
+  reflection needs a single fixed class to resolve, which a polymorphic
+  association can't provide, and that was previously an unrescued
+  `ArgumentError` that took down the whole response. That specific case now
+  reports `foreign_key: nil`/`class_name: nil` for the affected association,
+  the same way an already-handled plain polymorphic `belongs_to` does.
+- Add a general safety net around each association's metadata: if a single
+  association still fails for some other, not-yet-anticipated
+  `ActiveRecord` reflection quirk, only that association's entry degrades
+  (gaining an `error` field describing what went wrong) instead of the
+  entire `rails_model` call crashing for the whole model.
+
 ## 0.5.0
 
 - **Breaking:** `mcp` is no longer a runtime dependency of the `coatepec`

data/README.md

@@ -130,6 +130,31 @@ a no-op.
 | `rails_routes` | `query?`, `limit?` (1..200, default 50), `offset?` | Case-insensitive filter across name/verb/path/controller/action |
 | `rails_model` | `name` (constant path, e.g. `Widget` or `Admin::Widget`) | ActiveRecord models only; columns, associations, validators, enums -- no row data |
 
+### Example queries
+
+`rails_routes`:
+
+- "What are all the routes in this app?" -- `rails_routes()`
+- "What's the URL for widgets?" -- `rails_routes(query: "widget")`. `query` is a
+  case-insensitive substring match across name, verb, path, controller, *and*
+  action -- not just the path -- so a resource name alone typically returns
+  every route for that resource (index/create/new/...); narrow further with
+  something like `query: "new_widget"` to hit one route by name.
+- "Which routes accept POST?" -- `rails_routes(query: "POST")`, the same
+  substring match applied to the verb column.
+
+`rails_model`:
+
+- "What columns does Widget have, and which are nullable?" --
+  `rails_model(name: "Widget")` -- see `columns[].null`, `columns[].sql_type`,
+  `columns[].default`.
+- "What validations and associations does Widget enforce?" -- same call --
+  see `validators` and `associations`.
+- "What happens if I ask about a non-model class, like a controller?" --
+  `rails_model(name: "ApplicationController")` raises `not_active_record_model`
+  rather than introspecting it (a nonexistent constant raises `model_not_found`
+  instead) -- the tool only ever reflects on `ActiveRecord::Base` descendants.
+
 The warm test worker forces Rails' reload-checking on for its own boot,
 regardless of the target app's own `test.rb` setting (which disables it by
 default) -- so editing a model file takes effect on the next tool call

data/lib/coatepec/introspection/model.rb

@@ -93,7 +93,32 @@ module Coatepec
       end
 
       def associations_for(klass)
-        klass.reflect_on_all_associations.first(MAX_ITEMS).map { |assoc| build_association_data(assoc) }
+        klass.reflect_on_all_associations.first(MAX_ITEMS).map { |assoc| safe_association_data(assoc) }
+      end
+
+      # build_association_data's own field-level rescues (association_class_name,
+      # association_foreign_key) cover every failure mode seen in practice so
+      # far, but ActiveRecord's reflection internals are large enough that
+      # betting the whole rails_model call on having anticipated all of them
+      # is optimistic -- a has_one/has_many :through a polymorphic belongs_to
+      # is exactly the kind of case that wasn't anticipated until it crashed
+      # this method outright (see association_foreign_key). This is the
+      # boundary of last resort: one association's introspection failing
+      # degrades just that entry instead of the whole model. It deliberately
+      # does not rescue StandardError -- a NoMethodError here is a genuine
+      # Coatepec bug (e.g. a typo), and letting that crash loudly beats
+      # silently reporting it as "this association is fine, no data".
+      def safe_association_data(assoc)
+        build_association_data(assoc)
+      rescue NameError, ArgumentError, ::ActiveRecord::ActiveRecordError => e
+        degraded_association_data(assoc, e)
+      end
+
+      def degraded_association_data(assoc, error)
+        {
+          name: assoc.name.to_s, macro: assoc.macro.to_s, class_name: nil, foreign_key: nil, through: nil,
+          polymorphic: nil, error: "#{error.class}: #{error.message}"
+        }
       end
 
       def build_association_data(assoc)
@@ -101,7 +126,7 @@ module Coatepec
           name: assoc.name.to_s,
           macro: assoc.macro.to_s,
           class_name: association_class_name(assoc),
-          foreign_key: assoc.foreign_key.to_s,
+          foreign_key: association_foreign_key(assoc),
           through: assoc.through_reflection&.name&.to_s,
           polymorphic: assoc.polymorphic? || false
         }
@@ -120,6 +145,20 @@ module Coatepec
         nil
       end
 
+      # A has_one/has_many :through reflection whose `through:` target is
+      # itself a polymorphic belongs_to has no single fixed class either --
+      # ThroughReflection#foreign_key needs through_reflection.klass to find
+      # the source reflection, and .klass on a polymorphic reflection always
+      # raises ArgumentError (see association_class_name above). A dangling
+      # class_name on the reflection itself still raises NameError the same
+      # way. Report foreign_key: nil rather than letting either crash the
+      # call.
+      def association_foreign_key(assoc)
+        assoc.foreign_key.to_s
+      rescue NameError, ArgumentError
+        nil
+      end
+
       def validators_for(klass)
         klass.validators.first(MAX_ITEMS).map do |validator|
           {

data/lib/coatepec/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coatepec
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: coatepec
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Enrique Mogollan
 bindir: exe
 cert_chain: []
-date: 2026-08-05 00:00:00.000000000 Z
+date: 2026-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties