activeadmin_addons 1.7.0 → 1.9.0

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/application.rb

@@ -1,235 +0,0 @@
-require 'active_admin/router'
-require 'active_admin/reloader'
-require 'active_admin/application_settings'
-require 'active_admin/namespace_settings'
-
-module ActiveAdmin
-  class Application
-
-    class << self
-      def setting(name, default)
-        ApplicationSettings.register name, default
-      end
-
-      def inheritable_setting(name, default)
-        NamespaceSettings.register name, default
-      end
-    end
-
-    def settings
-      @settings ||= SettingsNode.build(ApplicationSettings)
-    end
-
-    def namespace_settings
-      @namespace_settings ||= SettingsNode.build(NamespaceSettings)
-    end
-
-    def respond_to_missing?(method, include_private = false)
-      [settings, namespace_settings].any? { |sets| sets.respond_to?(method) } || super
-    end
-
-    def method_missing(method, *args)
-      if settings.respond_to?(method)
-        settings.send(method, *args)
-      elsif namespace_settings.respond_to?(method)
-        namespace_settings.send(method, *args)
-      else
-        super
-      end
-    end
-
-    attr_reader :namespaces
-    def initialize
-      @namespaces = Namespace::Store.new
-    end
-
-    include AssetRegistration
-
-    # Event that gets triggered on load of Active Admin
-    BeforeLoadEvent = 'active_admin.application.before_load'.freeze
-    AfterLoadEvent  = 'active_admin.application.after_load'.freeze
-
-    # Runs before the app's AA initializer
-    def setup!
-      register_default_assets
-    end
-
-    # Runs after the app's AA initializer
-    def prepare!
-      remove_active_admin_load_paths_from_rails_autoload_and_eager_load
-      attach_reloader
-    end
-
-    # Registers a brand new configuration for the given resource.
-    def register(resource, options = {}, &block)
-      ns = options.fetch(:namespace){ default_namespace }
-      namespace(ns).register resource, options, &block
-    end
-
-    # Creates a namespace for the given name
-    #
-    # Yields the namespace if a block is given
-    #
-    # @return [Namespace] the new or existing namespace
-    def namespace(name)
-      name ||= :root
-
-      namespace = namespaces[name] ||= begin
-        namespace = Namespace.new(self, name)
-        ActiveSupport::Notifications.publish ActiveAdmin::Namespace::RegisterEvent, namespace
-        namespace
-      end
-
-      yield(namespace) if block_given?
-
-      namespace
-    end
-
-    # Register a page
-    #
-    # @param name [String] The page name
-    # @option [Hash] Accepts option :namespace.
-    # @&block The registration block.
-    #
-    def register_page(name, options = {}, &block)
-      ns = options.fetch(:namespace){ default_namespace }
-      namespace(ns).register_page name, options, &block
-    end
-
-    # Whether all configuration files have been loaded
-    def loaded?
-      @@loaded ||= false
-    end
-
-    # Removes all defined controllers from memory. Useful in
-    # development, where they are reloaded on each request.
-    def unload!
-      namespaces.each &:unload!
-      @@loaded = false
-    end
-
-    # Loads all ruby files that are within the load_paths setting.
-    # To reload everything simply call `ActiveAdmin.unload!`
-    def load!
-      unless loaded?
-        ActiveSupport::Notifications.publish BeforeLoadEvent, self # before_load hook
-        files.each{ |file| load file }                             # load files
-        namespace(default_namespace)                               # init AA resources
-        ActiveSupport::Notifications.publish AfterLoadEvent, self  # after_load hook
-        @@loaded = true
-      end
-    end
-
-    def load(file)
-      DatabaseHitDuringLoad.capture{ super }
-    end
-
-    # Returns ALL the files to be loaded
-    def files
-      load_paths.flatten.compact.uniq.flat_map{ |path| Dir["#{path}/**/*.rb"] }
-    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
-    #
-    # @param rails_router [ActionDispatch::Routing::Mapper]
-    def routes(rails_router)
-      load!
-      Router.new(router: rails_router, namespaces: namespaces).apply
-    end
-
-    # Adds before, around and after filters to all controllers.
-    # Example usage:
-    #   ActiveAdmin.before_filter :authenticate_admin!
-    #
-    AbstractController::Callbacks::ClassMethods.public_instance_methods.
-      select { |m| m.match(/(filter|action)/) }.each do |name|
-      define_method name do |*args, &block|
-        controllers_for_filters.each do |controller|
-          controller.public_send name, *args, &block
-        end
-      end
-    end
-
-    def controllers_for_filters
-      controllers = [BaseController]
-      controllers.push *Devise.controllers_for_filters if Dependency.devise?
-      controllers
-    end
-
-    private
-
-    def register_default_assets
-      stylesheets['active_admin.css'] = { media: 'screen' }
-      stylesheets['active_admin/print.css'] = { media: 'print' }
-      javascripts.add 'active_admin.js'
-    end
-
-    # Since app/admin is alphabetically before app/models, we have to remove it
-    # from the host app's +autoload_paths+ to prevent missing constant errors.
-    #
-    # As well, we have to remove it from +eager_load_paths+ to prevent the
-    # files from being loaded twice in production.
-    def remove_active_admin_load_paths_from_rails_autoload_and_eager_load
-      ActiveSupport::Dependencies.autoload_paths -= load_paths
-      Rails.application.config.eager_load_paths  -= load_paths
-    end
-
-    # Hook into the Rails code reloading mechanism so that things are reloaded
-    # properly in development mode.
-    #
-    # If any of the app files (e.g. models) has changed, we need to reload all
-    # the admin files. If the admin files themselves has changed, we need to
-    # regenerate the routes as well.
-    def attach_reloader
-      Rails.application.config.after_initialize do |app|
-        unload_active_admin = -> { ActiveAdmin.application.unload! }
-
-        if app.config.reload_classes_only_on_change
-          # Rails is about to unload all the app files (e.g. models), so we
-          # should first unload the classes generated by Active Admin, otherwise
-          # they will contain references to the stale (unloaded) classes.
-          Reloader.to_prepare(prepend: true, &unload_active_admin)
-        else
-          # If the user has configured the app to always reload app files after
-          # each request, so we should unload the generated classes too.
-          Reloader.to_complete(&unload_active_admin)
-        end
-
-        admin_dirs = {}
-
-        load_paths.each do |path|
-          admin_dirs[path] = [:rb]
-        end
-
-        routes_reloader = app.config.file_watcher.new([], admin_dirs) do
-          app.reload_routes!
-        end
-
-        app.reloaders << routes_reloader
-
-        Reloader.to_prepare do
-          # Rails might have reloaded the routes for other reasons (e.g.
-          # routes.rb has changed), in which case Active Admin would have been
-          # loaded via the `ActiveAdmin.routes` call in `routes.rb`.
-          #
-          # Otherwise, we should check if any of the admin files are changed
-          # and force the routes to reload if necessary. This would again causes
-          # Active Admin to load via `ActiveAdmin.routes`.
-          #
-          # Finally, if Active Admin is still not loaded at this point, then we
-          # would need to load it manually.
-          unless ActiveAdmin.application.loaded?
-            routes_reloader.execute_if_updated
-            ActiveAdmin.application.load!
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.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.3.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.3.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.3.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.3.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

data/vendor/bundle/ruby/2.3.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