administrate 0.8.1 → 0.12.0

data/lib/administrate/base_dashboard.rb

@@ -9,6 +9,9 @@ require "administrate/field/polymorphic"
 require "administrate/field/select"
 require "administrate/field/string"
 require "administrate/field/text"
+require "administrate/field/time"
+require "administrate/field/url"
+require "administrate/field/password"
 
 module Administrate
   class BaseDashboard
@@ -30,6 +33,10 @@ module Administrate
       end
     end
 
+    def all_attributes
+      attribute_types.keys
+    end
+
     def form_attributes
       self.class::FORM_ATTRIBUTES
     end
@@ -52,15 +59,12 @@ module Administrate
       "#{resource.class} ##{resource.id}"
     end
 
-    def association_includes
-      association_classes = [Field::HasMany, Field::HasOne, Field::BelongsTo]
-
-      collection_attributes.map do |key|
-        field = self.class::ATTRIBUTE_TYPES[key]
+    def collection_includes
+      attribute_includes(collection_attributes)
+    end
 
-        next key if association_classes.include?(field)
-        key if association_classes.include?(field.try :deferred_class)
-      end.compact
+    def item_includes
+      attribute_includes(show_page_attributes)
     end
 
     private
@@ -68,5 +72,20 @@ module Administrate
     def attribute_not_found_message(attr)
       "Attribute #{attr} could not be found in #{self.class}::ATTRIBUTE_TYPES"
     end
+
+    def association_classes
+      @association_classes ||=
+        ObjectSpace.each_object(Class).
+          select { |klass| klass < Administrate::Field::Associative }
+    end
+
+    def attribute_includes(attributes)
+      attributes.map do |key|
+        field = self.class::ATTRIBUTE_TYPES[key]
+
+        next key if association_classes.include?(field)
+        key if association_classes.include?(field.try(:deferred_class))
+      end.compact
+    end
   end
 end

data/lib/administrate/engine.rb

@@ -2,7 +2,7 @@ require "datetime_picker_rails"
 require "jquery-rails"
 require "kaminari"
 require "momentjs-rails"
-require "sass-rails"
+require "sassc-rails"
 require "selectize-rails"
 require "sprockets/railtie"
 

data/lib/administrate/field/associative.rb

@@ -7,16 +7,16 @@ module Administrate
         associated_dashboard.display_resource(data)
       end
 
+      def associated_class
+        associated_class_name.constantize
+      end
+
       protected
 
       def associated_dashboard
         "#{associated_class_name}Dashboard".constantize.new
       end
 
-      def associated_class
-        associated_class_name.constantize
-      end
-
       def associated_class_name
         options.fetch(:class_name, attribute.to_s.singularize.camelcase)
       end
@@ -24,6 +24,10 @@ module Administrate
       def primary_key
         options.fetch(:primary_key, :id)
       end
+
+      def foreign_key
+        options.fetch(:foreign_key, :"#{attribute}_id")
+      end
     end
   end
 end

data/lib/administrate/field/base.rb

@@ -24,7 +24,7 @@ module Administrate
         @options = options
       end
 
-      def self.permitted_attribute(attr)
+      def self.permitted_attribute(attr, _options = nil)
         attr
       end
 

data/lib/administrate/field/belongs_to.rb

@@ -3,12 +3,12 @@ require_relative "associative"
 module Administrate
   module Field
     class BelongsTo < Associative
-      def self.permitted_attribute(attr)
+      def self.permitted_attribute(attr, _options = nil)
         :"#{attr}_id"
       end
 
       def permitted_attribute
-        self.class.permitted_attribute(attribute)
+        foreign_key
       end
 
       def associated_resource_options
@@ -24,7 +24,10 @@ module Administrate
       private
 
       def candidate_resources
-        associated_class.all
+        scope = options[:scope] ? options[:scope].call : associated_class.all
+
+        order = options.delete(:order)
+        order ? scope.reorder(order) : scope
       end
 
       def display_candidate_resource(resource)

data/lib/administrate/field/date_time.rb

@@ -4,11 +4,18 @@ module Administrate
   module Field
     class DateTime < Base
       def date
-        I18n.localize(data.to_date, format: format)
+        I18n.localize(
+          data.in_time_zone(timezone).to_date,
+          format: format,
+        )
       end
 
       def datetime
-        I18n.localize(data, format: format, default: data)
+        I18n.localize(
+          data.in_time_zone(timezone),
+          format: format,
+          default: data,
+        )
       end
 
       private
@@ -16,6 +23,10 @@ module Administrate
       def format
         options.fetch(:format, :default)
       end
+
+      def timezone
+        options.fetch(:timezone, ::Time.zone.name || "UTC")
+      end
     end
   end
 end

data/lib/administrate/field/deferred.rb

@@ -25,11 +25,16 @@ module Administrate
         options.fetch(:searchable, deferred_class.searchable?)
       end
 
-      delegate(
-        :html_class,
-        :permitted_attribute,
-        to: :deferred_class,
-      )
+      def searchable_field
+        options.fetch(:searchable_field)
+      end
+
+      def permitted_attribute(attr, _options = nil)
+        options.fetch(:foreign_key,
+          deferred_class.permitted_attribute(attr, options))
+      end
+
+      delegate :html_class, to: :deferred_class
     end
   end
 end

data/lib/administrate/field/has_many.rb

@@ -7,12 +7,12 @@ module Administrate
     class HasMany < Associative
       DEFAULT_LIMIT = 5
 
-      def self.permitted_attribute(attribute)
-        { "#{attribute.to_s.singularize}_ids".to_sym => [] }
+      def self.permitted_attribute(attr, _options = nil)
+        { "#{attr.to_s.singularize}_ids".to_sym => [] }
       end
 
-      def associated_collection
-        Administrate::Page::Collection.new(associated_dashboard)
+      def associated_collection(order = self.order)
+        Administrate::Page::Collection.new(associated_dashboard, order: order)
       end
 
       def attribute_key
@@ -39,7 +39,7 @@ module Administrate
         self.class.permitted_attribute(attribute)
       end
 
-      def resources(page = 1)
+      def resources(page = 1, order = self.order)
         resources = order.apply(data).page(page).per(limit)
         includes.any? ? resources.includes(*includes) : resources
       end
@@ -49,13 +49,24 @@ module Administrate
       end
 
       def data
-        @data ||= associated_class.none 
+        @data ||= associated_class.none
+      end
+
+      def order_from_params(params)
+        Administrate::Order.new(
+          params.fetch(:order, sort_by),
+          params.fetch(:direction, direction),
+        )
+      end
+
+      def order
+        @order ||= Administrate::Order.new(sort_by, direction)
       end
 
       private
 
       def includes
-        associated_dashboard.association_includes
+        associated_dashboard.collection_includes
       end
 
       def candidate_resources
@@ -71,10 +82,6 @@ module Administrate
         associated_dashboard.display_resource(resource)
       end
 
-      def order
-        @_order ||= Administrate::Order.new(sort_by, direction)
-      end
-
       def sort_by
         options[:sort_by]
       end

data/lib/administrate/field/has_one.rb

@@ -3,25 +3,33 @@ require_relative "associative"
 module Administrate
   module Field
     class HasOne < Associative
-      def initialize(attribute, data, page, options = {})
-        resolver = Administrate::ResourceResolver.new("admin/#{attribute}")
-        @nested_form = Administrate::Page::Form.new(
+      def nested_form
+        @nested_form ||= Administrate::Page::Form.new(
           resolver.dashboard_class.new,
           data || resolver.resource_class.new,
         )
-
-        super
       end
 
-      def self.permitted_attribute(attr)
+      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/#{attr}").
+          Administrate::ResourceResolver.new("admin/#{associated_class_name}").
             dashboard_class.new.permitted_attributes + [:id]
 
         { "#{attr}_attributes": related_dashboard_attributes }
       end
 
-      attr_reader :nested_form
+      private
+
+      def resolver
+        @resolver ||=
+          Administrate::ResourceResolver.new("admin/#{associated_class_name}")
+      end
     end
   end
 end

data/lib/administrate/field/password.rb

@@ -0,0 +1,25 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Password < Field::Base
+      def self.searchable?
+        false
+      end
+
+      def truncate
+        data.to_s.gsub(/./, character)[0...truncation_length]
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+
+      def character
+        options.fetch(:character, "•")
+      end
+    end
+  end
+end

data/lib/administrate/field/polymorphic.rb

@@ -2,11 +2,49 @@ require_relative "associative"
 
 module Administrate
   module Field
-    class Polymorphic < Associative
+    class Polymorphic < BelongsTo
+      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 self.permitted_attribute(attr, _options = nil)
+        { attr => %i{type value} }
+      end
+
+      def permitted_attribute
+        { attribute => %i{type value} }
+      end
+
+      def selected_global_id
+        data ? data.to_global_id : nil
+      end
+
       protected
 
-      def associated_dashboard
-        "#{data.class.name}Dashboard".constantize.new
+      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 display_candidate_resource(resource)
+        associated_dashboard(resource.class).display_resource(resource)
       end
     end
   end

data/lib/administrate/field/time.rb

@@ -0,0 +1,8 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Time < Base
+    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

@@ -12,7 +12,7 @@ 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

data/lib/administrate/order.rb

@@ -6,11 +6,15 @@ module Administrate
     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(order) if
+        relation.columns_hash.keys.include?(attribute.to_s)
+
+      relation
     end
 
     def ordered_by?(attr)
@@ -41,5 +45,36 @@ module Administrate
     def opposite_direction
       direction.to_sym == :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)
+      relation.
+      left_joins(attribute.to_sym).
+      group(:id).
+      reorder("COUNT(#{attribute}.id) #{direction}")
+    end
+
+    def order_by_id(relation)
+      relation.reorder("#{attribute}_id #{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
   end
 end

data/lib/administrate/page/base.rb

@@ -15,6 +15,14 @@ module Administrate
         @resource_path ||= resource_name.gsub("/", "_")
       end
 
+      def collection_includes
+        dashboard.try(:collection_includes) || []
+      end
+
+      def item_includes
+        dashboard.try(:item_includes) || []
+      end
+
       protected
 
       def attribute_field(dashboard, resource, attribute_name, page)

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/resource_resolver.rb

@@ -5,7 +5,7 @@ module Administrate
     end
 
     def dashboard_class
-      Object.const_get(resource_class_name + "Dashboard")
+      ActiveSupport::Inflector.constantize("#{resource_class_name}Dashboard")
     end
 
     def namespace
@@ -13,7 +13,7 @@ module Administrate
     end
 
     def resource_class
-      Object.const_get(resource_class_name)
+      ActiveSupport::Inflector.constantize(resource_class_name)
     end
 
     def resource_name

data/lib/administrate/search.rb

@@ -3,32 +3,91 @@ 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(#{table_name}.#{attr_name}) LIKE ?"
+        table_name = query_table_name(attr)
+        attr_name = column_to_query(attr)
+
+        "LOWER(CAST(#{table_name}.#{attr_name} AS CHAR(256))) LIKE ?"
       end.join(" OR ")
     end
 
-    def search_terms
+    def query_values
       ["%#{term.mb_chars.downcase}%"] * search_attributes.count
     end
 
@@ -38,10 +97,62 @@ 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)
+        ActiveRecord::Base.connection.quote_table_name(attr.to_s.pluralize)
+      else
+        ActiveRecord::Base.connection.
+          quote_table_name(@scoped_resource.table_name)
+      end
+    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
+    end
+
+    def tables_to_join
+      attribute_types.keys.select do |attribute|
+        attribute_types[attribute].searchable? && association_search?(attribute)
+      end
+    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)
+    end
+
+    def term
+      query.terms
+    end
+
+    attr_reader :resolver, :query
   end
 end