activeadmin 1.1.0 → 2.4.0

data/lib/active_admin/router.rb

@@ -1,108 +1,114 @@
 module ActiveAdmin
+  # @private
   class Router
-    def initialize(application)
-      @application = application
+    attr_reader :namespaces, :router
+
+    def initialize(router:, namespaces:)
+      @router = router
+      @namespaces = 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,24 +24,32 @@ 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)
+      @name = name
+      @scope_method = method.try(:to_sym)
 
       if name.is_a? Proc
         raise "A string/symbol is required as the second argument if your label is a proc." unless method
-        @id = ActiveAdmin::Dependency.rails.parameterize method.to_s
+        @id = method.to_s.parameterize(separator: "_")
       else
         @scope_method ||= name.to_sym
-        @id = ActiveAdmin::Dependency.rails.parameterize name.to_s
+        @id = name.to_s.parameterize(separator: "_")
       end
 
-      @scope_method               = nil        if @scope_method == :all
-      @scope_method, @scope_block = nil, block if block_given?
+      @scope_method = nil if @scope_method == :all
+      if block_given?
+        @scope_method = nil
+        @scope_block = block
+      end
 
       @localizer        = options[:localizer]
       @show_count       = options.fetch(:show_count, true)
-      @display_if_block = options[:if]      || proc{ true }
-      @default_block    = options[:default] || proc{ false }
+      @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
+
+      # @return 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/sidebar_section.rb

@@ -6,7 +6,9 @@ module ActiveAdmin
     attr_accessor :name, :options, :block
 
     def initialize(name, options = {}, &block)
-      @name, @options, @block = name.to_s, options, block
+      @name = name.to_s
+      @options = options
+      @block = block
       normalize_display_options!
     end
 

data/lib/active_admin/version.rb

@@ -1,3 +1,3 @@
 module ActiveAdmin
-  VERSION = '1.1.0'
+  VERSION = '2.4.0'
 end

data/lib/active_admin/view_helpers/breadcrumb_helper.rb

@@ -12,9 +12,9 @@ module ActiveAdmin
           # 1. try using `display_name` if we can locate a DB object
           # 2. try using the model name translation
           # 3. default to calling `titlecase` on the URL fragment
-          if part =~ /\A(\d+|[a-f0-9]{24}|(?:[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}))\z/ && parts[index-1]
+          if part =~ /\A(\d+|[a-f0-9]{24}|(?:[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}))\z/ && parts[index - 1]
             parent = active_admin_config.belongs_to_config.try :target
-            config = parent && parent.resource_name.route_key == parts[index-1] ? parent : active_admin_config
+            config = parent && parent.resource_name.route_key == parts[index - 1] ? parent : active_admin_config
             name   = display_name config.find_resource part
           end
           name ||= I18n.t "activerecord.models.#{part.singularize}", count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT, default: part.titlecase

data/lib/active_admin/view_helpers/display_helper.rb

@@ -2,8 +2,9 @@ module ActiveAdmin
   module ViewHelpers
     module DisplayHelper
 
-      DISPLAY_NAME_FALLBACK = ->{
-        name, klass = "", self.class
+      DISPLAY_NAME_FALLBACK = -> {
+        name = ""
+        klass = self.class
         name << klass.model_name.human         if klass.respond_to? :model_name
         name << " ##{send(klass.primary_key)}" if klass.respond_to? :primary_key
         name.present? ? name : to_s
@@ -15,7 +16,7 @@ module ActiveAdmin
       # Attempts to call any known display name methods on the resource.
       # See the setting in `application.rb` for the list of methods and their priority.
       def display_name(resource)
-        render_in_context resource, display_name_method_for(resource) unless resource.nil?
+        ERB::Util.html_escape(render_in_context(resource, display_name_method_for(resource))) unless resource.nil?
       end
 
       # Looks up and caches the first available display name method.
@@ -25,7 +26,7 @@ module ActiveAdmin
         @@display_name_methods_cache ||= {}
         @@display_name_methods_cache[resource.class] ||= begin
           methods = active_admin_application.display_name_methods - association_methods_for(resource)
-          method  = methods.detect{ |method| resource.respond_to? method }
+          method  = methods.detect { |method| resource.respond_to? method }
 
           if method != :to_s || resource.method(method).source_location
             method
@@ -69,16 +70,24 @@ module ActiveAdmin
           object.to_s
         when Date, Time
           I18n.localize object, format: active_admin_application.localize_format
+        when Array
+          format_collection(object)
         else
           if defined?(::ActiveRecord) && object.is_a?(ActiveRecord::Base) ||
              defined?(::Mongoid)      && object.class.include?(Mongoid::Document)
             auto_link object
+          elsif defined?(::ActiveRecord) && object.is_a?(ActiveRecord::Relation)
+            format_collection(object)
           else
             display_name object
           end
         end
       end
 
+      def format_collection(collection)
+        safe_join(collection.map { |item| pretty_format(item) }, ', ')
+      end
+
       def boolean_attr?(resource, attr, value)
         case value
         when TrueClass, FalseClass

data/lib/active_admin/view_helpers/download_format_links_helper.rb

@@ -1,6 +1,7 @@
 module ActiveAdmin
   module ViewHelpers
     module DownloadFormatLinksHelper
+      private
 
       def build_download_formats(download_links)
         download_links = instance_exec(&download_links) if download_links.is_a?(Proc)

data/lib/active_admin/view_helpers/method_or_proc_helper.rb

@@ -1,4 +1,7 @@
+# Utility methods for internal use.
+# @private
 module MethodOrProcHelper
+  extend self
 
   # This method will either call the symbol on self or instance_exec the Proc
   # within self. Any args will be passed along to the method dispatch.

data/lib/active_admin/view_helpers.rb

@@ -2,7 +2,7 @@ module ActiveAdmin
   module ViewHelpers
 
     # Require all ruby files in the view helpers dir
-    Dir[File.expand_path('../view_helpers', __FILE__) + "/*.rb"].each{|f| require f }
+    Dir[File.expand_path('view_helpers', __dir__) + "/*.rb"].each { |f| require f }
 
     include ActiveAdminApplicationHelper
     include AutoLinkHelper

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

@@ -57,6 +57,12 @@ module ActiveAdmin
           end
           insert_tag(SemanticInputsProxy, form_builder, *args, &wrapped_block)
         else
+          # Set except option to prevent sensitive fields from being shown in forms by default.
+          opts = args.extract_options!
+          opts[:except] ||= []
+          ActiveAdmin.application.filter_attributes.each { |e| opts[:except] << e }
+          args << opts
+
           proxy_call_to_form(:inputs, *args, &block)
         end
       end
@@ -105,13 +111,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
@@ -126,7 +131,7 @@ module ActiveAdmin
         legend = args.shift if args.first.is_a?(::String)
         legend = html_options.delete(:name) if html_options.key?(:name)
         legend_tag = legend ? "<legend><span>#{legend}</span></legend>" : ""
-        fieldset_attrs = html_options.map {|k, v| %Q{#{k}="#{v}"} }.join(" ")
+        fieldset_attrs = html_options.map { |k, v| %Q{#{k}="#{v}"} }.join(" ")
         @opening_tag = "<fieldset #{fieldset_attrs}>#{legend_tag}<ol>"
         @closing_tag = "</ol></fieldset>"
         super(*(args << html_options), &block)

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

@@ -7,7 +7,7 @@ module ActiveAdmin
       def build(obj, *attrs)
         @collection     = Array.wrap(obj)
         @resource_class = @collection.first.class
-        options = { }
+        options = {}
         options[:for] = @collection.first if single_record?
         super(options)
         @table = table
@@ -16,7 +16,7 @@ module ActiveAdmin
       end
 
       def rows(*attrs)
-        attrs.each {|attr| row(attr) }
+        attrs.each { |attr| row(attr) }
       end
 
       def row(*args, &block)
@@ -26,7 +26,7 @@ module ActiveAdmin
         if options[:class]
           classes << options[:class]
         elsif title.present?
-          classes << "row-#{ActiveAdmin::Dependency.rails.parameterize(title.to_s)}"
+          classes << "row-#{title.to_s.parameterize(separator: "_")}"
         end
         options[:class] = classes.join(' ')
 

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
+          text_node link_to label, url, item.html_options
+        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

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

@@ -92,17 +92,17 @@ module ActiveAdmin
       end
 
       def build_pagination
-        options = { theme: 'active_admin' }
+        options = { theme: @display_total ? 'active_admin' : 'active_admin_countless' }
         options[:params]     = @params     if @params
         options[:param_name] = @param_name if @param_name
 
-        if !@display_total && collection.respond_to?(:offset)
+        if !@display_total
           # The #paginate method in kaminari will query the resource with a
           # count(*) to determine how many pages there should be unless
           # you pass in the :total_pages option. We issue a query to determine
           # if there is another page or not, but the limit/offset make this
           # query fast.
-          offset = collection.offset(collection.current_page * @per_page.to_i).limit(1).count
+          offset = collection.offset(collection.current_page * collection.limit_value).limit(1).count
           options[:total_pages] = collection.current_page + offset
           options[:right] = 0
         end

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

@@ -13,16 +13,20 @@ module ActiveAdmin
       include ::ActiveAdmin::Helpers::Collection
 
       def default_class_name
-        "scopes table_tools_segmented_control"
+        "scopes"
       end
 
       def tag_name
-        'ul'
+        'div'
       end
 
       def build(scopes, options = {})
-        scopes.each do |scope|
-          build_scope(scope, options) if call_method_or_proc_on(self, scope.display_if_block)
+        scopes.group_by(&:group).each do |group, group_scopes|
+          ul class: "table_tools_segmented_control #{group_class(group)}" do
+            group_scopes.each do |scope|
+              build_scope(scope, options) if call_method_or_exec_proc(scope.display_if_block)
+            end
+          end
         end
       end
 
@@ -60,6 +64,9 @@ module ActiveAdmin
         collection_size(scope_chain(scope, collection_before_scope))
       end
 
+      def group_class(group)
+        group.present? ? "scope-group-#{group}" : "scope-default-group"
+      end
     end
   end
 end

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

@@ -0,0 +1,13 @@
+module ActiveAdmin
+  module Views
+
+    class Sidebar < Component
+      builder_method :sidebar
+
+      def build(sections, attributes = {})
+        super(attributes)
+        sections.map(&method(:sidebar_section))
+      end
+    end
+  end
+end

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

@@ -22,8 +22,8 @@ module ActiveAdmin
         @namespace.site_title_link.present?
       end
 
-      def site_title_image?
-        @namespace.site_title_image.present?
+      def site_title_image
+        @site_title_image ||= @namespace.site_title_image(helpers)
       end
 
       private
@@ -33,7 +33,7 @@ module ActiveAdmin
       end
 
       def site_title_content
-        if site_title_image?
+        if site_title_image.present?
           title_image
         else
           title_text
@@ -41,12 +41,11 @@ module ActiveAdmin
       end
 
       def title_text
-        helpers.render_or_call_method_or_proc_on(helpers, @namespace.site_title)
+        @title_text ||= @namespace.site_title(helpers)
       end
 
       def title_image
-        path = helpers.render_or_call_method_or_proc_on(helpers, @namespace.site_title_image)
-        helpers.image_tag(path, id: "site_title_image", alt: title_text)
+        helpers.image_tag(site_title_image, id: "site_title_image", alt: title_text)
       end
 
     end