motor-admin 0.1.64 → 0.1.70

data/lib/motor/active_record_utils.rb

@@ -22,3 +22,4 @@ require_relative './active_record_utils/active_storage_links_extension'
 require_relative './active_record_utils/active_storage_blob_patch'
 require_relative './active_record_utils/active_record_filter_patch'
 require_relative './active_record_utils/active_record_connection_column_patch'
+require_relative './active_record_utils/action_text_attribute_patch'

data/lib/motor/active_record_utils/action_text_attribute_patch.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+if defined?(ActionText::Attribute)
+  ActionText::Attribute::ClassMethods.prepend(Module.new do
+    # rubocop:disable Naming/PredicateName
+    def has_rich_text(*args)
+      super
+
+      name = args.first
+
+      alias_method :"#{name}_body=", :"#{name}="
+
+      define_method(:"#{name}_body") do
+        send(name).body&.to_trix_html
+      end
+    end
+    # rubocop:enable Naming/PredicateName
+  end)
+end

data/lib/motor/active_record_utils/active_record_connection_column_patch.rb

@@ -10,4 +10,5 @@ ActiveRecord::ConnectionAdapters::Column.class_eval do
   def array
     false
   end
+  alias_method :array?, :array
 end

data/lib/motor/active_record_utils/active_record_filter_patch.rb

@@ -5,3 +5,14 @@ ActiveRecord::Filter.module_eval do
     @filters ||= HashWithIndifferentAccess.new
   end
 end
+
+if Rails::VERSION::MAJOR == 6
+  ActiveRecord::Relation::Filter.module_eval do
+    def build_arel(aliases = nil)
+      arel = super
+      my_alias_tracker = ActiveRecord::Associations::AliasTracker.create(connection, table.name, [])
+      build_filters(arel, my_alias_tracker)
+      arel
+    end
+  end
+end

data/lib/motor/active_record_utils/active_storage_links_extension.rb

@@ -6,10 +6,6 @@ module Motor
       def path
         Rails.application.routes.url_helpers.rails_blob_path(self, only_path: true)
       end
-
-      def url
-        Rails.application.routes.url_helpers.url_for(self)
-      end
     end
   end
 end

data/lib/motor/build_schema.rb

@@ -22,40 +22,6 @@ module Motor
 
     DEFAULT_SCOPE_TYPE = 'default'
 
-    DEFAULT_ACTIONS = [
-      {
-        name: 'create',
-        display_name: 'Create',
-        action_type: 'default',
-        preferences: {},
-        visible: true
-      },
-      {
-        name: 'edit',
-        display_name: 'Edit',
-        action_type: 'default',
-        preferences: {},
-        visible: true
-      },
-      {
-        name: 'remove',
-        display_name: 'Remove',
-        action_type: 'default',
-        preferences: {},
-        visible: true
-      }
-    ].freeze
-
-    DEFAULT_TABS = [
-      {
-        name: 'details',
-        display_name: 'Details',
-        tab_type: 'default',
-        preferences: {},
-        visible: true
-      }
-    ].freeze
-
     module_function
 
     def call(cache_keys = {}, current_ability = nil)
@@ -78,3 +44,4 @@ require_relative './build_schema/reorder_schema'
 require_relative './build_schema/merge_schema_configs'
 require_relative './build_schema/apply_permissions'
 require_relative './build_schema/utils'
+require_relative './build_schema/defaults'

data/lib/motor/build_schema/active_storage_attachment_schema.rb

@@ -2,113 +2,123 @@
 
 module Motor
   module BuildSchema
-    ACTIVE_STORAGE_ATTACHMENT_SCHEMA = {
-      name: 'active_storage/attachment',
-      slug: 'active_storage__attachments',
-      class_name: 'ActiveStorage::Attachment',
-      table_name: 'active_storage_attachments',
-      primary_key: 'id',
-      display_name: 'Attachments',
-      display_column: 'filename',
-      icon: 'paperclip',
-      columns: [
-        {
-          name: 'id',
-          display_name: 'ID',
-          column_type: 'integer',
-          access_type: 'read_only',
-          default_value: nil,
-          validators: [],
-          format: {},
-          is_array: false,
-          reference: nil,
-          virtual: false
-        },
-        {
-          name: 'path',
-          display_name: 'Path',
-          column_type: 'string',
-          access_type: 'read_only',
-          default_value: nil,
-          validators: [],
-          format: {},
-          is_array: false,
-          reference: nil,
-          virtual: true
-        },
-        {
-          name: 'name',
-          display_name: 'Name',
-          column_type: 'string',
-          access_type: 'read_write',
-          default_value: nil,
-          validators: [],
-          format: {},
-          is_array: false,
-          reference: nil,
-          virtual: false
-        },
-        {
-          name: 'record_type',
-          display_name: 'Record type',
-          column_type: 'string',
-          access_type: 'read_write',
-          default_value: nil,
-          validators: [],
-          format: {},
-          is_array: false,
-          reference: nil,
-          virtual: false
-        },
-        {
-          name: 'record_id',
-          display_name: 'Record',
-          column_type: 'integer',
-          access_type: 'read_write',
-          default_value: nil,
-          validators: [],
-          format: {},
-          is_array: false,
-          reference: {
-            name: 'record',
-            display_name: 'Record',
-            model_name: nil,
-            reference_type: 'belongs_to',
-            foreign_key: 'record_id',
-            polymorphic: true
-          },
-          virtual: false
-        },
-        {
-          name: 'file',
-          display_name: 'File',
-          column_type: 'file',
-          access_type: 'write_only',
-          default_value: nil,
-          validators: [],
-          format: {},
-          is_array: false,
-          reference: nil,
-          virtual: false
-        },
+    module ActiveStorageAttachmentSchema
+      module_function
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def call
+        model = ActiveStorage::Attachment
+
         {
-          name: 'created_at',
-          display_name: 'Created at',
-          column_type: 'datetime',
-          access_type: 'read_only',
-          default_value: nil,
-          validators: [],
-          format: {},
-          is_array: false,
-          reference: nil,
-          virtual: false
-        }
-      ],
-      associations: [],
-      scopes: [],
-      actions: Motor::BuildSchema::DEFAULT_ACTIONS.reject { |e| e[:name] == 'edit' },
-      tabs: Motor::BuildSchema::DEFAULT_TABS,
-      visible: true
-    }.with_indifferent_access
+          name: model.name.underscore,
+          slug: Utils.slugify(model),
+          class_name: model.class.name,
+          table_name: model.table_name,
+          primary_key: model.primary_key,
+          display_name: model.model_name.human(count: 2, default: 'Attachments'),
+          display_column: 'filename',
+          icon: 'paperclip',
+          columns: [
+            {
+              name: 'id',
+              display_name: 'ID',
+              column_type: 'integer',
+              access_type: 'read_only',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            },
+            {
+              name: 'path',
+              display_name: model.human_attribute_name(:path),
+              column_type: 'string',
+              access_type: 'read_only',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: true
+            },
+            {
+              name: 'name',
+              display_name: model.human_attribute_name(:name),
+              column_type: 'string',
+              access_type: 'read_write',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            },
+            {
+              name: 'record_type',
+              display_name: model.human_attribute_name(:record_type),
+              column_type: 'string',
+              access_type: 'read_write',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            },
+            {
+              name: 'record_id',
+              display_name: model.human_attribute_name(:record),
+              column_type: 'integer',
+              access_type: 'read_write',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: {
+                name: 'record',
+                display_name: model.human_attribute_name(:record),
+                model_name: nil,
+                reference_type: 'belongs_to',
+                foreign_key: 'record_id',
+                polymorphic: true
+              },
+              virtual: false
+            },
+            {
+              name: 'file',
+              display_name: model.human_attribute_name(:file),
+              column_type: 'file',
+              access_type: 'write_only',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            },
+            {
+              name: 'created_at',
+              display_name: model.human_attribute_name(:created_at),
+              column_type: 'datetime',
+              access_type: 'read_only',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            }
+          ],
+          associations: [],
+          scopes: [],
+          actions: Motor::BuildSchema::Defaults.actions.reject { |e| e[:name] == 'edit' },
+          tabs: Motor::BuildSchema::Defaults.tabs,
+          visible: true
+        }.with_indifferent_access
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+    end
   end
 end

data/lib/motor/build_schema/adjust_devise_model_schema.rb

@@ -47,7 +47,7 @@ module Motor
       def add_password_column!(columns)
         columns << {
           name: 'password',
-          display_name: 'Password',
+          display_name: I18n.t('motor.password'),
           column_type: 'string',
           access_type: 'write_only',
           default_value: nil,

data/lib/motor/build_schema/defaults.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module Defaults
+      module_function
+
+      # rubocop:disable Metrics/MethodLength
+      def actions
+        [
+          {
+            name: 'create',
+            display_name: I18n.t('motor.create'),
+            action_type: 'default',
+            preferences: {},
+            visible: true
+          },
+          {
+            name: 'edit',
+            display_name: I18n.t('motor.edit'),
+            action_type: 'default',
+            preferences: {},
+            visible: true
+          },
+          {
+            name: 'remove',
+            display_name: I18n.t('motor.remove'),
+            action_type: 'default',
+            preferences: {},
+            visible: true
+          }
+        ].freeze
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def tabs
+        [
+          {
+            name: 'details',
+            display_name: I18n.t('motor.details'),
+            tab_type: 'default',
+            preferences: {},
+            visible: true
+          }
+        ].freeze
+      end
+    end
+  end
+end

data/lib/motor/build_schema/load_from_rails.rb

@@ -6,6 +6,13 @@ module Motor
       MUTEX = Mutex.new
       UNIFIED_TYPES = ActiveRecordUtils::Types::UNIFIED_TYPES
 
+      I18N_SCOPES_KEY = 'activerecord.scopes'
+
+      ACTION_TEXT_REFLECTION_PREFIX = 'rich_text_'
+      ACTION_TEXT_COLUMN_SUFFIX = '_body'
+      ACTION_TEXT_SCOPE_PREFIX = 'with_rich_text_'
+      ACTIVE_STORAGE_SCOPE_PREFIX = 'with_attached_'
+
       module_function
 
       def call
@@ -38,6 +45,7 @@ module Motor
         models -= [ActiveRecord::SchemaMigration] if defined?(ActiveRecord::SchemaMigration)
         models -= [ActiveRecord::InternalMetadata] if defined?(ActiveRecord::InternalMetadata)
         models -= [ActiveStorage::Blob] if defined?(ActiveStorage::Blob)
+        models -= [ActionText::RichText] if defined?(ActionText::RichText)
         models -= [ActiveStorage::VariantRecord] if defined?(ActiveStorage::VariantRecord)
 
         models
@@ -46,7 +54,7 @@ module Motor
       def build_model_schema(model)
         model_name = model.name
 
-        return Motor::BuildSchema::ACTIVE_STORAGE_ATTACHMENT_SCHEMA if model_name == 'ActiveStorage::Attachment'
+        return Motor::BuildSchema::ActiveStorageAttachmentSchema.call if model_name == 'ActiveStorage::Attachment'
 
         {
           name: model_name.underscore,
@@ -54,14 +62,14 @@ module Motor
           table_name: model.table_name,
           class_name: model.name,
           primary_key: model.primary_key,
-          display_name: model_name.titleize.pluralize,
+          display_name: model.model_name.human(count: :many, default: model_name.titleize.pluralize),
           display_column: FindDisplayColumn.call(model),
           columns: fetch_columns(model),
           associations: fetch_associations(model),
-          icon: Motor::FindIcon.call(model.name.titleize),
+          icon: Motor::FindIcon.call(model_name),
           scopes: fetch_scopes(model),
-          actions: DEFAULT_ACTIONS,
-          tabs: DEFAULT_TABS,
+          actions: BuildSchema::Defaults.actions,
+          tabs: BuildSchema::Defaults.tabs,
           visible: true
         }.with_indifferent_access
       end
@@ -70,11 +78,14 @@ module Motor
         model.defined_scopes.map do |scope_name|
           scope_name = scope_name.to_s
 
-          next if scope_name.starts_with?('with_attached')
+          next if scope_name.starts_with?(ACTIVE_STORAGE_SCOPE_PREFIX)
+          next if scope_name.starts_with?(ACTION_TEXT_SCOPE_PREFIX)
 
           {
             name: scope_name,
-            display_name: scope_name.humanize,
+            display_name: I18n.t(scope_name,
+                                 scope: [I18N_SCOPES_KEY, model.name.underscore].join('.'),
+                                 default: scope_name.humanize),
             scope_type: DEFAULT_SCOPE_TYPE,
             visible: true,
             preferences: {}
@@ -102,9 +113,9 @@ module Motor
 
         {
           name: column.name,
-          display_name: Utils.humanize_column_name(column.name),
+          display_name: Utils.humanize_column_name(model.human_attribute_name(column.name)),
           column_type: is_enum ? 'string' : UNIFIED_TYPES[column.type.to_s] || column.type.to_s,
-          is_array: column.respond_to?(:array?) && column.array?,
+          is_array: column.array?,
           access_type: COLUMN_NAME_ACCESS_TYPES.fetch(column.name, ColumnAccessTypes::READ_WRITE),
           default_value: default_attrs[column.name],
           validators: fetch_validators(model, column.name),
@@ -135,27 +146,47 @@ module Motor
       end
 
       def build_reflection_column(name, model, ref, default_attrs)
+        if !ref.polymorphic? && ref.klass.name == 'ActionText::RichText'
+          return build_action_text_column(name, model, ref)
+        end
+
         column_name = ref.belongs_to? ? ref.foreign_key.to_s : name
         is_attachment = !ref.polymorphic? && ref.klass.name == 'ActiveStorage::Attachment'
         access_type = ref.belongs_to? || is_attachment ? ColumnAccessTypes::READ_WRITE : ColumnAccessTypes::READ_ONLY
 
         {
           name: column_name,
-          display_name: column_name.humanize,
+          display_name: model.human_attribute_name(name),
           column_type: is_attachment ? 'file' : 'integer',
           access_type: access_type,
           default_value: default_attrs[column_name],
           validators: fetch_validators(model, column_name, ref),
           format: {},
-          reference: build_reference(name, ref),
+          reference: build_reference(model, name, ref),
           virtual: false
         }
       end
 
-      def build_reference(name, reflection)
+      def build_action_text_column(name, model, ref)
+        name = name.delete_prefix(ACTION_TEXT_REFLECTION_PREFIX)
+
+        {
+          name: name + ACTION_TEXT_COLUMN_SUFFIX,
+          display_name: model.human_attribute_name(name),
+          column_type: 'richtext',
+          access_type: BuildSchema::ColumnAccessTypes::READ_WRITE,
+          default_value: '',
+          validators: fetch_validators(model, name, ref),
+          format: {},
+          reference: nil,
+          virtual: true
+        }
+      end
+
+      def build_reference(model, name, reflection)
         {
           name: name,
-          display_name: name.humanize,
+          display_name: model.human_attribute_name(name),
           model_name: reflection.polymorphic? ? nil : reflection.klass.name.underscore,
           reference_type: reflection.belongs_to? ? 'belongs_to' : 'has_one',
           foreign_key: reflection.foreign_key,
@@ -175,7 +206,7 @@ module Motor
 
           {
             name: name,
-            display_name: name.humanize,
+            display_name: model.human_attribute_name(name),
             slug: name.underscore,
             model_name: model_class.name.underscore,
             foreign_key: ref.foreign_key,