administrate 0.8.1 → 0.17.0

data/lib/administrate/field/polymorphic.rb

@@ -2,11 +2,49 @@ require_relative "associative"
 
 module Administrate
   module Field
-    class Polymorphic < Associative
-      protected
+    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|
+            [display_candidate_resource(resource), resource.to_global_id]
+          end]
+        end
+      end
+
+      def permitted_attribute
+        { attribute => %i{type value} }
+      end
+
+      def selected_global_id
+        data ? data.to_global_id : nil
+      end
+
+      private
+
+      def associated_dashboard(klass = data.class)
+        "#{klass.name}Dashboard".constantize.new
+      end
+
+      def classes
+        options.fetch(:classes, [])
+      end
+
+      private
+
+      def order
+        @_order ||= options.delete(:order)
+      end
+
+      def candidate_resources_for(klass)
+        order ? klass.order(order) : klass.all
+      end
 
-      def associated_dashboard
-        "#{data.class.name}Dashboard".constantize.new
+      def display_candidate_resource(resource)
+        associated_dashboard(resource.class).display_resource(resource)
       end
     end
   end

data/lib/administrate/field/select.rb

@@ -11,10 +11,19 @@ module Administrate
         collection
       end
 
+      def include_blank_option
+        options.fetch(:include_blank, false)
+      end
+
       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/field/time.rb

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,21 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Url < Field::Base
+      def self.searchable?
+        true
+      end
+
+      def truncate
+        data.to_s[0...truncation_length]
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+    end
+  end
+end

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
@@ -12,12 +12,16 @@ module Administrate
 
     def routes
       @routes ||= all_routes.select do |controller, _action|
-        controller.starts_with?(namespace.to_s)
+        controller.starts_with?("#{namespace}/")
       end.map do |controller, action|
         [controller.gsub(/^#{namespace}\//, ""), action]
       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,15 +2,19 @@ module Administrate
   class Order
     def initialize(attribute = nil, direction = nil)
       @attribute = attribute
-      @direction = direction || :asc
+      @direction = sanitize_direction(direction)
     end
 
     def apply(relation)
-      if relation.columns_hash.keys.include?(attribute.to_s)
-        relation.order("#{attribute} #{direction}")
-      else
-        relation
-      end
+      return order_by_association(relation) unless
+        reflect_association(relation).nil?
+
+      order = "#{relation.table_name}.#{attribute} #{direction}"
+
+      return relation.reorder(Arel.sql(order)) if
+        relation.columns_hash.keys.include?(attribute.to_s)
+
+      relation
     end
 
     def ordered_by?(attr)
@@ -30,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
@@ -39,7 +47,44 @@ 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
+    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(Arel.sql(query))
+    end
+
+    def order_by_id(relation)
+      relation.reorder("#{foreign_key(relation)} #{direction}")
+    end
+
+    def has_many_attribute?(relation)
+      reflect_association(relation).macro == :has_many
+    end
+
+    def belongs_to_attribute?(relation)
+      reflect_association(relation).macro == :belongs_to
+    end
+
+    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

@@ -15,7 +15,15 @@ module Administrate
         @resource_path ||= resource_name.gsub("/", "_")
       end
 
-      protected
+      def collection_includes
+        dashboard.try(:collection_includes) || []
+      end
+
+      def item_includes
+        dashboard.try(:item_includes) || []
+      end
+
+      private
 
       def attribute_field(dashboard, resource, attribute_name, page)
         value = get_attribute_value(resource, attribute_name)
@@ -25,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/collection.rb

@@ -21,7 +21,11 @@ module Administrate
         ordered_by?(attr) && order.direction
       end
 
-      delegate :ordered_by?, :order_params_for, to: :order
+      delegate :ordered_by?, to: :order
+
+      def order_params_for(attr, key: resource_name)
+        { key => order.order_params_for(attr) }
+      end
 
       private
 

data/lib/administrate/page/form.rb

@@ -10,8 +10,15 @@ module Administrate
 
       attr_reader :resource
 
-      def attributes
-        dashboard.form_attributes.map do |attribute|
+      def attributes(action = nil)
+        action =
+          case action
+          when "update" then "edit"
+          when "create" then "new"
+          else action
+          end
+
+        dashboard.form_attributes(action).map do |attribute|
           attribute_field(dashboard, resource, attribute, :form)
         end
       end
@@ -20,7 +27,7 @@ module Administrate
         dashboard.display_resource(resource)
       end
 
-      protected
+      private
 
       attr_reader :dashboard
     end

data/lib/administrate/resource_resolver.rb

@@ -5,15 +5,15 @@ module Administrate
     end
 
     def dashboard_class
-      Object.const_get(resource_class_name + "Dashboard")
+      ActiveSupport::Inflector.constantize("#{resource_class_name}Dashboard")
     end
 
     def namespace
-      controller_path.split("/").first
+      controller_path.split("/").first.to_sym
     end
 
     def resource_class
-      Object.const_get(resource_class_name)
+      ActiveSupport::Inflector.constantize(resource_class_name)
     end
 
     def resource_name
@@ -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

@@ -3,45 +3,167 @@ require "active_support/core_ext/object/blank"
 
 module Administrate
   class Search
-    def initialize(scoped_resource, dashboard_class, term)
-      @dashboard_class = dashboard_class
+    class Query
+      attr_reader :filters, :valid_filters
+
+      def blank?
+        terms.blank? && filters.empty?
+      end
+
+      def initialize(original_query, valid_filters = nil)
+        @original_query = original_query
+        @valid_filters = valid_filters
+        @filters, @terms = parse_query(original_query)
+      end
+
+      def original
+        @original_query
+      end
+
+      def terms
+        @terms.join(" ")
+      end
+
+      def to_s
+        original
+      end
+
+      private
+
+      def filter?(word)
+        valid_filters&.any? { |filter| word.match?(/^#{filter}:\w*$/) }
+      end
+
+      def parse_query(query)
+        filters = []
+        terms = []
+        query.to_s.split.each do |word|
+          if filter?(word)
+            filters << word
+          else
+            terms << word
+          end
+        end
+        [filters, terms]
+      end
+    end
+
+    def initialize(scoped_resource, dashboard, term)
+      @dashboard = dashboard
       @scoped_resource = scoped_resource
-      @term = term
+      @query = Query.new(term, valid_filters.keys)
     end
 
     def run
-      if @term.blank?
+      if query.blank?
         @scoped_resource.all
       else
-        @scoped_resource.where(query, *search_terms)
+        results = search_results(@scoped_resource)
+        results = filter_results(results)
+        results
       end
     end
 
     private
 
-    def query
+    def apply_filter(filter, filter_param, resources)
+      return resources unless filter
+      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_query|
+        filter_name, filter_param = filter_query.split(":")
+        filter = valid_filters[filter_name]
+        resources = apply_filter(filter, filter_param, resources)
+      end
+      resources
+    end
+
+    def query_template
       search_attributes.map do |attr|
-        table_name = ActiveRecord::Base.connection.
-          quote_table_name(@scoped_resource.table_name)
-        attr_name = ActiveRecord::Base.connection.quote_column_name(attr)
-        "lower(#{table_name}.#{attr_name}) LIKE ?"
+        table_name = query_table_name(attr)
+        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 search_terms
-      ["%#{term.mb_chars.downcase}%"] * search_attributes.count
+    def searchable_fields(attr)
+      return [attr] unless association_search?(attr)
+
+      attribute_types[attr].searchable_fields
+    end
+
+    def query_values
+      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?
+      @dashboard.search_attributes
+    end
+
+    def search_results(resources)
+      resources.
+        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
+      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)
+        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)
+      end
+    end
+
+    def column_to_query(attr)
+      ActiveRecord::Base.connection.quote_column_name(attr)
+    end
+
+    def tables_to_join
+      attribute_types.keys.select do |attribute|
+        attribute_types[attribute].searchable? && association_search?(attribute)
+      end
+    end
+
+    def association_search?(attribute)
+      attribute_types[attribute].associative?
+    end
+
+    def term
+      query.terms
     end
 
-    attr_reader :resolver, :term
+    attr_reader :resolver, :query
   end
 end

data/lib/administrate/version.rb

@@ -1,3 +1,3 @@
 module Administrate
-  VERSION = "0.8.1".freeze
+  VERSION = "0.17.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/USAGE

@@ -3,7 +3,7 @@ Description:
     pulling the attributes from database columns.
 
 Example:
-    rails generate administrate:dashboard FooBar
+    rails generate administrate:dashboard FooBar [--namespace admin]
 
     This will create:
         app/dashboards/foo_bar_dashboard.rb

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::DateTime",
+        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,6 +27,8 @@ module Administrate
       COLLECTION_ATTRIBUTE_LIMIT = 4
       READ_ONLY_ATTRIBUTES = %w[id created_at updated_at]
 
+      class_option :namespace, type: :string, default: :admin
+
       source_root File.expand_path("../templates", __FILE__)
 
       def create_dashboard_definition
@@ -35,7 +40,7 @@ module Administrate
 
       def create_resource_controller
         destination = Rails.root.join(
-          "app/controllers/admin/#{file_name.pluralize}_controller.rb",
+          "app/controllers/#{namespace}/#{file_name.pluralize}_controller.rb",
         )
 
         template("controller.rb.erb", destination)
@@ -43,8 +48,14 @@ module Administrate
 
       private
 
+      def namespace
+        options[:namespace]
+      end
+
       def attributes
-        klass.reflections.keys + klass.attribute_names - redundant_attributes
+        klass.reflections.keys +
+          klass.columns.map(&:name) -
+          redundant_attributes
       end
 
       def form_attributes
@@ -99,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
 
@@ -111,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)})"
@@ -128,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