activeadmin_addons 1.4.0 → 1.8.2

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/application_settings.rb

@@ -1,39 +0,0 @@
-require 'active_admin/settings_node'
-
-module ActiveAdmin
-  class ApplicationSettings < SettingsNode
-
-    # The default namespace to put controllers and routes inside. Set this
-    # in config/initializers/active_admin.rb using:
-    #
-    #   config.default_namespace = :super_admin
-    #
-    register :default_namespace, :admin
-
-    register :app_path, Rails.root
-
-    # Load paths for admin configurations. Add folders to this load path
-    # to load up other resources for administration. External gems can
-    # include their paths in this load path to provide active_admin UIs
-    register :load_paths, [File.expand_path('app/admin', Rails.root)]
-
-    # Set default localize format for Date/Time values
-    register :localize_format, :long
-
-    # Active Admin makes educated guesses when displaying objects, this is
-    # the list of methods it tries calling in order
-    # Note that Formtastic also has 'collection_label_methods' similar to this
-    # used by auto generated dropdowns in filter or belongs_to field of Active Admin
-    register :display_name_methods, [ :display_name,
-                                      :full_name,
-                                      :name,
-                                      :username,
-                                      :login,
-                                      :title,
-                                      :email,
-                                      :to_s ]
-
-    # To make debugging easier, by default don't stream in development
-    register :disable_streaming_in, ['development']
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/asset_registration.rb

@@ -1,37 +0,0 @@
-module ActiveAdmin
-  module AssetRegistration
-
-    def register_stylesheet(path, options = {})
-      Deprecation.warn <<-MSG.strip_heredoc
-        The `register_stylesheet` config is deprecated and will be removed
-        in v2. Import your "#{path}" stylesheet in the active_admin.scss.
-      MSG
-      stylesheets[path] = options
-    end
-
-    def stylesheets
-      @stylesheets ||= {}
-    end
-
-    def clear_stylesheets!
-      stylesheets.clear
-    end
-
-    def register_javascript(name)
-      Deprecation.warn <<-MSG.strip_heredoc
-        The `register_javascript` config is deprecated and will be removed
-        in v2. Import your "#{name}" javascript in the active_admin.js.
-      MSG
-      javascripts.add name
-    end
-
-    def javascripts
-      @javascripts ||= Set.new
-    end
-
-    def clear_javascripts!
-      javascripts.clear
-    end
-
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/authorization_adapter.rb

@@ -1,129 +0,0 @@
-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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/base_controller.rb

@@ -1,81 +0,0 @@
-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
-
-    before_action :only_render_implemented_actions
-    before_action :authenticate_active_admin_user
-
-    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
-
-    include Authorization
-    include Menu
-
-    private
-
-    # 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
-
-    # 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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/base_controller/authorization.rb

@@ -1,128 +0,0 @@
-module ActiveAdmin
-  class BaseController < ::InheritedResources::Base
-    module Authorization
-      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)
-        instance_exec(self, exception, &active_admin_namespace.on_unauthorized_access.to_proc)
-      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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/base_controller/menu.rb

@@ -1,34 +0,0 @@
-module ActiveAdmin
-  class BaseController < ::InheritedResources::Base
-    module Menu
-      extend ActiveSupport::Concern
-
-      included do
-        before_action :set_current_tab
-        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