administrate 0.8.1 → 0.17.0

data/lib/administrate/base_dashboard.rb

@@ -1,6 +1,7 @@
 require "administrate/field/belongs_to"
 require "administrate/field/boolean"
 require "administrate/field/date_time"
+require "administrate/field/date"
 require "administrate/field/email"
 require "administrate/field/has_many"
 require "administrate/field/has_one"
@@ -9,11 +10,26 @@ 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
     include Administrate
 
+    DASHBOARD_SUFFIX = "Dashboard".freeze
+
+    class << self
+      def model
+        to_s.chomp(DASHBOARD_SUFFIX).classify.constantize
+      end
+
+      def resource_name(opts)
+        model.model_name.human(opts)
+      end
+    end
+
     def attribute_types
       self.class::ATTRIBUTE_TYPES
     end
@@ -30,13 +46,28 @@ module Administrate
       end
     end
 
-    def form_attributes
-      self.class::FORM_ATTRIBUTES
+    def all_attributes
+      attribute_types.keys
+    end
+
+    def form_attributes(action = nil)
+      specific_form_attributes_for(action) || self.class::FORM_ATTRIBUTES
+    end
+
+    def specific_form_attributes_for(action)
+      return unless action
+
+      cname = "FORM_ATTRIBUTES_#{action.upcase}"
+
+      self.class.const_get(cname) if self.class.const_defined?(cname)
     end
 
     def permitted_attributes
       form_attributes.map do |attr|
-        attribute_types[attr].permitted_attribute(attr)
+        attribute_types[attr].permitted_attribute(
+          attr,
+          resource_class: self.class.model,
+        )
       end.uniq
     end
 
@@ -48,19 +79,22 @@ module Administrate
       self.class::COLLECTION_ATTRIBUTES
     end
 
+    def search_attributes
+      attribute_types.keys.select do |attribute|
+        attribute_types[attribute].searchable?
+      end
+    end
+
     def display_resource(resource)
       "#{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 +102,13 @@ module Administrate
     def attribute_not_found_message(attr)
       "Attribute #{attr} could not be found in #{self.class}::ATTRIBUTE_TYPES"
     end
+
+    def attribute_includes(attributes)
+      attributes.map do |key|
+        field = attribute_type_for(key)
+
+        key if field.associative?
+      end.compact
+    end
   end
 end

data/lib/administrate/custom_dashboard.rb

@@ -0,0 +1,15 @@
+module Administrate
+  class CustomDashboard
+    include Administrate
+
+    class << self
+      def resource_name(_opts)
+        named_resource.pluralize.titleize
+      end
+
+      def resource(resource_name)
+        define_singleton_method(:named_resource) { resource_name }
+      end
+    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"
 
@@ -22,6 +22,13 @@ module Administrate
     @@javascripts = []
     @@stylesheets = []
 
+    initializer "administrate.assets.precompile" do |app|
+      app.config.assets.precompile += [
+        "administrate/application.js",
+        "administrate/application.css",
+      ]
+    end
+
     def self.add_javascript(script)
       @@javascripts << script
     end

data/lib/administrate/field/associative.rb

@@ -3,26 +3,74 @@ require_relative "base"
 module Administrate
   module Field
     class Associative < Base
+      def self.foreign_key_for(resource_class, attr)
+        reflection(resource_class, attr).foreign_key
+      end
+
+      def self.associated_class(resource_class, attr)
+        reflection(resource_class, attr).klass
+      end
+
+      def self.associated_class_name(resource_class, attr)
+        reflection(resource_class, attr).class_name
+      end
+
+      def self.reflection(resource_class, attr)
+        resource_class.reflect_on_association(attr)
+      end
+
       def display_associated_resource
         associated_dashboard.display_resource(data)
       end
 
-      protected
+      def associated_class
+        if option_given?(:class_name)
+          associated_class_name.constantize
+        else
+          self.class.associated_class(resource.class, attribute)
+        end
+      end
+
+      private
 
       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)
+        if option_given?(:class_name)
+          deprecated_option(:class_name)
+        else
+          self.class.associated_class_name(
+            resource.class,
+            attribute,
+          )
+        end
       end
 
       def primary_key
-        options.fetch(:primary_key, :id)
+        if option_given?(:primary_key)
+          deprecated_option(:primary_key)
+        else
+          :id
+        end
+      end
+
+      def foreign_key
+        if option_given?(:foreign_key)
+          deprecated_option(:foreign_key)
+        else
+          self.class.foreign_key_for(resource.class, attribute)
+        end
+      end
+
+      def option_given?(name)
+        options.key?(name)
+      end
+
+      def deprecated_option(name)
+        Administrate.warn_of_deprecated_option(name)
+        options.fetch(name)
       end
     end
   end

data/lib/administrate/field/base.rb

@@ -12,10 +12,22 @@ module Administrate
         field_type.dasherize
       end
 
+      def self.associative?
+        self < Associative
+      end
+
       def self.searchable?
         false
       end
 
+      def self.field_type
+        to_s.split("::").last.underscore
+      end
+
+      def self.permitted_attribute(attr, _options = nil)
+        attr
+      end
+
       def initialize(attribute, data, page, options = {})
         @attribute = attribute
         @data = data
@@ -24,10 +36,6 @@ module Administrate
         @options = options
       end
 
-      def self.permitted_attribute(attr)
-        attr
-      end
-
       def html_class
         self.class.html_class
       end
@@ -40,15 +48,33 @@ module Administrate
         "/fields/#{self.class.field_type}/#{page}"
       end
 
-      attr_reader :attribute, :data, :page, :resource
+      def required?
+        return false unless resource.class.respond_to?(:validators_on)
 
-      protected
+        resource.class.validators_on(attribute).any? do |v|
+          next false unless v.class == ActiveRecord::Validations::PresenceValidator
 
-      attr_reader :options
+          options = v.options
+          next false if options.include?(:if)
+          next false if options.include?(:unless)
 
-      def self.field_type
-        to_s.split("::").last.underscore
+          if on_option = options[:on]
+            if on_option == :create && !resource.persisted?
+              next true
+            end
+
+            if on_option == :update && resource.persisted?
+              next true
+            end
+
+            next false
+          end
+
+          true
+        end
       end
+
+      attr_reader :attribute, :data, :options, :page, :resource
     end
   end
 end

data/lib/administrate/field/belongs_to.rb

@@ -3,16 +3,22 @@ require_relative "associative"
 module Administrate
   module Field
     class BelongsTo < Associative
-      def self.permitted_attribute(attr)
-        :"#{attr}_id"
+      def self.permitted_attribute(attr, options = {})
+        resource_class = options[:resource_class]
+        if resource_class
+          foreign_key_for(resource_class, attr)
+        else
+          Administrate.warn_of_missing_resource_class
+          :"#{attr}_id"
+        end
       end
 
       def permitted_attribute
-        self.class.permitted_attribute(attribute)
+        foreign_key
       end
 
       def associated_resource_options
-        [nil] + candidate_resources.map do |resource|
+        candidate_resources.map do |resource|
           [display_candidate_resource(resource), resource.send(primary_key)]
         end
       end
@@ -21,10 +27,17 @@ module Administrate
         data && data.send(primary_key)
       end
 
+      def include_blank_option
+        options.fetch(:include_blank, true)
+      end
+
       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.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/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

@@ -21,15 +21,39 @@ module Administrate
           options == other.options
       end
 
+      def associative?
+        deferred_class.associative?
+      end
+
       def searchable?
         options.fetch(:searchable, deferred_class.searchable?)
       end
 
-      delegate(
-        :html_class,
-        :permitted_attribute,
-        to: :deferred_class,
-      )
+      def searchable_field
+        ActiveSupport::Deprecation.warn(
+          "searchable_field is deprecated, use searchable_fields instead",
+        )
+        options.fetch(:searchable_field)
+      end
+
+      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
     end
   end
 end

data/lib/administrate/field/has_many.rb

@@ -7,12 +7,22 @@ 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 = {})
+        # 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
 
-      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
@@ -36,10 +46,13 @@ 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)
+      def resources(page = 1, order = self.order)
         resources = order.apply(data).page(page).per(limit)
         includes.any? ? resources.includes(*includes) : resources
       end
@@ -49,13 +62,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 +95,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,53 @@ 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 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,
           data || resolver.resource_class.new,
         )
-
-        super
       end
 
-      def self.permitted_attribute(attr)
-        related_dashboard_attributes =
-          Administrate::ResourceResolver.new("admin/#{attr}").
-            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
 
-      attr_reader :nested_form
+      private
+
+      def resolver
+        @resolver ||=
+          Administrate::ResourceResolver.new("admin/#{associated_class.name}")
+      end
     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/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