activeadmin-rb 1.4.0

data/features/users/logging_in.feature

@@ -0,0 +1,32 @@
+Feature: User Logging In
+
+  Logging in to the system as an admin user
+
+  Background:
+    Given I am logged out
+    And an admin user "admin@example.com" exists
+    When I go to the dashboard
+
+  Scenario: Logging in Successfully
+    When I fill in "Email" with "admin@example.com"
+    And I fill in "Password" with "password"
+    And I press "Login"
+    Then I should be on the the dashboard
+    And I should see the element "a[href='/admin/logout'       ]:contains('Logout')"
+    And I should see the element "a[href='/admin/admin_users/1']:contains('admin@example.com')"
+
+  Scenario: Attempting to log in with an incorrect email address
+    Given override locale "devise.failure.not_found_in_database" with "Invalid email or password."
+    When I fill in "Email" with "not-an-admin@example.com"
+    And I fill in "Password" with "not-my-password"
+    And I press "Login"
+    Then I should see "Login"
+    And I should see "Invalid email or password."
+
+  Scenario: Attempting to log in with an incorrect password
+    Given override locale "devise.failure.invalid" with "Invalid email or password."
+    When I fill in "Email" with "admin@example.com"
+    And I fill in "Password" with "not-my-password"
+    And I press "Login"
+    Then I should see "Login"
+    And I should see "Invalid email or password."

data/features/users/logging_out.feature

@@ -0,0 +1,29 @@
+Feature: User Logging out
+
+  Logging out of the system as an admin user
+
+  Scenario: Logging out successfully
+    Given a configuration of:
+    """
+      ActiveAdmin.setup do |config|
+        config.logout_link_method = :get
+      end
+    """
+    And I am logged in
+    When I go to the dashboard
+    Then I should see the element "a[data-method='get']:contains('Logout')"
+    And I follow "Logout"
+    Then I should see "Login"
+
+  Scenario: Logging out sucessfully with delete method
+    Given a configuration of:
+    """
+      ActiveAdmin.setup do |config|
+        config.logout_link_method = :delete
+      end
+    """
+    And I am logged in
+    When I am on the dashboard
+    Then I should see the element "a[data-method='delete']:contains('Logout')"
+    And I follow "Logout"
+    Then I should see "Login"

data/features/users/resetting_password.feature

@@ -0,0 +1,30 @@
+Feature: User Resetting Password
+
+  Resetting my password as an admin user
+
+  Background:
+    Given 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/gemfiles/rails_42.gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+eval_gemfile(File.expand_path(File.join("..", "Gemfile"), __dir__))
+
+gem "rails", "4.2.10"
+gem "devise", "~> 4.4" # required for Ruby 2.5, see devise/issues/4736
+gem "draper", "~> 2.1"
+gem "ransack", "~> 1.8.7" # 2.x for Rails 5.2+ only.
+gem "activerecord-jdbcsqlite3-adapter", platforms: :jruby
+
+gemspec path: "../"

data/gemfiles/rails_50.gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+eval_gemfile(File.expand_path(File.join("..", "Gemfile"), __dir__))
+
+gem "rails", "5.0.7"
+gem "devise", "~> 4.0"
+gem "draper", "~> 3.0"
+gem "ransack", "~> 1.8.7" # 2.x for Rails 5.2+ only.
+gem "activerecord-jdbcsqlite3-adapter", github: "jruby/activerecord-jdbc-adapter", platforms: :jruby
+
+gemspec path: "../"

data/gemfiles/rails_51.gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+eval_gemfile(File.expand_path(File.join("..", "Gemfile"), __dir__))
+
+gem "rails", "5.1.6"
+gem "devise", "~> 4.3"
+gem "draper", "~> 3.0"
+gem "ransack", "~> 1.8.7" # 2.x for Rails 5.2+ only.
+gem "activerecord-jdbcsqlite3-adapter", github: "jruby/activerecord-jdbc-adapter", platforms: :jruby
+
+gemspec path: "../"

data/gemfiles/rails_52.gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+eval_gemfile(File.expand_path(File.join("..", "Gemfile"), __dir__))
+
+gem "rails", "5.2.1"
+gem "bootsnap"
+gem "devise", "~> 4.4"
+gem "draper", "~> 3.0"
+gem "ransack", "2.0" # 2.x for Rails 5.2+ only.
+gem "activerecord-jdbcsqlite3-adapter", "~> 51.0", platforms: :jruby
+
+gemspec path: "../"

data/lib/active_admin.rb

@@ -0,0 +1,128 @@
+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 'coffee-rails'
+require 'arbre'
+
+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 :Event,                    'active_admin/event'
+  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, &ActiveAdmin::Event.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, &ActiveAdmin::Event.wrap_block_for_active_support_notifications(block)
+    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/lib/active_admin/abstract_view_factory.rb

@@ -0,0 +1,47 @@
+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/lib/active_admin/application.rb

@@ -0,0 +1,241 @@
+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
+
+    # == Deprecated Settings
+
+    def allow_comments=(*)
+      raise "`config.allow_comments` is no longer provided in ActiveAdmin 1.x. Use `config.comments` instead."
+    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