avo 2.9.1.pre5 → 2.10.0

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

data/lib/avo/fields/base_field.rb

@@ -4,8 +4,11 @@ module Avo
       extend ActiveSupport::DescendantsTracker
       extend Avo::Fields::FieldExtensions::HasFieldName
 
-      include Avo::Fields::FieldExtensions::VisibleInDifferentViews
+      include Avo::Concerns::IsResourceItem
+      include Avo::Concerns::HandlesFieldArgs
+
       include ActionView::Helpers::UrlHelper
+      include Avo::Fields::FieldExtensions::VisibleInDifferentViews
 
       include Avo::Concerns::HandlesFieldArgs
       include Avo::Concerns::HasHTMLAttributes
@@ -48,8 +51,9 @@ module Avo
       attr_reader :panel_name
 
       class_attribute :field_name_attribute
+      class_attribute :item_type, default: :field
 
-      def initialize(id, _options: {}, **args, &block)
+      def initialize(id, **args, &block)
         super(id, **args, &block)
 
         @id = id
@@ -206,9 +210,14 @@ module Avo
 
       # Try and build the component class or fallback to a blank one
       def component_for_view(view = :index)
+        # Use the edit variant for all "update" views
+        view = :edit if view.in? [:new, :create, :update]
+
         component_class = "::Avo::Fields::#{view_component_name}::#{view.to_s.camelize}Component"
         component_class.constantize
       rescue
+        # When returning nil, a race condition happens and throws an error in some environments.
+        # See https://github.com/avo-hq/avo/pull/365
         ::Avo::BlankFieldComponent
       end
 
@@ -228,6 +237,14 @@ module Avo
         true
       end
 
+      def visible_in_reflection?
+        true
+      end
+
+      def hidden_in_reflection?
+        !visible_in_reflection?
+      end
+
       private
 
       def model_or_class(model)

data/lib/avo/fields/field_extensions/visible_in_different_views.rb

@@ -7,13 +7,20 @@ module Avo
         attr_accessor :show_on_new
         attr_accessor :show_on_edit
 
-        def initialize(id, **args, &block)
+        def initialize(id = nil, **args, &block)
           @show_on_index = @show_on_index.nil? ? true : @show_on_index
           @show_on_show = @show_on_show.nil? ? true : @show_on_show
           @show_on_new = @show_on_new.nil? ? true : @show_on_new
           @show_on_edit = @show_on_edit.nil? ? true : @show_on_edit
         end
 
+        # Validates if the field is visible on certain view
+        def visible_on?(view)
+          raise "No view specified on visibility check." if view.blank?
+
+          send :"show_on_#{view.to_s}"
+        end
+
         def show_on(*where)
           return show_on_all if where.include? :all
 
@@ -44,6 +51,16 @@ module Avo
           end
         end
 
+        # When submitting the form on creation, the new page will be create but we don't have a visibility marker for create so we'll default to new
+        def show_on_create
+          show_on_new
+        end
+
+        # When submitting the form on update, the new page will be create but we don't have a visibility marker for update so we'll default to edit
+        def show_on_update
+          show_on_edit
+        end
+
         private
 
         def show_on_view(view)

data/lib/avo/fields/has_base_field.rb

@@ -29,7 +29,10 @@ module Avo
       end
 
       def frame_url
-        "#{@resource.record_path}/#{id}?turbo_frame=#{turbo_frame}"
+        Avo::Services::URIService.parse(@resource.record_path)
+          .append_path(id.to_s)
+          .append_query(turbo_frame: turbo_frame.to_s)
+          .to_s
       end
 
       # The value
@@ -59,6 +62,22 @@ module Avo
       def placeholder
         @placeholder || I18n.t("avo.choose_an_option")
       end
+
+      def has_own_panel?
+        true
+      end
+
+      def visible_in_reflection?
+        false
+      end
+
+      # Adds the view override component
+      # has_one, has_many, has_and_belongs_to_many fields don't have edit views
+      def component_for_view(view = :index)
+        view = :show if view.in? [:new, :create, :update, :edit]
+
+        super view
+      end
     end
   end
 end

data/lib/avo/fields/has_one_field.rb

@@ -22,7 +22,10 @@ module Avo
       end
 
       def frame_url
-        "#{@resource.record_path}/#{id}/#{value.id}?turbo_frame=#{turbo_frame}"
+        Avo::Services::URIService.parse(@resource.record_path)
+          .append_paths(id, value.id)
+          .append_query(turbo_frame: turbo_frame)
+          .to_s
       end
 
       def fill_field(model, key, value, params)

data/lib/avo/grid_collector.rb

@@ -13,15 +13,18 @@ module Avo
     end
 
     def cover(field_name, as:, **args, &block)
-      self.cover_field = self.class.parse_field(field_name, as: as, **args, &block)
+      field_parser = Avo::Dsl::FieldParser.new(id: field_name, as: as, order_index: items_index, **args, &block).parse
+      self.cover_field = field_parser.instance if field_parser.valid?
     end
 
     def title(field_name, as:, **args, &block)
-      self.title_field = self.class.parse_field(field_name, as: as, **args, &block)
+      field_parser = Avo::Dsl::FieldParser.new(id: field_name, as: as, order_index: items_index, **args, &block).parse
+      self.title_field = field_parser.instance if field_parser.valid?
     end
 
     def body(field_name, as:, **args, &block)
-      self.body_field = self.class.parse_field(field_name, as: as, **args, &block)
+      field_parser = Avo::Dsl::FieldParser.new(id: field_name, as: as, order_index: items_index, **args, &block).parse
+      self.body_field = field_parser.instance if field_parser.valid?
     end
 
     def hydrate(model:, view:, resource:)