avo 2.49.0 → 3.0.0.beta1

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/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

@@ -33,9 +33,11 @@ module Avo
       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_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,325 @@
+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 heading(body, **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
+
+      def items_holder
+        @items_holder || Avo::Resources::Items::Holder.new
+      end
+
+      # def items
+      #   items_holder.items
+      # end
+
+      def invalid_fields
+        items_holder.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
+        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
+
+      # 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)
+
+              panel.items.grep(Avo::Resources::Items::Row).each do |row|
+                set_target_to_top row.items.grep(Avo::Fields::BelongsToField)
+              end
+            end
+          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
+
+        # Return all the items but this time with all the panelless ones inside the main panel
+        [main_panel, *panelfull_items]
+      end
+
+      def items
+        if items_holder.present?
+          items_holder.items
+        else
+          []
+        end
+      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)
+            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?([: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
+          .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
+    end
+  end
+end

data/lib/avo/concerns/{has_resource_stimulus_controllers.rb → has_stimulus_controllers.rb}

@@ -1,6 +1,6 @@
 module Avo
   module Concerns
-    module HasResourceStimulusControllers
+    module HasStimulusControllers
       extend ActiveSupport::Concern
 
       included do

data/lib/avo/concerns/is_resource_item.rb

@@ -2,42 +2,30 @@
 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
+      # 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?
+        # 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

data/lib/avo/concerns/is_visible.rb

@@ -0,0 +1,15 @@
+# Adds the ability to set the visibility of an item in the execution context.
+module Avo
+  module Concerns
+    module IsVisible
+      attr_accessor :visible
+
+      def visible?
+        # Default to true
+        return true if visible.nil?
+
+        Avo::ExecutionContext.new(target: visible, resource: @resource).handle
+      end
+    end
+  end
+end

data/lib/avo/concerns/model_class_constantized.rb

@@ -4,8 +4,6 @@ module Avo
       extend ActiveSupport::Concern
 
       class_methods do
-        attr_reader :model_class
-
         # Cast the model class to a constantized version and memoize it like that
         def model_class=(value)
           @model_class = case value