rails_admin_next 1.0.0

data/lib/rails_admin_next/config/fields/types/polymorphic_association.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/types/belongs_to_association"
+
+module RailsAdminNext
+  module Config
+    module Fields
+      module Types
+        class PolymorphicAssociation < RailsAdminNext::Config::Fields::Types::BelongsToAssociation
+          # Register field type for the type loader
+          RailsAdminNext::Config::Fields::Types.register(self)
+
+          register_instance_option :partial do
+            :form_polymorphic_association
+          end
+
+          # Accessor whether association is visible or not. By default
+          # association checks that any of the child models are included in
+          # configuration.
+          register_instance_option :visible? do
+            associated_model_config.any?
+          end
+
+          register_instance_option :formatted_value do
+            (o = value) && o.send(RailsAdminNext.config(o).object_label_method)
+          end
+
+          register_instance_option :sortable do
+            false
+          end
+
+          register_instance_option :searchable do
+            false
+          end
+
+          # TODO: not supported yet
+          register_instance_option :associated_collection_cache_all do
+            false
+          end
+
+          # TODO: not supported yet
+          register_instance_option :associated_collection_scope do
+            nil
+          end
+
+          register_instance_option :allowed_methods do
+            [children_fields]
+          end
+
+          register_instance_option :eager_load do
+            false
+          end
+
+          def associated_model_config
+            @associated_model_config ||= association.klass.collect { |type| RailsAdminNext.config(type) }.reject(&:excluded?)
+          end
+
+          def collection(_scope = nil)
+            if value
+              [[formatted_value, selected_id]]
+            else
+              [[]]
+            end
+          end
+
+          def type_column
+            association.foreign_type.to_s
+          end
+
+          def type_collection
+            associated_model_config.collect do |config|
+              [config.label, config.abstract_model.model.name]
+            end
+          end
+
+          def type_urls
+            types = associated_model_config.collect do |config|
+              [config.abstract_model.model.name, config.abstract_model.to_param]
+            end
+            ::Hash[*types.collect { |v| [v[0], bindings[:view].index_path(v[1])] }.flatten]
+          end
+
+          # Reader for field's value
+          def value
+            bindings[:object].send(association.name)
+          end
+
+          def widget_options_for_types
+            type_collection.inject({}) do |options, model|
+              options.merge(
+                model.second.downcase.gsub("::", "-") => {
+                  xhr: true,
+                  remote_source: bindings[:view].index_path(model.second.underscore, source_object_id: bindings[:object].id, source_abstract_model: abstract_model.to_param, current_action: bindings[:view].current_action, compact: true),
+                  float_left: false
+                }
+              )
+            end
+          end
+
+          def widget_options
+            widget_options_for_types[selected_type.try(:downcase)] || {float_left: false}
+          end
+
+          def selected_type
+            bindings[:object].send(type_column)
+          end
+
+          def parse_input(params)
+            if (type_value = params[association.foreign_type.to_sym]).present?
+              config = associated_model_config.find { |c| type_value == c.abstract_model.model.name }
+              params[association.foreign_type.to_sym] = config.abstract_model.base_class.name if config
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/fields/types/serialized.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/types/text"
+
+module RailsAdminNext
+  module Config
+    module Fields
+      module Types
+        class Serialized < RailsAdminNext::Config::Fields::Types::Text
+          # Register field type for the type loader
+          RailsAdminNext::Config::Fields::Types.register(self)
+
+          register_instance_option :formatted_value do
+            RailsAdminNext.yaml_dump(value) unless value.nil?
+          end
+
+          def parse_value(value)
+            value.present? ? (RailsAdminNext.yaml_load(value) || nil) : nil
+          end
+
+          def parse_input(params)
+            params[name] = parse_value(params[name]) if params[name].is_a?(::String)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/fields/types/string.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/types/string_like"
+
+module RailsAdminNext
+  module Config
+    module Fields
+      module Types
+        class String < StringLike
+          RailsAdminNext::Config::Fields::Types.register(self)
+
+          def input_size
+            [50, length.to_i].reject(&:zero?).min
+          end
+
+          register_instance_option :html_attributes do
+            {
+              required: required?,
+              maxlength: length,
+              size: input_size
+            }
+          end
+
+          def generic_help
+            text = "#{required? ? I18n.translate("admin.form.required") : I18n.translate("admin.form.optional")}. "
+            if valid_length.present? && valid_length[:is].present?
+              text += "#{I18n.translate("admin.form.char_length_of").capitalize} #{valid_length[:is]}."
+            else
+              max_length = [length, valid_length[:maximum] || nil].compact.min
+              min_length = [0, valid_length[:minimum] || nil].compact.max
+              if max_length
+                text +=
+                  if min_length == 0
+                    "#{I18n.translate("admin.form.char_length_up_to").capitalize} #{max_length}."
+                  else
+                    "#{I18n.translate("admin.form.char_length_of").capitalize} #{min_length}-#{max_length}."
+                  end
+              end
+            end
+            text
+          end
+
+          register_instance_option :partial do
+            :form_field
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/fields/types/string_like.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/base"
+
+module RailsAdminNext
+  module Config
+    module Fields
+      module Types
+        class StringLike < RailsAdminNext::Config::Fields::Base
+          register_instance_option :filter_operators do
+            %w[_discard like not_like is starts_with ends_with] + (required? ? [] : %w[_separator _present _blank])
+          end
+
+          register_instance_option :treat_empty_as_nil? do
+            properties.try(:nullable?)
+          end
+
+          def parse_input(params)
+            params[name] = params[name].presence if params.key?(name) && treat_empty_as_nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/fields/types/text.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/types/string_like"
+
+module RailsAdminNext
+  module Config
+    module Fields
+      module Types
+        class Text < StringLike
+          # Register field type for the type loader
+          RailsAdminNext::Config::Fields::Types.register(self)
+
+          register_instance_option :html_attributes do
+            {
+              required: required?,
+              cols: "48",
+              rows: "3"
+            }
+          end
+
+          register_instance_option :partial do
+            :form_text
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/fields/types/time.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/types/datetime"
+
+module RailsAdminNext
+  module Config
+    module Fields
+      module Types
+        class Time < RailsAdminNext::Config::Fields::Types::Datetime
+          RailsAdminNext::Config::Fields::Types.register(self)
+
+          def parse_value(value)
+            parsed = super
+            return unless parsed
+
+            # Anchor to the dummy date in the zone *before* serializing so the wall-clock time is
+            # preserved at that date's UTC offset. A native <input type="time"> submits a bare
+            # %H:%M:%S, which Time.zone.parse resolves against today — whose DST offset can differ
+            # from the time column's 2000-01-01 storage date and would otherwise shift the hour.
+            abstract_model.model.type_for_attribute(name.to_s).serialize(parsed.change(year: 2000, month: 1, day: 1))
+          end
+
+          register_instance_option :filter_operators do
+            %w[default between] + (required? ? [] : %w[_separator _not_null _null])
+          end
+
+          register_instance_option :strftime_format do
+            "%H:%M"
+          end
+
+          # The native <input type="time" step="1"> control accepts and emits %H:%M:%S.
+          def form_value
+            value&.in_time_zone&.strftime("%H:%M:%S") || form_default_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/fields/types/timestamp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/types/datetime"
+
+module RailsAdminNext
+  module Config
+    module Fields
+      module Types
+        class Timestamp < RailsAdminNext::Config::Fields::Types::Datetime
+          # Register field type for the type loader
+          RailsAdminNext::Config::Fields::Types.register(self)
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/fields/types/uuid.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/types/string"
+
+module RailsAdminNext
+  module Config
+    module Fields
+      module Types
+        class Uuid < RailsAdminNext::Config::Fields::Types::String
+          RailsAdminNext::Config::Fields::Types.register(self)
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/fields/types.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
+require "rails_admin_next/config/fields"
+require "rails_admin_next/config/fields/association"
+
+module RailsAdminNext
+  module Config
+    module Fields
+      module Types
+        @@registry = {}
+
+        def self.load(type)
+          @@registry.fetch(type.to_sym) { raise "Unsupported field datatype: #{type}" }
+        end
+
+        def self.register(type, klass = nil)
+          if klass.nil? && type.is_a?(Class)
+            klass = type
+            type = klass.name.to_s.demodulize.underscore
+          end
+          @@registry[type.to_sym] = klass
+        end
+
+        require "rails_admin_next/config/fields/types/all"
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/fields.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  module Config
+    module Fields
+      # Default field factory loads fields based on their property type or
+      # association type.
+      #
+      # @see RailsAdminNext::Config::Fields.registry
+      mattr_reader :default_factory
+      @@default_factory = proc do |parent, properties, fields|
+        # If it's an association
+        if properties.association?
+          association = parent.abstract_model.associations.detect { |a| a.name.to_s == properties.name.to_s }
+          field = RailsAdminNext::Config::Fields::Types.load("#{association.polymorphic? ? :polymorphic : properties.type}_association").new(parent, properties.name, association)
+        else
+          field = RailsAdminNext::Config::Fields::Types.load(properties.type).new(parent, properties.name, properties)
+        end
+        fields << field
+        field
+      end
+
+      # Registry of field factories.
+      #
+      # Field factory is an anonymous function that receives the parent object,
+      # an array of field properties and an array of fields already instantiated.
+      #
+      # If the factory returns true then that property will not be run through
+      # the rest of the registered factories. If it returns false then the
+      # arguments will be passed to the next factory.
+      #
+      # By default a basic factory is registered which loads fields by their
+      # database column type. Also a password factory is registered which
+      # loads fields if their name is password. A third factory handles
+      # encrypted_password columns (used by Devise and similar libs).
+      #
+      # @see RailsAdminNext::Config::Fields.register_factory
+      # @see rails_admin_next/config/fields/factories/password.rb
+      # @see rails_admin_next/config/fields/factories/encrypted_password.rb
+      @@registry = [@@default_factory]
+
+      # Build an array of fields by the provided parent object's abstract_model's
+      # property and association information. Each property and association is
+      # passed to the registered field factories which will populate the fields
+      # array that will be returned.
+      #
+      # @see RailsAdminNext::Config::Fields.registry
+      def self.factory(parent)
+        fields = []
+        # Load fields for all properties (columns)
+
+        parent.abstract_model.properties.each do |properties|
+          # Unless a previous factory has already loaded current field as well
+          next if fields.detect { |f| f.name == properties.name }
+
+          # Loop through factories until one returns true
+          @@registry.detect { |factory| factory.call(parent, properties, fields) }
+        end
+        # Load fields for all associations (relations)
+        parent.abstract_model.associations.reject { |a| a.type == :belongs_to }.each do |association| # :belongs_to are created by factory for belongs_to fields
+          # Unless a previous factory has already loaded current field as well
+          next if fields.detect { |f| f.name == association.name }
+
+          # Loop through factories until one returns true
+          @@registry.detect { |factory| factory.call(parent, association, fields) }
+        end
+        fields
+      end
+
+      # Register a field factory to be included in the factory stack.
+      #
+      # Factories are invoked lifo (last in first out).
+      #
+      # @see RailsAdminNext::Config::Fields.registry
+      def self.register_factory(&block)
+        @@registry.unshift(block)
+      end
+    end
+  end
+end
+
+require "rails_admin_next/config/fields/types"
+require "rails_admin_next/config/fields/factories/password"
+require "rails_admin_next/config/fields/factories/enum"
+require "rails_admin_next/config/fields/factories/encrypted_password"
+require "rails_admin_next/config/fields/factories/active_storage"
+require "rails_admin_next/config/fields/factories/action_text"
+require "rails_admin_next/config/fields/factories/association"

data/lib/rails_admin_next/config/groupable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/group"
+
+module RailsAdminNext
+  module Config
+    module Groupable
+      # Register a group instance variable and accessor methods for objects
+      # extending the has groups mixin. The extended objects must implement
+      # reader for a parent object which includes this module.
+      #
+      # @see RailsAdminNext::Config::HasGroups.group
+      # @see RailsAdminNext::Config::Fields::Group
+      def group(name = nil)
+        @group = parent.group(name) unless name.nil? # setter
+        @group ||= parent.group(:default) # getter
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/has_description.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  module Config
+    # Provides accessor and autoregistering of model's description.
+    module HasDescription
+      attr_reader :description
+
+      def desc(description, &_block)
+        @description ||= description
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/has_fields.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  module Config
+    # Provides accessors and autoregistering of model's fields.
+    module HasFields
+      # Defines a configuration for a field.
+      def field(name, type = nil, add_to_section = true, &block)
+        field = _fields.detect { |f| name == f.name }
+
+        # some fields are hidden by default (belongs_to keys, has_many associations in list views.)
+        # unhide them if config specifically defines them
+        field.show if field && !field.instance_variable_get("@#{field.name}_registered").is_a?(Proc)
+        # Specify field as virtual if type is not specifically set and field was not
+        # found in default stack
+        if field.nil? && type.nil?
+          field = (_fields << RailsAdminNext::Config::Fields::Types.load(:string).new(self, name, nil)).last
+
+        # Register a custom field type if one is provided and it is different from
+        # one found in default stack
+        elsif type && type != (field.nil? ? nil : field.type)
+          if field
+            properties = field.properties
+            field = _fields[_fields.index(field)] = RailsAdminNext::Config::Fields::Types.load(type).new(self, name, properties)
+          else
+            properties = abstract_model.properties.detect { |p| name == p.name }
+            field = (_fields << RailsAdminNext::Config::Fields::Types.load(type).new(self, name, properties)).last
+          end
+        end
+
+        # If field has not been yet defined add some default properties
+        if add_to_section && !field.defined
+          field.defined = true
+          field.order = _fields.count(&:defined)
+        end
+
+        # If a block has been given evaluate it and sort fields after that
+        field.instance_eval(&block) if block
+        field
+      end
+
+      # configure field(s) from the default group in a section without changing the original order.
+      def configure(name, type = nil, &)
+        [*name].each { |field_name| field(field_name, type, false, &) }
+      end
+
+      # include fields by name and apply an optional block to each (through a call to fields),
+      # or include fields by conditions if no field names
+      def include_fields(*field_names, &)
+        if field_names.empty?
+          _fields.select { |f| f.instance_eval(&) }.each do |f|
+            next if f.defined
+
+            f.defined = true
+            f.order = _fields.count(&:defined)
+          end
+        else
+          fields(*field_names, &)
+        end
+      end
+
+      # exclude fields by name or by condition (block)
+      def exclude_fields(*field_names, &block)
+        block ||= proc { |f| field_names.include?(f.name) }
+        _fields.each { |f| f.defined = true } if _fields.select(&:defined).empty?
+        _fields.select { |f| f.instance_eval(&block) }.each { |f| f.defined = false }
+      end
+
+      # API candy
+      alias_method :exclude_fields_if, :exclude_fields
+      alias_method :include_fields_if, :include_fields
+
+      def include_all_fields
+        include_fields_if { true }
+      end
+
+      # Returns all field configurations for the model configuration instance. If no fields
+      # have been defined returns all fields. Defined fields are sorted to match their
+      # order property. If order was not specified it will match the order in which fields
+      # were defined.
+      #
+      # If a block is passed it will be evaluated in the context of each field
+      def fields(*field_names, &block)
+        return all_fields if field_names.empty? && !block
+
+        if field_names.empty?
+          defined = _fields.select(&:defined)
+          defined = _fields if defined.empty?
+        else
+          defined = field_names.collect { |field_name| _fields.detect { |f| f.name == field_name } }
+        end
+        defined.collect do |f|
+          unless f.defined
+            f.defined = true
+            f.order = _fields.count(&:defined)
+          end
+          f.instance_eval(&block) if block
+          f
+        end
+      end
+
+      # Defines configuration for fields by their type.
+      def fields_of_type(type, &block)
+        _fields.select { |f| type == f.type }.map! { |f| f.instance_eval(&block) } if block
+      end
+
+      # Accessor for all fields
+      def all_fields
+        ((ro_fields = _fields(true)).select(&:defined).presence || ro_fields).collect do |f|
+          f.section = self
+          f
+        end
+      end
+
+      # Get all fields defined as visible, in the correct order.
+      def visible_fields
+        i = 0
+        all_fields.collect { |f| f.with(bindings) }.select(&:visible?).sort_by { |f| [f.order, i += 1] } # stable sort, damn
+      end
+
+      def possible_fields
+        _fields(true)
+      end
+
+      protected
+
+      # Raw fields.
+      # Recursively returns parent section's raw fields
+      # Duping it if accessed for modification.
+      def _fields(readonly = false)
+        return @_fields if @_fields
+        return @_ro_fields if readonly && @_ro_fields
+
+        if instance_of?(RailsAdminNext::Config::Sections::Base)
+          @_ro_fields = @_fields = RailsAdminNext::Config::Fields.factory(self)
+        else
+          # parent is RailsAdminNext::Config::Model, recursion is on Section's classes
+          @_ro_fields ||= parent.send(self.class.superclass.to_s.underscore.split("/").last)._fields(true).clone.freeze
+        end
+        readonly ? @_ro_fields : (@_fields ||= @_ro_fields.collect(&:clone))
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/has_groups.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/config/fields/group"
+
+module RailsAdminNext
+  module Config
+    module HasGroups
+      # Accessor for a group
+      #
+      # If group with given name does not yet exist it will be created. If a
+      # block is passed it will be evaluated in the context of the group
+      def group(name, &block)
+        group = parent.groups.detect { |g| name == g.name }
+        group ||= (parent.groups << RailsAdminNext::Config::Fields::Group.new(self, name)).last
+        group.tap { |g| g.section = self }.instance_eval(&block) if block
+        group
+      end
+
+      # Reader for groups that are marked as visible
+      def visible_groups
+        parent.groups.collect { |f| f.section = self; f.with(bindings) }.select(&:visible?).select do |g| # rubocop:disable Style/Semicolon
+          g.visible_fields.present?
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/config/hideable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  module Config
+    # Defines a visibility configuration
+    module Hideable
+      # Visibility defaults to true.
+      def self.included(klass)
+        klass.register_instance_option :visible? do
+          !root.try :excluded?
+        end
+      end
+
+      # Reader whether object is hidden.
+      def hidden?
+        !visible
+      end
+
+      # Writer to hide object.
+      def hide(&block)
+        visible block ? proc { instance_eval(&block) == false } : false
+      end
+
+      # Writer to show field.
+      def show(&block)
+        visible block || true
+      end
+    end
+  end
+end