administrate 0.12.0 → 0.20.1

data/lib/administrate/field/belongs_to.rb

@@ -3,8 +3,18 @@ require_relative "associative"
 module Administrate
   module Field
     class BelongsTo < Associative
-      def self.permitted_attribute(attr, _options = nil)
-        :"#{attr}_id"
+      def self.permitted_attribute(attr, options = {})
+        resource_class = options[:resource_class]
+        if resource_class
+          foreign_key_for(resource_class, attr)
+        else
+          Administrate.warn_of_missing_resource_class
+          :"#{attr}_id"
+        end
+      end
+
+      def self.eager_load?
+        true
       end
 
       def permitted_attribute
@@ -12,13 +22,20 @@ module Administrate
       end
 
       def associated_resource_options
-        [nil] + candidate_resources.map do |resource|
-          [display_candidate_resource(resource), resource.send(primary_key)]
+        candidate_resources.map do |resource|
+          [
+            display_candidate_resource(resource),
+            resource.send(association_primary_key),
+          ]
         end
       end
 
       def selected_option
-        data && data.send(primary_key)
+        data&.send(association_primary_key)
+      end
+
+      def include_blank_option
+        options.fetch(:include_blank, true)
       end
 
       private

data/lib/administrate/field/date.rb

@@ -0,0 +1,20 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Date < Base
+      def date
+        I18n.localize(
+          data.to_date,
+          format: format,
+        )
+      end
+
+      private
+
+      def format
+        options.fetch(:format, :default)
+      end
+    end
+  end
+end

data/lib/administrate/field/deferred.rb

@@ -21,17 +21,40 @@ module Administrate
           options == other.options
       end
 
+      def associative?
+        deferred_class.associative?
+      end
+
+      def eager_load?
+        deferred_class.eager_load?
+      end
+
       def searchable?
         options.fetch(:searchable, deferred_class.searchable?)
       end
 
       def searchable_field
+        Administrate.deprecator.warn(
+          "searchable_field is deprecated, use searchable_fields instead",
+        )
         options.fetch(:searchable_field)
       end
 
-      def permitted_attribute(attr, _options = nil)
-        options.fetch(:foreign_key,
-          deferred_class.permitted_attribute(attr, options))
+      def searchable_fields
+        if options.key?(:searchable_field)
+          [searchable_field]
+        else
+          options.fetch(:searchable_fields)
+        end
+      end
+
+      def permitted_attribute(attr, opts = {})
+        if options.key?(:foreign_key)
+          Administrate.warn_of_deprecated_option(:foreign_key)
+          options.fetch(:foreign_key)
+        else
+          deferred_class.permitted_attribute(attr, options.merge(opts))
+        end
       end
 
       delegate :html_class, to: :deferred_class

data/lib/administrate/field/has_many.rb

@@ -7,12 +7,26 @@ module Administrate
     class HasMany < Associative
       DEFAULT_LIMIT = 5
 
-      def self.permitted_attribute(attr, _options = nil)
+      def self.permitted_attribute(attr, _options = {})
+        # This may seem arbitrary, and improvable by using reflection.
+        # Worry not: here we do exactly what Rails does. Regardless of the name
+        # of the foreign key, has_many associations use the suffix `_ids`
+        # for this.
+        #
+        # Eg: if the associated table and primary key are `countries.code`,
+        # you may expect `country_codes` as attribute here, but it will
+        # be `country_ids` instead.
+        #
+        # See https://github.com/rails/rails/blob/b30a23f53b52e59d31358f7b80385ee5c2ba3afe/activerecord/lib/active_record/associations/builder/collection_association.rb#L48
         { "#{attr.to_s.singularize}_ids".to_sym => [] }
       end
 
       def associated_collection(order = self.order)
-        Administrate::Page::Collection.new(associated_dashboard, order: order)
+        Administrate::Page::Collection.new(
+          associated_dashboard,
+          order: order,
+          collection_attributes: options[:collection_attributes],
+        )
       end
 
       def attribute_key
@@ -20,32 +34,45 @@ module Administrate
       end
 
       def associated_resource_options
-        candidate_resources.map do |resource|
-          [display_candidate_resource(resource), resource.send(primary_key)]
+        candidate_resources.map do |associated_resource|
+          [
+            display_candidate_resource(associated_resource),
+            associated_resource.send(association_primary_key),
+          ]
         end
       end
 
       def selected_options
         return if data.empty?
 
-        data.map { |object| object.send(primary_key) }
+        data.map { |object| object.send(association_primary_key) }
       end
 
       def limit
         options.fetch(:limit, DEFAULT_LIMIT)
       end
 
+      def paginate?
+        limit.respond_to?(:positive?) ? limit.positive? : limit.present?
+      end
+
       def permitted_attribute
-        self.class.permitted_attribute(attribute)
+        self.class.permitted_attribute(
+          attribute,
+          resource_class: resource.class,
+        )
       end
 
       def resources(page = 1, order = self.order)
-        resources = order.apply(data).page(page).per(limit)
+        resources = order.apply(data)
+        if paginate?
+          resources = resources.page(page).per(limit)
+        end
         includes.any? ? resources.includes(*includes) : resources
       end
 
       def more_than_limit?
-        data.count(:all) > limit
+        paginate? && data.count(:all) > limit
       end
 
       def data

data/lib/administrate/field/has_one.rb

@@ -3,6 +3,33 @@ require_relative "associative"
 module Administrate
   module Field
     class HasOne < Associative
+      def self.permitted_attribute(attr, options = {})
+        resource_class = options[:resource_class]
+        final_associated_class_name =
+          if options.key?(:class_name)
+            Administrate.warn_of_deprecated_option(:class_name)
+            options.fetch(:class_name)
+          elsif resource_class
+            associated_class_name(resource_class, attr)
+          else
+            Administrate.warn_of_missing_resource_class
+            if options
+              attr.to_s.singularize.camelcase
+            else
+              attr
+            end
+          end
+        related_dashboard_attributes =
+          Administrate::ResourceResolver.
+            new("admin/#{final_associated_class_name}").
+            dashboard_class.new.permitted_attributes + [:id]
+        { "#{attr}_attributes": related_dashboard_attributes }
+      end
+
+      def self.eager_load?
+        true
+      end
+
       def nested_form
         @nested_form ||= Administrate::Page::Form.new(
           resolver.dashboard_class.new,
@@ -10,25 +37,22 @@ module Administrate
         )
       end
 
-      def self.permitted_attribute(attr, options = nil)
-        associated_class_name =
-          if options
-            options.fetch(:class_name, attr.to_s.singularize.camelcase)
-          else
-            attr
-          end
-        related_dashboard_attributes =
-          Administrate::ResourceResolver.new("admin/#{associated_class_name}").
-            dashboard_class.new.permitted_attributes + [:id]
+      def nested_show
+        @nested_show ||= Administrate::Page::Show.new(
+          resolver.dashboard_class.new,
+          data || resolver.resource_class.new,
+        )
+      end
 
-        { "#{attr}_attributes": related_dashboard_attributes }
+      def linkable?
+        data.try(:persisted?)
       end
 
       private
 
       def resolver
         @resolver ||=
-          Administrate::ResourceResolver.new("admin/#{associated_class_name}")
+          Administrate::ResourceResolver.new("admin/#{associated_class.name}")
       end
     end
   end

data/lib/administrate/field/number.rb

@@ -1,16 +1,19 @@
 require_relative "base"
+require "active_support/number_helper"
 
 module Administrate
   module Field
     class Number < Field::Base
       def to_s
-        data.nil? ? "-" : format_string % value
+        result = data.nil? ? "-" : format_string % value
+        result = format(result) if options[:format]
+        prefix + result + suffix
       end
 
       private
 
       def format_string
-        prefix + "%.#{decimals}f" + suffix
+        "%.#{decimals}f"
       end
 
       def prefix
@@ -30,6 +33,14 @@ module Administrate
       def value
         data * options.fetch(:multiplier, 1)
       end
+
+      def format(result)
+        formatter = options[:format][:formatter]
+        formatter_options = options[:format][:formatter_options].to_h
+
+        ActiveSupport::NumberHelper.
+          try(formatter, result, **formatter_options) || result
+      end
     end
   end
 end

data/lib/administrate/field/polymorphic.rb

@@ -3,6 +3,10 @@ require_relative "associative"
 module Administrate
   module Field
     class Polymorphic < BelongsTo
+      def self.permitted_attribute(attr, _options = {})
+        { attr => %i{type value} }
+      end
+
       def associated_resource_grouped_options
         classes.map do |klass|
           [klass.to_s, candidate_resources_for(klass).map do |resource|
@@ -11,10 +15,6 @@ module Administrate
         end
       end
 
-      def self.permitted_attribute(attr, _options = nil)
-        { attr => %i{type value} }
-      end
-
       def permitted_attribute
         { attribute => %i{type value} }
       end
@@ -23,14 +23,15 @@ module Administrate
         data ? data.to_global_id : nil
       end
 
-      protected
+      private
 
       def associated_dashboard(klass = data.class)
         "#{klass.name}Dashboard".constantize.new
       end
 
       def classes
-        options.fetch(:classes, [])
+        klasses = options.fetch(:classes, [])
+        klasses.respond_to?(:call) ? klasses.call : klasses
       end
 
       private

data/lib/administrate/field/select.rb

@@ -8,13 +8,32 @@ module Administrate
       end
 
       def selectable_options
-        collection
+        values =
+          if options.key?(:collection)
+            options.fetch(:collection)
+          elsif active_record_enum?
+            active_record_enum_values
+          else
+            []
+          end
+
+        if values.respond_to? :call
+          values = values.arity.positive? ? values.call(self) : values.call
+        end
+
+        values
       end
 
-      private
+      def include_blank_option
+        options.fetch(:include_blank, false)
+      end
+
+      def active_record_enum?
+        resource.class.defined_enums.key?(attribute.to_s)
+      end
 
-      def collection
-        @collection ||= options.fetch(:collection, [])
+      def active_record_enum_values
+        resource.class.defined_enums[attribute.to_s].map(&:first)
       end
     end
   end

data/lib/administrate/field/time.rb

@@ -3,6 +3,17 @@ require_relative "base"
 module Administrate
   module Field
     class Time < Base
+      def time
+        return I18n.localize(data, format: format) if options[:format]
+
+        data.strftime("%I:%M%p")
+      end
+
+      private
+
+      def format
+        options[:format]
+      end
     end
   end
 end

data/lib/administrate/field/url.rb

@@ -11,6 +11,10 @@ module Administrate
         data.to_s[0...truncation_length]
       end
 
+      def html_options
+        @options[:html_options] || {}
+      end
+
       private
 
       def truncation_length

data/lib/administrate/namespace.rb

@@ -1,7 +1,7 @@
 module Administrate
   class Namespace
     def initialize(namespace)
-      @namespace = namespace
+      @namespace = namespace.to_sym
     end
 
     def resources
@@ -18,6 +18,10 @@ module Administrate
       end
     end
 
+    def resources_with_index_route
+      routes.select { |_resource, route| route == "index" }.map(&:first).uniq
+    end
+
     private
 
     attr_reader :namespace

data/lib/administrate/not_authorized_error.rb

@@ -0,0 +1,20 @@
+module Administrate
+  class NotAuthorizedError < StandardError
+    def initialize(action:, resource:)
+      @action = action
+      @resource = resource
+
+      case resource
+      when String, Symbol
+        super("Not allowed to perform #{action.inspect} on #{resource.inspect}")
+      when Module
+        super("Not allowed to perform #{action.inspect} on #{resource.name}")
+      else
+        super(
+          "Not allowed to perform #{action.inspect} on the given " +
+            resource.class.name
+        )
+      end
+    end
+  end
+end

data/lib/administrate/order.rb

@@ -1,18 +1,19 @@
 module Administrate
   class Order
-    def initialize(attribute = nil, direction = nil)
+    def initialize(attribute = nil, direction = nil, association_attribute: nil)
       @attribute = attribute
-      @direction = direction || :asc
+      @direction = sanitize_direction(direction)
+      @association_attribute = association_attribute
     end
 
     def apply(relation)
       return order_by_association(relation) unless
         reflect_association(relation).nil?
 
-      order = "#{relation.table_name}.#{attribute} #{direction}"
+      order = relation.arel_table[attribute].public_send(direction)
 
       return relation.reorder(order) if
-        relation.columns_hash.keys.include?(attribute.to_s)
+        column_exist?(relation, attribute)
 
       relation
     end
@@ -32,7 +33,11 @@ module Administrate
 
     private
 
-    attr_reader :attribute
+    attr_reader :attribute, :association_attribute
+
+    def sanitize_direction(direction)
+      %w[asc desc].include?(direction.to_s) ? direction.to_sym : :asc
+    end
 
     def reversed_direction_param_for(attr)
       if ordered_by?(attr)
@@ -43,38 +48,99 @@ module Administrate
     end
 
     def opposite_direction
-      direction.to_sym == :asc ? :desc : :asc
+      direction == :asc ? :desc : :asc
     end
 
     def order_by_association(relation)
-      return order_by_count(relation) if has_many_attribute?(relation)
-
-      return order_by_id(relation) if belongs_to_attribute?(relation)
-
-      relation
+      case relation_type(relation)
+      when :has_many
+        order_by_count(relation)
+      when :belongs_to
+        order_by_belongs_to(relation)
+      when :has_one
+        order_by_has_one(relation)
+      else
+        relation
+      end
     end
 
     def order_by_count(relation)
+      klass = reflect_association(relation).klass
+      query = klass.arel_table[klass.primary_key].count.public_send(direction)
       relation.
-      left_joins(attribute.to_sym).
-      group(:id).
-      reorder("COUNT(#{attribute}.id) #{direction}")
+        left_joins(attribute.to_sym).
+        group(:id).
+        reorder(query)
+    end
+
+    def order_by_belongs_to(relation)
+      if ordering_by_association_column?(relation)
+        order_by_attribute(relation)
+      else
+        order_by_id(relation)
+      end
+    end
+
+    def order_by_has_one(relation)
+      if ordering_by_association_column?(relation)
+        order_by_attribute(relation)
+      else
+        order_by_association_id(relation)
+      end
+    end
+
+    def order_by_attribute(relation)
+      relation.joins(
+        attribute.to_sym,
+      ).reorder(order_by_attribute_query)
     end
 
     def order_by_id(relation)
-      relation.reorder("#{attribute}_id #{direction}")
+      relation.reorder(order_by_id_query(relation))
+    end
+
+    def order_by_association_id(relation)
+      relation.reorder(order_by_association_id_query)
+    end
+
+    def ordering_by_association_column?(relation)
+      association_attribute &&
+        column_exist?(
+          reflect_association(relation).klass, association_attribute.to_sym
+        )
+    end
+
+    def column_exist?(table, column_name)
+      table.columns_hash.key?(column_name.to_s)
     end
 
-    def has_many_attribute?(relation)
-      reflect_association(relation).macro == :has_many
+    def order_by_id_query(relation)
+      relation.arel_table[foreign_key(relation)].public_send(direction)
     end
 
-    def belongs_to_attribute?(relation)
-      reflect_association(relation).macro == :belongs_to
+    def order_by_association_id_query
+      Arel::Table.new(association_table_name)[:id].public_send(direction)
+    end
+
+    def order_by_attribute_query
+      table = Arel::Table.new(association_table_name)
+      table[association_attribute].public_send(direction)
+    end
+
+    def relation_type(relation)
+      reflect_association(relation).macro
     end
 
     def reflect_association(relation)
       relation.klass.reflect_on_association(attribute.to_s)
     end
+
+    def foreign_key(relation)
+      reflect_association(relation).foreign_key
+    end
+
+    def association_table_name
+      attribute.tableize
+    end
   end
 end

data/lib/administrate/page/base.rb

@@ -23,7 +23,11 @@ module Administrate
         dashboard.try(:item_includes) || []
       end
 
-      protected
+      def item_associations
+        dashboard.try(:item_associations) || []
+      end
+
+      private
 
       def attribute_field(dashboard, resource, attribute_name, page)
         value = get_attribute_value(resource, attribute_name)
@@ -33,8 +37,6 @@ module Administrate
 
       def get_attribute_value(resource, attribute_name)
         resource.public_send(attribute_name)
-      rescue NameError
-        nil
       end
 
       attr_reader :dashboard, :options

data/lib/administrate/page/collection.rb

@@ -4,6 +4,7 @@ module Administrate
   module Page
     class Collection < Page::Base
       def attribute_names
+        options.fetch(:collection_attributes, nil) ||
         dashboard.collection_attributes
       end
 

data/lib/administrate/page/form.rb

@@ -10,9 +10,17 @@ module Administrate
 
       attr_reader :resource
 
-      def attributes
-        dashboard.form_attributes.map do |attribute|
-          attribute_field(dashboard, resource, attribute, :form)
+      def attributes(action = nil)
+        attributes = dashboard.form_attributes(action)
+
+        if attributes.is_a? Array
+          attributes = { "" => attributes }
+        end
+
+        attributes.transform_values do |attrs|
+          attrs.map do |attribute|
+            attribute_field(dashboard, resource, attribute, :form)
+          end
         end
       end
 
@@ -20,7 +28,7 @@ module Administrate
         dashboard.display_resource(resource)
       end
 
-      protected
+      private
 
       attr_reader :dashboard
     end

data/lib/administrate/page/show.rb

@@ -15,8 +15,16 @@ module Administrate
       end
 
       def attributes
-        dashboard.show_page_attributes.map do |attr_name|
-          attribute_field(dashboard, resource, attr_name, :show)
+        attributes = dashboard.show_page_attributes
+
+        if attributes.is_a? Array
+          attributes = { "" => attributes }
+        end
+
+        attributes.transform_values do |attrs|
+          attrs.map do |attr_name|
+            attribute_field(dashboard, resource, attr_name, :show)
+          end
         end
       end
     end