avo 2.43.0 → 3.0.2

data/lib/avo/base_resource_tool.rb

@@ -1,36 +1,29 @@
 module Avo
   class BaseResourceTool
-    include Avo::Concerns::IsResourceItem
-    include Avo::Fields::FieldExtensions::VisibleInDifferentViews
+    prepend Avo::Concerns::IsResourceItem
+
+    include Avo::Concerns::HasItemType
+    include Avo::Concerns::IsVisible
+    include Avo::Concerns::VisibleInDifferentViews
 
     class_attribute :name
     class_attribute :partial
-    class_attribute :item_type, default: :tool
 
     attr_accessor :params
-    attr_accessor :resource
-    attr_accessor :view
 
     def initialize(**args)
       # Set the visibility
-      show_on Avo.configuration.resource_default_view
-
-      show_on args[:show_on] if args[:show_on].present?
-      hide_on args[:hide_on] if args[:hide_on].present?
-      only_on args[:only_on] if args[:only_on].present?
-      except_on args[:except_on] if args[:except_on].present?
-    end
+      only_on Avo.configuration.resource_default_view
 
-    def hydrate(view: nil)
-      @view = view if view.present?
+      @args = args
 
-      self
+      post_initialize if respond_to?(:post_initialize)
     end
 
     def partial
       return self.class.partial if self.class.partial.present?
 
-      "avo/resource_tools/#{self.class.to_s.underscore}"
+      self.class.to_s.underscore
     end
   end
 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/breadcrumbs.rb

@@ -50,7 +50,7 @@ module Avo
           when Symbol
             context.send(name)
           when Proc
-            name.call(context)
+            Avo::ExecutionContext.new(target: name, context: context).handle
           else
             name.to_s
           end
@@ -61,7 +61,7 @@ module Avo
           when Symbol
             context.send(path)
           when Proc
-            path.call(context)
+            Avo::ExecutionContext.new(target: path, context: context).handle
           else
             context.url_for(path)
           end

data/lib/avo/concerns/{can_replace_fields.rb → can_replace_items.rb}

@@ -1,28 +1,24 @@
 module Avo
   module Concerns
-    module CanReplaceFields
+    module CanReplaceItems
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :backup_items_holder
+        class_attribute :temporary_items
       end
 
       class_methods do
         def with_temporary_items(&block)
           # back-up the previous items
-          self.backup_items_holder = items_holder
-
-          self.items_holder = Avo::ItemsHolder.new
-
-          instance_eval(&block)
+          self.temporary_items = block
         end
 
         def restore_items_from_backup
-          self.items_holder = backup_items_holder if backup_items_holder.present?
+          self.temporary_items = nil
         end
 
         def with_new_items(&block)
-          self.items_holder = Avo::ItemsHolder.new
+          self.items_holder = Avo::Resources::Items::Holder.new
 
           instance_eval(&block)
         end

data/lib/avo/concerns/filters_session_handler.rb

@@ -26,16 +26,18 @@ module Avo
       end
 
       def filters_session_key
-        @filters_session_key ||= '/filters/' << %w[
+        @filters_session_key ||= "/filters/" << %w[
           turbo_frame controller resource_name related_name
           action id
-        ].map { |key| params[key] }.compact.join('/')
+        ].map { |key| params[key] }.compact.join("/")
       end
 
       def cache_resource_filters?
-        return Avo.configuration.cache_resource_filters unless Avo.configuration.cache_resource_filters.is_a?(Proc)
-
-        Avo.configuration.cache_resource_filters.call(current_user: current_user, resource: @resource)
+        Avo::ExecutionContext.new(
+          target: Avo.configuration.cache_resource_filters,
+          current_user: _current_user,
+          resource: @resource
+        ).handle
       end
     end
   end

data/lib/avo/concerns/has_controls.rb

@@ -0,0 +1,37 @@
+module Avo
+  module Concerns
+    module HasControls
+      extend ActiveSupport::Concern
+      include Avo::Resources::Controls
+
+      included do
+        class_attribute :show_controls
+        class_attribute :edit_controls
+        class_attribute :index_controls
+        class_attribute :row_controls
+      end
+
+      def render_show_controls
+        [BackButton.new, DeleteButton.new, DetachButton.new, ActionsList.new, EditButton.new]
+      end
+
+      def render_edit_controls
+        [BackButton.new(label: I18n.t("avo.cancel").capitalize), DeleteButton.new, ActionsList.new, SaveButton.new]
+      end
+
+      def render_index_controls(item:)
+        [AttachButton.new(item: item), ActionsList.new(as_index_control: true), CreateButton.new(item: item)]
+      end
+
+      def render_row_controls(item:)
+        [
+          OrderControls.new,
+          ShowButton.new(item: item),
+          EditButton.new(item: item),
+          DetachButton.new(item: item),
+          DeleteButton.new(item: item)
+        ]
+      end
+    end
+  end
+end

data/lib/avo/concerns/has_description.rb

@@ -0,0 +1,23 @@
+# Adds the ability to set the visibility of an item in the execution context.
+module Avo
+  module Concerns
+    module HasDescription
+      extend ActiveSupport::Concern
+
+      class_methods do
+        attr_accessor :description
+      end
+
+      def description
+        Avo::ExecutionContext.new(target: @description || self.class.description, **description_attributes).handle
+      end
+
+      private
+
+      # Override this method to add custom attributes to the description execution context.
+      def description_attributes
+        {}
+      end
+    end
+  end
+end

data/lib/avo/concerns/has_helpers.rb

@@ -0,0 +1,18 @@
+module Avo
+  module Concerns
+    module HasHelpers
+      def helpers
+        @helpers ||= Class.new do
+          def initialize
+            helper_names = ActionController::Base.all_helpers_from_path Rails.root.join("app", "helpers")
+            helpers = ActionController::Base.modules_for_helpers helper_names
+
+            helpers.each do |helper|
+              extend helper
+            end
+          end
+        end.new
+      end
+    end
+  end
+end

data/lib/avo/concerns/has_item_type.rb

@@ -0,0 +1,42 @@
+# This concern helps us figure out what kind of items (field, tool, tab_group, or panel) have been passed to the resource or action.
+module Avo
+  module Concerns
+    module HasItemType
+      def is_field?
+        self.class.ancestors.include?(Avo::Fields::BaseField)
+      end
+
+      def is_heading?
+        self.class.ancestors.include?(Avo::Fields::HeadingField)
+      end
+
+      def is_panel?
+        self.class.ancestors.include?(Avo::Resources::Items::Panel)
+      end
+
+      def is_main_panel?
+        self.class.ancestors.include?(Avo::Resources::Items::MainPanel)
+      end
+
+      def is_tool?
+        self.class.ancestors.include?(Avo::BaseResourceTool)
+      end
+
+      def is_tab?
+        self.class.ancestors.include?(Avo::Resources::Items::Tab)
+      end
+
+      def is_tab_group?
+        self.class.ancestors.include?(Avo::Resources::Items::TabGroup)
+      end
+
+      def is_sidebar?
+        self.class.ancestors.include?(Avo::Resources::Items::Sidebar)
+      end
+
+      def is_row?
+        self.class.respond_to?(:item_type) && self.class.item_type == :row
+      end
+    end
+  end
+end

data/lib/avo/concerns/has_items.rb

@@ -0,0 +1,339 @@
+module Avo
+  module Concerns
+    module HasItems
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def deprecated_dsl_api(name, method)
+          message = "This API was deprecated. Please use the `#{name}` method inside the `#{method}` method."
+          raise DeprecatedAPIError.new message
+        end
+
+        # DSL methods
+        def field(name, as: :text, **args, &block)
+          deprecated_dsl_api __method__, "fields"
+        end
+
+        def panel(name = nil, **args, &block)
+          deprecated_dsl_api __method__, "fields"
+        end
+
+        def row(**args, &block)
+          deprecated_dsl_api __method__, "fields"
+        end
+
+        def tabs(**args, &block)
+          deprecated_dsl_api __method__, "fields"
+        end
+
+        def tool(klass, **args)
+          deprecated_dsl_api __method__, "fields"
+        end
+
+        def sidebar(**args, &block)
+          deprecated_dsl_api __method__, "fields"
+        end
+        # END DSL methods
+      end
+
+      attr_writer :items_holder
+
+      delegate :invalid_fields, to: :items_holder
+
+      delegate :field, to: :items_holder
+      delegate :panel, to: :items_holder
+      delegate :row, to: :items_holder
+      delegate :tabs, to: :items_holder
+      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
+      end
+
+      # def items
+      #   items_holder.items
+      # end
+
+      def 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)
+        self.class.fields(**args)
+      end
+
+      def tab_groups
+        self.class.tab_groups
+      end
+
+      # Dives deep into panels and tabs to fetch all the fields for a resource.
+      def only_fields(only_root: false)
+        fields = []
+
+        items.each do |item|
+          next if item.nil?
+
+          unless only_root
+            # Dive into panels to fetch their fields
+            if item.is_panel?
+              fields << extract_fields_from_items(item)
+            end
+
+            # Dive into tabs to fetch their fields
+            if item.is_tab_group?
+              item.items.map do |tab|
+                fields << extract_fields_from_items(tab)
+              end
+            end
+
+            # Dive into sidebar to fetch their fields
+            if item.is_sidebar?
+              fields << extract_fields_from_items(item)
+            end
+          end
+
+          if item.is_field?
+            fields << item
+          end
+
+          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
+      end
+
+      def get_field_definitions(only_root: false)
+        only_fields(only_root: only_root).map do |field|
+          field.hydrate(resource: self, user: user, view: view)
+        end
+      end
+
+      def get_preview_fields
+        get_field_definitions.select do |field|
+          field.visible_in_view?(view: :preview)
+        end
+      end
+
+      def get_fields(panel: nil, reflection: nil, only_root: false)
+        fields = get_field_definitions(only_root: only_root)
+          .select do |field|
+            # Get the fields for this view
+            field.visible_in_view?(view: view)
+          end
+          .select do |field|
+            field.visible?
+          end
+          .select do |field|
+            is_valid = true
+
+            # Strip out the reflection field in index queries with a parent association.
+            if reflection.present?
+              # regular non-polymorphic association
+              # we're matching the reflection inverse_of foriegn key with the field's foreign_key
+              if field.is_a?(Avo::Fields::BelongsToField)
+                if field.respond_to?(:foreign_key) &&
+                    reflection.inverse_of.present? &&
+                    reflection.inverse_of.respond_to?(:foreign_key) &&
+                    reflection.inverse_of.foreign_key == field.foreign_key
+                  is_valid = false
+                end
+
+                # polymorphic association
+                if field.respond_to?(:foreign_key) &&
+                    field.is_polymorphic? &&
+                    reflection.respond_to?(:polymorphic?) &&
+                    reflection.inverse_of.respond_to?(:foreign_key) &&
+                    reflection.inverse_of.foreign_key == field.reflection.foreign_key
+                  is_valid = false
+                end
+              end
+            end
+
+            is_valid
+          end
+
+        if panel.present?
+          fields = fields.select do |field|
+            field.panel_name == panel
+          end
+        end
+
+        # hydrate_fields fields
+        fields.each do |field|
+          field.hydrate(record: @record, view: @view, resource: self)
+        end
+
+        fields
+      end
+
+      def get_field(id)
+        get_field_definitions.find do |f|
+          f.id == id.to_sym
+        end
+      end
+
+      def tools
+        return [] if self.class.tools.blank?
+
+        items
+          .select do |item|
+            next if item.nil?
+
+            item.is_tool?
+          end
+          .map do |tool|
+            tool.hydrate view: view
+            tool
+          end
+          .select do |item|
+            item.visible_in_view?(view: view)
+          end
+      end
+
+      def get_items
+        # 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
+
+        # 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
+
+        # 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
+
+        grouped_items.flat_map { |group| group[:elements] }
+      end
+
+      def items
+        items_holder&.items || []
+      end
+
+      def visible_items
+        items
+          .map do |item|
+            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
+          end
+          .select do |item|
+            item.visible?
+          end
+          .select do |item|
+            if item.respond_to?(:visible_in_view?)
+              item.visible_in_view? view: view
+            else
+              true
+            end
+          end
+          .select do |item|
+            # On location field we can have field coordinates and setters with different names like latitude and longitude
+            if !item.is_a?(Avo::Fields::LocationField) && !item.is_heading? && view.in?(%w[edit update new create])
+              if item.respond_to?(:id)
+                item.resource.record.respond_to?("#{item.id}=")
+              else
+                true
+              end
+            else
+              true
+            end
+          end
+          .select do |item|
+            # Check if the user is authorized to view it.
+            # This is usually used for has_* fields
+            if item.respond_to? :authorized?
+              item.authorized?
+            else
+              true
+            end
+          end
+          .select do |item|
+            !item.is_a?(Avo::Resources::Items::Sidebar)
+          end.compact
+      end
+
+      def is_empty?
+        visible_items.blank?
+      end
+
+      private
+
+      def set_target_to_top(fields)
+        fields.each do |field|
+          field.target = :_top
+        end
+      end
+
+      def extract_fields_from_items(thing)
+        fields = []
+
+        thing.items.each do |item|
+          if item.is_field?
+            fields << item
+          elsif item.is_panel? || item.is_row?
+            fields << extract_fields_from_items(item)
+          end
+        end
+
+        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,42 +2,22 @@
 module Avo
   module Concerns
     module IsResourceItem
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :item_type, default: nil
-      end
-
-      def is_field?
-        self.class.item_type == :field
-      end
-
-      def is_panel?
-        self.class.item_type == :panel || self.class.item_type == :main_panel
-      end
-
-      def is_main_panel?
-        self.class.item_type == :main_panel
-      end
-
-      def is_tool?
-        self.class.item_type == :tool
-      end
-
-      def is_tab?
-        self.class.item_type == :tab
-      end
-
-      def is_tab_group?
-        self.class.item_type == :tab_group
-      end
-
-      def is_sidebar?
-        self.class.item_type == :sidebar
-      end
-
-      def is_row?
-        self.class.item_type == :row
+      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
+
+      # 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?
+        # For items that may contains other items like tabs and panels we should also check
+        # if any on their children have visible items.
+        if self.class.ancestors.include?(Avo::Concerns::HasItems)
+          return false unless visible_items.any?
+        end
+
+        super
       end
     end
   end