administrate 0.9.0 → 0.14.0

data/lib/administrate/namespace.rb

@@ -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,14 +2,16 @@ module Administrate
   class Order
     def initialize(attribute = nil, direction = nil)
       @attribute = attribute
-      @direction = direction || :asc
+      @direction = sanitize_direction(direction)
     end
 
     def apply(relation)
       return order_by_association(relation) unless
         reflect_association(relation).nil?
 
-      return relation.reorder("#{attribute} #{direction}") if
+      order = "#{relation.table_name}.#{attribute} #{direction}"
+
+      return relation.reorder(Arel.sql(order)) if
         relation.columns_hash.keys.include?(attribute.to_s)
 
       relation
@@ -32,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
@@ -41,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)
@@ -54,13 +60,13 @@ module Administrate
 
     def order_by_count(relation)
       relation.
-      left_joins(attribute.to_sym).
-      group(:id).
-      reorder("COUNT(#{attribute}.id) #{direction}")
+        left_joins(attribute.to_sym).
+        group(:id).
+        reorder("COUNT(#{attribute}.id) #{direction}")
     end
 
     def order_by_id(relation)
-      relation.reorder("#{attribute}_id #{direction}")
+      relation.reorder("#{foreign_key(relation)} #{direction}")
     end
 
     def has_many_attribute?(relation)
@@ -74,5 +80,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

@@ -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

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

data/lib/administrate/search.rb

@@ -3,33 +3,102 @@ require "active_support/core_ext/object/blank"
 
 module Administrate
   class Search
+    class Query
+      attr_reader :filters
+
+      def blank?
+        terms.blank? && filters.empty?
+      end
+
+      def initialize(original_query)
+        @original_query = original_query
+        @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)
+        word.match?(/^\w+:$/)
+      end
+
+      def parse_query(query)
+        filters = []
+        terms = []
+        query.to_s.split.each do |word|
+          if filter?(word)
+            filters << word.split(":").first
+          else
+            terms << word
+          end
+        end
+        [filters, terms]
+      end
+    end
+
     def initialize(scoped_resource, dashboard_class, term)
       @dashboard_class = dashboard_class
       @scoped_resource = scoped_resource
-      @term = term
+      @query = Query.new(term)
     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, resources)
+      return resources unless filter
+      filter.call(resources)
+    end
+
+    def filter_results(resources)
+      query.filters.each do |filter_name|
+        filter = valid_filters[filter_name]
+        resources = apply_filter(filter, 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(TEXT(#{table_name}.#{attr_name})) LIKE ?"
+        table_name = query_table_name(attr)
+        searchable_fields(attr).map do |field|
+          attr_name = column_to_query(field)
+          "LOWER(CAST(#{table_name}.#{attr_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
@@ -38,10 +107,56 @@ module Administrate
       end
     end
 
+    def search_results(resources)
+      resources.
+        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
     end
 
-    attr_reader :resolver, :term
+    def query_table_name(attr)
+      if association_search?(attr)
+        provided_class_name = attribute_types[attr].options[:class_name]
+        if provided_class_name
+          provided_class_name.constantize.table_name
+        else
+          ActiveRecord::Base.connection.quote_table_name(attr.to_s.pluralize)
+        end
+      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, :query
   end
 end

data/lib/administrate/version.rb

@@ -1,3 +1,3 @@
 module Administrate
-  VERSION = "0.9.0".freeze
+  VERSION = "0.14.0".freeze
 end

data/lib/administrate/view_generator.rb

@@ -5,8 +5,6 @@ module Administrate
   class ViewGenerator < Rails::Generators::Base
     include Administrate::GeneratorHelpers
 
-    private
-
     def self.template_source_path
       File.expand_path(
         "../../../app/views/administrate/application",
@@ -14,6 +12,8 @@ module Administrate
       )
     end
 
+    private
+
     def copy_resource_template(template_name)
       template_file = "#{template_name}.html.erb"
 

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

@@ -5,18 +5,20 @@ 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",
       }
 
       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 },
       }
 
@@ -50,7 +52,9 @@ module Administrate
       end
 
       def attributes
-        klass.reflections.keys + klass.attribute_names - redundant_attributes
+        klass.reflections.keys +
+          klass.columns.map(&:name) -
+          redundant_attributes
       end
 
       def form_attributes
@@ -134,7 +138,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,18 +1,43 @@
 module <%= namespace.classify %>
   class <%= class_name.pluralize %>Controller < <%= namespace.classify %>::ApplicationController
-    # To customize the behavior of this controller,
-    # you can overwrite any of the RESTful actions. For example:
+    # 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 index
+    # def update
     #   super
-    #   @resources = <%= class_name %>.
-    #     page(params[:page]).
-    #     per(10)
+    #   send_foo_updated_email(requested_resource)
     # end
 
-    # Define a custom finder by overriding the `find_resource` method:
+    # Override this method to specify custom lookup behavior.
+    # This will be used to set the resource for the `show`, `edit`, and `update`
+    # actions.
+    #
     # def find_resource(param)
-    #   <%= class_name %>.find_by!(slug: param)
+    #   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
+    # 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

@@ -18,20 +18,20 @@ class <%= class_name %>Dashboard < Administrate::BaseDashboard
   #
   # By default, it's limited to four items to reduce clutter on index pages.
   # Feel free to add, remove, or rearrange items.
-  COLLECTION_ATTRIBUTES = [
+  COLLECTION_ATTRIBUTES = %i[
 <%=
   attributes.first(COLLECTION_ATTRIBUTE_LIMIT).map do |attr|
-    "    :#{attr},"
+    "  #{attr}"
   end.join("\n")
 %>
   ].freeze
 
   # SHOW_PAGE_ATTRIBUTES
   # an array of attributes that will be displayed on the model's show page.
-  SHOW_PAGE_ATTRIBUTES = [
+  SHOW_PAGE_ATTRIBUTES = %i[
 <%=
   attributes.map do |attr|
-    "    :#{attr},"
+    "  #{attr}"
   end.join("\n")
 %>
   ].freeze
@@ -39,14 +39,26 @@ class <%= class_name %>Dashboard < Administrate::BaseDashboard
   # FORM_ATTRIBUTES
   # an array of attributes that will be displayed
   # on the model's form (`new` and `edit`) pages.
-  FORM_ATTRIBUTES = [
+  FORM_ATTRIBUTES = %i[
 <%=
   form_attributes.map do |attr|
-    "    :#{attr},"
+    "  #{attr}"
   end.join("\n")
 %>
   ].freeze
 
+  # COLLECTION_FILTERS
+  # a hash that defines filters that can be used while searching via the search
+  # field of the dashboard.
+  #
+  # For example to add an option to search for open resources by typing "open:"
+  # in the search field:
+  #
+  #   COLLECTION_FILTERS = {
+  #     open: ->(resources) { resources.where(open: true) }
+  #   }.freeze
+  COLLECTION_FILTERS = {}.freeze
+
   # Overwrite this method to customize how <%= file_name.pluralize.humanize.downcase %> are displayed
   # across all pages of the admin dashboard.
   #