avo 3.0.0.pre12 → 3.0.0.pre14

data/app/views/layouts/avo/application.html.erb

@@ -60,8 +60,8 @@
     <%= render partial: "avo/partials/scripts" %>
     <!-- Avo version: <%= Avo::VERSION %> -->
     <!-- Environment: <%= Rails.env %> -->
-    <!-- License ID: <%= Avo::App.license.id %> -->
-    <!-- License valid?: <%= Avo::App.license.valid ? "valid" : "invalid" %>  -->
+    <!-- License ID: <%= Avo.license.id %> -->
+    <!-- License valid?: <%= Avo.license.valid ? "valid" : "invalid" %>  -->
   </body>
 </html>
 <!-- ✨ Built with Avo • https://www.avohq.io/ -->

data/avo.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.files = Dir["{bin,app,config,db,lib,public}/**/*", "MIT-LICENSE", "Rakefile", "README.md", "avo.gemspec", "Gemfile", "Gemfile.lock"]
 
   spec.add_dependency "activerecord", ">= 6.1"
+  spec.add_dependency "activesupport", ">= 6.1"
   spec.add_dependency "actionview", ">= 6.1"
   spec.add_dependency "pagy"
   spec.add_dependency "zeitwerk", ">= 2.6.2"

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

@@ -86,7 +86,14 @@ module Avo
 
     def get_attributes_for_action
       get_fields.map do |field|
-        [field.id, field.value || field.default]
+        value = field.value || Avo::ExecutionContext.new(
+          target: field.default,
+          record: self.class.record,
+          resource: self.class.resource,
+          view: view
+        ).handle
+
+        [field.id, value]
       end.to_h
     end
 
@@ -94,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|
@@ -121,7 +131,7 @@ module Avo
         resource: resource
       }
 
-      args[:records] = records unless standalone
+      args[:records] = records
 
       handle(**args)
 

data/lib/avo/base_resource.rb

@@ -38,19 +38,17 @@ module Avo
     attr_accessor :record
 
     class_attribute :id, default: :id
-    class_attribute :title, default: :id
-    class_attribute :search_query, default: nil
-    class_attribute :search_query_help, default: ""
-    class_attribute :search_result_path
+    class_attribute :title
+    class_attribute :search, default: {}
     class_attribute :includes, default: []
     class_attribute :authorization_policy
     class_attribute :translation_key
     class_attribute :default_view_type, default: :table
     class_attribute :devise_password_optional, default: false
-    class_attribute :actions_loader
     class_attribute :scopes_loader
     class_attribute :filters_loader
-    class_attribute :grid_loader
+    class_attribute :view_types
+    class_attribute :grid_view
     class_attribute :visible_on_sidebar, default: true
     class_attribute :index_query, default: -> {
       query
@@ -58,7 +56,6 @@ module Avo
     class_attribute :find_record_method, default: -> {
       query.find id
     }
-    class_attribute :hide_from_global_search, default: false
     class_attribute :after_create_path, default: :show
     class_attribute :after_update_path, default: :show
     class_attribute :record_selector, default: true
@@ -74,42 +71,21 @@ module Avo
       delegate :t, to: ::I18n
       delegate :context, to: ::Avo::Current
 
-      def grid(&block)
-        grid_collector = GridCollector.new
-        grid_collector.instance_eval(&block)
-
-        self.grid_loader = grid_collector
-      end
-
       def action(action_class, arguments: {})
-        self.actions_loader ||= Avo::Loaders::Loader.new
-
-        action = {class: action_class, arguments: arguments}
-        self.actions_loader.use action
+        deprecated_dsl_api __method__, "actions"
       end
 
       def filter(filter_class, arguments: {})
-        self.filters_loader ||= Avo::Loaders::Loader.new
-
-        filter = { class: filter_class , arguments: arguments }
-        self.filters_loader.use filter
-      end
-
-      # This is the search_query scope
-      # This should be removed and passed to the search block
-      def scope
-        query_scope
+        deprecated_dsl_api __method__, "filters"
       end
 
-      def scopes(*args)
-        self.scopes_loader ||= Avo::Loaders::Loader.new
-
-        args.each do |scope_class|
-          self.scopes_loader.use scope_class
-        end
+      def scope(scope_class)
+        deprecated_dsl_api __method__, "scopes"
       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,
@@ -118,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
@@ -153,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
@@ -164,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?
@@ -195,54 +266,47 @@ module Avo
       # blank fields method
     end
 
-    def hydrate(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
+    [:action, :filter, :scope].each do |entity|
+      plural_entity = entity.to_s.pluralize
 
-        hydrate_model_with_default_values if @view == :new
+      # def actions / def filters / def scopes
+      define_method plural_entity do
+        # blank entity method
       end
 
-      self
-    end
-
-    def get_grid_fields
-      return if self.class.grid_loader.blank?
-
-      self.class.grid_loader.hydrate(record: @record, view: @view, resource: self)
-    end
-
-    def get_filters
-      return [] if self.class.filters_loader.blank?
-
-      self.class.filters_loader.bag
-    end
+      # def action / def filter / def scope
+      define_method entity do |entity_class, arguments: {}|
+        entity_loader(entity).use({class: entity_class, arguments: arguments})
+      end
 
-    def get_filter_arguments(filter_class)
-      filter = get_filters.find { |filter| filter[:class] == filter_class.constantize }
+      # def get_actions / def get_filters / def get_scopes
+      define_method "get_#{plural_entity}" do
+        return entity_loader(entity).bag if entity_loader(entity).present?
 
-      filter[:arguments]
-    end
+        instance_variable_set("@#{plural_entity}_loader", Avo::Loaders::Loader.new)
+        send plural_entity
 
-    def get_actions
-      return [] if self.class.actions_loader.blank?
+        entity_loader(entity).bag
+      end
 
-      self.class.actions_loader.bag
+      # 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].to_s == entity_class.to_s }[:arguments]
+      end
     end
 
-    def get_action_arguments(action_class)
-      action = get_actions.find { |action| action[:class].to_s == action_class.to_s }
+    def hydrate(record: nil, view: nil, user: nil, params: nil)
+      @view = view if view.present?
+      @user = user if user.present?
+      @params = params if params.present?
 
-      action[:arguments]
-    end
+      if record.present?
+        @record = record
 
-    def get_scopes
-      return [] if self.class.scopes_loader.blank?
+        hydrate_model_with_default_values if @view == :new
+      end
 
-      self.class.scopes_loader.bag
+      self
     end
 
     def default_panel_name
@@ -258,86 +322,59 @@ 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?
+      record_class = @record&.class
 
-      # get the model class off of the record
-      return @record.base_class if @record.present?
-
-      # generate a model class
-      class_name.safe_constantize
+      self.class.model_class record_class: record_class
     end
 
     def record_title
       return name if @record.nil?
 
-      the_title = @record.send title
-      return the_title if the_title.present?
+      # Get the title from the record if title is not set, try to get the name, title or label, or fallback to the id
+      return @record.try(:name) || @record.try(:title) || @record.try(:label) || @record.id  if title.nil?
 
-      @record.id
-    rescue
-      name
-    end
-
-    def translation_key
-      self.class.translation_key || "avo.resource_translations.#{class_name.underscore}"
-    end
-
-    def name
-      default = class_name.underscore.humanize
-
-      return @name if @name.present?
-
-      if translation_key
-        t(translation_key, count: 1, default: default).capitalize
-      else
-        default
+      # If the title is a symbol, get the value from the record else execute the block/string
+      case title
+      when Symbol
+        @record.send title
+      when Proc
+        Avo::ExecutionContext.new(target: title, resource: self, record: @record).handle
       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
+    def available_view_types
+      if self.class.view_types.present?
+        return Array(
+          Avo::ExecutionContext.new(
+            target: self.class.view_types,
+            resource: self,
+            record: record
+          ).handle
+        )
       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
       view_types = [:table]
 
-      view_types << :grid if get_grid_fields.present?
+      view_types << :grid if self.class.grid_view.present?
       view_types << :map if map_view.present?
 
       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
@@ -345,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]
@@ -402,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
 
@@ -423,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
@@ -461,18 +488,6 @@ module Avo
       resources_path(resource: self)
     end
 
-    def label_field
-      get_field_definitions.find do |field|
-        field.as_label.present?
-      end
-    rescue
-      nil
-    end
-
-    def label
-      label_field&.value || record_title
-    end
-
     def avatar_field
       get_field_definitions.find do |field|
         field.as_avatar.present?
@@ -497,18 +512,6 @@ module Avo
       nil
     end
 
-    def description_field
-      get_field_definitions.find do |field|
-        field.as_description.present?
-      end
-    rescue
-      nil
-    end
-
-    def search_description
-      description_field&.value
-    end
-
     def form_scope
       model_class.base_class.to_s.underscore.downcase
     end
@@ -517,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
@@ -541,5 +535,11 @@ module Avo
         record: record
       }
     end
+
+    private
+
+    def entity_loader(entity)
+      instance_variable_get("@#{entity.to_s.pluralize}_loader")
+    end
   end
 end

data/lib/avo/concerns/filters_session_handler.rb

@@ -1,4 +1,3 @@
-
 module Avo
   module Concerns
     module FiltersSessionHandler

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