activeadmin-orac 1.0.0.pre4

data/lib/active_admin/asset_registration.rb

@@ -0,0 +1,29 @@
+module ActiveAdmin
+  module AssetRegistration
+
+    def register_stylesheet(path, options = {})
+      stylesheets[path] = options
+    end
+
+    def stylesheets
+      @stylesheets ||= {}
+    end
+
+    def clear_stylesheets!
+      stylesheets.clear
+    end
+
+    def register_javascript(name)
+      javascripts.add name
+    end
+
+    def javascripts
+      @javascripts ||= Set.new
+    end
+
+    def clear_javascripts!
+      javascripts.clear
+    end
+
+  end
+end

data/lib/active_admin/authorization_adapter.rb

@@ -0,0 +1,132 @@
+module ActiveAdmin
+
+  # Default Authorization permissions for Active Admin
+  module Authorization
+    READ    = :read
+    CREATE  = :create
+    UPDATE  = :update
+    DESTROY = :destroy
+  end
+
+  Auth = Authorization
+
+
+  # Active Admin's default authorization adapter. This adapter returns true
+  # for all requests to `#authorized?`. It should be the starting point for
+  # implementing your own authorization adapter.
+  #
+  # To view an example subclass, check out `ActiveAdmin::CanCanAdapter`
+  class AuthorizationAdapter
+    attr_reader :resource, :user
+
+
+    # Initialize a new authorization adapter. This happens on each and
+    # every request to a controller.
+    #
+    # @param [ActiveAdmin::Resource, ActiveAdmin::Page] resource The resource
+    #        that the user is currently on. Note, we may be authorizing access
+    #        to a different subject, so don't rely on this other than to
+    #        pull configuration information from.
+    #
+    # @param [any] user The current user. The user is set to whatever is returned
+    #        from `#current_active_admin_user` in the controller.
+    #
+    def initialize(resource, user)
+      @resource = resource
+      @user = user
+    end
+
+    # Returns true of false depending on if the user is authorized to perform
+    # the action on the subject.
+    #
+    # @param [Symbol] action The name of the action to perform. Usually this will be
+    #        one of the `ActiveAdmin::Auth::*` symbols.
+    #
+    # @param [any] subject The subject the action is being performed on usually this
+    #        is a model object. Note, that this is NOT always in instance, it can be
+    #        the class of the subject also. For example, Active Admin uses the class
+    #        of the resource to decide if the resource should be displayed in the
+    #        global navigation. To deal with this nicely in a case statement, take
+    #        a look at `#normalized(klass)`
+    #
+    # @return [Boolean]
+    def authorized?(action, subject = nil)
+      true
+    end
+
+
+    # A hook method for authorization libraries to scope the collection. By
+    # default, we just return the same collection. The returned scope is used
+    # as the starting point for all queries to the db in the controller.
+    #
+    # @param [ActiveRecord::Relation] collection The collection the user is
+    #        attempting to view.
+    #
+    # @param [Symbol] action The name of the action to perform. Usually this will be
+    #        one of the `ActiveAdmin::Auth::*` symbols. Defaults to `Auth::READ` if
+    #        no action passed in.
+    #
+    # @return [ActiveRecord::Relation] A new collection, scoped to the
+    #          objects that the current user has access to.
+    def scope_collection(collection, action = Auth::READ)
+      collection
+    end
+
+    private
+
+    # The `#authorized?` method's subject can be set to both instances as well
+    # as classes of objects. This can make it much difficult to create simple
+    # case statements for authorization since you have to handle both the
+    # class level match and the instance level match.
+    #
+    # For example:
+    #
+    #     class MyAuthAdapter < ActiveAdmin::AuthorizationAdapter
+    #
+    #       def authorized?(action, subject = nil)
+    #         case subject
+    #         when Post
+    #           true
+    #         when Class
+    #           if subject == Post
+    #             true
+    #           end
+    #         end
+    #       end
+    #
+    #     end
+    #
+    # To handle this, the normalized method takes care of returning a object
+    # which implements `===` to be matched in a case statement.
+    #
+    # The above now becomes:
+    #
+    #     class MyAuthAdapter < ActiveAdmin::AuthorizationAdapter
+    #
+    #       def authorized?(action, subject = nil)
+    #         case subject
+    #         when normalized(Post)
+    #           true
+    #         end
+    #       end
+    #
+    #     end
+    def normalized(klass)
+      NormalizedMatcher.new(klass)
+    end
+
+    class NormalizedMatcher
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def ===(other)
+        @klass == other || other.is_a?(@klass)
+      end
+
+    end
+
+  end
+
+end

data/lib/active_admin/base_controller.rb

@@ -0,0 +1,87 @@
+require 'active_admin/base_controller/authorization'
+require 'active_admin/base_controller/menu'
+
+module ActiveAdmin
+  # BaseController for ActiveAdmin.
+  # It implements ActiveAdmin controllers core features.
+  class BaseController < ::InheritedResources::Base
+    helper ::ActiveAdmin::ViewHelpers
+    helper_method :env
+
+    layout :determine_active_admin_layout
+
+    if ActiveAdmin::Dependency.rails >= 4
+      before_action :only_render_implemented_actions
+      before_action :authenticate_active_admin_user
+    else
+      before_filter :only_render_implemented_actions
+      before_filter :authenticate_active_admin_user
+    end
+
+    class << self
+      # Ensure that this method is available for the DSL
+      public :actions
+
+      # Reference to the Resource object which initialized
+      # this controller
+      attr_accessor :active_admin_config
+    end
+
+    # By default Rails will render un-implemented actions when the view exists. Because Active
+    # Admin allows you to not render any of the actions by using the #actions method, we need
+    # to check if they are implemented.
+    def only_render_implemented_actions
+      raise AbstractController::ActionNotFound unless action_methods.include?(params[:action])
+    end
+
+    include Menu
+    include Authorization
+
+    private
+
+    # Calls the authentication method as defined in ActiveAdmin.authentication_method
+    def authenticate_active_admin_user
+      send(active_admin_namespace.authentication_method) if active_admin_namespace.authentication_method
+    end
+
+    def current_active_admin_user
+      send(active_admin_namespace.current_user_method) if active_admin_namespace.current_user_method
+    end
+    helper_method :current_active_admin_user
+
+    def current_active_admin_user?
+      !!current_active_admin_user
+    end
+    helper_method :current_active_admin_user?
+
+    def active_admin_config
+      self.class.active_admin_config
+    end
+    helper_method :active_admin_config
+
+    def active_admin_namespace
+      active_admin_config.namespace
+    end
+    helper_method :active_admin_namespace
+
+
+    ACTIVE_ADMIN_ACTIONS = [:index, :show, :new, :create, :edit, :update, :destroy]
+
+    # Determine which layout to use.
+    #
+    #   1.  If we're rendering a standard Active Admin action, we want layout(false)
+    #       because these actions are subclasses of the Base page (which implements
+    #       all the required layout code)
+    #   2.  If we're rendering a custom action, we'll use the active_admin layout so
+    #       that users can render any template inside Active Admin.
+    def determine_active_admin_layout
+      ACTIVE_ADMIN_ACTIONS.include?(params[:action].to_sym) ? false : 'active_admin'
+    end
+
+    def active_admin_root
+      controller, action = active_admin_namespace.root_to.split '#'
+      {controller: controller, action: action}
+    end
+
+  end
+end

data/lib/active_admin/base_controller/authorization.rb

@@ -0,0 +1,130 @@
+module ActiveAdmin
+  class BaseController < ::InheritedResources::Base
+    module Authorization
+      include MethodOrProcHelper
+      extend ActiveSupport::Concern
+
+      ACTIONS_DICTIONARY = {
+        index:   ActiveAdmin::Authorization::READ,
+        show:    ActiveAdmin::Authorization::READ,
+        new:     ActiveAdmin::Authorization::CREATE,
+        create:  ActiveAdmin::Authorization::CREATE,
+        edit:    ActiveAdmin::Authorization::UPDATE,
+        update:  ActiveAdmin::Authorization::UPDATE,
+        destroy: ActiveAdmin::Authorization::DESTROY
+      }
+
+      included do
+        rescue_from ActiveAdmin::AccessDenied, with: :dispatch_active_admin_access_denied
+
+        helper_method :authorized?
+        helper_method :authorize!
+      end
+
+      protected
+
+      # Authorize the action and subject. Available in the controller
+      # as well as all the views.
+      #
+      # @param [Symbol] action The action to check if the user has permission
+      #                 to perform on the subject.
+      #
+      # @param [any] subject The subject that the user is trying to perform
+      #                 the action on.
+      #
+      # @return [Boolean]
+      #
+      def authorized?(action, subject = nil)
+        active_admin_authorization.authorized?(action, subject)
+      end
+
+
+      # Authorize the action and subject. Available in the controller
+      # as well as all the views. If the action is not allowd, it raises
+      # an ActiveAdmin::AccessDenied exception.
+      #
+      # @param [Symbol] action The action to check if the user has permission
+      #                 to perform on the subject.
+      #
+      # @param [any] subject The subject that the user is trying to perform
+      #                 the action on.
+      #
+      # @return [Boolean] True if authorized, otherwise raises
+      #                 an ActiveAdmin::AccessDenied.
+      def authorize!(action, subject = nil)
+        unless authorized? action, subject
+          raise ActiveAdmin::AccessDenied.new(current_active_admin_user,
+                                              action,
+                                              subject)
+        end
+      end
+
+      # Performs authorization on the resource using the current controller
+      # action as the permission action.
+      #
+      def authorize_resource!(resource)
+        permission = action_to_permission(params[:action])
+        authorize! permission, resource
+      end
+
+      # Retrieve or instantiate the authorization instance for this resource
+      #
+      # @return [ActiveAdmin::AuthorizationAdapter]
+      def active_admin_authorization
+        @active_admin_authorization ||=
+         active_admin_authorization_adapter.new active_admin_config, current_active_admin_user
+      end
+
+      # Returns the class to be used as the authorization adapter
+      #
+      # @return [Class]
+      def active_admin_authorization_adapter
+        adapter = active_admin_namespace.authorization_adapter
+        if adapter.is_a? String
+          ActiveSupport::Dependencies.constantize adapter
+        else
+          adapter
+        end
+      end
+
+      # Converts a controller action into one of the correct Active Admin
+      # authorization names. Uses the ACTIONS_DICTIONARY to convert the
+      # action name to permission.
+      #
+      # @param [String, Symbol] action The controller action name.
+      #
+      # @return [Symbol] The permission name to use.
+      def action_to_permission(action)
+        if action && action = action.to_sym
+          Authorization::ACTIONS_DICTIONARY[action] || action
+        end
+      end
+
+      def dispatch_active_admin_access_denied(exception)
+        call_method_or_exec_proc active_admin_namespace.on_unauthorized_access, exception
+      end
+
+      def rescue_active_admin_access_denied(exception)
+        error = exception.message
+
+        respond_to do |format|
+          format.html do
+            flash[:error] = error
+            redirect_backwards_or_to_root
+          end
+
+          body = ActiveAdmin::Dependency.rails.render_key
+
+          format.csv  { render body =>        error,           status: :unauthorized }
+          format.json { render json: { error: error },         status: :unauthorized }
+          format.xml  { render xml: "<error>#{error}</error>", status: :unauthorized }
+        end
+      end
+
+      def redirect_backwards_or_to_root
+        ActiveAdmin::Dependency.rails.redirect_back self, active_admin_root
+      end
+
+    end
+  end
+end

data/lib/active_admin/base_controller/menu.rb

@@ -0,0 +1,38 @@
+module ActiveAdmin
+  class BaseController < ::InheritedResources::Base
+    module Menu
+      extend ActiveSupport::Concern
+
+      included do
+        if ActiveAdmin::Dependency.rails >= 4
+          before_action :set_current_tab
+        else
+          before_filter :set_current_tab
+        end
+        helper_method :current_menu
+      end
+
+      protected
+
+      def current_menu
+        active_admin_config.navigation_menu
+      end
+
+      # Set's @current_tab to be name of the tab to mark as current
+      # Get's called through a before filter
+      def set_current_tab
+        @current_tab = if current_menu && active_admin_config.belongs_to? && parent?
+          parent_item = active_admin_config.belongs_to_config.target.menu_item
+          if current_menu.include? parent_item
+            parent_item
+          else
+            active_admin_config.menu_item
+          end
+        else
+          active_admin_config.menu_item
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/batch_actions.rb

@@ -0,0 +1,16 @@
+ActiveAdmin.before_load do |app|
+  require "active_admin/batch_actions/resource_extension"
+  require "active_admin/batch_actions/controller"
+
+  # Add our Extensions
+  ActiveAdmin::Resource.send :include, ActiveAdmin::BatchActions::ResourceExtension
+  ActiveAdmin::ResourceController.send :include, ActiveAdmin::BatchActions::Controller
+
+  # Require all the views
+  require "active_admin/batch_actions/views/batch_action_form"
+  require "active_admin/batch_actions/views/selection_cells"
+  require "active_admin/batch_actions/views/batch_action_selector"
+
+  # Register the views with the view factory
+  app.view_factory.register batch_action_selector: ActiveAdmin::BatchActions::BatchActionSelector
+end

data/lib/active_admin/batch_actions/controller.rb

@@ -0,0 +1,40 @@
+module ActiveAdmin
+  module BatchActions
+    module Controller
+
+      # Controller action that is called when submitting the batch action form
+      def batch_action
+        if action_present?
+          selection  =            params[:collection_selection] ||  []
+          inputs     = JSON.parse params[:batch_action_inputs]  || '{}'
+          valid_keys = render_in_context(self, current_batch_action.inputs).try(:keys)
+          inputs     = inputs.with_indifferent_access.slice *valid_keys
+          instance_exec selection, inputs, &current_batch_action.block
+        else
+          raise "Couldn't find batch action \"#{params[:batch_action]}\""
+        end
+      end
+
+      protected
+
+      def action_present?
+        params[:batch_action].present? && current_batch_action
+      end
+
+      def current_batch_action
+        active_admin_config.batch_actions.detect{ |action| action.sym.to_s == params[:batch_action] }
+      end
+
+      COLLECTION_APPLIES = [
+        :authorization_scope,
+        :filtering,
+        :scoping,
+        :includes,
+      ].freeze
+
+      def batch_action_collection(only = COLLECTION_APPLIES)
+        find_collection(only: only)
+      end
+    end
+  end
+end