administrate 0.12.0 → 0.20.1

data/lib/administrate/resource_resolver.rb

@@ -9,7 +9,7 @@ module Administrate
     end
 
     def namespace
-      controller_path.split("/").first
+      controller_path.split("/").first.to_sym
     end
 
     def resource_class
@@ -21,7 +21,7 @@ module Administrate
     end
 
     def resource_title
-      model_path_parts.join(" ")
+      resource_class.model_name.human
     end
 
     private
@@ -35,7 +35,8 @@ module Administrate
     end
 
     def controller_path_parts
-      controller_path.split("/")[1..-1].map(&:singularize)
+      path_parts = controller_path.split("/")[1..-1]
+      path_parts << path_parts.pop.singularize
     end
 
     attr_reader :controller_path

data/lib/administrate/search.rb

@@ -4,14 +4,15 @@ require "active_support/core_ext/object/blank"
 module Administrate
   class Search
     class Query
-      attr_reader :filters
+      attr_reader :filters, :valid_filters
 
       def blank?
         terms.blank? && filters.empty?
       end
 
-      def initialize(original_query)
+      def initialize(original_query, valid_filters = nil)
         @original_query = original_query
+        @valid_filters = valid_filters
         @filters, @terms = parse_query(original_query)
       end
 
@@ -30,7 +31,7 @@ module Administrate
       private
 
       def filter?(word)
-        word.match?(/^\w+:$/)
+        valid_filters&.any? { |filter| word.match?(/^#{filter}:/) }
       end
 
       def parse_query(query)
@@ -38,7 +39,7 @@ module Administrate
         terms = []
         query.to_s.split.each do |word|
           if filter?(word)
-            filters << word.split(":").first
+            filters << word
           else
             terms << word
           end
@@ -47,10 +48,10 @@ module Administrate
       end
     end
 
-    def initialize(scoped_resource, dashboard_class, term)
-      @dashboard_class = dashboard_class
+    def initialize(scoped_resource, dashboard, term)
+      @dashboard = dashboard
       @scoped_resource = scoped_resource
-      @query = Query.new(term)
+      @query = Query.new(term, valid_filters.keys)
     end
 
     def run
@@ -65,15 +66,20 @@ module Administrate
 
     private
 
-    def apply_filter(filter, resources)
+    def apply_filter(filter, filter_param, resources)
       return resources unless filter
-      filter.call(resources)
+      if filter.parameters.size == 1
+        filter.call(resources)
+      else
+        filter.call(resources, filter_param)
+      end
     end
 
     def filter_results(resources)
-      query.filters.each do |filter_name|
+      query.filters.each do |filter_query|
+        filter_name, filter_param = filter_query.split(":")
         filter = valid_filters[filter_name]
-        resources = apply_filter(filter, resources)
+        resources = apply_filter(filter, filter_param, resources)
       end
       resources
     end
@@ -81,43 +87,59 @@ 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
-      attribute_types.keys.select do |attribute|
-        attribute_types[attribute].searchable?
-      end
+      @dashboard.search_attributes
     end
 
     def search_results(resources)
       resources.
-        joins(tables_to_join).
+        left_joins(tables_to_join).
         where(query_template, *query_values)
     end
 
     def valid_filters
-      if @dashboard_class.const_defined?(:COLLECTION_FILTERS)
-        @dashboard_class.const_get(:COLLECTION_FILTERS).stringify_keys
+      if @dashboard.class.const_defined?(:COLLECTION_FILTERS)
+        @dashboard.class.const_get(:COLLECTION_FILTERS).stringify_keys
       else
         {}
       end
     end
 
     def attribute_types
-      @dashboard_class::ATTRIBUTE_TYPES
+      @dashboard.class.const_get(:ATTRIBUTE_TYPES)
     end
 
     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 +147,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 +157,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.20.1".freeze
 end

data/lib/administrate/view_generator.rb

@@ -1,11 +1,16 @@
 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,
+      desc: "Namespace where the admin dashboards live",
+      default: "admin",
+    )
 
     def self.template_source_path
       File.expand_path(
@@ -14,12 +19,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,46 @@
 require "administrate/engine"
+require "administrate/version"
 
 module Administrate
+  def self.warn_of_missing_resource_class
+    deprecator.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)
+    deprecator.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
+
+  def self.warn_of_deprecated_method(klass, method)
+    deprecator.warn(
+      "The method #{klass}##{method} is deprecated. " +
+      "If you are seeing this message you are probably " +
+      "using a dashboard that depends explicitly on it. " +
+      "Please make sure you update it to a version that " +
+      "does not use a deprecated API",
+    )
+  end
+
+  def self.warn_of_deprecated_authorization_method(method)
+    deprecator.warn(
+      "The method `#{method}` is deprecated. " +
+      "Please use `accessible_action?` instead, " +
+      "or see the documentation for other options.",
+    )
+  end
+
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new(VERSION, "Administrate")
+  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 },
       }
 
@@ -24,7 +27,12 @@ module Administrate
       COLLECTION_ATTRIBUTE_LIMIT = 4
       READ_ONLY_ATTRIBUTES = %w[id created_at updated_at]
 
-      class_option :namespace, type: :string, default: "admin"
+      class_option(
+        :namespace,
+        type: :string,
+        desc: "Namespace where the admin dashboards live",
+        default: "admin",
+      )
 
       source_root File.expand_path("../templates", __FILE__)
 
@@ -50,9 +58,22 @@ module Administrate
       end
 
       def attributes
-        klass.reflections.keys +
+        attrs = (
+          klass.reflections.keys +
           klass.columns.map(&:name) -
           redundant_attributes
+        )
+
+        primary_key = attrs.delete(klass.primary_key)
+        created_at = attrs.delete("created_at")
+        updated_at = attrs.delete("updated_at")
+
+        [
+          primary_key,
+          *attrs.sort,
+          created_at,
+          updated_at,
+        ].compact
       end
 
       def form_attributes
@@ -107,11 +128,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 +140,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 +149,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

@@ -1,12 +1,11 @@
-module <%= namespace.classify %>
-  class <%= class_name.pluralize %>Controller < <%= namespace.classify %>::ApplicationController
+module <%= namespace.to_s.camelize %>
+  class <%= class_name.pluralize %>Controller < <%= namespace.to_s.camelize %>::ApplicationController
     # Overwrite any of the RESTful controller actions to implement custom behavior
     # 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,18 +16,31 @@ 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(action_name)).
+    #     transform_values { |value| value == "" ? nil : value }
     # end
 
-    # See https://administrate-prototype.herokuapp.com/customizing_controller_actions
+    # See https://administrate-demo.herokuapp.com/customizing_controller_actions
     # for more information
   end
 end

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
 

data/lib/generators/administrate/install/install_generator.rb

@@ -1,3 +1,9 @@
+if defined?(Zeitwerk)
+  Zeitwerk::Loader.eager_load_all
+else
+  Rails.application.eager_load!
+end
+
 require "rails/generators/base"
 require "administrate/generator_helpers"
 require "administrate/namespace"
@@ -8,12 +14,17 @@ module Administrate
       include Administrate::GeneratorHelpers
       source_root File.expand_path("../templates", __FILE__)
 
-      class_option :namespace, type: :string, default: "admin"
+      class_option(
+        :namespace,
+        type: :string,
+        desc: "Namespace where the admin dashboards will live",
+        default: "admin",
+      )
 
       def run_routes_generator
         if dashboard_resources.none?
           call_generator("administrate:routes", "--namespace", namespace)
-          load Rails.root.join("config/routes.rb")
+          Rails.application.reload_routes!
         end
       end
 
@@ -31,6 +42,12 @@ module Administrate
         end
       end
 
+      def model_check
+        if valid_dashboard_models.none?
+          puts "WARNING: Add models before installing Administrate."
+        end
+      end
+
       private
 
       def namespace
@@ -44,6 +61,30 @@ module Administrate
       def dashboard_resources
         Administrate::Namespace.new(namespace).resources
       end
+
+      def valid_dashboard_models
+        database_models - invalid_dashboard_models
+      end
+
+      def database_models
+        ActiveRecord::Base.descendants.reject(&:abstract_class?)
+      end
+
+      def invalid_dashboard_models
+        (models_without_tables + namespaced_models + unnamed_constants).uniq
+      end
+
+      def models_without_tables
+        database_models.reject(&:table_exists?)
+      end
+
+      def namespaced_models
+        database_models.select { |model| model.to_s.include?("::") }
+      end
+
+      def unnamed_constants
+        ActiveRecord::Base.descendants.reject { |d| d.name == d.to_s }
+      end
     end
   end
 end

data/lib/generators/administrate/install/templates/application_controller.rb.erb

@@ -1,10 +1,10 @@
-# All Administrate controllers inherit from this `Admin::ApplicationController`,
-# making it the ideal place to put authentication logic or other
-# before_actions.
+# All Administrate controllers inherit from this
+# `Administrate::ApplicationController`, making it the ideal place to put
+# authentication logic or other before_actions.
 #
 # If you want to add pagination or other controller-level concerns,
 # you're free to overwrite the RESTful controller actions.
-module <%= namespace.classify %>
+module <%= namespace.camelize %>
   class ApplicationController < Administrate::ApplicationController
     before_action :authenticate_admin
 

data/lib/generators/administrate/routes/routes_generator.rb

@@ -5,30 +5,38 @@ else
 end
 
 require "rails/generators/base"
+require "administrate/generator_helpers"
 require "administrate/namespace"
+require "generators/administrate/test_record"
 
 module Administrate
   module Generators
     class RoutesGenerator < Rails::Generators::Base
+      include Administrate::GeneratorHelpers
       source_root File.expand_path("../templates", __FILE__)
-      class_option :namespace, type: :string, default: "admin"
+      class_option(
+        :namespace,
+        type: :string,
+        desc: "Namespace where the admin dashboards live",
+        default: "admin",
+      )
 
       def insert_dashboard_routes
-        if should_route_dashboard?
+        if valid_dashboard_models.any?
           route(dashboard_routes)
         end
       end
 
       def warn_about_invalid_models
-        namespaced_models.each do |invalid_model|
-          puts "WARNING: Unable to generate a dashboard for #{invalid_model}."
-          puts "         Administrate does not yet support namespaced models."
-        end
-
-        models_without_tables.each do |invalid_model|
-          puts "WARNING: Unable to generate a dashboard for #{invalid_model}."
-          puts "         It is not connected to a database table."
-          puts "         Make sure your database migrations are up to date."
+        invalid_dashboard_models.each do |model|
+          puts "WARNING: Unable to generate a dashboard for #{model}."
+          if namespaced_models.include?(model)
+            puts "       - Administrate does not yet support namespaced models."
+          end
+          if models_without_tables.include?(model)
+            puts "       - It is not connected to a database table."
+            puts "         Make sure your database migrations are up to date."
+          end
         end
 
         unnamed_constants.each do |invalid_model|
@@ -49,15 +57,18 @@ module Administrate
       end
 
       def valid_dashboard_models
-        database_models - invalid_database_models
+        database_models - invalid_dashboard_models
       end
 
       def database_models
-        ActiveRecord::Base.descendants.reject(&:abstract_class?)
+        ActiveRecord::Base.descendants.
+          reject(&:abstract_class?).
+          reject { |k| k < Administrate::Generators::TestRecord }.
+          sort_by(&:to_s)
       end
 
-      def invalid_database_models
-        models_without_tables + namespaced_models + unnamed_constants
+      def invalid_dashboard_models
+        (models_without_tables + namespaced_models + unnamed_constants).uniq
       end
 
       def models_without_tables
@@ -76,21 +87,9 @@ module Administrate
         ERB.new(File.read(routes_file_path)).result(binding)
       end
 
-      def routes_includes_resources?
-        File.read(rails_routes_file_path).include?(dashboard_routes)
-      end
-
-      def rails_routes_file_path
-        Rails.root.join("config/routes.rb")
-      end
-
       def routes_file_path
         File.expand_path(find_in_source_paths("routes.rb.erb"))
       end
-
-      def should_route_dashboard?
-        routes_includes_resources? || valid_dashboard_models.any?
-      end
     end
   end
 end