avo 2.18.1.pre.1.eagerloaddirs → 2.19.0

data/lib/avo/resources/controls/action.rb

@@ -14,9 +14,7 @@ module Avo
         end
 
         def action
-          return @instance if @instance.present?
-
-          @instance = @klass.new(model: @model, resource: @resource, view: @view)
+          @instance ||= @klass.new(model: @model, resource: @resource, view: @view)
         end
 
         def path

data/lib/avo/services/authorization_clients/nil_client.rb

@@ -0,0 +1,37 @@
+module Avo
+  module Services
+    module AuthorizationClients
+      class NilClient
+        def authorize(user, record, action, policy_class: nil)
+          true
+        end
+
+        def policy(user, record)
+          NilPolicy.new
+        end
+
+        def policy!(user, record)
+          NilPolicy.new
+        end
+
+        def apply_policy(user, model, policy_class: nil)
+          model
+        end
+
+        class NilPolicy
+          def initialize(user = nil, record = nil)
+          end
+          # rubocop:enable Style/RedundantInitialize
+
+          def method_missing(method, *args, &block)
+            self
+          end
+
+          def respond_to_missing?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avo/services/authorization_service.rb

@@ -9,8 +9,12 @@ module Avo
         def client
           client = Avo.configuration.authorization_client
 
+          client = nil if Avo::App.license.lacks(:authorization)
+
           klass = case client
-          when :pundit, nil
+          when nil
+            nil_client
+          when :pundit
             pundit_client
           else
             if client.is_a?(String)
@@ -92,8 +96,14 @@ module Avo
         end
 
         def pundit_client
+          raise Avo::MissingGemError.new("Please add `gem 'pundit'` to your Gemfile.") unless defined?(Pundit)
+
           Avo::Services::AuthorizationClients::PunditClient
         end
+
+        def nil_client
+          Avo::Services::AuthorizationClients::NilClient
+        end
       end
 
       def initialize(user = nil, record = nil, policy_class: nil)

data/lib/avo/version.rb

@@ -1,3 +1,3 @@
 module Avo
-  VERSION = "2.18.1.pre.1.eagerloaddirs" unless const_defined?(:VERSION)
+  VERSION = "2.19.0" unless const_defined?(:VERSION)
 end

data/lib/avo.rb

@@ -57,6 +57,8 @@ module Avo
   class NotAuthorizedError < StandardError; end
 
   class NoPolicyError < StandardError; end
+
+  class MissingGemError < StandardError; end
 end
 
 loader.eager_load

data/lib/generators/avo/resource_generator.rb

@@ -7,6 +7,11 @@ module Generators
 
       namespace "avo:resource"
 
+      class_option "model-class",
+        type: :string,
+        required: false,
+        desc: "The name of the model."
+
       def create
         template "resource/resource.tt", "app/avo/resources/#{resource_name}.rb"
         template "resource/controller.tt", "app/controllers/avo/#{controller_name}.rb"
@@ -33,6 +38,282 @@ module Generators
           model.capitalize.singularize.camelize
         end
       end
+
+      def class_from_args
+        @class_from_args ||= options["model-class"]&.capitalize
+      end
+
+      def model_class_from_args
+        "\n  self.model_class = ::#{class_from_args}" if class_from_args.present?
+      end
+
+      private
+
+      def model_class
+        @model_class ||= class_from_args || singular_name
+      end
+
+      def model
+        @model ||= model_class.classify.safe_constantize
+      end
+
+      def model_db_columns
+        @model_db_columns ||= model.columns_hash.reject { |name, _| db_columns_to_ignore.include? name }
+      end
+
+      def db_columns_to_ignore
+        %w[id encrypted_password reset_password_token reset_password_sent_at remember_created_at created_at updated_at]
+      end
+
+      def reflections
+        @reflections ||= model.reflections.reject do |name, _|
+          reflections_sufixes_to_ignore.include?(name.split("_").pop) || reflections_to_ignore.include?(name)
+        end
+      end
+
+      def reflections_sufixes_to_ignore
+        %w[blob blobs tags]
+      end
+
+      def reflections_to_ignore
+        %w[taggings]
+      end
+
+      def attachments
+        @attachments ||= reflections.select do |_, reflection|
+          reflection.options[:class_name] == "ActiveStorage::Attachment"
+        end
+      end
+
+      def tags
+        @tags ||= reflections.select { |_, reflection| reflection.options[:as] == :taggable }
+      end
+
+      def associations
+        @associations ||= reflections.reject { |key| attachments.key?(key) || tags.key?(key) }
+      end
+
+      def fields
+        @fields ||= {}
+      end
+
+      def invoked_by_model_generator?
+        @options.dig("from_model_generator")
+      end
+
+      def generate_fields
+        return generate_fields_from_args if invoked_by_model_generator?
+
+        if model.blank?
+          puts "Can't generate fields from model. '#{model_class}.rb' not found!"
+          return
+        end
+
+        fields_from_model_db_columns
+        fields_from_model_enums
+        fields_from_model_attachements
+        fields_from_model_associations
+        fields_from_model_tags
+
+        generated_fields_template
+      end
+
+      def generated_fields_template
+        return if fields.blank?
+
+        fields_string = "\n  # Fields generated from the model"
+
+        fields.each do |field_name, field_options|
+          options = ""
+          field_options[:options].each { |k, v| options += ", #{k}: #{v}" } if field_options[:options].present?
+
+          fields_string += "\n  #{field_string field_name, field_options[:field], options}"
+        end
+
+        fields_string
+      end
+
+      def field_string(name, type, options)
+        "field :#{name}, as: :#{type}#{options}"
+      end
+
+      def generate_fields_from_args
+        @args.each do |arg|
+          name, type = arg.split(":")
+          type = "string" if type.blank?
+          fields[name] = field(name, type.to_sym)
+        end
+
+        generated_fields_template
+      end
+
+      def fields_from_model_tags
+        tags.each do |name, _|
+          fields[(remove_last_word_from name).pluralize] = {field: "tags"}
+        end
+      end
+
+      def fields_from_model_associations
+        associations.each do |name, association|
+          fields[name] = associations_mapping[association.class]
+
+          if association.is_a? ActiveRecord::Reflection::ThroughReflection
+            fields[name][:options][:through] = ":#{association.options[:through]}"
+          end
+        end
+      end
+
+      def fields_from_model_attachements
+        attachments.each do |name, attachment|
+          fields[remove_last_word_from name] = attachments_mapping[attachment.class]
+        end
+      end
+
+      # "hello_world_hehe".split('_') => ['hello', 'world', 'hehe']
+      # ['hello', 'world', 'hehe'].pop => ['hello', 'world']
+      # ['hello', 'world'].join('_') => "hello_world"
+      def remove_last_word_from(snake_case_string)
+        snake_case_string = snake_case_string.split("_")
+        snake_case_string.pop
+        snake_case_string.join("_")
+      end
+
+      def fields_from_model_enums
+        model.defined_enums.each_key do |enum|
+          fields[enum] = {
+            field: "select",
+            options: {
+              enum: "::#{model_class.capitalize}.#{enum.pluralize}"
+            }
+          }
+        end
+      end
+
+      def fields_from_model_db_columns
+        model_db_columns.each do |name, data|
+          fields[name] = field(name, data.type)
+        end
+      end
+
+      def field(name, type)
+        names_mapping[name.to_sym] || fields_mapping[type.to_sym] || {field: "text"}
+      end
+
+      def associations_mapping
+        {
+          ActiveRecord::Reflection::BelongsToReflection => {
+            field: "belongs_to"
+          },
+          ActiveRecord::Reflection::HasOneReflection => {
+            field: "has_one"
+          },
+          ActiveRecord::Reflection::HasManyReflection => {
+            field: "has_many"
+          },
+          ActiveRecord::Reflection::ThroughReflection => {
+            field: "has_many",
+            options: {
+              through: ":..."
+            }
+          },
+          ActiveRecord::Reflection::HasAndBelongsToManyReflection => {
+            field: "has_and_belongs_to_many"
+          }
+        }
+      end
+
+      def attachments_mapping
+        {
+          ActiveRecord::Reflection::HasOneReflection => {
+            field: "file"
+          },
+          ActiveRecord::Reflection::HasManyReflection => {
+            field: "files"
+          }
+        }
+      end
+
+      def names_mapping
+        {
+          id: {
+            field: "id"
+          },
+          description: {
+            field: "textarea"
+          },
+          gravatar: {
+            field: "gravatar"
+          },
+          email: {
+            field: "text"
+          },
+          password: {
+            field: "password"
+          },
+          password_confirmation: {
+            field: "password"
+          },
+          stage: {
+            field: "select"
+          },
+          budget: {
+            field: "currency"
+          },
+          money: {
+            field: "currency"
+          },
+          country: {
+            field: "country"
+          }
+        }
+      end
+
+      def fields_mapping
+        {
+          primary_key: {
+            field: "id"
+          },
+          string: {
+            field: "text"
+          },
+          text: {
+            field: "textarea"
+          },
+          integer: {
+            field: "number"
+          },
+          float: {
+            field: "number"
+          },
+          decimal: {
+            field: "number"
+          },
+          datetime: {
+            field: "datetime"
+          },
+          timestamp: {
+            field: "datetime"
+          },
+          time: {
+            field: "datetime"
+          },
+          date: {
+            field: "date"
+          },
+          binary: {
+            field: "number"
+          },
+          boolean: {
+            field: "boolean"
+          },
+          references: {
+            field: "belongs_to"
+          },
+          json: {
+            field: "code"
+          }
+        }
+      end
     end
   end
 end

data/lib/generators/avo/templates/action.tt

@@ -1,5 +1,8 @@
 class <%= class_name.camelize %> < Avo::BaseAction
   self.name = "<%= name.underscore.humanize %>"
+  # self.visible = -> do
+  #   true
+  # end
 
   def handle(**args)
     models, fields, current_user, resource = args.values_at(:models, :fields, :current_user, :resource)

data/lib/generators/avo/templates/filters/boolean_filter.tt

@@ -1,5 +1,8 @@
 class <%= class_name.camelize %> < Avo::Filters::BooleanFilter
   self.name = "<%= name.underscore.humanize %>"
+  # self.visible = -> do
+  #   true
+  # end
 
   def apply(request, query, values)
     query

data/lib/generators/avo/templates/filters/multiple_select_filter.tt

@@ -1,5 +1,8 @@
 class <%= class_name.camelize %> < Avo::Filters::MultipleSelectFilter
   self.name = "<%= name.underscore.humanize %>"
+  # self.visible = -> do
+  #   true
+  # end
 
   def apply(request, query, value)
     query

data/lib/generators/avo/templates/filters/select_filter.tt

@@ -1,5 +1,8 @@
 class <%= class_name.camelize %> < Avo::Filters::SelectFilter
   self.name = "<%= name.underscore.humanize %>"
+  # self.visible = -> do
+  #   true
+  # end
 
   def apply(request, query, value)
     query

data/lib/generators/avo/templates/filters/text_filter.tt

@@ -1,6 +1,9 @@
 class <%= class_name.camelize %> < Avo::Filters::TextFilter
   self.name = "<%= name.underscore.humanize %>"
   self.button_label = 'Filter by <%= class_name.underscore.humanize.downcase.gsub(' filter', '') %>'
+  # self.visible = -> do
+  #   true
+  # end
 
   def apply(request, query, value)
     query

data/lib/generators/avo/templates/initializer/avo.tt

@@ -44,6 +44,10 @@ Avo.configure do |config|
   # config.via_per_page = 8
   # config.id_links_to_resource = false
   # config.cache_resources_on_index_view = true
+  ## permanent enable or disable cache_resource_filters, default value is false
+  # config.cache_resource_filters = false
+  ## provide a lambda to enable or disable cache_resource_filters per user/resource.
+  # config.cache_resource_filters = ->(current_user:, resource:) { current_user.cache_resource_filters?}
 
   ## == Customization ==
   # config.app_name = 'Avocadelicious'

data/lib/generators/avo/templates/resource/controller.tt

@@ -1,4 +1,4 @@
 # This controller has been generated to enable Rails' resource routes.
-# You shouldn't need to modify it in order to use Avo.
+# More information on https://docs.avohq.io/2.0/controllers.html
 class <%= controller_class %> < Avo::ResourcesController
 end

data/lib/generators/avo/templates/resource/resource.tt

@@ -1,10 +1,10 @@
 class <%= resource_class %> < Avo::BaseResource
   self.title = :id
-  self.includes = []
+  self.includes = []<%= model_class_from_args %>
   # self.search_query = -> do
   #   scope.ransack(id_eq: params[:q], m: "or").result(distinct: false)
   # end
 
-  field :id, as: :id
+  field :id, as: :id<%= generate_fields %>
   # add fields here
 end

data/lib/generators/model_generator.rb

@@ -0,0 +1,10 @@
+require 'rails/generators'
+require 'rails/generators/rails/model/model_generator'
+
+module Rails
+  module Generators
+    class ModelGenerator
+      hook_for :avo_resource, type: :boolean, default: true unless ARGV.include?("--skip-avo-resource")
+    end
+  end
+end

data/lib/generators/rails/avo_resource_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators/active_record/model/model_generator'
+
+module Rails
+  module Generators
+    class AvoResourceGenerator < ::Rails::Generators::Base
+      def invoke_avo_command
+        invoke "avo:resource", @args, {from_model_generator: true}
+      end
+    end
+  end
+end