avo 0.5.0.beta5 → 0.5.0.beta10

data/lib/avo.rb

@@ -1,20 +1,20 @@
-require 'zeitwerk'
-require_relative 'avo/version'
-require_relative 'avo/engine' if defined?(Rails)
+require "zeitwerk"
+require_relative "avo/version"
+require_relative "avo/engine" if defined?(Rails)
 
 loader = Zeitwerk::Loader.for_gem
 loader.setup
 
 module Avo
-  ROOT_PATH = Pathname.new(File.join(__dir__, '..'))
-  IN_DEVELOPMENT = ENV['AVO_IN_DEVELOPMENT'] == '1'
+  ROOT_PATH = Pathname.new(File.join(__dir__, ".."))
+  IN_DEVELOPMENT = ENV["AVO_IN_DEVELOPMENT"] == "1"
   PACKED = !IN_DEVELOPMENT
 
   class << self
     def webpacker
       @webpacker ||= ::Webpacker::Instance.new(
         root_path: ROOT_PATH,
-        config_path: ROOT_PATH.join('config/webpacker.yml')
+        config_path: ROOT_PATH.join("config/webpacker.yml")
       )
     end
   end

data/lib/avo/action_model.rb

@@ -0,0 +1,20 @@
+module Avo
+  class ActionModel
+    include ActiveModel::Model
+
+    # This class augments a model the action form declaration.
+    def initialize(attributes = {})
+      set_attr_accessors attributes
+
+      super(attributes)
+    end
+
+    private
+
+    def set_attr_accessors(attributes)
+      attributes.each do |k, v|
+        self.class.class_eval { attr_accessor k }
+      end
+    end
+  end
+end

data/lib/avo/app.rb

@@ -10,32 +10,15 @@ module Avo
     class_attribute :license, default: nil
 
     class << self
-  #     def load_controllers
-  #       BaseResource.descendants.each do |resource|
-  #         controller_name = "#{resource.to_s.gsub('Resource', '').pluralize}Controller"
-  #         puts controller_name.inspect
-  # #           eval <<DYNAMIC
-  # #   class #{controller_name} < Avo::ResourcesController
-  # #     # title :Person
-  # #     # attribute :name, String
-  # #     # ...or substitute other stuff in here.
-  # #   end
-  # # DYNAMIC
-
-  #         Avo.const_set(controller_name.to_sym, Class.new(Avo::ResourcesController))
-  #         # puts controller_name.inspect
-  #       end
-  #     end
-
       def boot
         init_fields
 
         I18n.locale = Avo.configuration.language_code
 
-        if Rails.cache.class == ActiveSupport::Cache::NullStore
-          self.app[:cache_store] ||= ActiveSupport::Cache::MemoryStore.new
+        if Rails.cache.instance_of?(ActiveSupport::Cache::NullStore)
+          app[:cache_store] ||= ActiveSupport::Cache::MemoryStore.new
         else
-          self.app[:cache_store] = Rails.cache
+          app[:cache_store] = Rails.cache
         end
       end
 
@@ -52,7 +35,7 @@ module Avo
       end
 
       def cache_store
-        self.app[:cache_store]
+        app[:cache_store]
       end
 
       # This method will find all fields available in the Avo::Fields namespace and add them to the fields class_variable array
@@ -64,48 +47,23 @@ module Avo
       # Avo::Fields::DateTimeField -> date_time
       def init_fields
         Avo::Fields::BaseField.descendants.each do |class_name|
-          next if class_name.to_s == 'BaseField'
+          next if class_name.to_s == "BaseField"
 
-          if class_name.to_s.end_with? 'Field'
+          if class_name.to_s.end_with? "Field"
             load_field class_name.get_field_name, class_name
           end
         end
       end
 
       def load_field(method_name, klass)
-        self.fields.push(
+        fields.push(
           name: method_name,
-          class: klass,
+          class: klass
         )
-
-        # Avo::Loaders::FieldsLoader.define_method method_name.to_sym do |*args, &block|
-        #   puts ['Avo::Loaders::FieldsLoader.define_method->', args, block.present?].inspect
-
-        #   if block.present?
-        #     puts '111->'.inspect
-        #     field = klass.new(args[0], **args[1] || {}, &block)
-        #   else
-        #     puts '222->'.inspect
-        #     field = klass.new(args[0], **args[1] || {})
-        #   end
-
-        #   puts field.inspect
-
-        #   self.bag.push field
-
-        #   # field
-        #   # if block.present?
-        #   #   field_class = klass::new(args[0], **args[1] || {}, &block)
-        #   # else
-        #   #   field_class = klass::new(args[0], **args[1] || {})
-        #   # end
-
-        #   # klass_entity.add_field(self, field_class)
-        # end
       end
 
       def init_resources
-        self.app[:resources] = BaseResource.descendants
+        app[:resources] = BaseResource.descendants
           .select do |resource|
             resource != BaseResource
           end
@@ -117,35 +75,45 @@ module Avo
       end
 
       def get_resources
-        self.app[:resources]
+        app[:resources]
       end
 
       # Returns the Avo resource by camelized name
       #
-      # get_resource_by_name('User') => Avo::Resources::User
+      # get_resource_by_name('User') => UserResource
       def get_resource(resource)
-        self.app[:resources].find do |available_resource|
+        app[:resources].find do |available_resource|
           "#{resource}Resource".safe_constantize == available_resource.class
         end
       end
 
       # Returns the Avo resource by singular snake_cased name
       #
-      # get_resource_by_name('user') => Avo::Resources::User
+      # get_resource_by_name('user') => UserResource
       def get_resource_by_name(name)
-        self.get_resource name.singularize.camelize
+        get_resource name.singularize.camelize
       end
 
       # Returns the Avo resource by singular snake_cased name
       #
-      # get_resource_by_name('User') => Avo::Resources::User
-      # get_resource_by_name(User) => Avo::Resources::User
+      # get_resource_by_name('User') => UserResource
+      # get_resource_by_name(User) => UserResource
       def get_resource_by_model_name(name)
         get_resources.find do |resource|
           resource.model_class.model_name.name == name.to_s
         end
       end
 
+      # Returns the Avo resource by singular snake_cased name
+      #
+      # get_resource_by_controller_name('delayed_backend_active_record_jobs') => DelayedJobResource
+      # get_resource_by_controller_name('users') => UserResource
+      def get_resource_by_controller_name(name)
+        get_resources.find do |resource|
+          resource.model_class.to_s.pluralize.underscore.tr("/", "_") == name.to_s
+        end
+      end
+
       # Returns the Rails model class by singular snake_cased name
       #
       # get_model_class_by_name('user') => User
@@ -156,7 +124,7 @@ module Avo
       def get_available_resources(user = nil)
         App.get_resources
           .select do |resource|
-            Services::AuthorizationService.authorize user, resource.model, Avo.configuration.authorization_methods.stringify_keys['index'], raise_exception: false
+            Services::AuthorizationService.authorize user, resource.model, Avo.configuration.authorization_methods.stringify_keys["index"], raise_exception: false
           end
           .sort_by { |r| r.name }
       end
@@ -171,14 +139,18 @@ module Avo
         # We should eager load all the classes so we find all descendants
         Rails.application.eager_load!
 
-        Proc.new do
+        proc do
           BaseResource.descendants
             .select do |resource|
-              resource != :Resource
+              resource != :BaseResource
             end
             .map do |resource|
               if resource.is_a? Class
-                route_key = resource.to_s.underscore.gsub('_resource', '').downcase.pluralize.to_sym
+                route_key = if resource.model_class.present?
+                  resource.model_class.model_name.route_key
+                else
+                  resource.to_s.underscore.gsub("_resource", "").downcase.pluralize.to_sym
+                end
 
                 resources route_key
               end

data/lib/avo/base_action.rb

@@ -1,113 +1,124 @@
 module Avo
   class BaseAction
+    extend FieldsCollector
+    extend HasContext
+
     class_attribute :name, default: self.class.to_s.demodulize.underscore.humanize(keep_id_suffix: true)
-    class_attribute :message, default: I18n.t('avo.are_you_sure_you_want_to_run_this_option')
-    class_attribute :confirm_text, default: I18n.t('avo.run')
-    class_attribute :cancel_text, default: I18n.t('avo.cancel')
+    class_attribute :message
+    class_attribute :confirm_button_label
+    class_attribute :cancel_button_label
     class_attribute :no_confirmation, default: false
+    class_attribute :model
+    class_attribute :view
+    class_attribute :user
+    class_attribute :resource
+    class_attribute :fields
 
     attr_accessor :response
     attr_accessor :model
     attr_accessor :resource
     attr_accessor :user
+    attr_accessor :fields_loader
 
-    attr_accessor :field_loader
+    def initialize(model: nil, resource: nil, user: nil)
+      self.class.model = model if model.present?
+      self.class.resource = resource if resource.present?
+      self.class.user = user if user.present?
 
-    alias :field :field_loader
-    alias :f :field
+      self.class.message ||= I18n.t("avo.are_you_sure_you_want_to_run_this_option")
+      self.class.confirm_button_label ||= I18n.t("avo.run")
+      self.class.cancel_button_label ||= I18n.t("avo.cancel")
 
-    def initialize
-      @fields ||= []
       @response ||= {}
       @response[:message_type] ||= :notice
-      @response[:message] ||= I18n.t('avo.action_ran_successfully')
+      @response[:message] ||= I18n.t("avo.action_ran_successfully")
+    end
+
+    def context
+      self.class.context
     end
 
-    def boot_fields(request)
-      @field_loader = Avo::Loaders::FieldsLoader.new
-      fields request if self.respond_to? :fields
+    def get_field_definitions
+      return [] if self.class.fields.blank?
+
+      self.class.fields.map do |field|
+        field.hydrate(action: self)
+      end
     end
 
-    def get_fields(view_type: :table)
+    def get_fields
       get_field_definitions.map do |field|
         field.hydrate(action: self, model: @model)
       end
-      .select do |field|
-        field.can_see.present? ? field.can_see.call : true
+        .select do |field|
+        field.visible?
       end
     end
 
-    def get_field_definitions
-      @field_loader.bag.map do |field|
-        field.hydrate(action: self)
+    def get_attributes_for_action
+      get_fields.map do |field|
+        [field.id, field.value]
       end
+        .to_h
     end
 
-    def hydrate(model: nil, resource: nil, user: nil)
-      @model = model if model.present?
-      @resource = resource if resource.present?
-      @user = user if user.present?
-
-      self
-    end
-
-    def handle_action(request, models, raw_fields)
+    def handle_action(models:, fields:)
       avo_fields = get_fields.map { |field| [field.id, field] }.to_h
 
-      if raw_fields.present?
-        fields = raw_fields.to_unsafe_h.map do |name, value|
+      if fields.present?
+        processed_fields = fields.to_unsafe_h.map do |name, value|
           [name, avo_fields[name.to_sym].resolve_attribute(value)]
         end
 
-        fields = fields.to_h
+        processed_fields = processed_fields.to_h
       else
-        fields = {}
+        processed_fields = {}
       end
 
-      result = self.handle request, models, fields
+      handle models: models, fields: processed_fields
 
       self
     end
 
     def param_id
-      self.class.to_s.demodulize.underscore.gsub '/', '_'
+      self.class.to_s.demodulize.underscore.tr "/", "_"
     end
 
     def succeed(text)
-      self.response[:message_type] = :notice
-      self.response[:message] = text
+      response[:message_type] = :notice
+      response[:message] = text
 
       self
     end
 
     def fail(text)
-      self.response[:message_type] = :alert
-      self.response[:message] = text
+      response[:message_type] = :alert
+      response[:message] = text
 
       self
     end
 
     def redirect_to(path = nil, &block)
-      self.response[:type] = :redirect
-      if block.present?
-        self.response[:path] = block
+      response[:type] = :redirect
+      response[:path] = if block.present?
+        block
       else
-        self.response[:path] = path
+        path
       end
 
       self
     end
 
     def reload
-      self.response[:type] = :reload
+      response[:type] = :reload
 
       self
     end
 
     def download(path, filename)
-      self.response[:type] = :download
-      self.response[:path] = path
-      self.response[:filename] = filename
+      response[:type] = :download
+      response[:path] = path
+      response[:filename] = filename
 
       self
     end

data/lib/avo/base_resource.rb

@@ -1,6 +1,8 @@
 module Avo
   class BaseResource
     extend ActiveSupport::DescendantsTracker
+    extend FieldsCollector
+    extend HasContext
 
     attr_accessor :view
     attr_accessor :model
@@ -11,45 +13,33 @@ module Avo
     class_attribute :title, default: :id
     class_attribute :search, default: [:id]
     class_attribute :includes, default: []
+    class_attribute :model_class
     class_attribute :translation_key
     class_attribute :default_view_type, default: :table
     class_attribute :devise_password_optional, default: false
-    class_attribute :fields_loader
     class_attribute :actions_loader
     class_attribute :filters_loader
-    class_attribute :grid_cover_loader
-    class_attribute :grid_title_loader
-    class_attribute :grid_body_loader
+    class_attribute :fields
+    class_attribute :grid_loader
 
     class << self
-      def fields(&block)
-        self.fields_loader ||= Avo::Loaders::FieldsLoader.new
-
-        yield(fields_loader)
-      end
-
-      def actions(&block)
-        self.actions_loader ||= Avo::Loaders::ActionsLoader.new
+      def grid(&block)
+        grid_collector = GridCollector.new
+        grid_collector.instance_eval(&block)
 
-        yield(actions_loader)
+        self.grid_loader = grid_collector
       end
 
-      def filters(&block)
-        self.filters_loader ||= Avo::Loaders::FiltersLoader.new
+      def action(action_class)
+        self.actions_loader ||= Avo::Loaders::Loader.new
 
-        yield(filters_loader)
+        self.actions_loader.use action_class
       end
 
-      def grid(&block)
-        self.grid_cover_loader ||= Avo::Loaders::FieldsLoader.new
-        self.grid_title_loader ||= Avo::Loaders::FieldsLoader.new
-        self.grid_body_loader ||= Avo::Loaders::FieldsLoader.new
-
-        yield(grid_cover_loader, grid_title_loader, grid_body_loader)
-      end
+      def filter(filter_class)
+        self.filters_loader ||= Avo::Loaders::Loader.new
 
-      def context
-        App.context
+        self.filters_loader.use filter_class
       end
     end
 
@@ -67,18 +57,26 @@ module Avo
       self
     end
 
+    def get_field_definitions
+      return [] if self.class.fields.blank?
+
+      self.class.fields.map do |field|
+        field.hydrate(resource: self, panel_name: default_panel_name, user: user)
+      end
+    end
+
     def get_fields(panel: nil, reflection: nil)
       fields = get_field_definitions.select do |field|
-        field.send("show_on_#{@view.to_s}")
-      end
-      .select do |field|
-        field.can_see.present? ? field.can_see.call : true
+        field.send("show_on_#{@view}")
       end
-      .select do |field|
+        .select do |field|
+                 field.visible?
+               end
+        .select do |field|
         unless field.respond_to?(:foreign_key) &&
-          reflection.present? &&
-          reflection.respond_to?(:foreign_key) &&
-          reflection.foreign_key == field.foreign_key
+            reflection.present? &&
+            reflection.respond_to?(:foreign_key) &&
+            reflection.foreign_key == field.foreign_key
           true
         end
       end
@@ -89,27 +87,15 @@ module Avo
         end
       end
 
-      fields = fields.map do |field|
+      fields.map do |field|
         field.hydrate(model: @model, view: @view, resource: self)
       end
-
-      fields
     end
 
     def get_grid_fields
-      return if self.class.grid_title_loader.blank?
-
-      card = {
-        cover: [*self.class.grid_cover_loader.bag],
-        title: [*self.class.grid_title_loader.bag],
-        body: [*self.class.grid_body_loader.bag],
-      }
+      return if self.class.grid_loader.blank?
 
-      card.each do |section, fields|
-        fields = fields.map do |field|
-          field.hydrate(model: @model, view: @view, resource: self)
-        end
-      end
+      self.class.grid_loader.hydrate(model: @model, view: @view, resource: self)
     end
 
     def get_filters
@@ -124,41 +110,35 @@ module Avo
       self.class.actions_loader.bag
     end
 
-    def get_field_definitions
-      self.class.fields_loader.bag.map do |field|
-        field.hydrate(resource: self, panel_name: default_panel_name, user: user)
-      end
-    end
-
     def default_panel_name
       return @params[:related_name].capitalize if @params[:related_name].present?
 
       case @view
       when :show
-        I18n.t('avo.resource_details', item: self.name.downcase, title: model_title).upcase_first
+        I18n.t("avo.resource_details", item: name.downcase, title: model_title).upcase_first
       when :edit
-        I18n.t('avo.update_item', item: self.name.downcase, title: model_title).upcase_first
+        I18n.t("avo.update_item", item: name.downcase, title: model_title).upcase_first
       when :new
-        I18n.t('avo.create_new_item', item: self.name.downcase).upcase_first
+        I18n.t("avo.create_new_item", item: name.downcase).upcase_first
       end
     end
 
     def panels
-      panels = [
+      [
         {
           name: default_panel_name,
           type: :fields,
-          in_panel: true,
+          in_panel: true
         }
       ]
-
-      panels
     end
 
     def model_class
+      return self.class.model_class if self.class.model_class.present?
+
       return @model.class if @model.present?
 
-      self.class.name.demodulize.chomp('Resource').safe_constantize
+      self.class.name.demodulize.chomp("Resource").safe_constantize
     end
 
     def model_title
@@ -172,7 +152,7 @@ module Avo
 
       return I18n.t(@translation_key, count: 1).capitalize if @translation_key
 
-      self.class.name.demodulize.chomp('Resource').titlecase
+      self.class.name.demodulize.chomp("Resource").titlecase
     end
 
     def singular_name
@@ -204,14 +184,10 @@ module Avo
     end
 
     def context
-      App.context
+      self.class.context
     end
 
-    # def fields
-    #   raise NotImplementedError
-    # end
-
-    def query_search(query: '', via_resource_name: , via_resource_id:, user:)
+    def query_search(via_resource_name:, via_resource_id:, user:, query: "")
       # model_class = self.model
 
       db_query = AuthorizationService.apply_policy(user, model_class)
@@ -219,18 +195,18 @@ module Avo
       if via_resource_name.present?
         related_model = App.get_resource_by_name(via_resource_name).model
 
-        db_query = related_model.find(via_resource_id).public_send(self.plural_name.downcase)
+        db_query = related_model.find(via_resource_id).public_send(plural_name.downcase)
       end
 
       new_query = []
 
-      [self.search].flatten.each_with_index do |search_by, index|
-        new_query.push 'or' if index != 0
+      [search].flatten.each_with_index do |search_by, index|
+        new_query.push "or" if index != 0
 
         new_query.push "text(#{search_by}) ILIKE '%#{query}%'"
       end
 
-      db_query.where(new_query.join(' '))
+      db_query.where(new_query.join(" "))
     end
 
     def attached_file_fields
@@ -241,7 +217,7 @@ module Avo
 
     def fill_model(model, params)
       # Map the received params to their actual fields
-      fields_by_database_id = self.get_field_definitions.map { |field| [field.database_id(model).to_s, field] }.to_h
+      fields_by_database_id = get_field_definitions.map { |field| [field.database_id(model).to_s, field] }.to_h
 
       params.each do |key, value|
         field = fields_by_database_id[key]
@@ -259,16 +235,16 @@ module Avo
     end
 
     def file_hash
-      content_to_be_hashed = ''
+      content_to_be_hashed = ""
 
       # resource file hash
-      resource_path = Rails.root.join('app', 'avo', 'resources', "#{name.underscore}.rb").to_s
+      resource_path = Rails.root.join("app", "avo", "resources", "#{name.underscore}.rb").to_s
       if File.file? resource_path
         content_to_be_hashed += File.read(resource_path)
       end
 
       # policy file hash
-      policy_path = Rails.root.join('app', 'policies', "#{name.underscore}_policy.rb").to_s
+      policy_path = Rails.root.join("app", "policies", "#{name.underscore}_policy.rb").to_s
       if File.file? policy_path
         content_to_be_hashed += File.read(policy_path)
       end
@@ -278,9 +254,9 @@ module Avo
 
     def cache_hash(parent_model)
       if parent_model.present?
-        [self.model, self.file_hash, parent_model]
+        [model, file_hash, parent_model]
       else
-        [self.model, self.file_hash]
+        [model, file_hash]
       end
     end
 
@@ -290,24 +266,24 @@ module Avo
       default_values = get_fields.select do |field|
         !field.computed
       end
-      .map do |field|
-        id = field.id
-        value = field.value
+        .map do |field|
+                         id = field.id
+                         value = field.value
 
-        if field.respond_to? :foreign_key
-          id = field.foreign_key.to_sym
+                         if field.respond_to? :foreign_key
+                           id = field.foreign_key.to_sym
 
-          reflection = @model._reflections[@params[:via_relation]]
+                           reflection = @model._reflections[@params[:via_relation]]
 
-          if reflection.present? && reflection.foreign_key.present?
-            value = @params[:via_resource_id]
-          end
-        end
+                           if reflection.present? && reflection.foreign_key.present?
+                             value = @params[:via_resource_id]
+                           end
+                         end
 
-        [id, value]
-      end
-      .to_h
-      .select do |id, value|
+                         [id, value]
+                       end
+        .to_h
+        .select do |id, value|
         value.present?
       end