avo 2.9.2.pre1 → 2.10.0

data/lib/avo/base_resource.rb

@@ -4,10 +4,10 @@ module Avo
     extend HasContext
 
     include ActionView::Helpers::UrlHelper
-    include Avo::Concerns::HasTools
     include Avo::Concerns::HasModel
     include Avo::Concerns::HasFields
     include Avo::Concerns::HasStimulusControllers
+    include Avo::Concerns::ModelClassConstantized
 
     delegate :view_context, to: ::Avo::App
     delegate :simple_format, :content_tag, to: :view_context
@@ -29,7 +29,6 @@ module Avo
     class_attribute :search_query, default: nil
     class_attribute :search_query_help, default: ""
     class_attribute :includes, default: []
-    class_attribute :model_class
     class_attribute :translation_key
     class_attribute :default_view_type, default: :table
     class_attribute :devise_password_optional, default: false
@@ -44,7 +43,6 @@ module Avo
     class_attribute :hide_from_global_search, default: false
     class_attribute :after_create_path, default: :show
     class_attribute :after_update_path, default: :show
-    class_attribute :invalid_fields
     class_attribute :record_selector, default: true
     class_attribute :keep_filters_panel_open, default: false
 
@@ -123,80 +121,6 @@ module Avo
       self
     end
 
-    def get_field_definitions
-      return [] if self.class.fields.blank?
-
-      fields = self.class.fields.map do |field|
-        field.hydrate(resource: self, panel_name: default_panel_name, user: user)
-      end
-
-      if Avo::App.license.lacks_with_trial(:custom_fields)
-        fields = fields.reject do |field|
-          field.custom?
-        end
-      end
-
-      if Avo::App.license.lacks_with_trial(:advanced_fields)
-        fields = fields.reject do |field|
-          field.type == "tags"
-        end
-      end
-
-      fields
-    end
-
-    def get_fields(panel: nil, reflection: nil)
-      fields = get_field_definitions
-        .select do |field|
-          field.send("show_on_#{@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.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.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(model: @model, view: @view)
-
-      fields
-    end
-
-    def get_field(id)
-      get_field_definitions.find do |f|
-        f.id == id.to_sym
-      end
-    end
-
     def get_grid_fields
       return if self.class.grid_loader.blank?
 
@@ -215,14 +139,6 @@ module Avo
       self.class.actions_loader.bag
     end
 
-    def hydrate_fields(model: nil, view: nil)
-      fields.map do |field|
-        field.hydrate(model: @model, view: @view, resource: self)
-      end
-
-      self
-    end
-
     def default_panel_name
       return @params[:related_name].capitalize if @params.present? && @params[:related_name].present?
 
@@ -236,16 +152,6 @@ module Avo
       end
     end
 
-    def panels
-      [
-        {
-          name: default_panel_name,
-          type: :fields,
-          in_panel: true
-        }
-      ]
-    end
-
     def class_name_without_resource
       self.class.name.demodulize.chomp("Resource")
     end

data/lib/avo/base_resource_tool.rb

@@ -1,9 +1,11 @@
 module Avo
   class BaseResourceTool
+    include Avo::Concerns::IsResourceItem
     include Avo::Fields::FieldExtensions::VisibleInDifferentViews
 
     class_attribute :name
     class_attribute :partial
+    class_attribute :item_type, default: :tool
 
     attr_accessor :params
     attr_accessor :resource
@@ -20,7 +22,7 @@ module Avo
     end
 
     def hydrate(view: nil)
-      @view = view
+      @view = view if view.present?
 
       self
     end

data/lib/avo/concerns/handles_field_args.rb

@@ -28,7 +28,7 @@ module Avo
         add_prop_from_args args, name: name, default: default, type: :array
       end
 
-      def add_string_prop(args, name, default = nil)
+      def add_string_prop(args, name, default = [])
         add_prop_from_args args, name: name, default: default, type: :string
       end
     end

data/lib/avo/concerns/has_fields.rb

@@ -4,88 +4,285 @@ module Avo
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :fields
-        class_attribute :fields_index, default: 0
+        class_attribute :items_holder
+        class_attribute :items_index, default: 0
+        class_attribute :tabs_holder
+        class_attribute :tabs_tabs_holder
+        class_attribute :raw_tabs
+        class_attribute :tools_holder
       end
 
       class_methods do
-        def field(field_name, as:, **args, &block)
-          self.invalid_fields ||= []
+        delegate :tool, to: :items_holder
 
-          field_instance = parse_field(field_name, as: as, order_index: fields_index, **args, &block)
+        # DSL methods
+        def field(name, **args, &block)
+          ensure_items_holder_initialized
 
-          if field_instance.present?
-            add_to_fields field_instance
+          self.items_holder.field name, **args, &block
+        end
+
+        def panel(name = nil, **args, &block)
+          ensure_items_holder_initialized
+
+          self.items_holder.panel name, **args, &block
+        end
+
+        def tabs(&block)
+          ensure_items_holder_initialized
+
+          self.items_holder.tabs Avo::TabGroupBuilder.parse_block(&block)
+        end
+
+        def heading(body, **args)
+          self.items_holder.add_item Avo::Fields::HeadingField.new(body, order_index: items_index, **args)
+        end
+        # END DSL methods
+
+        def items
+          if self.items_holder.present?
+            self.items_holder.items
           else
-            self.invalid_fields << ({
-              name: field_name,
-              as: as,
-              resource: name,
-              message: "There's an invalid field configuration for this resource. <br/> <code class='px-1 py-px rounded bg-red-600'>field :#{field_name}, as: #{as}</code>"
-            })
+            []
           end
         end
 
-        def parse_field(field_name, as:, **args, &block)
-          # The field is passed as a symbol eg: :text, :color_picker, :trix
-          if as.is_a? Symbol
-            parse_symbol field_name, as: as, **args, &block
-          elsif as.is_a? Class
-            parse_class field_name, as: as, **args, &block
+        def tools
+          self.tools_holder
+        end
+
+        # Dives deep into panels and tabs to fetch all the fields for a resource.
+        def fields(only_root: false)
+          fields = []
+
+          self.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
+            end
+
+
+            if item.is_field?
+              fields << item
+            end
           end
+
+          fields.flatten
         end
 
-        def heading(body, **args)
-          add_to_fields Avo::Fields::HeadingField.new(body, order_index: fields_index, **args)
+        def tab_groups
+          self.items.select do |item|
+            item.instance_of? Avo::TabGroup
+          end
         end
 
         private
 
+        def extract_fields_from_items(thing)
+          fields = []
+
+          thing.items.each do |item|
+            if item.is_field?
+              fields << item
+            elsif item.is_panel?
+              fields << extract_fields_from_items(item)
+            end
+          end
+
+          fields
+        end
+
+        def ensure_items_holder_initialized
+          self.items_holder ||= Avo::ItemsHolder.new
+        end
+
         def add_to_fields(instance)
-          self.fields ||= []
-          self.fields << instance
-          self.fields_index += 1
+          self.items ||= []
+          self.items << instance
+          increment_order_index
         end
 
-        def instantiate_field(field_name, klass:, **args, &block)
-          if block
-            klass.new(field_name, **args || {}, &block)
-          else
-            klass.new(field_name, **args || {})
-          end
+        def increment_order_index
+          self.items_index += 1
+        end
+      end
+
+      delegate :invalid_fields, to: :items_holder
+      delegate :items, to: :items_holder
+
+      def hydrate_fields(model: nil, view: nil)
+        fields.map do |field|
+          field.hydrate(model: @model, view: @view, resource: self)
+        end
+
+        self
+      end
+
+      def get_tabs
+        tabs_holder
+      end
+
+      def fields(**args)
+        self.class.fields(**args)
+      end
+
+      def tab_groups
+        self.class.tab_groups
+      end
+
+      def get_field_definitions(only_root: false)
+        fields = self.fields(only_root: only_root)
+
+        return [] if fields.blank?
+
+        items = fields.map do |field|
+          field.hydrate(resource: self, user: user, view: view)
         end
 
-        def field_class_from_symbol(symbol)
-          matched_field = Avo::App.fields.find do |field|
-            field[:name].to_s == symbol.to_s
+        if Avo::App.license.lacks_with_trial(:custom_fields)
+          items = items.reject do |field|
+            field.custom?
           end
+        end
 
-          return matched_field[:class] if matched_field.present? && matched_field[:class].present?
+        if Avo::App.license.lacks_with_trial(:advanced_fields)
+          items = items.reject do |field|
+            field.type == "tags"
+          end
         end
 
-        def parse_symbol(field_name, as:, **args, &block)
-          field_class = field_class_from_symbol(as)
+        items
+      end
 
-          if field_class.present?
-            # The field has been registered before.
-            instantiate_field(field_name, klass: field_class, **args, &block)
-          else
-            # The symbol can be transformed to a class and found.
-            class_name = as.to_s.camelize
-            field_class = "#{class_name}Field"
+      def get_fields(panel: nil, reflection: nil, only_root: false)
+        fields = get_field_definitions(only_root: only_root)
+          .select do |field|
+            field.visible_on?(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.foreign_key == field.foreign_key
+                  is_valid = false
+                end
 
-            # Discover & load custom field classes
-            if Object.const_defined? field_class
-              instantiate_field(field_name, klass: field_class.safe_constantize, **args, &block)
+                # polymorphic association
+                if field.respond_to?(:foreign_key) &&
+                    field.is_polymorphic? &&
+                    reflection.respond_to?(:polymorphic?) &&
+                    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
 
-        def parse_class(field_name, as:, **args, &block)
-          # The field has been passed as a class.
-          if Object.const_defined? as.to_s
-            instantiate_field(field_name, klass: as, **args, &block)
+        hydrate_fields(model: @model, view: @view)
+
+        fields
+      end
+
+      def get_field(id)
+        get_field_definitions.find do |f|
+          f.id == id.to_sym
+        end
+      end
+
+      def tools
+        check_license
+
+        return [] if App.license.lacks_with_trial :resource_tools
+        return [] if self.class.tools.blank?
+
+        self.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_on?(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 = []
+
+        items.each do |item|
+          # fields and tabs can be hidden on some views
+          if item.respond_to? :visible_on?
+            next unless item.visible_on?(view)
+          end
+          if item.respond_to? :visible?
+            next unless item.visible?
+          end
+
+          if item.is_field?
+            if item.has_own_panel?
+              panelfull_items << item
+            else
+              panelless_items << item
+            end
+          else
+            panelfull_items << item
+          end
+        end
+
+        # Add all the panelles fields to a new panel
+        main_panel_holder = Avo::ItemsHolder.new
+        main_panel_holder.items = panelless_items
+
+        # Add that panel to the main panel
+        main_panel = Avo::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
+
+      private
+
+      def check_license
+        if !Rails.env.production? && App.license.present? && App.license.lacks(:resource_tools)
+          # Add error message to let the developer know the resource tool will not be available in a production environment.
+          Avo::App.error_messages.push "Warning: Your license is invalid or doesn't support resource tools. The resource tools will not be visible in a production environment."
         end
       end
     end

data/lib/avo/concerns/has_html_attributes.rb

@@ -50,7 +50,7 @@ module Avo
       end
 
       def add_default_data_attributes(attributes, name, element, view)
-        if !attributes.nil? && name == :data && element == :input && view.in?([:edit, :new]) && resource.present?
+        if !attributes.nil? && name == :data && element == :input && view.in?([:edit, :new]) && resource.present? && resource.respond_to?(:get_stimulus_controllers)
           extra_attributes = resource.get_stimulus_controllers
             .split(" ")
             .map do |controller|

data/lib/avo/concerns/is_resource_item.rb

@@ -0,0 +1,36 @@
+# 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 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
+    end
+  end
+end

data/lib/avo/concerns/model_class_constantized.rb

@@ -0,0 +1,23 @@
+module Avo
+  module Concerns
+    module ModelClassConstantized
+      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
+          when Class
+            value
+          when String, Symbol
+            value.to_s.safe_constantize
+          else
+            raise ArgumentError.new "Failed to find a proper model class for #{self.to_s}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avo/dashboards/base_dashboard.rb

@@ -65,7 +65,7 @@ module Avo
         end
 
         def navigation_path
-          "#{Avo::App.root_path}/dashboards/#{id}"
+          Avo::App.view_context.avo.dashboard_path id
         end
 
         def is_visible?

data/lib/avo/dsl/field_parser.rb

@@ -0,0 +1,83 @@
+module Avo
+  module Dsl
+    class FieldParser
+      attr_reader :as
+      attr_reader :args
+      attr_reader :id
+      attr_reader :block
+      attr_reader :instance
+      attr_reader :order_index
+
+      def initialize(id:, order_index: 0, **args, &block)
+        @id = id
+        @as = args.fetch(:as, nil)
+        @order_index = order_index
+        @args = args
+        @block = block
+        @instance = nil
+      end
+
+      def valid?
+        instance.present?
+      end
+
+      def invalid?
+        !valid?
+      end
+
+      def parse
+        # The field is passed as a symbol eg: :text, :color_picker, :trix
+        @instance = if as.is_a? Symbol
+          parse_from_symbol
+        elsif as.is_a? Class
+          parse_from_class
+        end
+
+        self
+      end
+
+      private
+
+      def parse_from_symbol
+        field_class = field_class_from_symbol(as)
+
+        if field_class.present?
+          # The field has been registered before.
+          instantiate_field(id, klass: field_class, **args, &block)
+        else
+          # The symbol can be transformed to a class and found.
+          class_name = as.to_s.camelize
+          field_class = "#{class_name}Field"
+
+          # Discover & load custom field classes
+          if Object.const_defined? field_class
+            instantiate_field(id, klass: field_class.safe_constantize, **args, &block)
+          end
+        end
+      end
+
+      def parse_from_class
+        # The field has been passed as a class.
+        if Object.const_defined? as.to_s
+          instantiate_field(id, klass: as, **args, &block)
+        end
+      end
+
+      def instantiate_field(id, klass:, **args, &block)
+        if block
+          klass.new(id, **args || {}, &block)
+        else
+          klass.new(id, **args || {})
+        end
+      end
+
+      def field_class_from_symbol(symbol)
+        matched_field = Avo::App.fields.find do |field|
+          field[:name].to_s == symbol.to_s
+        end
+
+        return matched_field[:class] if matched_field.present? && matched_field[:class].present?
+      end
+    end
+  end
+end