avo 2.9.2.pre1 → 2.10.3.pre.1

data/lib/avo/concerns/has_fields.rb

@@ -4,88 +4,287 @@ 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.respond_to?(:foreign_key) &&
+                    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.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
 
-        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/configuration.rb

@@ -40,7 +40,7 @@ module Avo
       @per_page = 24
       @per_page_steps = [12, 24, 48, 72]
       @via_per_page = 8
-      @locale = "en-US"
+      @locale = nil
       @currency = "USD"
       @default_view_type = :table
       @license = "community"
@@ -78,16 +78,6 @@ module Avo
       @profile_menu = nil
     end
 
-    def locale_tag
-      ::ISO::Tag.new(locale)
-    end
-
-    def language_code
-      locale_tag.language.code
-    rescue
-      "en"
-    end
-
     def current_user_method(&block)
       @current_user = block if block.present?
     end
@@ -123,7 +113,7 @@ module Avo
     end
 
     def computed_root_path
-      Avo::App.root_path
+      Avo.configuration.root_path
     end
 
     def feature_enabled?(feature)

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
@@ -72,6 +76,8 @@ module Avo
         @index_text_align = args[:index_text_align] || :left
         @html = args[:html] || nil
 
+        @args = args
+
         @updatable = true
         @computable = true
         @computed = block.present?
@@ -206,9 +212,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 +239,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/country_field.rb

@@ -1,6 +1,8 @@
 module Avo
   module Fields
     class CountryField < BaseField
+      include Avo::Fields::FieldExtensions::HasIncludeBlank
+
       attr_reader :countries
       attr_reader :display_code
 

data/lib/avo/fields/date_field.rb

@@ -3,26 +3,30 @@ module Avo
     class DateField < TextField
       attr_reader :first_day_of_week
       attr_reader :picker_format
+      attr_reader :disable_mobile
       attr_reader :format
       attr_reader :relative
 
       def initialize(id, **args, &block)
         super(id, **args, &block)
 
-        @first_day_of_week = args[:first_day_of_week].present? ? args[:first_day_of_week].to_i : 0
-        @picker_format = args[:picker_format].present? ? args[:picker_format] : "Y-m-d"
-        @format = args[:format].present? ? args[:format] : :long
-        @relative = args[:relative].present? ? args[:relative] : false
+        add_string_prop args, :first_day_of_week, 0
+        add_string_prop args, :picker_format, "Y-m-d"
+        add_string_prop args, :format, "yyyy-LL-dd"
+        add_boolean_prop args, :relative
+        add_boolean_prop args, :disable_mobile
       end
 
       def formatted_value
         return if value.blank?
 
-        if @format.is_a?(Symbol)
-          value.to_formatted_s(@format)
-        else
-          value.strftime(@format)
-        end
+        value.iso8601
+      end
+
+      def edit_formatted_value
+        return nil if value.nil?
+
+        value.iso8601
       end
     end
   end

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

@@ -0,0 +1,17 @@
+module Avo
+  module Fields
+    module FieldExtensions
+      module HasIncludeBlank
+        def include_blank
+          if @args[:include_blank] == true
+            placeholder || '—'
+          elsif @args[:include_blank] == false
+            false
+          else
+            @args[:include_blank]
+          end
+        end
+      end
+    end
+  end
+end