avo 4.0.24 → 4.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39956b77dc24c5bbbd7a35d6c033f516156909bf5557dbb6373b47d4a74c0a8e
-  data.tar.gz: d1896e708aa942746a7533b511eda01be161af473d7494e02bbd938bca04bc29
+  metadata.gz: c9af230951e4e3e672c18aab3e12a7ce14bc7e5f8923960fa00e3749de11b3ac
+  data.tar.gz: 0e880b044eb331bac8b975aa5f6d8c9c426290a7792d1fbc2e9e4d9fd4e33360
 SHA512:
-  metadata.gz: bd7a950180b5775bb47ca3c515699017efd81516ff1888d7305ed8553dc4d0401879600e5938ecbfdcc58262246b692cdf7a6f2b1bc15a096de12a55d70d481e
-  data.tar.gz: d84124993cb5bcac958745f9531f13f343ac7b1a7b9c8435980e87eeeeb638a7e0f9cd22d8ad5eb24890021b2d7c540d5e25ed2cfd6b58628544f1eff6595d7b
+  metadata.gz: 4c0f04c32828259ac8209ebb26251d716f3b0ffb0b9ff6c10665a7ca7a89482fd1373b0674589fa56b87292c992c2ed4aef9df5aa5ca2c1d2ad321ebdab97e9a
+  data.tar.gz: 620e026722f24a47b8421fa20e9306f7015168c3f695bf5e2e41aef8d3587118c4b58ac0ea87c37dc68b4457a38e100fe9043103cea5902af9baaadbb53329f4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    avo (4.0.24)
+    avo (4.0.25)
       actionview (>= 6.1)
       active_link_to
       activerecord (>= 6.1)

data/app/assets/builds/avo/application.css

@@ -6167,6 +6167,9 @@ tag.tagify__tag {
   .panel__card, .panel__body {
     width: 100%;
   }
+  .panel__body > .card + .card {
+    margin-top: calc(var(--spacing) * 4);
+  }
   .panel__body[data-content-focus] {
     --tw-outline-style: none;
     outline-style: none;
@@ -7194,6 +7197,52 @@ tag.tagify__tag {
     background-color: var(--color-primary);
     outline-offset: var(--focus-outline-offset-inset);
   }
+  .dropdown-menu__footer {
+    display: flex;
+    flex-direction: column;
+    align-self: stretch;
+    border-top-style: var(--tw-border-style);
+    border-top-width: 1px;
+    border-color: var(--color-tertiary);
+    padding: var(--spacing);
+  }
+  .dropdown-menu__footer :is(a, button) {
+    display: flex;
+    min-height: calc(var(--spacing) * 8);
+    width: 100%;
+    cursor: pointer;
+    align-items: center;
+    justify-content: flex-start;
+    gap: calc(var(--spacing) * 1.5);
+    border-radius: var(--radius-md);
+    --tw-border-style: none;
+    border-style: none;
+    background-color: transparent;
+    padding-inline: calc(var(--spacing) * 2);
+    padding-block: calc(var(--spacing) * 1.5);
+    font-size: var(--text-sm);
+    line-height: var(--tw-leading, var(--text-sm--line-height));
+    --tw-leading: calc(var(--spacing) * 5);
+    line-height: calc(var(--spacing) * 5);
+    --tw-font-weight: var(--font-weight-normal);
+    font-weight: var(--font-weight-normal);
+    white-space: nowrap;
+    color: var(--color-content-secondary);
+    &:hover {
+      background-color: var(--color-secondary);
+      color: var(--color-content);
+    }
+    &:focus-visible {
+      background-color: var(--color-primary);
+      outline-offset: var(--focus-outline-offset-inset);
+    }
+    svg {
+      width: calc(var(--spacing) * 4);
+      height: calc(var(--spacing) * 4);
+      flex-shrink: 0;
+      color: inherit;
+    }
+  }
   .dropdown-menu__icon, .dropdown-menu__list > :is(a, button) svg {
     width: calc(var(--spacing) * 4);
     height: calc(var(--spacing) * 4);

data/app/assets/stylesheets/css/components/ui/dropdown.css

@@ -160,6 +160,34 @@
   outline-offset: var(--focus-outline-offset-inset);
 }
 
+/* ==========================================================================
+   Footer (DropdownComponent with_footer)
+   A row under the list, outside the scrollable group and the inline search's
+   filter scope — always visible. Items share the menu-item metrics but read
+   quieter, as footer actions rather than options.
+   ========================================================================== */
+
+.dropdown-menu__footer {
+  @apply flex flex-col self-stretch p-1 border-t border-tertiary;
+}
+
+.dropdown-menu__footer :is(a, button) {
+  @apply flex items-center w-full justify-start gap-1.5 px-2 py-1.5 min-h-8 rounded-md border-none bg-transparent whitespace-nowrap text-content-secondary font-normal text-sm cursor-pointer leading-5;
+
+  &:hover {
+    @apply bg-secondary text-content;
+  }
+
+  &:focus-visible {
+    @apply bg-primary;
+    outline-offset: var(--focus-outline-offset-inset);
+  }
+
+  svg {
+    @apply shrink-0 size-4 text-inherit;
+  }
+}
+
 .dropdown-menu__icon,
 .dropdown-menu__list > :is(a, button) svg {
   @apply shrink-0 size-4 text-inherit;

data/app/assets/stylesheets/css/components/ui/panel.css

@@ -21,6 +21,14 @@
   @apply w-full;
 }
 
+/* Several `card`s declared in one `panel do ... end` block land as adjacent
+   children of the body, which is a plain block container — so without this they
+   render flush, borders touching. Matches the panel's own `gap-y-4` rhythm.
+   Adjacent-sibling scoped so a lone card stays flush with the panel. */
+.panel__body > .card + .card {
+  @apply mt-4;
+}
+
 /* Shift+T anchors focus on the panel body. Mirror the table view's focus state:
    suppress the body's own (clipped) outline and lift the ring to the whole panel,
    exactly like `.card:has(table:focus-visible)` does for the index table. */

data/app/components/avo/index/resource_controls_component.rb

@@ -57,11 +57,15 @@ class Avo::Index::ResourceControlsComponent < Avo::ResourceComponent
     Avo.resource_manager.get_resource_by_model_class @parent_record.class
   end
 
+  # Rails uses ThroughReflection for both `has_many :through` and
+  # `has_one :through`, so the class alone can't tell a collection from a
+  # singular association — `collection?` is what separates them.
   def is_has_many_association?
+    return @reflection.collection? if @reflection.instance_of?(ActiveRecord::Reflection::ThroughReflection)
+
     @reflection.class.in? [
       ActiveRecord::Reflection::HasManyReflection,
-      ActiveRecord::Reflection::HasAndBelongsToManyReflection,
-      ActiveRecord::Reflection::ThroughReflection
+      ActiveRecord::Reflection::HasAndBelongsToManyReflection
     ]
   end
 

data/app/components/avo/keyboard_shortcuts_component.rb

@@ -17,7 +17,8 @@ class Avo::KeyboardShortcutsComponent < Avo::BaseComponent
             keys_aria_label: "Up arrow or down arrow"
           ),
           shortcut(action: "Go back", keys: ["B"]),
-          shortcut(action: "Toggle keyboard shortcut badges", keys: ["Shift", "K"])
+          shortcut(action: "Toggle keyboard shortcut badges", keys: ["Shift", "K"]),
+          *assistant_shortcuts
         ]
       ),
       build_section(
@@ -89,6 +90,15 @@ class Avo::KeyboardShortcutsComponent < Avo::BaseComponent
 
   private
 
+  # avo-intelligence binds Cmd/Ctrl+J itself (its chat bar listens for the keydown directly, so it
+  # fires from inside a field too). Core has no assistant to open, so the modal only lists it when
+  # the gem is installed.
+  def assistant_shortcuts
+    return [] unless Avo.plugin_manager.installed?("avo-intelligence")
+
+    [shortcut(action: "Open the assistant", keys: {mac: ["Cmd", "J"], other: ["Ctrl", "J"]})]
+  end
+
   def build_section(title, shortcuts)
     {
       id: "hotkey-group-#{title.parameterize.underscore}",

data/app/components/avo/u_i/dropdown_component.html.erb

@@ -29,6 +29,9 @@
           <% if @searchable %>
             <p class="dropdown-menu__search-empty" data-popover-menu-target="empty" hidden>No matching options</p>
           <% end %>
+          <% if footer? %>
+            <div class="dropdown-menu__footer"><%= footer %></div>
+          <% end %>
         </div>
       <% end %>
     <% end %>

data/app/components/avo/u_i/dropdown_component.rb

@@ -14,6 +14,9 @@ class Avo::UI::DropdownComponent < Avo::BaseComponent
 
   renders_one :trigger
   renders_one :items
+  # A row pinned under the list — outside the scrollable group and the inline
+  # search's filter scope, so it stays visible. Popover mode only.
+  renders_one :footer
 
   # this is used to trigger the dropdown menu from trigger element
   # data: {action: component.action} => click->dropdown-menu#toggle

data/app/controllers/avo/associations_controller.rb

@@ -110,7 +110,7 @@ module Avo
       association_name = BaseResource.valid_association_name(@record, @field.for_attribute || params[:related_name])
 
       if through_reflection?
-        join_record.destroy!
+        join_record&.destroy!
       elsif has_many_reflection?
         @record.send(association_name).delete @attachment_record
       else
@@ -223,13 +223,29 @@ module Avo
       @reflection.source_reflection.foreign_key
     end
 
-    def through_foreign_key
-      @reflection.through_reflection.foreign_key
+    # Resolve the join record through the (scoped) through association rather
+    # than an unscoped `find_by` on the join model. When a pair of records is
+    # linked more than once, the association's scope is the only thing that
+    # tells one join row from another — `-> { where level: :admin }` picking the
+    # admin row out of a user's memberships, say. An unscoped lookup matches on
+    # the two foreign keys alone and destroys whichever row it happens to hit.
+    #
+    # A `has_many :through` narrows the association down to the record being
+    # detached. A `has_one :through` already *is* that record, so it only has to
+    # be checked against the one named in the URL — otherwise a stale page or a
+    # double detach would destroy whatever is currently attached.
+    def join_record
+      return through_association.find_by(source_foreign_key => @attachment_record.id) if @reflection.collection?
+
+      record = through_association
+      record if record.present? && record[source_foreign_key] == @attachment_record.id
     end
 
-    def join_record
-      @reflection.through_reflection.klass.find_by(source_foreign_key => @attachment_record.id,
-        through_foreign_key => @record.id)
+    # The through association itself: a collection proxy for `has_many :through`,
+    # the join record (or nil) for `has_one :through`. Reading it rather than the
+    # join model is what keeps the association's scope in play.
+    def through_association
+      @record.send(@reflection.through_reflection.name)
     end
 
     def has_many_reflection?
@@ -243,6 +259,13 @@ module Avo
       @reflection.instance_of? ActiveRecord::Reflection::ThroughReflection
     end
 
+    # Rails uses ThroughReflection for both `has_many :through` and
+    # `has_one :through`, so `through_reflection?` alone can't tell a collection
+    # from a singular association.
+    def collection_through_reflection?
+      through_reflection? && @reflection.collection?
+    end
+
     def additional_params
       @additional_params ||= params[:fields].slice(*@attach_fields&.map(&:id))
     end
@@ -257,22 +280,57 @@ module Avo
     end
 
     def attach_record(association_name, attachment_record)
-      if through_reflection? && additional_params.present?
+      # Hand-build the join record only when attach fields have to land before
+      # the insert: `<<` saves immediately, and a join model that validates one
+      # of those columns (StorePatron#review) fails before we could fill it.
+      # Otherwise prefer `<<` — it fills in the polymorphic source type and
+      # handles composite primary keys, neither of which we do by hand.
+      #
+      # Collection-only, and not merely by preference: it builds *through* the
+      # association, and `new` is a collection proxy method. A singular through
+      # also needs replace semantics, which only assignment gives — building a
+      # second join record would leave the association with two rows to pick
+      # from.
+      if collection_through_reflection? && additional_params.present?
         new_join_record(attachment_record).save!
-      elsif has_many_reflection? || through_reflection?
+      elsif has_many_reflection? || collection_through_reflection?
         @record.send(association_name) << attachment_record
       else
         @record.send(:"#{association_name}=", attachment_record)
         @record.save!
+
+        persist_join_record if through_reflection?
       end
     end
 
+    # A singular through association owns exactly one join record, and the
+    # assignment in `attach_record` already created or replaced it through the
+    # (scoped) through association.
+    def persist_join_record
+      through_record = through_association
+
+      return if through_record.blank?
+
+      # Fill the attach fields onto that row instead of inserting a second one
+      # that the association's scope wouldn't even match.
+      @resource.fill_record(through_record, additional_params, fields: @attach_fields) if additional_params.present?
+
+      # Rails writes the join record with `create`, which returns an unsaved
+      # record instead of raising when it's invalid. Without this `save!` the
+      # attach would report success while nothing was written.
+      through_record.save!
+    end
+
+    # Build the join record *through* the (scoped) through association, so Rails
+    # stamps the scope's attributes on it — `-> { where level: :admin }` writing
+    # `level` — along with the through foreign key. Building it on the join
+    # model instead writes the two foreign keys and nothing else, so a scoped
+    # association reports a successful attach and then doesn't match the row it
+    # just wrote. The `<<` arm below already goes through the association; this
+    # only differs in having attach fields to fill.
     def new_join_record(attachment_record)
       @resource.fill_record(
-        @reflection.through_reflection.klass.new(
-          source_foreign_key => attachment_record.id,
-          through_foreign_key => @record.id
-        ),
+        through_association.new(source_foreign_key => attachment_record.id),
         additional_params,
         fields: @attach_fields
       )

data/lib/avo/version.rb

@@ -1,3 +1,3 @@
 module Avo
-  VERSION = "4.0.24" unless const_defined?(:VERSION)
+  VERSION = "4.0.25" unless const_defined?(:VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: avo
 version: !ruby/object:Gem::Version
-  version: 4.0.24
+  version: 4.0.25
 platform: ruby
 authors:
 - Adrian Marin