activeadmin_addons 1.4.0 → 1.8.2

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/features/users/resetting_password.feature

@@ -1,34 +0,0 @@
-Feature: User Resetting Password
-
-  Resetting my password as an admin user
-
-  Background:
-    Given a configuration of:
-    """
-      ActiveAdmin.register Post
-    """
-    And I am logged out
-    And an admin user "admin@example.com" exists
-
-  Scenario: Resetting password successfully
-    When I go to the dashboard
-    And I follow "Forgot your password?"
-    When I fill in "Email" with "admin@example.com"
-    And I press "Reset My Password"
-    Then I should see "You will receive an email with instructions on how to reset your password in a few minutes."
-
-  Scenario: Changing password after resetting
-    When "admin@example.com" requests a password reset with token "foobarbaz"
-    When I go to the admin password reset form with token "foobarbaz"
-    And I fill in the password field with "password"
-    And I fill in "Password confirmation" with "password"
-    And I press "Change my password"
-    Then I should see "success"
-
-  Scenario: Changing password after resetting with errors
-    When "admin@example.com" requests a password reset with token "foobarbaz" but it expires
-    When I go to the admin password reset form with token "foobarbaz"
-    And I fill in the password field with "password"
-    And I fill in "Password confirmation" with "wrong"
-    And I press "Change my password"
-    Then I should see "expired"

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/gemfiles/rails_42.gemfile

@@ -1,10 +0,0 @@
-source "https://rubygems.org"
-
-eval_gemfile(File.expand_path(File.join("..", "Gemfile"), __dir__))
-
-gem "rails", "4.2.10"
-gem "devise", "~> 3.5"
-gem "draper", "~> 2.1"
-gem "activerecord-jdbcsqlite3-adapter", "~> 1.3", platforms: :jruby
-
-gemspec path: "../"

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/gemfiles/rails_50.gemfile

@@ -1,10 +0,0 @@
-source "https://rubygems.org"
-
-eval_gemfile(File.expand_path(File.join("..", "Gemfile"), __dir__))
-
-gem "rails", "5.0.6"
-gem "devise", "~> 4.0"
-gem "draper", "~> 3.0"
-gem "activerecord-jdbcsqlite3-adapter", "~> 50.0", platforms: :jruby
-
-gemspec path: "../"

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/gemfiles/rails_51.gemfile

@@ -1,10 +0,0 @@
-source "https://rubygems.org"
-
-eval_gemfile(File.expand_path(File.join("..", "Gemfile"), __dir__))
-
-gem "rails", "5.1.4"
-gem "devise", "~> 4.3"
-gem "draper", "~> 3.0"
-gem "activerecord-jdbcsqlite3-adapter", "~> 51.0", platforms: :jruby
-
-gemspec path: "../"

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

@@ -1,133 +0,0 @@
-require 'active_support/core_ext'
-require 'set'
-
-require 'ransack'
-require 'ransack_ext'
-require 'kaminari'
-require 'formtastic'
-require 'formtastic_i18n'
-require 'inherited_resources'
-require 'jquery-rails'
-require 'arbre'
-require 'sprockets/es6'
-
-require 'active_admin/helpers/i18n'
-
-module ActiveAdmin
-
-  autoload :VERSION,                  'active_admin/version'
-  autoload :Application,              'active_admin/application'
-  autoload :AssetRegistration,        'active_admin/asset_registration'
-  autoload :Authorization,            'active_admin/authorization_adapter'
-  autoload :AuthorizationAdapter,     'active_admin/authorization_adapter'
-  autoload :Callbacks,                'active_admin/callbacks'
-  autoload :Component,                'active_admin/component'
-  autoload :BaseController,           'active_admin/base_controller'
-  autoload :CanCanAdapter,            'active_admin/cancan_adapter'
-  autoload :ControllerAction,         'active_admin/controller_action'
-  autoload :CSVBuilder,               'active_admin/csv_builder'
-  autoload :Dependency,               'active_admin/dependency'
-  autoload :Deprecation,              'active_admin/deprecation'
-  autoload :Devise,                   'active_admin/devise'
-  autoload :DSL,                      'active_admin/dsl'
-  autoload :FormBuilder,              'active_admin/form_builder'
-  autoload :Inputs,                   'active_admin/inputs'
-  autoload :Localizers,               'active_admin/localizers'
-  autoload :Menu,                     'active_admin/menu'
-  autoload :MenuCollection,           'active_admin/menu_collection'
-  autoload :MenuItem,                 'active_admin/menu_item'
-  autoload :Namespace,                'active_admin/namespace'
-  autoload :OrderClause,              'active_admin/order_clause'
-  autoload :Page,                     'active_admin/page'
-  autoload :PagePresenter,            'active_admin/page_presenter'
-  autoload :PageController,           'active_admin/page_controller'
-  autoload :PageDSL,                  'active_admin/page_dsl'
-  autoload :PunditAdapter,            'active_admin/pundit_adapter'
-  autoload :Resource,                 'active_admin/resource'
-  autoload :ResourceController,       'active_admin/resource_controller'
-  autoload :ResourceDSL,              'active_admin/resource_dsl'
-  autoload :Scope,                    'active_admin/scope'
-  autoload :ScopeChain,               'active_admin/helpers/scope_chain'
-  autoload :SidebarSection,           'active_admin/sidebar_section'
-  autoload :TableBuilder,             'active_admin/table_builder'
-  autoload :ViewFactory,              'active_admin/view_factory'
-  autoload :ViewHelpers,              'active_admin/view_helpers'
-  autoload :Views,                    'active_admin/views'
-
-  class << self
-
-    attr_accessor :application
-
-    def application
-      @application ||= ::ActiveAdmin::Application.new
-    end
-
-    # Gets called within the initializer
-    def setup
-      application.setup!
-      yield(application)
-      application.prepare!
-    end
-
-    delegate :register,      to: :application
-    delegate :register_page, to: :application
-    delegate :unload!,       to: :application
-    delegate :load!,         to: :application
-    delegate :routes,        to: :application
-
-    # A callback is triggered each time (before) Active Admin loads the configuration files.
-    # In development mode, this will happen whenever the user changes files. In production
-    # it only happens on boot.
-    #
-    # The block takes the current instance of [ActiveAdmin::Application]
-    #
-    # Example:
-    #
-    #     ActiveAdmin.before_load do |app|
-    #       # Do some stuff before AA loads
-    #     end
-    #
-    # @param [Block] block A block to call each time (before) AA loads resources
-    def before_load(&block)
-      ActiveSupport::Notifications.subscribe ActiveAdmin::Application::BeforeLoadEvent, &wrap_block_for_active_support_notifications(block)
-    end
-
-    # A callback is triggered each time (after) Active Admin loads the configuration files. This
-    # is an opportunity to hook into Resources after they've been loaded.
-    #
-    # The block takes the current instance of [ActiveAdmin::Application]
-    #
-    # Example:
-    #
-    #     ActiveAdmin.after_load do |app|
-    #       app.namespaces.each do |name, namespace|
-    #         puts "Namespace: #{name} loaded!"
-    #       end
-    #     end
-    #
-    # @param [Block] block A block to call each time (after) AA loads resources
-    def after_load(&block)
-      ActiveSupport::Notifications.subscribe ActiveAdmin::Application::AfterLoadEvent, &wrap_block_for_active_support_notifications(block)
-    end
-
-    private
-
-    def wrap_block_for_active_support_notifications block
-      proc { |event, *args| block.call *args }
-    end
-
-  end
-
-end
-
-# Require things that don't support autoload
-require 'active_admin/engine'
-require 'active_admin/error'
-
-# Require internal plugins
-require 'active_admin/batch_actions'
-require 'active_admin/filters'
-
-# Require ORM-specific plugins
-require 'active_admin/orm/active_record' if defined? ActiveRecord
-require 'active_admin/orm/mongoid'       if defined? Mongoid

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

@@ -1,47 +0,0 @@
-module ActiveAdmin
-  class AbstractViewFactory < SettingsNode
-
-    def self.register(view_hash)
-      view_hash.each do |view_key, view_class|
-        super view_key, view_class
-        add_writer(view_key)
-        send "#{view_key}=", view_class
-      end
-    end
-
-    def self.add_writer(name)
-      define_singleton_method("#{name}=") do |value|
-        value.builder_method name
-        instance_variable_set :"@#{name}", value
-      end
-    end
-
-    # Register a new view key with the view factory
-    #
-    # eg:
-    #
-    #   factory = AbstractViewFactory.new
-    #   factory.register my_view: SomeViewClass
-    #
-    # You can setup many at the same time:
-    #
-    #   factory.register  my_view: SomeClass,
-    #                     another_view: OtherViewClass
-    #
-    def register(view_hash)
-      self.class.register view_hash
-    end
-
-    def default_for(key)
-      self.class.send key
-    end
-
-    def [](key)
-      send key
-    end
-
-    def []=(key, value)
-      send "#{key}=", value
-    end
-  end
-end

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