avo 2.46.0 → 3.0.0.pre2

data/lib/avo/configuration.rb

@@ -2,10 +2,8 @@ module Avo
   class Configuration
     include ResourceConfiguration
 
-    attr_writer :app_name
-    attr_writer :branding
     attr_writer :root_path
-    attr_writer :cache_store
+    attr_accessor :app_name
     attr_accessor :timezone
     attr_accessor :per_page
     attr_accessor :per_page_steps
@@ -38,13 +36,12 @@ module Avo
     attr_accessor :main_menu
     attr_accessor :profile_menu
     attr_accessor :model_resource_mapping
-    attr_accessor :tabs_style
     attr_accessor :resource_default_view
     attr_accessor :authorization_client
     attr_accessor :field_wrapper_layout
     attr_accessor :sign_out_path_name
     attr_accessor :resources
-    attr_accessor :prefix_path
+    attr_writer :branding
 
     def initialize
       @root_path = "/avo"
@@ -91,13 +88,10 @@ module Avo
       @main_menu = nil
       @profile_menu = nil
       @model_resource_mapping = {}
-      @tabs_style = :tabs
       @resource_default_view = :show
       @authorization_client = :pundit
       @field_wrapper_layout = :inline
       @resources = nil
-      @prefix_path = nil
-      @cache_store = computed_cache_store
     end
 
     def current_user_method(&block)
@@ -121,8 +115,8 @@ module Avo
     end
 
     def namespace
-      if Avo.configuration.root_path.present?
-        Avo.configuration.root_path.delete "/"
+      if computed_root_path.present?
+        computed_root_path.delete "/"
       else
         root_path.delete "/"
       end
@@ -134,6 +128,10 @@ module Avo
       @root_path
     end
 
+    def computed_root_path
+      Avo.configuration.root_path
+    end
+
     def feature_enabled?(feature)
       !@disabled_features.map(&:to_sym).include?(feature.to_sym)
     end
@@ -141,41 +139,6 @@ module Avo
     def branding
       Avo::Configuration::Branding.new(**@branding || {})
     end
-
-    def app_name
-      if @app_name.respond_to? :call
-        Avo::Hosts::BaseHost.new(block: @app_name).handle
-      else
-        @app_name
-      end
-    end
-
-    def cache_store
-      Avo::ExecutionContext.new(
-        target: @cache_store,
-        production_rejected_cache_stores: %w[ActiveSupport::Cache::MemoryStore ActiveSupport::Cache::NullStore]
-      ).handle
-    end
-
-    # When not in production or test we'll just use the MemoryStore which is good enough.
-    # When running in production we'll use Rails.cache if it's not ActiveSupport::Cache::MemoryStore or ActiveSupport::Cache::NullStore.
-    # If it's one of rejected cache stores, we'll use the FileStore.
-    # We decided against the MemoryStore in production because it will not be shared between multiple processes (when using Puma).
-    def computed_cache_store
-      -> {
-        if Rails.env.production?
-          if Rails.cache.class.to_s.in?(production_rejected_cache_stores)
-            ActiveSupport::Cache.lookup_store(:file_store, Rails.root.join("tmp", "cache"))
-          else
-            Rails.cache
-          end
-        elsif Rails.env.test?
-          Rails.cache
-        else
-          ActiveSupport::Cache.lookup_store(:memory_store)
-        end
-      }
-    end
   end
 
   def self.configuration

data/lib/avo/current.rb

@@ -0,0 +1,5 @@
+class Avo::Current < ActiveSupport::CurrentAttributes
+  attribute :app
+  attribute :license
+  attribute :params, :request, :context, :current_user, :view_context
+end

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.find do |field|
+        matched_field = Avo::App.fields.all.find do |field|
           field[:name].to_s == symbol.to_s
         end
 

data/lib/avo/dynamic_router.rb

@@ -9,7 +9,7 @@ module Avo
             Avo::App.eager_load(:resources) unless Rails.application.config.eager_load
           end
 
-          Avo::App.fetch_resources
+          Avo::Resources::ResourceManager.fetch_resources
             .select do |resource|
               resource != :BaseResource
             end
@@ -17,7 +17,11 @@ module Avo
               resource.is_a? Class
             end
             .map do |resource|
-              resources resource.new.route_key
+              resources resource.new.route_key do
+                member do
+                  get :preview
+                end
+              end
             end
         end
       end

data/lib/avo/engine.rb

@@ -7,34 +7,59 @@ Gem.loaded_specs["avo"].dependencies.each do |d|
     require "action_view/railtie"
   when "activestorage"
     require "active_storage/engine"
-  when "actiontext"
-    require "action_text/engine"
   else
     require d.name
   end
 end
 
+# In development we should load the engine so we get the autoload for components
+if ENV["RAILS_ENV"] === "development"
+  require "view_component/engine"
+end
+
 module Avo
   class Engine < ::Rails::Engine
     isolate_namespace Avo
 
     config.after_initialize do
+      # Reset before reloads in development
+      ::Avo.asset_manager.reset
+
+      # Boot Avo
+      ::Avo::App.boot
+      ::Avo.plugin_manager.boot_plugins
+
+      # After deploy we want to make sure the license response is being cleared.
+      # We need a fresh license response.
+      # This is disabled in development because the initialization process might be triggered more than once.
+      unless Rails.env.development?
+        begin
+          Licensing::HQ.new.clear_response
+        rescue => exception
+          Avo.logger.info "Failed to clear Avo HQ response: #{exception.message}"
+        end
+      end
+    end
+
+    # Ensure we reboot the app when something changes
+    config.to_prepare do
       # Boot Avo
       ::Avo::App.boot
     end
 
     initializer "avo.autoload" do |app|
-      Avo::ENTITIES.values.each do |path_params|
-        path = Rails.root.join(*path_params)
+      # This undoes Rails' previous nested directories behavior in the `app` dir.
+      # More on this: https://github.com/fxn/zeitwerk/issues/250
+      avo_directory = Rails.root.join("app", "avo").to_s
+      ActiveSupport::Dependencies.autoload_paths.delete(avo_directory)
 
-        if File.directory? path.to_s
-          Rails.autoloaders.main.push_dir path.to_s
-        end
+      if Dir.exist?(avo_directory)
+        Rails.autoloaders.main.push_dir(avo_directory, namespace: Avo)
+        app.config.watchable_dirs[avo_directory] = [:rb]
       end
     end
 
     initializer "avo.init_fields" do |app|
-      # Init the fields
       ::Avo::App.init_fields
     end
 
@@ -46,17 +71,16 @@ module Avo
       end
     end
 
-    initializer "debug_exception_response_format" do |app|
-      app.config.debug_exception_response_format = :api
-      # app.config.logger = ::Logger.new(STDOUT)
-    end
-
     initializer "avo.test_buddy" do |app|
       if Avo::IN_DEVELOPMENT
         Rails.autoloaders.main.push_dir Avo::Engine.root.join("spec", "helpers")
       end
     end
 
+    initializer "debug_exception_response_format" do |app|
+      app.config.debug_exception_response_format = :api
+    end
+
     config.app_middleware.use(
       Rack::Static,
       urls: ["/avo-assets"],
@@ -71,22 +95,5 @@ module Avo
       Rails::Generators.configure! app.config.generators
       require_relative "../generators/model_generator"
     end
-
-    initializer "avo.locales" do |app|
-      I18n.load_path += Dir[Avo::Engine.root.join("lib", "generators", "avo", "templates", "locales", "*.{rb,yml}")]
-    end
-
-    # After deploy we want to make sure the license response is being cleared.
-    # We need a fresh license response.
-    # This is disabled in development because the initialization process might be triggered more than once.
-    config.after_initialize do
-      unless Rails.env.development?
-        begin
-          Licensing::HQ.new.clear_response
-        rescue => exception
-          puts "Failed to clear Avo HQ response: #{exception.message}"
-        end
-      end
-    end
   end
 end

data/lib/avo/error_manager.rb

@@ -0,0 +1,25 @@
+module Avo
+  class ErrorManager
+    class << self
+      def build
+        new
+      end
+    end
+
+    attr_reader :errors
+
+    alias_method :all, :errors
+
+    def initialize
+      @errors = []
+    end
+
+    def add(error)
+      errors << error
+    end
+
+    def has_errors?
+      errors.present?
+    end
+  end
+end

data/lib/avo/execution_context.rb

@@ -1,6 +1,6 @@
 module Avo
   class ExecutionContext
-    attr_accessor :target, :context, :params, :view_context, :current_user, :request, :include, :main_app, :avo
+    attr_accessor :target, :context, :params, :view_context, :current_user, :request, :include
 
     def initialize(**args)
       # Extend the class with custom modules if required.
@@ -10,13 +10,6 @@ module Avo
         end
       end
 
-      # If you want this block to behave like a view you can delegate the missing methods to the view_context
-      #
-      # Ex: Avo::ExecutionContext.new(target: ..., delegate_missing_to: :view_context).handle
-      if args[:delegate_missing_to].present?
-        self.class.send(:delegate_missing_to, args[:delegate_missing_to])
-      end
-
       # If target doesn't respond to call, we don't need to initialize the others attr_accessors.
       return unless (@target = args[:target]).respond_to? :call
 
@@ -26,15 +19,16 @@ module Avo
       end
 
       # Set defaults on not initialized accessors
-      @context ||= Avo::App.context
-      @params ||= Avo::App.params
-      @view_context ||= Avo::App.view_context
-      @current_user ||= Avo::App.current_user
-      @request ||= view_context&.request
-      @main_app ||= view_context&.main_app
-      @avo ||= view_context&.avo
+      @context ||= Avo::Current.context
+      @current_user ||= Avo::Current.current_user
+      @params ||= Avo::Current.params
+      @request ||= Avo::Current.request
+      @view_context ||= Avo::Current.view_context
     end
 
+    delegate :result, to: :card
+    delegate :authorize, to: Avo::Services::AuthorizationService
+
     # Return target if target is not callable, otherwise, execute target on this instance context
     def handle
       target.respond_to?(:call) ? instance_exec(&target) : target

data/lib/avo/fields/badge_field.rb

@@ -8,7 +8,7 @@ module Avo
 
         hide_on [:edit, :new]
 
-        default_options = {info: :info, success: :success, danger: :danger, warning: :warning, neutral: :neutral}
+        default_options = {info: :info, success: :success, danger: :danger, warning: :warning}
         @options = args[:options].present? ? default_options.merge(args[:options]) : default_options
       end
     end

data/lib/avo/fields/base_field.rb

@@ -2,21 +2,24 @@ module Avo
   module Fields
     class BaseField
       extend ActiveSupport::DescendantsTracker
-      extend Avo::Fields::FieldExtensions::HasFieldName
 
-      include Avo::Concerns::IsResourceItem
-      include Avo::Concerns::HandlesFieldArgs
-
-      include ActionView::Helpers::UrlHelper
-      include Avo::Fields::FieldExtensions::VisibleInDifferentViews
-
-      include Avo::Concerns::HasHTMLAttributes
-      include Avo::Fields::Concerns::IsRequired
+      prepend Avo::Concerns::HasItemType
+      prepend Avo::Concerns::IsResourceItem
+      include Avo::Concerns::IsVisible
+      include Avo::Concerns::VisibleInDifferentViews
+      include Avo::Fields::Concerns::HasFieldName
+      include Avo::Fields::Concerns::HasDefault
+      include Avo::Fields::Concerns::HasHTMLAttributes
+      include Avo::Fields::Concerns::HandlesFieldArgs
       include Avo::Fields::Concerns::IsReadonly
       include Avo::Fields::Concerns::IsDisabled
-      include Avo::Fields::Concerns::HasDefault
+      include Avo::Fields::Concerns::IsRequired
+
+      include ActionView::Helpers::UrlHelper
 
-      delegate :view_context, to: ::Avo::App
+      delegate :app, to: ::Avo::Current
+      delegate :view_context, to: :app
+      delegate :context, to: :app
       delegate :simple_format, :content_tag, to: :view_context
       delegate :main_app, to: :view_context
       delegate :avo, to: :view_context
@@ -30,35 +33,30 @@ module Avo
       attr_reader :nullable
       attr_reader :null_values
       attr_reader :format_using
-      attr_reader :autocomplete
       attr_reader :help
       attr_reader :default
-      attr_reader :visible
       attr_reader :as_label
       attr_reader :as_avatar
       attr_reader :as_description
       attr_reader :index_text_align
       attr_reader :stacked
+      attr_reader :for_presentation_only
 
       # Private options
+      attr_reader :updatable
       attr_reader :computable # if allowed to be computable
       attr_reader :computed # if block is present
       attr_reader :computed_value # the value after computation
 
       # Hydrated payload
-      attr_reader :model
-      attr_reader :view
-      attr_reader :resource
-      attr_reader :action
-      attr_reader :user
-      attr_reader :panel_name
+      attr_accessor :record
+      attr_accessor :action
+      attr_accessor :user
+      attr_accessor :panel_name
 
       class_attribute :field_name_attribute
-      class_attribute :item_type, default: :field
 
       def initialize(id, **args, &block)
-        super(id, **args, &block)
-
         @id = id
         @name = args[:name]
         @translation_key = args[:translation_key]
@@ -70,12 +68,10 @@ 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
         @default = args[:default] || nil
-        @visible = args[:visible]
+        @visible = args[:visible] || true
         @as_label = args[:as_label] || false
         @as_avatar = args[:as_avatar] || false
         @as_description = args[:as_description] || false
@@ -84,43 +80,29 @@ module Avo
         @view = args[:view] || nil
         @value = args[:value] || nil
         @stacked = args[:stacked] || nil
+        @for_presentation_only = args[:for_presentation_only] || false
         @resource = args[:resource]
-        @action = args[:action]
 
         @args = args
 
+        @updatable = !readonly
         @computable = true
         @computed = block.present?
         @computed_value = nil
 
-        # Set the visibility
-        show_on args[:show_on] if args[:show_on].present?
-        hide_on args[:hide_on] if args[:hide_on].present?
-        only_on args[:only_on] if args[:only_on].present?
-        except_on args[:except_on] if args[:except_on].present?
+        post_initialize if respond_to?(:post_initialize)
       end
 
-      def hydrate(**kwargs)
-        # List of permitted keyword argument keys as symbols
-        permited_kwargs_keys = %i[model resource action view panel_name user]
-
-        # Check for unrecognized keys
-        unrecognized_keys = kwargs.keys - permited_kwargs_keys
-        raise ArgumentError, "Unrecognized argument(s): #{unrecognized_keys.join(', ')}" if unrecognized_keys.any?
-
-        # Set instance variables with provided values
-        kwargs.each do |key, value|
-          instance_variable_set("@#{key}", value)
-        end
-
-        # Return self for method chaining, if desired
-        self
+      def translation_key
+        @translation_key || "avo.field_translations.#{@id}"
       end
 
-      def translation_key
-        return @translation_key if @translation_key.present?
+      def translated_name(default:)
+        t(translation_key, count: 1, default: default).capitalize
+      end
 
-        "avo.field_translations.#{@id}"
+      def translated_plural_name(default:)
+        t(translation_key, count: 2, default: default).capitalize
       end
 
       # Getting the name of the resource (user/users, post/posts)
@@ -130,8 +112,8 @@ module Avo
       def name
         return @name if custom_name?
 
-        if translation_key && ::Avo::App.translation_enabled
-          t(translation_key, count: 1, default: default_name).humanize
+        if translation_key
+          translated_name default: default_name
         else
           default_name
         end
@@ -140,15 +122,19 @@ module Avo
       def plural_name
         default = name.pluralize
 
-        if translation_key && ::Avo::App.translation_enabled
-          t(translation_key, count: 2, default: default).humanize
+        if translation_key
+          translated_plural_name default: default
         else
           default
         end
       end
 
+      def table_header_label
+        name
+      end
+
       def custom_name?
-        @name.present?
+        !@name.nil?
       end
 
       def default_name
@@ -156,21 +142,7 @@ module Avo
       end
 
       def placeholder
-        if @placeholder.respond_to?(:call)
-          return Avo::Hosts::ResourceViewRecordHost.new(block: @placeholder, record: @model, resource: @resource, view: @view).handle
-        end
-
-        @placeholder || name
-      end
-
-      def visible?
-        return true if visible.nil?
-
-        if visible.respond_to?(:call)
-          visible.call resource: @resource
-        else
-          visible
-        end
+        Avo::ExecutionContext.new(target: @placeholder || name, record: record, resource: @resource, view: @view).handle
       end
 
       def value(property = nil)
@@ -178,8 +150,8 @@ module Avo
 
         property ||= id
 
-        # Get model value
-        final_value = @model.send(property) if is_model?(@model) && @model.respond_to?(property)
+        # Get record value
+        final_value = record.send(property) if is_model?(record) && record.respond_to?(property)
 
         # On new views and actions modals we need to prefill the fields with the default value
         if should_fill_with_default_value? && default.present?
@@ -188,50 +160,21 @@ module Avo
 
         # Run computable callback block if present
         if computable && block.present?
-          final_value = instance_exec(@model, @resource, @view, self, &block)
+          final_value = instance_exec(record, @resource, @view, self, &block)
         end
 
-        if @format_using.present?
-          # Apply the changes in the
-          Avo::ExecutionContext.new(
-            target: @format_using,
-            model: model,
-            key: property,
-            value: final_value,
-            resource: resource,
-            view: view,
-            field: self,
-            delegate_missing_to: :view_context,
-            include: self.class.included_modules
-          ).handle
-        else
-          final_value
-        end
-      end
-
-      # Fills the model with the received value on create and update actions.
-      def fill_field(model, key, value, params)
-        return model unless model.methods.include? key.to_sym
+        # Run the value through resolver if present
+        final_value = instance_exec(final_value, &@format_using) if @format_using.present?
 
-        if @update_using.present?
-          value = update_using(model, key, value, params)
-        end
+        final_value
+      end
 
-        model.public_send("#{key}=", value)
+      def fill_field(record, key, value, params)
+        return record unless record.methods.include? key.to_sym
 
-        model
-      end
+        record.send("#{key}=", value)
 
-      def update_using(model, key, value, params)
-        Avo::ExecutionContext.new(
-          target: @update_using,
-          model: model,
-          key: key,
-          value: value,
-          resource: resource,
-          field: self,
-          include: self.class.included_modules
-        ).handle
+        record
       end
 
       # Try to see if the field has a different database ID than it's name
@@ -257,21 +200,31 @@ module Avo
         "#{type.camelize}Field"
       end
 
+      # For custom components the namespace will be different than Avo::Fields so we should take that into account.
+      def view_component_namespace
+        "#{self.class.to_s.deconstantize}::#{view_component_name}"
+      end
+
       # 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 = "#{view_component_namespace}::#{view.to_s.camelize}Component"
         component_class.constantize
       rescue
+        unless Rails.env.test?
+          Avo.logger.info "Failed to find component for the `#{self.class}` field on the `#{view}` view."
+        end
         # 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
 
-      def model_errors
-        model.nil? ? {} : model.errors
+      def record_errors
+        return {} if record.nil?
+
+        record.errors
       end
 
       def type
@@ -292,23 +245,18 @@ module Avo
         !visible_in_reflection?
       end
 
-      def updatable
-        !is_readonly? && 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
+      def options_for_filter
+        options
       end
 
       private
 
       def model_or_class(model)
-        model.instance_of?(String) ? "class" : "model"
+        if model.instance_of?(String)
+          "class"
+        else
+          "model"
+        end
       end
 
       def is_model?(model)