avo 3.0.1.beta24 → 3.0.2

data/app/helpers/avo/application_helper.rb

@@ -129,6 +129,10 @@ module Avo
         })
     end
 
+    def frame_id(resource)
+      ["frame", resource.model_name.singular, resource.record.id].compact.join("-")
+    end
+
     private
 
     # Taken from the original library

data/app/javascript/js/controllers/fields/reload_belongs_to_field_controller.js

@@ -0,0 +1,51 @@
+import { Controller } from '@hotwired/stimulus'
+
+// Used as a custom Stream Action <turbo-stream action="update-belongs-to" />
+export default class extends Controller {
+  static values = {
+    polymorphic: Boolean,
+    searchable: Boolean,
+    targetName: String,
+    relationName: String,
+  }
+
+  beforeStreamRender(event) {
+    const { relationName } = event.target.dataset
+    if (event.target.action !== 'update-belongs-to' || this.relationNameValue !== relationName) {
+      return false
+    }
+
+    event.detail.render = (stream) => {
+      if (this.searchableValue) {
+        this.updateSearchable(stream)
+      } else {
+        this.updateNonSearchable(stream)
+      }
+    }
+  }
+
+  updateSearchable(stream) {
+    // Update the id component
+    document.querySelector(`input[name="${this.targetNameValue}"][type="hidden"]`).value = stream.dataset.targetRecordId
+    // Update the label
+    document.querySelector(`input[name="${this.targetNameValue}"][type="text"]`).value = stream.dataset.targetResourceLabel
+  }
+
+  updateNonSearchable(stream) {
+    const select = this.selectorContext(stream).querySelector(`select[name="${this.targetNameValue}"]`)
+    const option = document.createElement('option')
+    option.value = stream.dataset.targetRecordId
+    option.text = stream.dataset.targetResourceLabel
+    option.selected = true
+    select.appendChild(option)
+  }
+
+  selectorContext(stream) {
+    // if polymorphic, search for the select in the correct sub-container
+    if (this.polymorphicValue) {
+      return document.querySelector(`[data-type="${stream.dataset.targetResourceClass}"]`)
+    }
+
+    return document
+  }
+}

data/app/javascript/js/controllers.js

@@ -24,6 +24,7 @@ import MultipleSelectFilterController from './controllers/multiple_select_filter
 import PerPageController from './controllers/per_page_controller'
 import PreviewController from './controllers/preview_controller'
 import ProgressBarFieldController from './controllers/fields/progress_bar_field_controller'
+import ReloadBelongsToFieldController from './controllers/fields/reload_belongs_to_field_controller'
 import ResourceEditController from './controllers/resource_edit_controller'
 import ResourceIndexController from './controllers/resource_index_controller'
 import ResourceShowController from './controllers/resource_show_controller'
@@ -76,6 +77,7 @@ application.register('date-field', DateFieldController)
 application.register('easy-mde', EasyMdeController)
 application.register('key-value', KeyValueController)
 application.register('progress-bar-field', ProgressBarFieldController)
+application.register('reload-belongs-to-field', ReloadBelongsToFieldController)
 application.register('trix-field', TrixFieldController)
 
 // Custom controllers

data/app/views/avo/actions/show.html.erb

@@ -7,8 +7,7 @@
     data-resource-id="<%= params[:id] %>"
     class="hidden text-slate-800"
   >
-    <%= form_with model: @record,
-      scope: 'fields',
+    <%= form_with scope: 'fields',
       url: Avo::Services::URIService.parse(@resource.records_path).append_paths("actions").to_s,
       local: true,
       data: @action.class.form_data_attributes do |form|
@@ -17,10 +16,11 @@
       <% c.with_heading do %>
         <%= @action.action_name %>
       <% end %>
+
       <div class="flex-1 flex">
         <%= @action.get_message %>
       </div>
-      <%= hidden_field_tag :action_id, @action.param_id %>
+      <%= hidden_field_tag :action_id, @action.to_param %>
       <%= form.hidden_field :avo_resource_ids, value: params[:id] || params[:resource_ids], 'data-action-target': 'resourceIds' %>
       <%= form.hidden_field :avo_selected_query, 'data-action-target': 'selectedAllQuery' %>
       <%= form.hidden_field :arguments, value: params[:arguments] %>
@@ -35,6 +35,7 @@
           <% end %>
         </div>
       <% end %>
+
       <% c.with_controls do %>
         <%= a_button type: :button,
           data: { action: 'click->modal#close' },

data/app/views/avo/base/_new_via_belongs_to.html.erb

@@ -0,0 +1,12 @@
+<%= turbo_frame_tag "new_via_belongs_to" do %>
+  <%= render(Avo::ModalComponent.new(width: :xl, body_class: "bg-application")) do |c| %>
+    <div class="pt-4 pb-8">
+      <%= render Avo::Views::ResourceEditComponent.new(
+        resource: @resource,
+        record: @record,
+        view: @view,
+        display_breadcrumbs: false
+      ) %>
+    </div>
+  <% end %>
+<% end %>

data/app/views/avo/base/close_modal_and_reload_field.turbo_stream.erb

@@ -0,0 +1,8 @@
+<%= turbo_stream.remove("new_via_belongs_to") %>
+
+<turbo-stream action="update-belongs-to"
+              data-relation-name="<%= params[:via_relation] %>"
+              data-target-record-id="<%= @record.id %>"
+              data-target-resource-label="<%= @resource.record_title %>"
+              data-target-resource-class="<%= @record.class.name %>">
+</turbo-stream>

data/app/views/avo/base/create_fail_action.turbo_stream.erb

@@ -0,0 +1,13 @@
+<%= turbo_stream.replace(frame_id(@resource), template: "avo/base/new")  %>
+
+<%= turbo_stream.append "alerts" do %>
+  <%= render Avo::FlashAlertsComponent.new flashes: flash %>
+<% end %>
+
+<% if @record.errors.any? %>
+  <%= turbo_stream.append("alerts") do %>
+    <% @record.errors.full_messages.each do |message| %>
+      <%= render Avo::AlertComponent.new :error, message %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/avo/partials/_flash_alerts.turbo_stream.erb

@@ -0,0 +1,3 @@
+<%= turbo_stream.append "alerts" do %>
+  <%= render Avo::FlashAlertsComponent.new flashes: flash.discard %>
+<% end %>

data/config/i18n-tasks.yml

@@ -3,7 +3,7 @@
 # The "main" locale.
 base_locale: en
 ## All available locales are inferred from the data by default. Alternatively, specify them explicitly:
-locales: [en, fr, nb, nn, pt-BR, pt, ro, tr]
+locales: [ar, en, es, fr, nb, nn, pt-BR, pt, ro, tr]
 ## Reporting locale, default: en. Available: en, ru.
 # internal_locale: en
 

data/config/initializers/pagy.rb

@@ -1,4 +1,5 @@
 require "pagy/extras/trim"
+require "pagy/extras/countless"
 
 # For locales without native pagy i18n support
 def pagy_locale_path(file_name)
@@ -7,6 +8,7 @@ end
 
 extra_locales = [
   {locale: "en"},
+  {locale: "es"},
   {locale: "fr"},
   {locale: "nb"},
   {locale: "pt-BR"},

data/config/master.key

@@ -0,0 +1 @@
+2aeb23d82b909d9c6b5abb62f7058c2a

data/lib/avo/base_action.rb

@@ -7,22 +7,19 @@ module Avo
     class_attribute :confirm_button_label
     class_attribute :cancel_button_label
     class_attribute :no_confirmation, default: false
-    class_attribute :record
-    class_attribute :view
-    class_attribute :user
-    class_attribute :resource
     class_attribute :standalone, default: false
     class_attribute :visible
     class_attribute :may_download_file, default: false
     class_attribute :turbo
+    class_attribute :authorize, default: true
 
+    attr_accessor :view
     attr_accessor :response
     attr_accessor :record
     attr_accessor :resource
     attr_accessor :user
     attr_reader :arguments
 
-    delegate :view, to: :class
     # TODO: find a differnet way to delegate this to the uninitialized Current variable
     delegate :context, to: Avo::Current
     def current_user
@@ -32,6 +29,7 @@ module Avo
     delegate :view_context, to: Avo::Current
     delegate :avo, to: :view_context
     delegate :main_app, to: :view_context
+    delegate :to_param, to: :class
 
     class << self
       delegate :context, to: ::Avo::Current
@@ -53,6 +51,23 @@ module Avo
           {}
         end
       end
+
+      def to_param
+        to_s
+      end
+
+      def link_arguments(resource:, **args)
+        path = Avo::Services::URIService.parse(resource.record.present? ? resource.record_path : resource.records_path)
+          .append_paths("actions")
+          .append_query(action_id: to_param, **args)
+          .to_s
+
+        data = {
+          turbo_frame: "actions_show",
+        }
+
+        [path, data]
+      end
     end
 
     def action_name
@@ -62,11 +77,15 @@ module Avo
     end
 
     def initialize(record: nil, resource: nil, user: nil, view: nil, arguments: {})
-      self.class.record = record
-      self.class.resource = resource
-      self.class.user = user
-      self.class.view = Avo::ViewInquirer.new(view)
-      @arguments = arguments
+      @record = record
+      @resource = resource
+      @user = user
+      @view = Avo::ViewInquirer.new(view)
+      @arguments = Avo::ExecutionContext.new(
+        target: arguments,
+        resource: resource,
+        record: record
+      ).handle.with_indifferent_access
 
       self.class.message ||= I18n.t("avo.are_you_sure_you_want_to_run_this_option")
       self.class.confirm_button_label ||= I18n.t("avo.run")
@@ -84,26 +103,17 @@ module Avo
     end
 
     def get_message
-      Avo::ExecutionContext.new(target: self.class.message, record: self.class.record, resource: self.class.resource).handle
-    end
-
-    def get_attributes_for_action
-      get_fields.map do |field|
-        value = field.value || Avo::ExecutionContext.new(
-          target: field.default,
-          record: self.class.record,
-          resource: self.class.resource,
-          view: view
-        ).handle
-
-        [field.id, value]
-      end.to_h
+      Avo::ExecutionContext.new(target: self.class.message, record: @record, resource: @resource).handle
     end
 
     def handle_action(**args)
       processed_fields = if args[:fields].present?
         # Fetching the field definitions and not the actual fields (get_fields) because they will break if the user uses a `visible` block and adds a condition using the `params` variable. The params are different in the show method and the handle method.
-        action_fields = get_field_definitions.map { |field| [field.id, field] }.to_h
+        action_fields = get_field_definitions.map do |field|
+          field.hydrate(resource: @resource)
+
+          [field.id, field]
+        end.to_h
 
         # For some fields, like belongs_to, the id and database_id differ (user vs user_id).
         # That's why we need to fetch the database_id for when we process the action.
@@ -134,6 +144,8 @@ module Avo
     end
 
     def visible_in_view(parent_resource: nil)
+      return false unless authorized?
+
       if visible.blank?
         # Hide on the :new view by default
         return false if view.new?
@@ -147,16 +159,12 @@ module Avo
         target: visible,
         params: params,
         parent_resource: parent_resource,
-        resource: self.class.resource,
-        view: self.class.view,
+        resource: @resource,
+        view: @view,
         arguments: arguments
       ).handle
     end
 
-    def param_id
-      self.class.to_s
-    end
-
     def succeed(text)
       add_message text, :success
 
@@ -220,13 +228,11 @@ module Avo
       self
     end
 
-    # We're overriding this method to hydrate with the proper resource attribute.
-    def hydrate_fields
-      fields.map do |field|
-        field.hydrate(record: @record, view: @view, resource: resource)
-      end
-
-      self
+    def authorized?
+      Avo::ExecutionContext.new(
+        target: authorize,
+        action: self
+      ).handle
     end
 
     private

data/lib/avo/base_resource.rb

@@ -10,6 +10,8 @@ module Avo
     include Avo::Concerns::ModelClassConstantized
     include Avo::Concerns::HasDescription
     include Avo::Concerns::HasHelpers
+    include Avo::Concerns::Hydration
+    include Avo::Concerns::Pagination
 
     # Avo::Current methods
     delegate :context, to: Avo::Current
@@ -232,6 +234,7 @@ module Avo
     delegate :underscore_name, to: :class
     delegate :find_record, to: :class
     delegate :model_key, to: :class
+    delegate :tab, to: :items_holder
 
     def initialize(record: nil, view: nil, user: nil, params: nil)
       @view = Avo::ViewInquirer.new(view) if view.present?
@@ -252,7 +255,7 @@ module Avo
     end
 
     def detect_fields
-      self.items_holder = Avo::Resources::Items::Holder.new
+      self.items_holder = Avo::Resources::Items::Holder.new(parent: self)
 
       # Used in testing to replace items
       if temporary_items.present?
@@ -321,14 +324,10 @@ module Avo
       end
     end
 
-    def hydrate(record: nil, view: nil, user: nil, params: nil)
-      @view = Avo::ViewInquirer.new(view) if view.present?
-      @user = user if user.present?
-      @params = params if params.present?
-
-      if record.present?
-        @record = record
+    def hydrate(...)
+      super(...)
 
+      if @record.present?
         hydrate_model_with_default_values if @view&.new?
       end
 

data/lib/avo/concerns/borrow_items_holder.rb

@@ -0,0 +1,35 @@
+module Avo
+  module Concerns
+    module BorrowItemsHolder
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :items_holder
+      end
+
+      class_methods do
+        def parse_block(parent:, **args, &block)
+          # item = Avo::Resources::Items:: ...
+          item = new(parent: parent, **args)
+
+          # Borrow the current items holder to the parent (parent = Action || Resource, etc.)
+          # Save parent's items holder to restore it after the block is parsed
+          # This is useful when you execute parent's methods like `some_fields_method` inside some DSL block.
+          # When you do that, Docile will not find the method in the current object (item), but in the parent.
+          # So we need to temporarily replace the parent's items holder with the current one because the parent's methods
+          # will be executed in the parent's context.
+          # For more context: https://github.com/ms-ati/docile/issues/107
+          parent_item_holder = parent.items_holder
+          parent.items_holder = item.items_holder
+
+          dsl_evaluation = Docile.dsl_eval(item, &block).build
+
+          # Restore the parent's items holder
+          parent.items_holder = parent_item_holder
+
+          dsl_evaluation
+        end
+      end
+    end
+  end
+end

data/lib/avo/concerns/has_items.rb

@@ -47,6 +47,7 @@ module Avo
       delegate :tool, to: :items_holder
       delegate :heading, to: :items_holder
       delegate :sidebar, to: :items_holder
+      delegate :main_panel, to: :items_holder
 
       def items_holder
         @items_holder || Avo::Resources::Items::Holder.new
@@ -57,7 +58,15 @@ module Avo
       # end
 
       def invalid_fields
-        items_holder.invalid_fields
+        invalid_fields = items_holder.invalid_fields
+
+        items_holder.items.each do |item|
+          if item.respond_to? :items
+            invalid_fields += item.invalid_fields
+          end
+        end
+
+        invalid_fields
       end
 
       def fields(**args)
@@ -101,6 +110,10 @@ module Avo
           if item.is_row?
             fields << extract_fields_from_items(tab)
           end
+
+          if item.is_main_panel?
+            fields << extract_fields_from_items(item)
+          end
         end
 
         fields.flatten
@@ -194,65 +207,56 @@ module Avo
           end
       end
 
-      # Separates the fields that are in a panel and those that are just hanging out.
-      # Take the ones that aren't placed into a panel and add them to the "default" panel.
-      # This is to keep compatibility with the versions before 2.10 when you didn't have the ability to add fields to panels.
       def get_items
-        panelless_items = []
-        panelfull_items = []
-
-        visible_items
-          .each do |item|
-            if item.is_field?
-              if item.has_own_panel?
-                panelfull_items << item
-              else
-                panelless_items << item
-              end
-            else
-              panelfull_items << item
-            end
-          end
-
-        # Make sure all tabs panelfull_items are setted as inside tabs
-        panelfull_items.grep(Avo::Resources::Items::TabGroup).each do |tab_group|
-          tab_group.items.grep(Avo::Resources::Items::Tab).each do |tab|
-            tab.items.grep(Avo::Resources::Items::Panel).each do |panel|
-              set_target_to_top panel.items.grep(Avo::Fields::BelongsToField)
+        # Each group is built only by standalone items or items that have their own panel, keeping the items order
+        grouped_items = visible_items.slice_when do |prev, curr|
+          # Slice when the item type changes from standalone to panel or vice-versa
+          is_standalone?(prev) != is_standalone?(curr)
+        end.to_a.map do |group|
+          { elements: group, is_standalone: is_standalone?(group.first) }
+        end
 
-              panel.items.grep(Avo::Resources::Items::Row).each do |row|
-                set_target_to_top row.items.grep(Avo::Fields::BelongsToField)
-              end
-            end
+        # Creates a main panel if it's missing and adds first standalone group of items if present
+        if items.none? { |item| item.is_main_panel? }
+          if (standalone_group = grouped_items.find { |group| group[:is_standalone] }).present?
+            calculated_main_panel = Avo::Resources::Items::MainPanel.new
+            hydrate_item calculated_main_panel
+            calculated_main_panel.items_holder.items = standalone_group[:elements]
+            grouped_items[grouped_items.index standalone_group] = { elements: [calculated_main_panel], is_standalone: false }
           end
         end
 
-        # Add all the panelles fields to a new panel
-        main_panel_holder = Avo::Resources::Items::Holder.new
-        main_panel_holder.items = panelless_items
-
-        # Add that panel to the main panel
-        main_panel = Avo::Resources::Items::MainPanel.new
-        main_panel.items_holder = main_panel_holder
+        # For each standalone group, wrap items in a panel
+        grouped_items.select { |group| group[:is_standalone] }.each do |group|
+          calculated_panel = Avo::Resources::Items::Panel.new
+          calculated_panel.items_holder.items = group[:elements]
+          hydrate_item calculated_panel
+          group[:elements] = calculated_panel
+        end
 
-        # Return all the items but this time with all the panelless ones inside the main panel
-        [main_panel, *panelfull_items]
+        grouped_items.flat_map { |group| group[:elements] }
       end
 
       def items
-        if items_holder.present?
-          items_holder.items
-        else
-          []
-        end
+        items_holder&.items || []
       end
 
       def visible_items
         items
           .map do |item|
-            if view.present?
-              res = self.class.ancestors.include?(Avo::BaseResource) ? self : resource
-              item.hydrate(view: view, resource: res)
+            hydrate_item item
+
+            if item.is_a? Avo::Resources::Items::TabGroup
+              # Set the target to _top for all belongs_to fields in the tab group
+              item.items.grep(Avo::Resources::Items::Tab).each do |tab|
+                tab.items.grep(Avo::Resources::Items::Panel).each do |panel|
+                  set_target_to_top panel.items.grep(Avo::Fields::BelongsToField)
+
+                  panel.items.grep(Avo::Resources::Items::Row).each do |row|
+                    set_target_to_top row.items.grep(Avo::Fields::BelongsToField)
+                  end
+                end
+              end
             end
 
             item
@@ -288,7 +292,9 @@ module Avo
               true
             end
           end
-          .compact
+          .select do |item|
+            !item.is_a?(Avo::Resources::Items::Sidebar)
+          end.compact
       end
 
       def is_empty?
@@ -316,6 +322,18 @@ module Avo
 
         fields
       end
+
+      # Standalone items are fields that don't have their own panel
+      def is_standalone?(item)
+        item.is_field? && !item.has_own_panel?
+      end
+
+      def hydrate_item(item)
+        return unless item.respond_to? :hydrate
+
+        res = self.class.ancestors.include?(Avo::BaseResource) ? self : resource
+        item.hydrate(view: view, resource: res)
+      end
     end
   end
 end

data/lib/avo/concerns/hydration.rb

@@ -0,0 +1,17 @@
+module Avo
+  module Concerns
+    module Hydration
+      extend ActiveSupport::Concern
+
+      def hydrate(**args)
+        args.each do |key, value|
+          value = Avo::ViewInquirer.new value if key == :view
+
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/avo/concerns/is_resource_item.rb

@@ -2,20 +2,12 @@
 module Avo
   module Concerns
     module IsResourceItem
+      include Avo::Concerns::Hydration
+
       # These attributes are required to be hydrated in order to properly find the visible_items
       attr_accessor :resource
       attr_accessor :view
 
-      def hydrate(**args)
-        args.each do |key, value|
-          if respond_to?("#{key}=")
-            send("#{key}=", value)
-          end
-        end
-
-        self
-      end
-
       # Returns the final state of if an item is visible or not
       # For items that have children it checks to see if it contains any visible children.
       def visible?

data/lib/avo/concerns/pagination.rb

@@ -0,0 +1,53 @@
+module Avo
+  module Concerns
+    module Pagination
+      extend ActiveSupport::Concern
+
+      included do
+        include Pagy::Backend
+
+        class_attribute :pagination, default: {}
+
+        PAGINATION_METHOD = {
+          default: :pagy,
+          countless: :pagy_countless,
+        } unless defined? PAGINATION_METHOD
+
+        PAGINATION_DEFAULTS = {
+          type: :default,
+          size: [1, 2, 2, 1],
+        } unless defined? PAGINATION_DEFAULTS
+      end
+
+      def pagination_type
+        @pagination_type ||= ActiveSupport::StringInquirer.new(pagination_hash[:type].to_s)
+      end
+
+      def apply_pagination(index_params:, query:)
+        extra_pagy_params = {}
+
+        # Reset open filters when a user navigates to a new page
+        extra_pagy_params[:keep_filters_panel_open] = if params[:keep_filters_panel_open] == "1"
+          "0"
+        end
+
+        send PAGINATION_METHOD[pagination_type.to_sym],
+          query,
+          items: index_params[:per_page],
+          link_extra: "data-turbo-frame=\"#{params[:turbo_frame]}\"",
+          params: extra_pagy_params,
+          size: pagination_hash[:size]
+      end
+
+      private
+
+      def pagination_hash
+        @pagination ||= PAGINATION_DEFAULTS.merge Avo::ExecutionContext.new(
+          target: pagination,
+          resource: self,
+          view: @view
+        ).handle
+      end
+    end
+  end
+end