activeadministration 0.0.1

data/lib/active_admin/abstract_view_factory.rb

@@ -0,0 +1,86 @@
+module ActiveAdmin
+  class AbstractViewFactory
+    @@default_views = {}
+
+    def self.register(view_hash)
+      view_hash.each do |view_key, view_class|
+        @@default_views[view_key] = view_class
+      end
+    end
+
+    def initialize
+      @views = {}
+    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)
+      view_hash.each do |view_key, view_class|
+        @views[view_key] = view_class
+      end
+    end
+
+    def default_for(key)
+      @@default_views[key.to_sym]
+    end
+
+    def has_key?(key)
+      @views.has_key?(key.to_sym) || @@default_views.has_key?(key.to_sym)
+    end
+
+    def [](key)
+      get_view_for_key(key)
+    end
+
+    def []=(key, value)
+      set_view_for_key(key, value)
+    end
+
+    # Override respond to to include keys
+    def respond_to?(method)
+      key = key_from_method_name(method)
+      if has_key?(key)
+        true
+      else
+        super
+      end
+    end
+
+    private
+
+    def method_missing(method, *args)
+      key = key_from_method_name(method)
+      if has_key?(key)
+        if method.to_s.include?('=')
+          set_view_for_key key, args.first
+        else
+          get_view_for_key key
+        end
+      else
+        super
+      end
+    end
+
+    def key_from_method_name(method)
+      method.to_s.gsub('=', '').to_sym
+    end
+
+    def get_view_for_key(key)
+      @views[key.to_sym] || @@default_views[key.to_sym]
+    end
+
+    def set_view_for_key(key, view)
+      @views[key.to_sym] = view
+    end
+  end
+end

data/lib/active_admin/application.rb

@@ -0,0 +1,250 @@
+require 'active_admin/router'
+require 'active_admin/helpers/settings'
+
+module ActiveAdmin
+  class Application
+    include Settings
+    include Settings::Inheritance
+
+    settings_inherited_by Namespace
+
+    # The default namespace to put controllers and routes inside. Set this
+    # in config/initializers/active_admin.rb using:
+    #
+    #   config.default_namespace = :super_admin
+    #
+    setting :default_namespace, :admin
+
+    attr_reader :namespaces
+    def initialize
+      @namespaces = {}
+    end
+
+    # 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
+    setting :load_paths, [File.expand_path('app/admin', Rails.root)]
+
+    # The default number of resources to display on index pages
+    inheritable_setting :default_per_page, 30
+
+    # The title which gets displayed in the main layout
+    inheritable_setting :site_title, ""
+
+    # Set the site title link href (defaults to AA dashboard)
+    inheritable_setting :site_title_link, ""
+
+    # Set the site title image displayed in the main layout (has precendence over :site_title)
+    inheritable_setting :site_title_image, ""
+    
+    # Set a favicon
+    inheritable_setting :favicon, false
+
+    # The view factory to use to generate all the view classes. Take
+    # a look at ActiveAdmin::ViewFactory
+    inheritable_setting :view_factory, ActiveAdmin::ViewFactory.new
+
+    # The method to call in controllers to get the current user
+    inheritable_setting :current_user_method, false
+
+    # The method to call in the controllers to ensure that there
+    # is a currently authenticated admin user
+    inheritable_setting :authentication_method, false
+
+    # The path to log user's out with. If set to a symbol, we assume
+    # that it's a method to call which returns the path
+    inheritable_setting :logout_link_path, :destroy_admin_user_session_path
+
+    # The method to use when generating the link for user logout
+    inheritable_setting :logout_link_method, :get
+
+    # Whether the batch actions are enabled or not
+    inheritable_setting :batch_actions, false
+
+    # Whether filters are enabled
+    inheritable_setting :filters, true
+
+    # The namespace root.
+    inheritable_setting :root_to, 'dashboard#index'
+
+    # Display breadcrumbs
+    inheritable_setting :breadcrumb, true
+
+    # Default CSV options
+    inheritable_setting :csv_options, {col_sep: ','}
+
+    # Default Download Links options
+    inheritable_setting :download_links, true
+
+    # The authorization adapter to use
+    inheritable_setting :authorization_adapter, ActiveAdmin::AuthorizationAdapter
+
+    # A proc to be used when a user is not authorized to view the current resource
+    inheritable_setting :on_unauthorized_access, :rescue_active_admin_access_denied
+
+    # Active Admin makes educated guesses when displaying objects, this is
+    # the list of methods it tries calling in order
+    setting :display_name_methods, [ :display_name,
+                                      :full_name,
+                                      :name,
+                                      :username,
+                                      :login,
+                                      :title,
+                                      :email,
+                                      :to_s ]
+
+    # == Deprecated Settings
+
+    # (none currently)
+
+    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
+    #
+    # @returns [Namespace] the new or existing namespace
+    def namespace(name)
+      name ||= :root
+
+      if namespaces[name]
+        namespace = namespaces[name]
+      else
+        namespace = namespaces[name] = Namespace.new(self, name)
+        ActiveAdmin::Event.dispatch ActiveAdmin::Namespace::RegisterEvent, namespace
+      end
+
+      yield(namespace) if block_given?
+
+      namespace
+    end
+
+    # Register a page
+    #
+    # @param name [String] The page name
+    # @options [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.values.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?
+        ActiveAdmin::Event.dispatch BeforeLoadEvent, self # before_load hook
+        files.each{ |file| load file }                    # load files
+        namespace(default_namespace)                      # init AA resources
+        ActiveAdmin::Event.dispatch AfterLoadEvent, self  # after_load hook
+        @@loaded = true
+      end
+    end
+
+    def load(file)
+      super
+    rescue ActiveRecord::StatementInvalid => exception
+      raise DatabaseHitDuringLoad.new exception
+    end
+
+    # Returns ALL the files to be loaded
+    def files
+      load_paths.flatten.compact.uniq.map{ |path| Dir["#{path}/**/*.rb"] }.flatten
+    end
+
+    def router
+      @router ||= Router.new(self)
+    end
+
+    # One-liner called by user's config/routes.rb file
+    def routes(rails_router)
+      load!
+      router.apply(rails_router)
+    end
+
+    # Adds before, around and after filters to all controllers.
+    # Example usage:
+    #   ActiveAdmin.before_filter :authenticate_admin!
+    #
+    %w(before_filter skip_before_filter after_filter skip_after_filter around_filter skip_filter).each do |name|
+      define_method name do |*args, &block|
+        ActiveAdmin::BaseController.send              name, *args, &block
+        ActiveAdmin::Devise::PasswordsController.send name, *args, &block
+        ActiveAdmin::Devise::SessionsController.send  name, *args, &block
+        ActiveAdmin::Devise::UnlocksController.send   name, *args, &block
+        ActiveAdmin::Devise::RegistrationsController.send name, *args, &block
+      end
+    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
+
+    # Hooks the app/admin directory into our Rails Engine's +watchable_dirs+, so the
+    # files are automatically reloaded in your development environment.
+    #
+    # If files have changed on disk, we forcibly unload all AA configurations, and
+    # tell the host application to redraw routes (triggering AA itself to reload).
+    def attach_reloader
+      load_paths.each do |path|
+        ActiveAdmin::Engine.config.watchable_dirs[path] = [:rb]
+      end
+
+      Rails.application.config.after_initialize do
+        ActionDispatch::Reloader.to_prepare do
+          ActiveAdmin.application.unload!
+          Rails.application.reload_routes!
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/asset_registration.rb

@@ -0,0 +1,29 @@
+module ActiveAdmin
+  module AssetRegistration
+
+    def register_stylesheet(path, options = {})
+      stylesheets[path] = options
+    end
+
+    def stylesheets
+      @stylesheets ||= {}
+    end
+
+    def clear_stylesheets!
+      @stylesheets = {}
+    end
+
+    def register_javascript(name)
+      javascripts.add name
+    end
+
+    def javascripts
+      @javascripts ||= Set.new
+    end
+
+    def clear_javascripts!
+      @javascripts = Set.new
+    end
+
+  end
+end

data/lib/active_admin/authorization_adapter.rb

@@ -0,0 +1,132 @@
+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(klasss)`
+    #
+    # @returns [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.
+    #
+    # @returns [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