activeadmin 1.1.0 → 2.4.0

data/lib/active_admin/form_builder.rb

@@ -13,7 +13,6 @@ end
 
 module ActiveAdmin
   class FormBuilder < ::Formtastic::FormBuilder
-    include MethodOrProcHelper
 
     self.input_namespaces = [::Object, ::ActiveAdmin::Inputs, ::Formtastic::Inputs]
 
@@ -21,7 +20,7 @@ module ActiveAdmin
     self.input_class_finder = ::Formtastic::InputClassFinder
     self.action_class_finder = ::Formtastic::ActionClassFinder
 
-    def cancel_link(url = {action: "index"}, html_options = {}, li_attrs = {})
+    def cancel_link(url = { action: "index" }, html_options = {}, li_attrs = {})
       li_attrs[:class] ||= "cancel"
       li_content = template.link_to I18n.t('active_admin.cancel'), url, html_options
       template.content_tag(:li, li_content, li_attrs)
@@ -29,119 +28,155 @@ module ActiveAdmin
 
     attr_accessor :already_in_an_inputs_block
 
-    def assoc_heading(assoc)
-      object.class.reflect_on_association(assoc).klass.model_name.
-        human(count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT)
+    def has_many(assoc, options = {}, &block)
+      HasManyBuilder.new(self, assoc, options).render(&block)
     end
+  end
 
-    def has_many(assoc, options = {}, &block)
-      # remove options that should not render as attributes
-      custom_settings = :new_record, :allow_destroy, :heading, :sortable, :sortable_start
-      builder_options = {new_record: true}.merge! options.slice  *custom_settings
-      options         = {for: assoc      }.merge! options.except *custom_settings
-      options[:class] = [options[:class], "inputs has_many_fields"].compact.join(' ')
-      sortable_column = builder_options[:sortable]
-      sortable_start  = builder_options.fetch(:sortable_start, 0)
+  # Decorates a FormBuilder with the additional attributes and methods
+  # to build a has_many block.  Nested has_many blocks are handled by
+  # nested decorators.
+  class HasManyBuilder < SimpleDelegator
+    attr_reader :assoc
+    attr_reader :options
+    attr_reader :heading, :sortable_column, :sortable_start
+    attr_reader :new_record, :destroy_option
+
+    def initialize(has_many_form, assoc, options)
+      super has_many_form
+      @assoc = assoc
+      @options = extract_custom_settings!(options.dup)
+      @options.reverse_merge!(for: assoc)
+      @options[:class] = [options[:class], "inputs has_many_fields"].compact.join(' ')
 
       if sortable_column
-        options[:for] = [assoc, sorted_children(assoc, sortable_column)]
+        @options[:for] = [assoc, sorted_children(sortable_column)]
       end
+    end
 
+    def render(&block)
       html = "".html_safe
-      unless builder_options.key?(:heading) && !builder_options[:heading]
-        html << template.content_tag(:h3) do
-          builder_options[:heading] || assoc_heading(assoc)
-        end
-      end
+      html << template.content_tag(:h3) { heading } if heading.present?
+      html << template.capture { content_has_many(&block) }
+      html = wrap_div_or_li(html)
+      template.concat(html) if template.output_buffer
+      html
+    end
 
-      html << template.capture do
-        form_block = proc do |has_many_form|
-          index    = parent_child_index options[:parent] if options[:parent]
-          block_contents = template.capture do
-            block.call(has_many_form, index)
-          end
-          template.concat(block_contents)
-          template.concat has_many_actions(has_many_form, builder_options, "".html_safe)
-        end
+    protected
 
-        template.assigns[:has_many_block] = true
-        contents = without_wrapper { inputs(options, &form_block) } || "".html_safe
+    # remove options that should not render as attributes
+    def extract_custom_settings!(options)
+      @heading = options.key?(:heading) ? options.delete(:heading) : default_heading
+      @sortable_column = options.delete(:sortable)
+      @sortable_start  = options.delete(:sortable_start) || 0
+      @new_record = options.key?(:new_record) ? options.delete(:new_record) : true
+      @destroy_option = options.delete(:allow_destroy)
+      options
+    end
 
-        if builder_options[:new_record]
-          contents << js_for_has_many(assoc, form_block, template, builder_options[:new_record], options[:class])
-        else
-          contents
-        end
+    def default_heading
+      assoc_klass.model_name.
+        human(count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT)
+    end
+
+    def assoc_klass
+      @assoc_klass ||= __getobj__.object.class.reflect_on_association(assoc).klass
+    end
+
+    def content_has_many(&block)
+      form_block = proc do |form_builder|
+        render_has_many_form(form_builder, options[:parent], &block)
       end
 
-      tag = @already_in_an_inputs_block ? :li : :div
-      html = template.content_tag(tag, html, class: "has_many_container #{assoc}", 'data-sortable' => sortable_column, 'data-sortable-start' => sortable_start)
-      template.concat(html) if template.output_buffer
-      html
+      template.assigns[:has_many_block] = true
+      contents = without_wrapper { inputs(options, &form_block) }
+      contents ||= "".html_safe
+
+      js = new_record ? js_for_has_many(options[:class], &form_block) : ''
+      contents << js
     end
 
-    protected
+    # Renders the Formtastic inputs then appends ActiveAdmin delete and sort actions.
+    def render_has_many_form(form_builder, parent, &block)
+      index = parent && form_builder.send(:parent_child_index, parent)
+      template.concat template.capture { yield(form_builder, index) }
+      template.concat has_many_actions(form_builder, "".html_safe)
+    end
 
-    def has_many_actions(has_many_form, builder_options, contents)
-      if has_many_form.object.new_record?
+    def has_many_actions(form_builder, contents)
+      if form_builder.object.new_record?
         contents << template.content_tag(:li) do
           template.link_to I18n.t('active_admin.has_many_remove'), "#", class: 'button has_many_remove'
         end
-      elsif call_method_or_proc_on(has_many_form.object,
-                                   builder_options[:allow_destroy],
-                                   exec: false)
-
-        has_many_form.input(:_destroy, as: :boolean,
-                            wrapper_html: {class: 'has_many_delete'},
+      elsif allow_destroy?(form_builder.object)
+        form_builder.input(:_destroy, as: :boolean,
+                            wrapper_html: { class: 'has_many_delete' },
                             label: I18n.t('active_admin.has_many_delete'))
       end
 
-      if builder_options[:sortable]
-        has_many_form.input builder_options[:sortable], as: :hidden
+      if sortable_column
+        form_builder.input sortable_column, as: :hidden
 
         contents << template.content_tag(:li, class: 'handle') do
-          "MOVE"
+          I18n.t('active_admin.move')
         end
       end
 
       contents
     end
 
-    def sorted_children(assoc, column)
-      object.public_send(assoc).sort_by do |o|
+    def allow_destroy?(form_object)
+      !! case destroy_option
+         when Symbol, String
+           form_object.public_send destroy_option
+         when Proc
+           destroy_option.call form_object
+         else
+           destroy_option
+         end
+    end
+
+    def sorted_children(column)
+      __getobj__.object.public_send(assoc).sort_by do |o|
         attribute = o.public_send column
         [attribute.nil? ? Float::INFINITY : attribute, o.id || Float::INFINITY]
       end
     end
 
-    private
-
     def without_wrapper
-      is_being_wrapped = @already_in_an_inputs_block
-      @already_in_an_inputs_block = false
+      is_being_wrapped = already_in_an_inputs_block
+      self.already_in_an_inputs_block = false
 
       html = yield
 
-      @already_in_an_inputs_block = is_being_wrapped
+      self.already_in_an_inputs_block = is_being_wrapped
       html
     end
 
     # Capture the ADD JS
-    def js_for_has_many(assoc, form_block, template, new_record, class_string)
-      assoc_reflection = object.class.reflect_on_association assoc
-      assoc_name       = assoc_reflection.klass.model_name
+    def js_for_has_many(class_string, &form_block)
+      assoc_name       = assoc_klass.model_name
       placeholder      = "NEW_#{assoc_name.to_s.underscore.upcase.gsub(/\//, '_')}_RECORD"
       opts = {
-        for: [assoc, assoc_reflection.klass.new],
+        for: [assoc, assoc_klass.new],
         class: class_string,
         for_options: { child_index: placeholder }
       }
-      html = template.capture{ inputs_for_nested_attributes opts, &form_block }
+      html = template.capture { __getobj__.send(:inputs_for_nested_attributes, opts, &form_block) }
       text = new_record.is_a?(String) ? new_record : I18n.t('active_admin.has_many_new', model: assoc_name.human)
 
       template.link_to text, '#', class: "button has_many_add", data: {
         html: CGI.escapeHTML(html).html_safe, placeholder: placeholder
       }
     end
+
+    def wrap_div_or_li(html)
+      template.content_tag(already_in_an_inputs_block ? :li : :div,
+                           html,
+                           class: "has_many_container #{assoc}",
+                           'data-sortable' => sortable_column,
+                           'data-sortable-start' => sortable_start)
+    end
   end
 end

data/lib/active_admin/generators/boilerplate.rb

@@ -9,8 +9,16 @@ module ActiveAdmin
         @class_name.constantize.new.attributes.keys
       end
 
+      def assignable_attributes
+        attributes - %w(id created_at updated_at)
+      end
+
+      def permit_params
+        assignable_attributes.map { |a| a.to_sym.inspect }.join(', ')
+      end
+
       def rows
-        attributes.map { |a| row(a) }.join("\n")
+        attributes.map { |a| row(a) }.join("\n  ")
       end
 
       def row(name)
@@ -18,7 +26,7 @@ module ActiveAdmin
       end
 
       def columns
-        attributes.map { |a| column(a) }.join("\n")
+        attributes.map { |a| column(a) }.join("\n  ")
       end
 
       def column(name)
@@ -26,7 +34,7 @@ module ActiveAdmin
       end
 
       def filters
-        attributes.map { |a| filter(a) }.join("\n")
+        attributes.map { |a| filter(a) }.join("\n  ")
       end
 
       def filter(name)
@@ -34,7 +42,7 @@ module ActiveAdmin
       end
 
       def form_inputs
-        attributes.reject{|a| %w(id created_at updated_at).include? a}.map{ |a| form_input(a) }.join("\n")
+        assignable_attributes.map { |a| form_input(a) }.join("\n  ")
       end
 
       def form_input(name)

data/lib/active_admin/helpers/scope_chain.rb

@@ -1,5 +1,6 @@
 module ActiveAdmin
   module ScopeChain
+    private
     # Scope an ActiveRecord::Relation chain
     #
     # Example:

data/lib/active_admin/inputs/datepicker_input.rb

@@ -9,10 +9,17 @@ module ActiveAdmin
         end
       end
 
+      # Can pass proc to filter label option
+      def label_from_options
+        res = super
+        res = res.call if res.is_a? Proc
+        res
+      end
+
       private
       def datepicker_options
         options = self.options.fetch(:datepicker_options, {})
-        options = Hash[options.map{ |k, v| [k.to_s.camelcase(:lower), v] }]
+        options = Hash[options.map { |k, v| [k.to_s.camelcase(:lower), v] }]
         { datepicker_options: options }
       end
     end

data/lib/active_admin/inputs/filters/base/search_method_select.rb

@@ -57,8 +57,8 @@ module ActiveAdmin
 
           def current_filter
             @current_filter ||= begin
-              methods = filters.map{ |f| "#{method}_#{f}" }
-              methods.detect{ |m| @object.public_send m } || methods.first
+              methods = filters.map { |f| "#{method}_#{f}" }
+              methods.detect { |m| @object.public_send m } || methods.first
             end
           end
 

data/lib/active_admin/inputs/filters/select_input.rb

@@ -15,7 +15,7 @@ module ActiveAdmin
             "#{reflection.through_reflection.name}_#{reflection.foreign_key}"
           else
             name = method.to_s
-            name.concat '_id' if reflection
+            name.concat "_#{reflection.association_primary_key}" if reflection_searchable?
             name
           end
         end
@@ -48,6 +48,10 @@ module ActiveAdmin
           klass.reorder("#{method} asc").distinct.pluck method
         end
 
+        def reflection_searchable?
+          reflection && !reflection.polymorphic?
+        end
+
       end
     end
   end

data/lib/active_admin/menu.rb

@@ -68,14 +68,8 @@ module ActiveAdmin
         self == item || include?(item)
       end
 
-      # Returns sorted array of menu items that should be displayed in this context.
-      # Sorts by priority first, then alphabetically by label if needed.
-      def items(context = nil)
-        @children.values.select{ |i| i.display?(context) }.sort do |a, b|
-          result = a.priority       <=> b.priority
-          result = a.label(context) <=> b.label(context) if result == 0
-          result
-        end
+      def items
+        @children.values
       end
 
       attr_reader :children

data/lib/active_admin/menu_item.rb

@@ -1,9 +1,6 @@
-require 'active_admin/view_helpers/method_or_proc_helper'
-
 module ActiveAdmin
   class MenuItem
     include Menu::MenuNode
-    include MethodOrProcHelper
 
     attr_reader :html_options, :parent, :priority
 
@@ -53,7 +50,7 @@ module ActiveAdmin
       @url            = options[:url]          || '#'
       @priority       = options[:priority]     || 10
       @html_options   = options[:html_options] || {}
-      @should_display = options[:if]           || proc{true}
+      @should_display = options[:if]           || proc { true }
       @parent         = options[:parent]
 
       yield(self) if block_given? # Builder style syntax
@@ -63,35 +60,10 @@ module ActiveAdmin
       @id ||= normalize_id @dirty_id
     end
 
-    def label(context = nil)
-      render_in_context context, @label
-    end
-
-    def url(context = nil)
-      render_in_context context, @url
-    end
+    attr_reader :label
+    attr_reader :url
 
     # Don't display if the :if option passed says so
-    # Don't display if the link isn't real, we have children, and none of the children are being displayed.
-    def display?(context = nil)
-      return false unless render_in_context(context, @should_display)
-      return false if     !real_url?(context) && @children.any? && !items(context).any?
-      true
-    end
-
-    # Returns an array of the ancestry of this menu item.
-    # The first item is the immediate parent of the item.
-    def ancestors
-      parent ? [parent, parent.ancestors].flatten : []
-    end
-
-    private
-
-    # URL is not nil, empty, or '#'
-    def real_url?(context = nil)
-      url = url context
-      url.present? && url != '#'
-    end
-
+    attr_reader :should_display
   end
 end

data/lib/active_admin/namespace.rb

@@ -25,6 +25,12 @@ module ActiveAdmin
   # resource will be accessible from "/posts" and the controller will be PostsController.
   #
   class Namespace
+    class << self
+      def setting(name, default)
+        Deprecation.warn "This method does not do anything and will be removed."
+      end
+    end
+
     RegisterEvent = 'active_admin.namespace.register'.freeze
 
     attr_reader :application, :resources, :menus
@@ -41,6 +47,18 @@ module ActiveAdmin
       @name.to_sym
     end
 
+    def settings
+      @settings ||= SettingsNode.build(application.namespace_settings)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      settings.respond_to?(method) || super
+    end
+
+    def method_missing(method, *args)
+      settings.respond_to?(method) ? settings.send(method, *args) : super
+    end
+
     # Register a resource into this namespace. The preffered method to access this is to
     # use the global registration ActiveAdmin.register which delegates to the proper
     # namespace instance.
@@ -100,12 +118,6 @@ module ActiveAdmin
       resources[klass]
     end
 
-    # Override from ActiveAdmin::Settings to inherit default attributes
-    # from the application
-    def read_default_setting(name)
-      application.public_send name
-    end
-
     def fetch_menu(name)
       @menus.fetch(name)
     end
@@ -138,8 +150,8 @@ module ActiveAdmin
       if logout_link_path
         html_options = html_options.reverse_merge(method: logout_link_method || :get)
         menu.add id: 'logout', priority: priority, html_options: html_options,
-          label: ->{ I18n.t 'active_admin.logout' },
-          url:   ->{ render_or_call_method_or_proc_on self, active_admin_namespace.logout_link_path },
+          label: -> { I18n.t 'active_admin.logout' },
+          url:   -> { render_or_call_method_or_proc_on self, active_admin_namespace.logout_link_path },
           if:    :current_active_admin_user?
       end
     end

data/lib/active_admin/namespace_settings.rb

@@ -0,0 +1,123 @@
+require 'active_admin/dynamic_settings_node'
+
+module ActiveAdmin
+  class NamespaceSettings < DynamicSettingsNode
+    # The default number of resources to display on index pages
+    register :default_per_page, 30
+
+    # The max number of resources to display on index pages and batch exports
+    register :max_per_page, 10_000
+
+    # The title which gets displayed in the main layout
+    register :site_title, "", :string_symbol_or_proc
+
+    # Set the site title link href (defaults to AA dashboard)
+    register :site_title_link, ""
+
+    # Set the site title image displayed in the main layout (has precendence over :site_title)
+    register :site_title_image, "", :string_symbol_or_proc
+
+    # Add to the site head
+    register :head, "", :string_symbol_or_proc
+
+    # Set the site footer text (defaults to Powered by ActiveAdmin text with version)
+    register :footer, "", :string_symbol_or_proc
+
+    # Set a favicon
+    register :favicon, false
+
+    # Additional meta tags to place in head of logged in pages
+    register :meta_tags, {}
+
+    # Additional meta tags to place in head of logged out pages
+    register :meta_tags_for_logged_out_pages, { robots: "noindex, nofollow" }
+
+    # The view factory to use to generate all the view classes. Take
+    # a look at ActiveAdmin::ViewFactory
+    register :view_factory, ActiveAdmin::ViewFactory.new
+
+    # The method to call in controllers to get the current user
+    register :current_user_method, false
+
+    # The method to call in the controllers to ensure that there
+    # is a currently authenticated admin user
+    register :authentication_method, false
+
+    # The path to log user's out with. If set to a symbol, we assume
+    # that it's a method to call which returns the path
+    register :logout_link_path, :destroy_admin_user_session_path
+
+    # The method to use when generating the link for user logout
+    register :logout_link_method, :get
+
+    # Whether the batch actions are enabled or not
+    register :batch_actions, false
+
+    # Whether filters are enabled
+    register :filters, true
+
+    # The namespace root
+    register :root_to, 'dashboard#index'
+
+    # Options that are passed to root_to
+    register :root_to_options, {}
+
+    # Options passed to the routes, i.e. { path: '/custom' }
+    register :route_options, {}
+
+    # Display breadcrumbs
+    register :breadcrumb, true
+
+    # Display create another checkbox on a new page
+    # @return [Boolean] (true)
+    register :create_another, false
+
+    # Default CSV options
+    register :csv_options, { col_sep: ',', byte_order_mark: "\xEF\xBB\xBF" }
+
+    # Default Download Links options
+    register :download_links, true
+
+    # The authorization adapter to use
+    register :authorization_adapter, ActiveAdmin::AuthorizationAdapter
+
+    # A proc to be used when a user is not authorized to view the current resource
+    register :on_unauthorized_access, :rescue_active_admin_access_denied
+
+    # A regex to detect unsupported browser, set to false to disable
+    register :unsupported_browser_matcher, /MSIE [1-8]\.0/
+
+    # Whether to display 'Current Filters' on search screen
+    register :current_filters, true
+
+    # class to handle ordering
+    register :order_clause, ActiveAdmin::OrderClause
+
+    # default show_count for scopes
+    register :scopes_show_count, true
+
+    # Request parameters that are permitted by default
+    register :permitted_params, [
+      :utf8, :_method, :authenticity_token, :commit, :id
+    ]
+
+    # Set flash message keys that shouldn't show in ActiveAdmin
+    register :flash_keys_to_except, ['timedout']
+
+    # Include association filters by default
+    register :include_default_association_filters, true
+
+    register :maximum_association_filter_arity, :unlimited
+
+    register :filter_columns_for_large_association, [
+        :display_name,
+        :full_name,
+        :name,
+        :username,
+        :login,
+        :title,
+        :email,
+    ]
+    register :filter_method_for_large_association, '_starts_with'
+  end
+end

data/lib/active_admin/order_clause.rb

@@ -3,7 +3,7 @@ module ActiveAdmin
     attr_reader :field, :order, :active_admin_config
 
     def initialize(active_admin_config, clause)
-      clause =~ /^([\w\_\.]+)(->'\w+')?_(desc|asc)$/
+      clause =~ /^([\w\.]+)(->'\w+')?_(desc|asc)$/
       @column = $1
       @op = $2
       @order = $3
@@ -16,7 +16,7 @@ module ActiveAdmin
     end
 
     def apply(chain)
-      chain.reorder(sql)
+      chain.reorder(Arel.sql sql)
     end
 
     def to_sql

data/lib/active_admin/orm/active_record/comments/comment.rb

@@ -3,7 +3,7 @@ module ActiveAdmin
 
     self.table_name = "#{table_name_prefix}active_admin_comments#{table_name_suffix}"
 
-    belongs_to :resource, polymorphic: true
+    belongs_to :resource, polymorphic: true, optional: true
     belongs_to :author,   polymorphic: true
 
     validates_presence_of :body, :namespace, :resource
@@ -18,7 +18,7 @@ module ActiveAdmin
     def self.find_for_resource_in_namespace(resource, namespace)
       where(
         resource_type: resource_type(resource),
-        resource_id:   resource,
+        resource_id:   resource.id,
         namespace:     namespace.to_s
       ).order(ActiveAdmin.application.namespaces[namespace.to_sym].comments_order)
     end

data/lib/active_admin/orm/active_record/comments/views/active_admin_comments.rb

@@ -11,10 +11,12 @@ module ActiveAdmin
         attr_accessor :resource
 
         def build(resource)
-          @resource = resource
-          @comments = ActiveAdmin::Comment.find_for_resource_in_namespace(resource, active_admin_namespace.name).page(params[:page])
-          super(title, for: resource)
-          build_comments
+          if authorized?(ActiveAdmin::Auth::READ, ActiveAdmin::Comment)
+            @resource = resource
+            @comments = active_admin_authorization.scope_collection(ActiveAdmin::Comment.find_for_resource_in_namespace(resource, active_admin_namespace.name).includes(:author).page(params[:page]))
+            super(title, for: resource)
+            build_comments
+          end
         end
 
         protected
@@ -24,10 +26,18 @@ module ActiveAdmin
         end
 
         def build_comments
-          @comments.any? ? @comments.each(&method(:build_comment)) : build_empty_message
-          div page_entries_info(@comments).html_safe, class: 'pagination_information'
+          if @comments.any?
+            @comments.each(&method(:build_comment))
+            div page_entries_info(@comments).html_safe, class: 'pagination_information'
+          else
+            build_empty_message
+          end
+
           text_node paginate @comments
-          build_comment_form
+
+          if authorized?(ActiveAdmin::Auth::CREATE, ActiveAdmin::Comment)
+            build_comment_form
+          end
         end
 
         def build_comment(comment)