avo 3.0.0.pre13 → 3.0.0.pre14

data/config/initializers/pagy.rb

@@ -5,13 +5,15 @@ def pagy_locale_path(file_name)
   Avo::Engine.root.join("lib", "generators", "avo", "templates", "locales", "pagy", file_name)
 end
 
-Pagy::I18n.load(
-  { locale: 'en' },
-  { locale: 'fr' },
-  { locale: 'nb' },
-  { locale: 'pt-BR' },
-  { locale: 'pt' },
-  { locale: 'tr' },
-  { locale: 'nn', filepath: pagy_locale_path("nn.yml") },
-  { locale: 'ro', filepath: pagy_locale_path("ro.yml") },
-)
+extra_locales = [
+  {locale: "en"},
+  {locale: "fr"},
+  {locale: "nb"},
+  {locale: "pt-BR"},
+  {locale: "pt"},
+  {locale: "tr"},
+  {locale: "nn", filepath: pagy_locale_path("nn.yml")},
+  {locale: "ro", filepath: pagy_locale_path("ro.yml")}
+]
+
+Pagy::I18n.send(:build, *extra_locales)

data/config/routes.rb

@@ -4,9 +4,9 @@ Avo::Engine.routes.draw do
   get "resources", to: redirect(Avo.configuration.root_path)
   get "dashboards", to: redirect(Avo.configuration.root_path)
 
-  mount AvoFilters::Engine, at: "/avo_filters" if defined?(AvoFilters)
-  mount AvoDashboards::Engine, at: "/dashboards" if defined?(AvoDashboards::Engine)
-  mount AvoPro::Engine, at: "/avo_pro" if defined?(AvoPro)
+  mount Avo::DynamicFilters::Engine, at: "/avo-dynamic_filters" if defined?(Avo::DynamicFilters::Engine)
+  mount Avo::Dashboards::Engine, at: "/dashboards" if defined?(Avo::Dashboards::Engine)
+  mount Avo::Pro::Engine, at: "/avo/avo-pro" if defined?(Avo::Pro::Engine)
 
   post "/rails/active_storage/direct_uploads", to: "/active_storage/direct_uploads#create"
 

data/db/factories.rb

@@ -110,7 +110,8 @@ FactoryBot.define do
   factory :city do
     name { Faker::Address.city }
     population { rand(10000..999000) }
-    coordinates { [Faker::Address.latitude, Faker::Address.longitude] }
+    latitude { Faker::Address.latitude }
+    longitude { Faker::Address.longitude }
     is_capital { [true, false].sample }
     features { Faker::Address.community }
     metadata { Faker::Address.community }

data/lib/avo/base_action.rb

@@ -101,12 +101,15 @@ module Avo
       records, fields, current_user, resource = args.values_at(:records, :fields, :current_user, :resource)
       # Fetching the field definitions and not the actual fields (get_fields) because they will break if the user uses a `visible` block and adds a condition using the `params` variable. The params are different in the show method and the handle method.
       action_fields = get_field_definitions.map { |field| [field.id, field] }.to_h
+      puts ["action_fields->", action_fields].inspect
 
       # For some fields, like belongs_to, the id and database_id differ (user vs user_id).
       # That's why we need to fetch the database_id for when we process the action.
       action_fields_by_database_id = action_fields.map do |id, value|
         [value.database_id.to_sym, value]
       end.to_h
+      puts ["action_fields_by_database_id->", action_fields_by_database_id].inspect
+      abort 1.inspect
 
       if fields.present?
         processed_fields = fields.to_unsafe_h.map do |name, value|
@@ -128,7 +131,7 @@ module Avo
         resource: resource
       }
 
-      args[:records] = records unless standalone
+      args[:records] = records
 
       handle(**args)
 

data/lib/avo/base_resource.rb

@@ -84,6 +84,8 @@ module Avo
       end
 
       # This resolves the scope when doing "where" queries (not find queries)
+      #
+      # It's used to apply the authorization feature.
       def query_scope
         authorization.apply_policy Avo::ExecutionContext.new(
           target: index_query,
@@ -92,6 +94,8 @@ module Avo
       end
 
       # This resolves the scope when finding records (not "where" queries)
+      #
+      # It's used to apply the authorization feature.
       def find_scope
         authorization.apply_policy model_class
       end
@@ -127,8 +131,31 @@ module Avo
         end
       end
 
+      # Returns the model class being used for this resource.
+      #
+      # The Resource instance has a model_class method too so it can support the STI use cases
+      # where we figure out the model class from the record
+      def model_class(record_class: nil)
+        # get the model class off of the static property
+        return @model_class if @model_class.present?
+
+        # get the model class off of the record for STI models
+        return record_class if record_class.present?
+
+        # generate a model class
+        class_name.safe_constantize
+      end
+
+      # This is used as the model class ID
+      # We use this instead of the route_key to maintain compatibility with uncountable models
+      # With uncountable models route key appends an _index suffix (Fish->fish_index)
+      # Example: User->users, MediaItem->media_items, Fish->fish
+      def model_key
+        model_class.model_name.plural
+      end
+
       def class_name
-        name.demodulize
+        to_s.demodulize
       end
 
       def route_key
@@ -138,11 +165,81 @@ module Avo
       def singular_route_key
         route_key.singularize
       end
+
+      def translation_key
+        @translation_key || "avo.resource_translations.#{class_name.underscore}"
+      end
+
+      def name
+        default = class_name.underscore.humanize
+
+        if translation_key
+          t(translation_key, count: 1, default: default).capitalize
+        else
+          default
+        end
+      end
+      alias_method :singular_name, :name
+
+      def plural_name
+        default = name.pluralize
+
+        if translation_key
+          t(translation_key, count: 2, default: default).capitalize
+        else
+          default
+        end
+      end
+
+      def underscore_name
+        return @name if @name.present?
+
+        name.demodulize.underscore
+      end
+
+      def navigation_label
+        plural_name.humanize
+      end
+
+      def find_record(id, query: nil, params: nil)
+        Avo::ExecutionContext.new(
+          target: find_record_method,
+          query: query || find_scope, # If no record is given we'll use the default
+          id: id,
+          params: params
+        ).handle
+      end
+
+      def search_query
+        search.dig(:query)
+      end
+
+      def fetch_search(key, record: nil)
+        # self.class.fetch_search
+        Avo::ExecutionContext.new(target: search[key], resource: self, record: record).handle
+      end
     end
 
     delegate :context, to: ::Avo::Current
+    delegate :name, to: :class
+    delegate :singular_name, to: :class
+    delegate :plural_name, to: :class
+    delegate :underscore_name, to: :class
+    delegate :underscore_name, to: :class
+    delegate :find_record, to: :class
+    delegate :model_key, to: :class
+
+    def initialize(record: nil, view: nil, user: nil, params: nil)
+      @view = view if view.present?
+      @user = user if user.present?
+      @params = params if params.present?
+
+      if record.present?
+        @record = record
+
+        hydrate_model_with_default_values if @view == :new
+      end
 
-    def initialize
       detect_fields
 
       unless self.class.model_class.present?
@@ -194,7 +291,7 @@ module Avo
 
       # def get_action_arguments / def get_filter_arguments / def get_scope_arguments
       define_method "get_#{entity}_arguments" do |entity_class|
-        send("get_#{plural_entity}").find { |entity| entity[:class] == entity_class.constantize }[:arguments]
+        send("get_#{plural_entity}").find { |entity| entity[:class].to_s == entity_class.to_s }[:arguments]
       end
     end
 
@@ -225,15 +322,14 @@ module Avo
       end
     end
 
+    # Returns the model class being used for this resource.
+    #
+    # We use the class method as a fallback but we pass it the record too so it can support the STI use cases
+    # where we figure out the model class from that record.
     def model_class
-      # get the model class off of the static property
-      return self.class.model_class if self.class.model_class.present?
-
-      # get the model class off of the record
-      return @record.base_class if @record.present?
+      record_class = @record&.class
 
-      # generate a model class
-      class_name.safe_constantize
+      self.class.model_class record_class: record_class
     end
 
     def record_title
@@ -251,46 +347,6 @@ module Avo
       end
     end
 
-    def translation_key
-      self.class.translation_key || "avo.resource_translations.#{class_name.underscore}"
-    end
-
-    def name
-      return @name if @name.present?
-
-      default = class_name.underscore.humanize
-
-      if translation_key
-        t(translation_key, count: 1, default: default).capitalize
-      else
-        default
-      end
-    end
-
-    def singular_name
-      name
-    end
-
-    def plural_name
-      default = name.pluralize
-
-      if translation_key
-        t(translation_key, count: 2, default: default).capitalize
-      else
-        default
-      end
-    end
-
-    def underscore_name
-      return @name if @name.present?
-
-      self.class.name.demodulize.underscore
-    end
-
-    def navigation_label
-      plural_name.humanize
-    end
-
     def available_view_types
       if self.class.view_types.present?
         return Array(
@@ -310,15 +366,15 @@ module Avo
       view_types
     end
 
-    def attached_file_fields
+    def attachment_fields
       get_field_definitions.select do |field|
         [Avo::Fields::FileField, Avo::Fields::FilesField].include? field.class
       end
     end
 
-    def fill_record(record, params, extra_params: [])
-      # Map the received params to their actual fields
-      fields_by_database_id = get_field_definitions
+    # Map the received params to their actual fields
+    def fields_by_database_id
+      get_field_definitions
         .reject do |field|
           field.computed
         end
@@ -326,7 +382,9 @@ module Avo
           [field.database_id.to_s, field]
         end
         .to_h
+    end
 
+    def fill_record(record, params, extra_params: [])
       # Write the field values
       params.each do |key, value|
         field = fields_by_database_id[key]
@@ -383,20 +441,18 @@ module Avo
           !field.computed
         end
         .map do |field|
-          id = field.id
           value = field.value
 
           if field.type == "belongs_to"
-            id = field.foreign_key.to_sym
 
             reflection = @record._reflections[@params[:via_relation]]
 
             if field.polymorphic_as.present? && field.types.map(&:to_s).include?(@params[:via_relation_class])
               # set the value to the actual record
-              via_resource = Avo::App.resources.get_resource_by_model_class(@params[:via_relation_class])
+              via_resource = Avo.resource_manager.get_resource_by_model_class(@params[:via_relation_class])
               value = via_resource.find_record(@params[:via_record_id])
             elsif reflection.present? && reflection.foreign_key.present? && field.id.to_s == @params[:via_relation].to_s
-              resource = Avo::App.resources.get_resource_by_model_class params[:via_relation_class]
+              resource = Avo.resource_manager.get_resource_by_model_class params[:via_relation_class]
               record = resource.find_record @params[:via_record_id], params: params
               id_param = reflection.options[:primary_key] || :id
 
@@ -404,28 +460,18 @@ module Avo
             end
           end
 
-          [id, value]
+          [field, value]
         end
         .to_h
-        .select do |id, value|
+        .select do |_, value|
           value.present?
         end
 
-      default_values.each do |id, value|
-        if @record.send(id).nil?
-          @record.send("#{id}=", value)
-        end
+      default_values.each do |field, value|
+        field.assign_value record: @record, value: value
       end
     end
 
-    # This is used as the model class ID
-    # We use this instead of the route_key to maintain compatibility with uncountable models
-    # With uncountable models route key appends an _index suffix (Fish->fish_index)
-    # Example: User->users, MediaItem->media_items, Fish->fish
-    def model_key
-      model_class.model_name.plural
-    end
-
     def model_name
       model_class.model_name
     end
@@ -474,15 +520,6 @@ module Avo
       record.present? && record_id.present?
     end
 
-    def find_record(id, query: nil, params: nil)
-      Avo::ExecutionContext.new(
-        target: self.class.find_record_method,
-        query: query || self.class.find_scope,
-        id: id,
-        params: params
-      ).handle
-    end
-
     def id_attribute
       :id
     end
@@ -499,14 +536,6 @@ module Avo
       }
     end
 
-    def search_query
-      self.class.search.dig(:query)
-    end
-
-    def fetch_search(key)
-      Avo::ExecutionContext.new(target: self.class.search[key], resource: self, record: record).handle
-    end
-
     private
 
     def entity_loader(entity)

data/lib/avo/concerns/has_item_type.rb

@@ -33,6 +33,10 @@ module Avo
       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

@@ -18,6 +18,10 @@ module Avo
           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
@@ -42,6 +46,7 @@ module Avo
 
       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
@@ -96,6 +101,10 @@ module Avo
           if item.is_field?
             fields << item
           end
+
+          if item.is_row?
+            fields << extract_fields_from_items(tab)
+          end
         end
 
         fields.flatten
@@ -213,8 +222,10 @@ module Avo
         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|
-              panel.items.grep(Avo::Fields::BelongsToField).each do |field|
-                field.target = :_top
+              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
@@ -250,9 +261,6 @@ module Avo
 
             item
           end
-          .select do |item|
-            item.visible_in_view?(view: view)
-          end
           .select do |item|
             item.visible?
           end
@@ -264,7 +272,8 @@ module Avo
             end
           end
           .select do |item|
-            if !item.is_heading? && view.in?([:edit, :update, :new, :create])
+            # 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
@@ -290,25 +299,21 @@ module Avo
         visible_items.blank?
       end
 
-      def hydrate(**args)
-        super(**args)
+      private
 
-        items_holder.items.each do |item|
-          item.hydrate(**args)
+      def set_target_to_top(fields)
+        fields.each do |field|
+          field.target = :_top
         end
-
-        self
       end
 
-      private
-
       def extract_fields_from_items(thing)
         fields = []
 
         thing.items.each do |item|
           if item.is_field?
             fields << item
-          elsif item.is_panel?
+          elsif item.is_panel? || item.is_row?
             fields << extract_fields_from_items(item)
           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

data/lib/avo/current.rb

@@ -1,9 +1,30 @@
 class Avo::Current < ActiveSupport::CurrentAttributes
+  # if Rails.env.development?
+  # singleton_class.attr_accessor :previous_attributes
+  # before_reset {
+  #   puts ["before_reset->", self.previous_attributes].inspect
+  #   if attributes.present?
+  #     puts ["has attributes->"].inspect
+  #     self.previous_attributes = attributes
+  #   end
+  #   puts ["before_reset->", self.previous_attributes].inspect
+  # }
+
+  # attr_accessor :previous_attributes
+
+  # def previous_attributes=(value)
+  #   @previous_attributes = value
+  # end
+  # end
+
   attribute :app
   attribute :license
   attribute :context, :current_user, :view_context
+  attribute :error_manager
+  attribute :resource_manager
+  attribute :tool_manager
+  attribute :plugin_manager
 
-  delegate :request, to: :view_context
   delegate :params, to: :request
 
   def request

data/lib/avo/dsl/field_parser.rb

@@ -72,7 +72,7 @@ module Avo
       end
 
       def field_class_from_symbol(symbol)
-        matched_field = Avo::App.fields.all.find do |field|
+        matched_field = Avo.field_manager.all.find do |field|
           field[:name].to_s == symbol.to_s
         end
 

data/lib/avo/dynamic_router.rb

@@ -1,12 +1,23 @@
 module Avo
   class DynamicRouter
+    def self.eager_load(entity)
+      paths = Avo::ENTITIES.fetch entity
+
+      return unless paths.present?
+
+      pathname = Rails.root.join(*paths)
+      if pathname.directory?
+        Rails.autoloaders.main.eager_load_dir(pathname.to_s)
+      end
+    end
+
     def self.routes
       Avo::Engine.routes.draw do
         scope "resources", as: "resources" do
           # Check if the user chose to manually register the resource files.
           # If so, eager_load the resources dir.
           if Avo.configuration.resources.nil?
-            Avo::App.eager_load(:resources) unless Rails.application.config.eager_load
+            Avo::DynamicRouter.eager_load(:resources) unless Rails.application.config.eager_load
           end
 
           Avo::Resources::ResourceManager.fetch_resources

data/lib/avo/engine.rb

@@ -3,6 +3,8 @@ Gem.loaded_specs["avo"].dependencies.each do |d|
   case d.name
   when "activerecord"
     require "active_record/railtie"
+  when "activesupport"
+    require "active_support/railtie"
   when "actionview"
     require "action_view/railtie"
   when "activestorage"
@@ -23,7 +25,7 @@ module Avo
       ::Avo.asset_manager.reset
 
       # Boot Avo
-      ::Avo::App.boot
+      ::Avo.boot
 
       # After deploy we want to make sure the license response is being cleared.
       # We need a fresh license response.
@@ -40,7 +42,7 @@ module Avo
     # Ensure we reboot the app when something changes
     config.to_prepare do
       # Boot Avo
-      ::Avo::App.boot
+      ::Avo.boot
     end
 
     initializer "avo.autoload" do |app|
@@ -55,10 +57,6 @@ module Avo
       end
     end
 
-    initializer "avo.init_fields" do |app|
-      ::Avo::App.init_fields
-    end
-
     initializer "avo.reloader" do |app|
       Avo::Reloader.new.tap do |reloader|
         reloader.execute
@@ -94,7 +92,6 @@ module Avo
 
     initializer "avo.locales" do |app|
       I18n.load_path += Dir[Avo::Engine.root.join("lib", "generators", "avo", "templates", "locales", "*.{rb,yml}")]
-      I18n.load_path += Dir[Rails.root.join("config", "locales", "*.{rb,yml}")]
     end
   end
 end

data/lib/avo/fields/base_field.rb

@@ -65,6 +65,7 @@ module Avo
         @nullable = args[:nullable] || false
         @null_values = args[:null_values] || [nil, ""]
         @format_using = args[:format_using] || nil
+        @update_using = args[:update_using] || nil
         @placeholder = args[:placeholder]
         @autocomplete = args[:autocomplete] || nil
         @help = args[:help] || nil
@@ -170,8 +171,8 @@ module Avo
             target: format_using,
             value: final_value,
             record: record,
-            resource: @resource,
-            view: @view,
+            resource: resource,
+            view: view,
             field: self,
             include: self.class.included_modules
           ).handle
@@ -180,10 +181,22 @@ module Avo
         final_value
       end
 
+      # Fills the record with the received value on create and update actions.
       def fill_field(record, key, value, params)
         return record unless record.methods.include? key.to_sym
 
-        record.send("#{key}=", value)
+        if @update_using.present?
+          value = Avo::ExecutionContext.new(
+            target: @update_using,
+            record: record,
+            key: key,
+            value: value,
+            resource: resource,
+            field: self
+          ).handle
+        end
+
+        record.public_send("#{key}=", value)
 
         record
       end
@@ -264,6 +277,15 @@ module Avo
         !is_disabled? && visible?
       end
 
+      # Used by Avo to fill the record with the default value on :new and :edit views
+      def assign_value(record:, value:)
+        id = type == "belongs_to" ? foreign_key : database_id
+
+        if record.send(id).nil?
+          record.send("#{id}=", value)
+        end
+      end
+
       private
 
       def model_or_class(model)