activeadmin 2.2.0

data/lib/active_admin.rb

@@ -0,0 +1,134 @@
+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 'sassc-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/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,234 @@
+require 'active_admin/router'
+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
+      register_stylesheet 'active_admin.css', media: 'screen'
+      register_stylesheet 'active_admin/print.css', media: 'print'
+      register_javascript '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.
+          ActiveSupport::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.
+          ActiveSupport::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
+
+        ActiveSupport::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/lib/active_admin/application_settings.rb

@@ -0,0 +1,42 @@
+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']
+
+    # Remove sensitive attributes from being displayed, made editable, or exported by default
+    register :filter_attributes, [:encrypted_password, :password, :password_confirmation]
+  end
+end