activeadmin 1.3.1 → 1.4.0

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

@@ -17,6 +17,17 @@ ActiveAdmin.application.view_factory.show_page.send :include, ActiveAdmin::Comme
 # Load the model as soon as it's referenced. By that point, Rails & Kaminari will be ready
 ActiveAdmin.autoload :Comment, 'active_admin/orm/active_record/comments/comment'
 
+# Hint i18n-tasks about model and attribute translations used by default install
+# i18n-tasks-use t('activerecord.models.comment')
+# i18n-tasks-use t('activerecord.models.active_admin/comment')
+# i18n-tasks-use t('activerecord.attributes.active_admin/comment.author_type')
+# i18n-tasks-use t('activerecord.attributes.active_admin/comment.body')
+# i18n-tasks-use t('activerecord.attributes.active_admin/comment.created_at')
+# i18n-tasks-use t('activerecord.attributes.active_admin/comment.namespace')
+# i18n-tasks-use t('activerecord.attributes.active_admin/comment.resource_type')
+# i18n-tasks-use t('activerecord.attributes.active_admin/comment.updated_at')
+# i18n-tasks-use t('active_admin.scopes.all')
+
 # Walk through all the loaded namespaces after they're loaded
 ActiveAdmin.after_load do |app|
   app.namespaces.each do |namespace|

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 }.merge(ActiveAdmin::Dependency.rails.optional_belongs_to_flag)
     belongs_to :author,   polymorphic: true
 
     validates_presence_of :body, :namespace, :resource

data/lib/active_admin/resource/action_items.rb

@@ -24,6 +24,7 @@ module ActiveAdmin
       #                         this action item on.
       #                 :except: A single or array of controller actions not to
       #                          display this action item on.
+      #                 :priority: A single integer value. To control the display order. Default is 10.
       def add_action_item(name, options = {}, &block)
         self.action_items << ActiveAdmin::ActionItem.new(name, options, &block)
       end
@@ -38,7 +39,7 @@ module ActiveAdmin
       #
       # @return [Array] Array of ActionItems for the controller actions
       def action_items_for(action, render_context = nil)
-        action_items.select{ |item| item.display_on? action, render_context }
+        action_items.select { |item| item.display_on? action, render_context }.sort_by(&:priority)
       end
 
       # Clears all the existing action items for this resource
@@ -110,6 +111,10 @@ module ActiveAdmin
     def html_class
       "action_item #{@options[:class]}".rstrip
     end
+
+    def priority
+      @options[:priority] || 10
+    end
   end
 
 end

data/lib/active_admin/resource_controller/decorators.rb

@@ -2,7 +2,7 @@ module ActiveAdmin
   class ResourceController < BaseController
     module Decorators
 
-    protected
+      protected
 
       def apply_decorator(resource)
         decorate? ? decorator_class.new(resource) : resource
@@ -24,7 +24,7 @@ module ActiveAdmin
         end
       end
 
-    private
+      private
 
       def decorate?
         case action_name
@@ -62,7 +62,7 @@ module ActiveAdmin
           end
         end
 
-      private
+        private
 
         def self.wrap!(parent, name)
           ::Class.new parent do

data/lib/active_admin/resource_controller/scoping.rb

@@ -15,7 +15,7 @@ module ActiveAdmin
       # Collection can be scoped conditionally with an :if or :unless proc.
       def begin_of_association_chain
         return nil unless active_admin_config.scope_to?(self)
-        render_in_context(self, active_admin_config.scope_to_method)
+        StringSymbolOrProcSetting.new(active_admin_config.scope_to_method).value(self)
       end
 
       # Overriding from InheritedResources::BaseHelpers

data/lib/active_admin/router.rb

@@ -1,108 +1,113 @@
 module ActiveAdmin
+  # @private
   class Router
-    def initialize(application)
-      @application = application
+    attr_reader :namespaces, :router
+
+    def initialize(router:, namespaces:)
+      @router, @namespaces = router, namespaces
     end
 
-    # Creates all the necessary routes for the ActiveAdmin configurations
-    #
-    # Use this within the routes.rb file:
-    #
-    #   Application.routes.draw do |map|
-    #     ActiveAdmin.routes(self)
-    #   end
-    #
-    def apply(router)
-      define_root_routes router
-      define_resource_routes router
+    def apply
+      define_root_routes
+      define_resources_routes
     end
 
-    def define_root_routes(router)
-      router.instance_exec @application.namespaces do |namespaces|
-        namespaces.each do |namespace|
-          if namespace.root?
-            root namespace.root_to_options.merge(to: namespace.root_to)
-          else
-            namespace namespace.name, namespace.route_options.dup do
-              root namespace.root_to_options.merge(to: namespace.root_to, as: :root)
-            end
+    private
+
+    def define_root_routes
+      namespaces.each do |namespace|
+        if namespace.root?
+          router.root namespace.root_to_options.merge(to: namespace.root_to)
+        else
+          router.namespace namespace.name, namespace.route_options.dup do
+            router.root namespace.root_to_options.merge(to: namespace.root_to, as: :root)
           end
         end
       end
     end
 
     # Defines the routes for each resource
-    def define_resource_routes(router)
-      router.instance_exec @application.namespaces, self do |namespaces, aa_router|
-        resources = namespaces.flat_map{ |n| n.resources.values }
-        resources.each do |config|
-          routes = aa_router.resource_routes(config)
-
-          # Add in the parent if it exists
-          if config.belongs_to?
-            belongs_to = routes
-            routes     = Proc.new do
-              # If it's optional, make the normal resource routes
-              instance_exec &belongs_to if config.belongs_to_config.optional?
-
-              # Make the nested belongs_to routes
-              # :only is set to nothing so that we don't clobber any existing routes on the resource
-              resources config.belongs_to_config.target.resource_name.plural, only: [] do
-                instance_exec &belongs_to
-              end
-            end
-          end
+    def define_resources_routes
+      resources = namespaces.flat_map{ |n| n.resources.values }
+      resources.each do |config|
+        define_resource_routes(config)
+      end
+    end
 
-          # Add on the namespace if required
-          unless config.namespace.root?
-            nested = routes
-            routes = Proc.new do
-              namespace config.namespace.name, config.namespace.route_options.dup do
-                instance_exec &nested
-              end
-            end
-          end
+    def define_resource_routes(config)
+      if config.namespace.root?
+        define_routes(config)
+      else
+        # Add on the namespace if required
+        define_namespace(config)
+      end
+    end
 
-          instance_exec &routes
-        end
+    def define_routes(config)
+      if config.belongs_to?
+        define_belongs_to_routes(config)
+      else
+        page_or_resource_routes(config)
       end
     end
 
+    def page_or_resource_routes(config)
+      config.is_a?(Page) ? page_routes(config) : resource_routes(config)
+    end
+
     def resource_routes(config)
-      Proc.new do
-        # Builds one route for each HTTP verb passed in
-        build_route = proc{ |verbs, *args|
-          [*verbs].each{ |verb| send verb, *args }
-        }
-        # Deals with +ControllerAction+ instances
-        build_action = proc{ |action|
-          build_route.call(action.http_verb, action.name)
-        }
-        case config
-        when ::ActiveAdmin::Resource
-          resources config.resource_name.route_key, only: config.defined_actions do
-            member do
-              config.member_actions.each &build_action
-            end
-
-            collection do
-              config.collection_actions.each &build_action
-              post :batch_action if config.batch_actions_enabled?
-            end
-          end
-        when ::ActiveAdmin::Page
-          page = config.underscored_resource_name
-          get "/#{page}" => "#{page}#index"
-          config.page_actions.each do |action|
-            Array.wrap(action.http_verb).each do |verb|
-              build_route.call verb, "/#{page}/#{action.name}" => "#{page}##{action.name}"
-            end
-          end
-        else
-          raise "Unsupported config class: #{config.class}"
+      router.resources config.resource_name.route_key, only: config.defined_actions do
+        define_actions(config)
+      end
+    end
+
+    def page_routes(config)
+      page = config.underscored_resource_name
+      router.get "/#{page}" => "#{page}#index"
+      config.page_actions.each do |action|
+        Array.wrap(action.http_verb).each do |verb|
+          build_route(verb, "/#{page}/#{action.name}" => "#{page}##{action.name}")
         end
       end
+    end
+
+    # Defines member and collection actions
+    def define_actions(config)
+      router.member do
+        config.member_actions.each { |action| build_action(action) }
+      end
+
+      router.collection do
+        config.collection_actions.each { |action| build_action(action) }
+        router.post :batch_action if config.batch_actions_enabled?
+      end
+    end
+
+    # Deals with +ControllerAction+ instances
+    # Builds one route for each HTTP verb passed in
+    def build_action(action)
+      build_route(action.http_verb, action.name)
+    end
+
+    def build_route(verbs, *args)
+      Array.wrap(verbs).each { |verb| router.send(verb, *args) }
+    end
+
+    def define_belongs_to_routes(config)
+      # If it's optional, make the normal resource routes
+      page_or_resource_routes(config) if config.belongs_to_config.optional?
+
+      # Make the nested belongs_to routes
+      # :only is set to nothing so that we don't clobber any existing routes on the resource
+      router.resources config.belongs_to_config.target.resource_name.plural, only: [] do
+        page_or_resource_routes(config)
+      end
+    end
 
+    def define_namespace(config)
+      router.namespace config.namespace.name, config.namespace.route_options.dup do
+        define_routes(config)
+      end
     end
   end
 end

data/lib/active_admin/scope.rb

@@ -1,7 +1,7 @@
 module ActiveAdmin
   class Scope
 
-    attr_reader :scope_method, :id, :scope_block, :display_if_block, :show_count, :default_block
+    attr_reader :scope_method, :id, :scope_block, :display_if_block, :show_count, :default_block, :group
 
     # Create a Scope
     #
@@ -24,6 +24,9 @@ module ActiveAdmin
     #   Scope.new ->{Date.today.strftime '%A'}, :published_today
     #   # => Scope with dynamic title using the :published_today scope method
     #
+    #   Scope.new :published, nil, group: :status
+    #   # => Scope with the group :status
+    #
     def initialize(name, method = nil, options = {}, &block)
       @name, @scope_method = name, method.try(:to_sym)
 
@@ -42,6 +45,7 @@ module ActiveAdmin
       @show_count       = options.fetch(:show_count, true)
       @display_if_block = options[:if]      || proc{ true }
       @default_block    = options[:default] || proc{ false }
+      @group            = options[:group].try(:to_sym)
     end
 
     def name

data/lib/active_admin/settings_node.rb

@@ -0,0 +1,19 @@
+module ActiveAdmin
+
+  class SettingsNode
+    class << self
+      # Never instantiated.  Variables are stored in the singleton_class.
+      private_class_method :new
+
+      # @returns anonymous class with same accessors as the superclass.
+      def build(superclass = self)
+        Class.new(superclass)
+      end
+
+      def register(name, value)
+        class_attribute name
+        send "#{name}=", value
+      end
+    end
+  end
+end

data/lib/active_admin/version.rb

@@ -1,3 +1,3 @@
 module ActiveAdmin
-  VERSION = '1.3.1'
+  VERSION = '1.4.0'
 end

data/lib/active_admin/views/components/active_admin_form.rb

@@ -105,13 +105,12 @@ module ActiveAdmin
         create_another = params[:create_another]
         label = @resource.class.model_name.human
         Arbre::Context.new do
-          li do
+          li class: 'create_another' do
             input(
               checked: create_another,
               id: 'create_another',
-              class: 'create_another',
               name: 'create_another',
-              type: 'checkbox',
+              type: 'checkbox'
             )
             label(I18n.t('active_admin.create_another', model: label), for: 'create_another')
           end

data/lib/active_admin/views/components/menu.rb

@@ -0,0 +1,32 @@
+module ActiveAdmin
+  module Views
+
+    # Renders an ActiveAdmin::Menu as a set of unordered list items.
+    #
+    # This component takes cares of deciding which items should be
+    # displayed given the current context and renders them appropriately.
+    #
+    # The entire component is rendered within one ul element.
+    class Menu < Component
+      attr_reader :menu
+      builder_method :menu
+
+      # @param [ActiveAdmin::Menu] menu the Menu to render
+      # @param [Hash] options the options as passed to the underlying ul element.
+      #
+      def build(menu, options = {})
+        @menu = menu
+        super(options)
+
+        menu.items.each do |item|
+          menu_item(item) if helpers.render_in_context self, item.should_display
+        end
+        children.sort!
+      end
+
+      def tag_name
+        'ul'
+      end
+    end
+  end
+end

data/lib/active_admin/views/components/menu_item.rb

@@ -0,0 +1,58 @@
+module ActiveAdmin
+  module Views
+
+    # Arbre component used to render ActiveAdmin::MenuItem
+    class MenuItem < Component
+      builder_method :menu_item
+      attr_reader :label
+      attr_reader :url
+      attr_reader :priority
+
+      def build(item, options = {})
+        super(options.merge(id: item.id))
+        @label = helpers.render_in_context self, item.label
+        @url = helpers.render_in_context self, item.url
+        @priority = item.priority
+        @submenu = nil
+
+        add_class "current" if item.current? assigns[:current_tab]
+
+        if url
+          a label, item.html_options.merge(href: url)
+        else
+          span label, item.html_options
+        end
+
+        if item.items.any?
+          add_class "has_nested"
+          @submenu = menu(item)
+        end
+      end
+
+      def tag_name
+        'li'
+      end
+
+      # Sorts by priority first, then alphabetically by label if needed.
+      def <=>(other)
+        result = priority <=> other.priority
+        result == 0 ? label <=> other.label : result
+      end
+
+      def visible?
+        url.nil? || real_url? || @submenu && @submenu.children.any?
+      end
+
+      def to_s
+        visible? ? super : ''
+      end
+
+      private
+
+      # URL is not nil, empty, or '#'
+      def real_url?
+        url && url.present? && url != '#'
+      end
+    end
+  end
+end