activeadmin 0.6.6 → 1.0.0.pre1

data/lib/active_admin/resource/action_items.rb

@@ -5,8 +5,7 @@ module ActiveAdmin
   class Resource
     module ActionItems
 
-      # Add the default action items to a resource when it's
-      # initialized
+      # Adds the default action items to a resource when it's initialized
       def initialize(*args)
         super
         add_default_action_items
@@ -19,13 +18,18 @@ module ActiveAdmin
 
       # Add a new action item to a resource
       #
+      # @param [Symbol] name
       # @param [Hash] options valid keys include:
       #                 :only:  A single or array of controller actions to display
       #                         this action item on.
       #                 :except: A single or array of controller actions not to
       #                          display this action item on.
-      def add_action_item(options = {}, &block)
-        self.action_items << ActiveAdmin::ActionItem.new(options, &block)
+      def add_action_item(name, options = {}, &block)
+        self.action_items << ActiveAdmin::ActionItem.new(name, options, &block)
+      end
+
+      def remove_action_item(name)
+        self.action_items.delete_if { |item| item.name == name }
       end
 
       # Returns a set of action items to display for a specific controller action
@@ -34,7 +38,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 }
       end
 
       # Clears all the existing action items for this resource
@@ -51,26 +55,25 @@ module ActiveAdmin
 
       # Adds the default action items to each resource
       def add_default_action_items
-        # New Link on all actions except :new and :show
-        add_action_item :except => [:new, :show] do
+        # New link on index
+        add_action_item :new, only: :index do
           if controller.action_methods.include?('new') && authorized?(ActiveAdmin::Auth::CREATE, active_admin_config.resource_class)
-            link_to(I18n.t('active_admin.new_model', :model => active_admin_config.resource_label), new_resource_path)
+            link_to I18n.t('active_admin.new_model', model: active_admin_config.resource_label), new_resource_path
           end
         end
 
         # Edit link on show
-        add_action_item :only => :show do
+        add_action_item :edit, only: :show do
           if controller.action_methods.include?('edit') && authorized?(ActiveAdmin::Auth::UPDATE, resource)
-            link_to(I18n.t('active_admin.edit_model', :model => active_admin_config.resource_label), edit_resource_path(resource))
+            link_to I18n.t('active_admin.edit_model', model: active_admin_config.resource_label), edit_resource_path(resource)
           end
         end
 
         # Destroy link on show
-        add_action_item :only => :show do
-          if controller.action_methods.include?("destroy") && authorized?(ActiveAdmin::Auth::DESTROY, resource)
-            link_to(I18n.t('active_admin.delete_model', :model => active_admin_config.resource_label),
-              resource_path(resource),
-              :method => :delete, 'data-confirm' => I18n.t('active_admin.delete_confirmation'))
+        add_action_item :destroy, only: :show do
+          if controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, resource)
+            link_to I18n.t('active_admin.delete_model', model: active_admin_config.resource_label), resource_path(resource),
+              method: :delete, data: {confirm: I18n.t('active_admin.delete_confirmation')}
           end
         end
       end
@@ -82,10 +85,12 @@ module ActiveAdmin
   class ActionItem
     include ActiveAdmin::OptionalDisplay
 
-    attr_accessor :block
+    attr_accessor :block, :name
 
-    def initialize(options = {}, &block)
-      @options, @block = options, block
+    def initialize(name, options = {}, &block)
+      @name = name
+      @options = options
+      @block = block
       normalize_display_options!
     end
   end

data/lib/active_admin/resource/belongs_to.rb

@@ -4,7 +4,12 @@ module ActiveAdmin
   class Resource
     class BelongsTo
 
-      class TargetNotFound < StandardError; end
+      class TargetNotFound < StandardError
+        def initialize(key, namespace)
+          super "Could not find #{key} in #{namespace.name} " +
+                "with #{namespace.resources.map(&:resource_name)}"
+        end
+      end
 
       # The resource which initiated this relationship
       attr_reader :owner
@@ -16,8 +21,7 @@ module ActiveAdmin
       # Returns the target resource class or raises an exception if it doesn't exist
       def target
         key = @target_name.to_s.camelize
-        namespace.resources[key] or raise TargetNotFound, "Could not find #{key} in" +
-          " #{namespace.name} with #{namespace.resources.map(&:resource_name)}"
+        namespace.resources[key] or raise TargetNotFound.new key, namespace
       end
 
       def namespace

data/lib/active_admin/resource/controllers.rb

@@ -1,6 +1,7 @@
 module ActiveAdmin
   class Resource
     module Controllers
+      delegate :resources_configuration, to: :controller
 
       # Returns a properly formatted controller name for this
       # config within its namespace

data/lib/active_admin/resource/includes.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  class Resource
+    module Includes
+
+      # Return an array of includes for this resource
+      def includes
+        @includes ||= []
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource/menu.rb

@@ -24,10 +24,10 @@ module ActiveAdmin
         menu_resource_class = respond_to?(:resource_class) ? resource_class : self
         resource = self
         {
-          :id    => resource_name.plural,
-          :label => proc{ resource.plural_resource_label },
-          :url   => proc{ resource.route_collection_path(params) },
-          :if    => proc{ authorized?(:read, menu_resource_class) }
+          id: resource_name.plural,
+          label: proc{ resource.plural_resource_label },
+          url:   proc{ resource.route_collection_path(params) },
+          if:    proc{ authorized?(:read, menu_resource_class) }
         }
       end
 
@@ -36,7 +36,7 @@ module ActiveAdmin
       def navigation_menu_name
         case @navigation_menu_name ||= DEFAULT_MENU
         when Proc
-          controller.instance_eval(&@navigation_menu_name).to_sym
+          controller.instance_exec(&@navigation_menu_name).to_sym
         else
           @navigation_menu_name
         end

data/lib/active_admin/resource/naming.rb

@@ -2,76 +2,60 @@ module ActiveAdmin
   class Resource
 
     module Naming
-
-      # Returns a name used to uniquely identify this resource
-      # this should be an instance of ActiveAdmin:Resource::Name, which responds to
-      # #singular, #plural, #route_key, #human etc.
       def resource_name
-        custom_name = @options[:as] && @options[:as].gsub(/\s/,'')
-        @resource_name ||= if custom_name || !resource_class.respond_to?(:model_name)
-            Resource::Name.new(resource_class, custom_name)
+        @resource_name ||= begin
+          as = @options[:as].gsub /\s/, '' if @options[:as]
+
+          if as || !resource_class.respond_to?(:model_name)
+            Name.new resource_class, as
           else
-            Resource::Name.new(resource_class)
+            Name.new resource_class
           end
+        end
       end
 
       # Returns the name to call this resource such as "Bank Account"
       def resource_label
-        resource_name.translate :count => 1, :default => resource_name.gsub('::', ' ').titleize
+        resource_name.translate count: 1,
+          default: resource_name.to_s.gsub('::', ' ').titleize
       end
 
       # Returns the plural version of this resource such as "Bank Accounts"
       def plural_resource_label(options = {})
-        resource_name.translate ({:count => 1.1, :default => resource_label.pluralize.titleize}).merge(options)
+        defaults = {count:   Helpers::I18n::PLURAL_MANY_COUNT,
+                    default: resource_label.pluralize.titleize}
+        resource_name.translate defaults.merge options
+      end
+
+      # Forms use the model's original `param_key`, so we can't use our
+      # custom `resource_name` when the model's been renamed in ActiveAdmin.
+      def param_key
+        if resource_class.respond_to? :model_name
+          resource_class.model_name.param_key
+        else
+          resource_name.param_key
+        end
       end
     end
 
-    # A subclass of ActiveModel::Name which supports the different APIs presented
-    # in Rails < 3.1 and > 3.1.
     class Name < ActiveModel::Name
+      delegate :hash, to: :to_str
 
       def initialize(klass, name = nil)
-        if ActiveModel::Name.instance_method(:initialize).arity == 1
-          super(proxy_for_initializer(klass, name))
-        else
-          super(klass, nil, name)
-        end
+        super(klass, nil, name)
       end
 
       def translate(options = {})
-        I18n.t i18n_key, {:scope => [:activerecord, :models]}.merge(options)
-      end
-
-      def proxy_for_initializer(klass, name)
-        return klass unless name
-        return StringClassProxy.new(klass, name) if klass
-
-        StringProxy.new(name)
+        I18n.t i18n_key, {scope: [:activerecord, :models]}.merge(options)
       end
 
       def route_key
         plural
       end
 
-      class StringProxy
-        def initialize(name)
-          @name = name
-        end
-
-        def name
-          @name
-        end
-      end
-
-      class StringClassProxy < StringProxy
-        delegate :lookup_ancestors, :i18n_scope, :to => :"@klass"
-
-        def initialize(klass, name)
-          @klass = klass || name
-          super(name)
-        end
+      def eql?(other)
+        to_str.eql?(other.to_str)
       end
-
     end
 
   end

data/lib/active_admin/resource/page_presenters.rb

@@ -32,7 +32,7 @@ module ActiveAdmin
       #
       # @param [Symbol, String] action The action to get the config for
       # @param [String] type The string specified in the presenters index_name method
-      # @returns [PagePresenter, nil]
+      # @return [PagePresenter, nil]
       def get_page_presenter(action, type=nil)
 
         if action.to_s == "index" && type && page_presenters[:index].kind_of?(Hash)

data/lib/active_admin/resource/routes.rb

@@ -1,13 +1,13 @@
 module ActiveAdmin
   class Resource
     module Routes
-      # @params params [Hash] of params: {study_id: 3}
+      # @param params [Hash] of params: { study_id: 3 }
       # @return [String] the path to this resource collection page
       # @example "/admin/posts"
       def route_collection_path(params = {})
         RouteBuilder.new(self).collection_path(params)
       end
-      
+
       # @param resource [ActiveRecord::Base] the instance we want the path of
       # @return [String] the path to this resource collection page
       # @example "/admin/posts/1"
@@ -15,13 +15,17 @@ module ActiveAdmin
         RouteBuilder.new(self).instance_path(resource)
       end
 
+      def route_edit_instance_path(resource)
+        RouteBuilder.new(self).edit_instance_path(resource)
+      end
+
       # Returns the routes prefix for this config
       def route_prefix
         namespace.module_name.try(:underscore)
       end
 
       def route_uncountable?
-        config = controller.resources_configuration[:self]
+        config = resources_configuration[:self]
 
         config[:route_collection_name] == config[:route_instance_name]
       end
@@ -35,29 +39,41 @@ module ActiveAdmin
 
         def collection_path(params)
           route_name = route_name(
-            resource.controller.resources_configuration[:self][:route_collection_name],
-            (resource.route_uncountable? ? 'index_path' : 'path')
+            resource.resources_configuration[:self][:route_collection_name],
+            suffix: (resource.route_uncountable? ? "index_path" : "path")
           )
 
-          routes.send(route_name, *route_collection_params(params))
+          routes.public_send route_name, *route_collection_params(params)
         end
 
         # @return [String] the path to this resource collection page
         # @param instance [ActiveRecord::Base] the instance we want the path of
         # @example "/admin/posts/1"
         def instance_path(instance)
-          route_name = route_name(resource.controller.resources_configuration[:self][:route_instance_name])
+          route_name = route_name(resource.resources_configuration[:self][:route_instance_name])
+
+          routes.public_send route_name, *route_instance_params(instance)
+        end
+
+        # @return [String] the path to the edit page of this resource
+        # @param instance [ActiveRecord::Base] the instance we want the path of
+        # @example "/admin/posts/1/edit"
+        def edit_instance_path(instance)
+          path = resource.resources_configuration[:self][:route_instance_name]
+          route_name = route_name(path, action: :edit)
 
-          routes.send(route_name, *route_instance_params(instance))
+          routes.public_send route_name, *route_instance_params(instance)
         end
 
         private
 
         attr_reader :resource
 
-        def route_name(resource_path_name, suffix = 'path')
+        def route_name(resource_path_name, options = {})
+          suffix = options[:suffix] || "path"
           route = []
 
+          route << options[:action]           # "edit" or "new"
           route << resource.route_prefix      # "admin"
           route << belongs_to_name if nested? # "category"
           route << resource_path_name         # "posts" or "post"
@@ -70,7 +86,7 @@ module ActiveAdmin
         # @return params to pass to instance path
         def route_instance_params(instance)
           if nested?
-            [instance.send(belongs_to_name).to_param, instance.to_param]
+            [instance.public_send(belongs_to_name).to_param, instance.to_param]
           else
             instance.to_param
           end
@@ -91,7 +107,7 @@ module ActiveAdmin
         end
 
         def routes
-          Rails.application.routes.url_helpers
+          Helpers::Routes
         end
       end
     end

data/lib/active_admin/resource/scope_to.rb

@@ -20,7 +20,7 @@ module ActiveAdmin
       # method to call as the association. If its different, you can
       # pass in the association_method as an option.
       #
-      #   scope_to :current_user, :association_method => :blog_posts
+      #   scope_to :current_user, association_method: :blog_posts
       #
       # will result in the following
       #
@@ -28,11 +28,11 @@ module ActiveAdmin
       #
       # To conditionally use this scope, you can use conditional procs
       #
-      #   scope_to :current_user, :if => proc{ admin_user_signed_in? }
+      #   scope_to :current_user, if: proc{ admin_user_signed_in? }
       #
       # or
       #
-      #   scope_to :current_user, :unless => proc{ current_user.admin? }
+      #   scope_to :current_user, unless: proc{ current_user.admin? }
       #
       def scope_to(*args, &block)
         options = args.extract_options!
@@ -55,10 +55,10 @@ module ActiveAdmin
 
       def scope_to_config
         @scope_to_config ||= {
-          :method               => nil,
-          :association_method   => nil,
-          :if                   => nil,
-          :unless               => nil
+          method:             nil,
+          association_method: nil,
+          if:                 nil,
+          unless:             nil
         }
       end
 

data/lib/active_admin/resource/sidebars.rb

@@ -15,6 +15,7 @@ module ActiveAdmin
 
       def sidebar_sections_for(action, render_context = nil)
         sidebar_sections.select{|section| section.display_on?(action, render_context) }
+          .sort_by(&:priority)
       end
 
       def sidebar_sections?

data/lib/active_admin/resource_controller.rb

@@ -1,9 +1,8 @@
-require 'inherited_resources'
-require 'active_admin/resource_controller/actions'
 require 'active_admin/resource_controller/action_builder'
 require 'active_admin/resource_controller/data_access'
 require 'active_admin/resource_controller/decorators'
 require 'active_admin/resource_controller/scoping'
+require 'active_admin/resource_controller/streaming'
 require 'active_admin/resource_controller/sidebars'
 require 'active_admin/resource_controller/resource_class_methods'
 
@@ -14,21 +13,21 @@ module ActiveAdmin
     layout :determine_active_admin_layout
 
     respond_to :html, :xml, :json
-    respond_to :csv, :only => :index
+    respond_to :csv, only: :index
 
-    include Actions
     include ActionBuilder
     include Decorators
     include DataAccess
     include Scoping
+    include Streaming
     include Sidebars
     extend  ResourceClassMethods
 
     def self.active_admin_config=(config)
       if @active_admin_config = config
-        defaults :resource_class => config.resource_class,
-                 :route_prefix   => config.route_prefix,
-                 :instance_name  => config.resource_name.singular
+        defaults resource_class: config.resource_class,
+                 route_prefix:   config.route_prefix,
+                 instance_name:  config.resource_name.singular
       end
     end