administrate 0.12.0 → 0.15.0

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,36 @@ module Administrate
           options == other.options
       end
 
+      def associative?
+        deferred_class.associative?
+      end
+
       def searchable?
         options.fetch(:searchable, deferred_class.searchable?)
       end
 
       def searchable_field
+        ActiveSupport::Deprecation.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,7 +7,17 @@ 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
 
@@ -36,7 +46,10 @@ module Administrate
       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)

data/lib/administrate/field/has_one.rb

@@ -3,6 +3,29 @@ 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 nested_form
         @nested_form ||= Administrate::Page::Form.new(
           resolver.dashboard_class.new,
@@ -10,25 +33,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,20 @@ 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
+
+        case formatter
+        when :number_to_delimited
+          ActiveSupport::NumberHelper.number_to_delimited(
+            result, **formatter_options
+          )
+        else
+          result
+        end
+      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,7 +23,7 @@ module Administrate
         data ? data.to_global_id : nil
       end
 
-      protected
+      private
 
       def associated_dashboard(klass = data.class)
         "#{klass.name}Dashboard".constantize.new

data/lib/administrate/field/select.rb

@@ -14,7 +14,12 @@ module Administrate
       private
 
       def collection
-        @collection ||= options.fetch(:collection, [])
+        values = options.fetch(:collection, [])
+        if values.respond_to? :call
+          return values.arity.positive? ? values.call(self) : values.call
+        end
+
+        @collection ||= values
       end
     end
   end

data/lib/administrate/namespace.rb

@@ -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/order.rb

@@ -2,7 +2,7 @@ module Administrate
   class Order
     def initialize(attribute = nil, direction = nil)
       @attribute = attribute
-      @direction = direction || :asc
+      @direction = sanitize_direction(direction)
     end
 
     def apply(relation)
@@ -11,7 +11,7 @@ module Administrate
 
       order = "#{relation.table_name}.#{attribute} #{direction}"
 
-      return relation.reorder(order) if
+      return relation.reorder(Arel.sql(order)) if
         relation.columns_hash.keys.include?(attribute.to_s)
 
       relation
@@ -34,6 +34,10 @@ module Administrate
 
     attr_reader :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)
         opposite_direction
@@ -43,7 +47,7 @@ module Administrate
     end
 
     def opposite_direction
-      direction.to_sym == :asc ? :desc : :asc
+      direction == :asc ? :desc : :asc
     end
 
     def order_by_association(relation)
@@ -55,14 +59,16 @@ module Administrate
     end
 
     def order_by_count(relation)
+      klass = reflect_association(relation).klass
+      query = "COUNT(#{klass.table_name}.#{klass.primary_key}) #{direction}"
       relation.
-      left_joins(attribute.to_sym).
-      group(:id).
-      reorder("COUNT(#{attribute}.id) #{direction}")
+        left_joins(attribute.to_sym).
+        group(:id).
+        reorder(Arel.sql(query))
     end
 
     def order_by_id(relation)
-      relation.reorder("#{attribute}_id #{direction}")
+      relation.reorder("#{foreign_key(relation)} #{direction}")
     end
 
     def has_many_attribute?(relation)
@@ -76,5 +82,9 @@ module Administrate
     def reflect_association(relation)
       relation.klass.reflect_on_association(attribute.to_s)
     end
+
+    def foreign_key(relation)
+      reflect_association(relation).foreign_key
+    end
   end
 end

data/lib/administrate/page/base.rb

@@ -23,7 +23,7 @@ module Administrate
         dashboard.try(:item_includes) || []
       end
 
-      protected
+      private
 
       def attribute_field(dashboard, resource, attribute_name, page)
         value = get_attribute_value(resource, attribute_name)
@@ -33,8 +33,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/form.rb

@@ -20,7 +20,7 @@ module Administrate
         dashboard.display_resource(resource)
       end
 
-      protected
+      private
 
       attr_reader :dashboard
     end

data/lib/administrate/resource_resolver.rb

@@ -21,7 +21,7 @@ module Administrate
     end
 
     def resource_title
-      model_path_parts.join(" ")
+      resource_class.model_name.human
     end
 
     private

data/lib/administrate/search.rb

@@ -81,14 +81,24 @@ module Administrate
     def query_template
       search_attributes.map do |attr|
         table_name = query_table_name(attr)
-        attr_name = column_to_query(attr)
-
-        "LOWER(CAST(#{table_name}.#{attr_name} AS CHAR(256))) LIKE ?"
+        searchable_fields(attr).map do |field|
+          column_name = column_to_query(field)
+          "LOWER(CAST(#{table_name}.#{column_name} AS CHAR(256))) LIKE ?"
+        end.join(" OR ")
       end.join(" OR ")
     end
 
+    def searchable_fields(attr)
+      return [attr] unless association_search?(attr)
+
+      attribute_types[attr].searchable_fields
+    end
+
     def query_values
-      ["%#{term.mb_chars.downcase}%"] * search_attributes.count
+      fields_count = search_attributes.sum do |attr|
+        searchable_fields(attr).count
+      end
+      ["%#{term.mb_chars.downcase}%"] * fields_count
     end
 
     def search_attributes
@@ -99,7 +109,7 @@ module Administrate
 
     def search_results(resources)
       resources.
-        joins(tables_to_join).
+        left_joins(tables_to_join).
         where(query_template, *query_values)
     end
 
@@ -117,7 +127,15 @@ module Administrate
 
     def query_table_name(attr)
       if association_search?(attr)
-        ActiveRecord::Base.connection.quote_table_name(attr.to_s.pluralize)
+        provided_class_name = attribute_types[attr].options[:class_name]
+        unquoted_table_name =
+          if provided_class_name
+            Administrate.warn_of_deprecated_option(:class_name)
+            provided_class_name.constantize.table_name
+          else
+            @scoped_resource.reflect_on_association(attr).klass.table_name
+          end
+        ActiveRecord::Base.connection.quote_table_name(unquoted_table_name)
       else
         ActiveRecord::Base.connection.
           quote_table_name(@scoped_resource.table_name)
@@ -125,12 +143,7 @@ module Administrate
     end
 
     def column_to_query(attr)
-      if association_search?(attr)
-        ActiveRecord::Base.connection.
-          quote_column_name(attribute_types[attr].searchable_field)
-      else
-        ActiveRecord::Base.connection.quote_column_name(attr)
-      end
+      ActiveRecord::Base.connection.quote_column_name(attr)
     end
 
     def tables_to_join
@@ -140,13 +153,7 @@ module Administrate
     end
 
     def association_search?(attribute)
-      return unless attribute_types[attribute].respond_to?(:deferred_class)
-
-      [
-        Administrate::Field::BelongsTo,
-        Administrate::Field::HasMany,
-        Administrate::Field::HasOne,
-      ].include?(attribute_types[attribute].deferred_class)
+      attribute_types[attribute].associative?
     end
 
     def term

data/lib/administrate/version.rb

@@ -1,3 +1,3 @@
 module Administrate
-  VERSION = "0.12.0".freeze
+  VERSION = "0.15.0".freeze
 end

data/lib/administrate/view_generator.rb

@@ -1,11 +1,11 @@
 require "rails/generators/base"
 require "administrate/generator_helpers"
+require "administrate/namespace"
 
 module Administrate
   class ViewGenerator < Rails::Generators::Base
     include Administrate::GeneratorHelpers
-
-    private
+    class_option :namespace, type: :string, default: "admin"
 
     def self.template_source_path
       File.expand_path(
@@ -14,12 +14,18 @@ module Administrate
       )
     end
 
+    private
+
+    def namespace
+      options[:namespace]
+    end
+
     def copy_resource_template(template_name)
       template_file = "#{template_name}.html.erb"
 
       copy_file(
         template_file,
-        "app/views/admin/#{resource_path}/#{template_file}",
+        "app/views/#{namespace}/#{resource_path}/#{template_file}",
       )
     end
 

data/lib/administrate.rb

@@ -1,4 +1,23 @@
 require "administrate/engine"
 
 module Administrate
+  def self.warn_of_missing_resource_class
+    ActiveSupport::Deprecation.warn(
+      "Calling Field::Base.permitted_attribute without the option " +
+      ":resource_class is deprecated. If you are seeing this " +
+      "message, you are probably using a custom field type that" +
+      "does this. Please make sure to update it to a version that " +
+      "does not use a deprecated API",
+    )
+  end
+
+  def self.warn_of_deprecated_option(name)
+    ActiveSupport::Deprecation.warn(
+      "The option :#{name} is deprecated. " +
+      "Administrate should detect it automatically. " +
+      "Please file an issue at " +
+      "https://github.com/thoughtbot/administrate/issues " +
+      "if you think otherwise.",
+    )
+  end
 end

data/lib/generators/administrate/dashboard/dashboard_generator.rb

@@ -5,18 +5,21 @@ module Administrate
     class DashboardGenerator < Rails::Generators::NamedBase
       ATTRIBUTE_TYPE_MAPPING = {
         boolean: "Field::Boolean",
-        date: "Field::DateTime",
+        date: "Field::Date",
         datetime: "Field::DateTime",
-        enum: "Field::String",
+        enum: "Field::Select",
         float: "Field::Number",
         integer: "Field::Number",
         time: "Field::Time",
         text: "Field::Text",
         string: "Field::String",
+        uuid: "Field::String",
       }
 
       ATTRIBUTE_OPTIONS_MAPPING = {
-        enum: { searchable: false },
+        # procs must be defined in one line!
+        enum: {  searchable: false,
+                 collection: ->(field) { field.resource.class.send(field.attribute.to_s.pluralize).keys } },
         float: { decimals: 2 },
       }
 
@@ -107,11 +110,11 @@ module Administrate
         if relationship.has_one?
           "Field::HasOne"
         elsif relationship.collection?
-          "Field::HasMany" + relationship_options_string(relationship)
+          "Field::HasMany"
         elsif relationship.polymorphic?
           "Field::Polymorphic"
         else
-          "Field::BelongsTo" + relationship_options_string(relationship)
+          "Field::BelongsTo"
         end
       end
 
@@ -119,14 +122,6 @@ module Administrate
         @klass ||= Object.const_get(class_name)
       end
 
-      def relationship_options_string(relationship)
-        if relationship.class_name != relationship.name.to_s.classify
-          options_string(class_name: relationship.class_name)
-        else
-          ""
-        end
-      end
-
       def options_string(options)
         if options.any?
           ".with_options(#{inspect_hash_as_ruby(options)})"
@@ -136,7 +131,16 @@ module Administrate
       end
 
       def inspect_hash_as_ruby(hash)
-        hash.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+        hash.map do |key, value|
+          v_str = value.respond_to?(:call) ? proc_string(value) : value.inspect
+          "#{key}: #{v_str}"
+        end.join(", ")
+      end
+
+      def proc_string(value)
+        source = value.source_location
+        proc_string = IO.readlines(source.first)[source.second - 1]
+        proc_string[/->[^}]*} | (lambda|proc).*end/x]
       end
     end
   end

data/lib/generators/administrate/dashboard/templates/controller.rb.erb

@@ -4,9 +4,8 @@ module <%= namespace.classify %>
     # For example, you may want to send an email after a foo is updated.
     #
     # def update
-    #   foo = Foo.find(params[:id])
-    #   foo.update(params[:foo])
-    #   send_foo_updated_email
+    #   super
+    #   send_foo_updated_email(requested_resource)
     # end
 
     # Override this method to specify custom lookup behavior.
@@ -17,15 +16,28 @@ module <%= namespace.classify %>
     #   Foo.find_by!(slug: param)
     # end
 
+    # The result of this lookup will be available as `requested_resource`
+
     # Override this if you have certain roles that require a subset
     # this will be used to set the records shown on the `index` action.
     #
     # def scoped_resource
-    #  if current_user.super_admin?
-    #    resource_class
-    #  else
-    #    resource_class.with_less_stuff
-    #  end
+    #   if current_user.super_admin?
+    #     resource_class
+    #   else
+    #     resource_class.with_less_stuff
+    #   end
+    # end
+
+    # Override `resource_params` if you want to transform the submitted
+    # data before it's persisted. For example, the following would turn all
+    # empty values into nil values. It uses other APIs such as `resource_class`
+    # and `dashboard`:
+    #
+    # def resource_params
+    #   params.require(resource_class.model_name.param_key).
+    #     permit(dashboard.permitted_attributes).
+    #     transform_values { |value| value == "" ? nil : value }
     # end
 
     # See https://administrate-prototype.herokuapp.com/customizing_controller_actions

data/lib/generators/administrate/dashboard/templates/dashboard.rb.erb

@@ -21,7 +21,7 @@ class <%= class_name %>Dashboard < Administrate::BaseDashboard
   COLLECTION_ATTRIBUTES = %i[
 <%=
   attributes.first(COLLECTION_ATTRIBUTE_LIMIT).map do |attr|
-    "  #{attr}"
+    "    #{attr}"
   end.join("\n")
 %>
   ].freeze
@@ -31,7 +31,7 @@ class <%= class_name %>Dashboard < Administrate::BaseDashboard
   SHOW_PAGE_ATTRIBUTES = %i[
 <%=
   attributes.map do |attr|
-    "  #{attr}"
+    "    #{attr}"
   end.join("\n")
 %>
   ].freeze
@@ -42,7 +42,7 @@ class <%= class_name %>Dashboard < Administrate::BaseDashboard
   FORM_ATTRIBUTES = %i[
 <%=
   form_attributes.map do |attr|
-    "  #{attr}"
+    "    #{attr}"
   end.join("\n")
 %>
   ].freeze
@@ -55,7 +55,7 @@ class <%= class_name %>Dashboard < Administrate::BaseDashboard
   # in the search field:
   #
   #   COLLECTION_FILTERS = {
-  #     open: ->(resources) { where(open: true) }
+  #     open: ->(resources) { resources.where(open: true) }
   #   }.freeze
   COLLECTION_FILTERS = {}.freeze