activeadmin 0.2.2 → 0.3.0

data/lib/active_admin/application.rb

@@ -0,0 +1,228 @@
+require 'active_admin/router'
+require 'active_admin/helpers/settings'
+
+module ActiveAdmin
+  class Application
+    include Settings
+
+    # 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
+
+    # The default number of resources to display on index pages
+    setting :default_per_page, 30
+
+    # A hash of all the registered namespaces
+    setting :namespaces, {}
+
+    # The title which gets displayed in the main layout
+    setting :site_title, ""
+
+    # 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 view factory to use to generate all the view classes. Take
+    # a look at ActiveAdmin::ViewFactory
+    setting :view_factory, ActiveAdmin::ViewFactory.new
+
+    # The method to call in controllers to get the current user
+    setting :current_user_method, false
+
+    # The method to call in the controllers to ensure that there
+    # is a currently authenticated admin user
+    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
+    setting :logout_link_path, :destroy_admin_user_session_path
+
+    # The method to use when generating the link for user logout
+    setting :logout_link_method, :get
+
+    # 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
+
+    # @deprecated The default sort order for index pages
+    deprecated_setting :default_sort_order, 'id_desc'
+
+    # DEPRECATED: This option is deprecated and will be removed. Use
+    # the #allow_comments_in option instead
+    attr_accessor :admin_notes
+
+
+    include AssetRegistration
+
+    def initialize
+      register_default_assets
+    end
+
+    def prepare!
+      remove_active_admin_load_paths_from_rails_autoload_and_eager_load
+      attach_reloader
+      generate_stylesheets
+    end
+
+    # Registers a brand new configuration for the given resource.
+    def register(resource, options = {}, &block)
+      namespace_name = options.has_key?(:namespace) ? options[:namespace] : default_namespace
+      namespace = find_or_create_namespace(namespace_name)
+      namespace.register(resource, options, &block)
+    end
+
+    # Creates a namespace for the given name
+    def find_or_create_namespace(name)
+      name ||= :root
+      return namespaces[name] if namespaces[name]
+      namespace = Namespace.new(self, name)
+      ActiveAdmin::Event.dispatch ActiveAdmin::Namespace::RegisterEvent, namespace
+      namespaces[name] = namespace
+      namespace
+    end
+
+
+    # Stores if everything has been loaded or we need to reload
+    @@loaded = false
+
+    # Returns true if all the configuration files have been loaded.
+    def loaded?
+      @@loaded
+    end
+
+    # Removes all the controllers that were defined by registering
+    # resources for administration.
+    #
+    # We remove them, then load them on each request in development
+    # to allow for changes without having to restart the server.
+    def unload!
+      namespaces.values.each{|namespace| namespace.unload! }
+      self.namespaces = {}
+      @@loaded = false
+    end
+
+    # Loads all of the ruby files that are within the load path of
+    # ActiveAdmin.load_paths. This should load all of the administration
+    # UIs so that they are available for the router to proceed.
+    #
+    # The files are only loaded if we haven't already loaded all the files
+    # and they aren't marked for re-loading. To mark the files for re-loading
+    # you must first call ActiveAdmin.unload!
+    def load!
+      # No work to do if we've already loaded
+      return false if loaded?
+
+      # Load files
+      files_in_load_path.each{|file| load file }
+
+      # If no configurations, let's make sure you can still login
+      load_default_namespace if namespaces.values.empty?
+
+      # Load Menus
+      namespaces.values.each{|namespace| namespace.load_menu! }
+
+      @@loaded = true
+    end
+
+    # Returns ALL the files to load from all the load paths
+    def files_in_load_path
+      load_paths.flatten.compact.uniq.collect{|path| Dir["#{path}/**/*.rb"] }.flatten
+    end
+
+    def router
+      @router ||= Router.new(self)
+    end
+
+    def routes(rails_router)
+      # Ensure that all the configurations (which define the routes)
+      # are all loaded
+      load!
+
+      router.apply(rails_router)
+    end
+
+    def load_default_namespace
+      find_or_create_namespace(default_namespace)
+    end
+
+    #
+    # Add before, around and after filters to each registered resource.
+    #
+    # eg:
+    #
+    #   ActiveAdmin.before_filter :authenticate_admin!
+    #
+    def before_filter(*args, &block)
+      ResourceController.before_filter(*args, &block)
+    end
+
+    def skip_before_filter(*args, &block)
+      ResourceController.skip_before_filter(*args, &block)
+    end
+
+    def after_filter(*args, &block)
+      ResourceController.after_filter(*args, &block)
+    end
+
+    def around_filter(*args, &block)
+      ResourceController.around_filter(*args, &block)
+    end
+
+    # Helper method to add a dashboard section
+    def dashboard_section(name, options = {}, &block)
+      ActiveAdmin::Dashboards.add_section(name, options, &block)
+    end
+
+    private
+
+    def register_default_assets
+      register_stylesheet 'active_admin.css'
+      register_javascript 'active_admin.js'
+    end
+
+    # Since we're dealing with all our own file loading, we need
+    # to remove our paths from the ActiveSupport autoload paths.
+    # If not, file naming becomes very important and can cause clashes.
+    def remove_active_admin_load_paths_from_rails_autoload_and_eager_load
+      ActiveSupport::Dependencies.autoload_paths.reject!{|path| load_paths.include?(path) }
+      # Don't eagerload our configs, we'll deal with them ourselves
+      Rails.application.config.eager_load_paths = Rails.application.config.eager_load_paths.reject do |path|
+        load_paths.include?(path)
+      end
+    end
+
+    def attach_reloader
+      ActiveAdmin::Reloader.new(Rails.version).attach!
+    end
+
+
+    def generate_stylesheets
+      # This must be required after initialization
+      require 'sass/plugin'
+      require 'active_admin/sass/helpers'
+
+      # Create our own asset pipeline in Rails 3.0
+      if ActiveAdmin.use_asset_pipeline?
+        # Add our mixins to the load path for SASS
+        ::Sass::Engine::DEFAULT_OPTIONS[:load_paths] <<  File.expand_path("../../../app/assets/stylesheets", __FILE__)
+      else
+        require 'active_admin/sass/css_loader'
+        ::Sass::Plugin.add_template_location(File.expand_path("../../../app/assets/stylesheets", __FILE__))
+        ::Sass::Plugin.add_template_location(File.expand_path("../sass", __FILE__))
+      end
+    end
+  end
+end

data/lib/active_admin/arbre.rb

@@ -1,14 +1,14 @@
-require "active_admin/arbre/html"
-require "active_admin/arbre/attributes"
+require "active_admin/arbre/builder"
 require "active_admin/arbre/core_extensions"
-require "active_admin/arbre/element"
 require "active_admin/arbre/context"
-require "active_admin/arbre/collection"
-require "active_admin/arbre/class_list"
-require "active_admin/arbre/tag"
-require "active_admin/arbre/document"
-require "active_admin/arbre/html5_elements"
-require "active_admin/arbre/text_node"
+require "active_admin/arbre/html/element"
+require "active_admin/arbre/html/attributes"
+require "active_admin/arbre/html/collection"
+require "active_admin/arbre/html/class_list"
+require "active_admin/arbre/html/tag"
+require "active_admin/arbre/html/document"
+require "active_admin/arbre/html/html5_elements"
+require "active_admin/arbre/html/text_node"
 
 # Arbre - The DOM Tree in Ruby
 #
@@ -19,5 +19,5 @@ end
 require 'action_view'
 
 ActionView::Template.register_template_handler :arb, lambda { |template|
-  "self.class.send :include, Arbre::HTML; @_helpers = self; begin; #{template.source}; end; current_dom_context"
+  "self.class.send :include, Arbre::Builder; @_helpers = self; @__current_dom_element__ = Arbre::Context.new(assigns, self); begin; #{template.source}; end; current_dom_context"
 }

data/lib/active_admin/arbre/{html.rb → builder.rb}

@@ -1,5 +1,24 @@
 module Arbre
-  module HTML
+
+  # Include this module in any context to start building html.
+  #
+  #   assigns = {}
+  #   include Arbre::Builder
+  #   span("foo").to_s #=> "<span>foo</span>
+  #
+  # When you include the module, you are required to setup 2 variables:
+  #
+  # * assigns: This is a hash that includes local variables
+  # * helpers: This is an object that provides helper methods to all
+  #              objects within the context.
+  module Builder
+
+    # Retrieve the current DOM context.
+    #
+    # If no `@__current_dom_element__` has been set, this method will
+    # setup the initial context.
+    #
+    # @return [Arbre::Element] the current element that is in context
     def current_dom_context
       @__current_dom_element__ ||= Arbre::Context.new(assigns, helpers)
       @__current_dom_element__.current_dom_context
@@ -9,6 +28,14 @@ module Arbre
       @_helpers
     end
 
+    # Implements the method lookup chain. When you call a method that
+    # doesn't exist, we:
+    #
+    #  1. Try to call the method on the current DOM context
+    #  2. Return an assigned variable of the same name
+    #  3. Call the method on the helper object
+    #  4. Call super
+    #
     def method_missing(name, *args, &block)
       if current_dom_context.respond_to?(name)
         current_dom_context.send name, *args, &block
@@ -74,7 +101,7 @@ module Arbre
       # Inserts a text node if the tag is a string
       def insert_text_node_if_string(tag)
         if tag.is_a?(String)
-          current_dom_context << TextNode.from_string(tag)
+          current_dom_context << Arbre::HTML::TextNode.from_string(tag)
         end
       end
     end

data/lib/active_admin/arbre/context.rb

@@ -1,8 +1,16 @@
+require 'active_admin/arbre/html/element'
+
 module Arbre
   class Context < Arbre::HTML::Element
     def indent_level
       # A context does not increment the indent_level
       super - 1
     end
+
+    def length
+      to_html.length
+    end
+    alias :bytesize :length
+
   end
 end

data/lib/active_admin/arbre/{element.rb → html/element.rb}

@@ -2,16 +2,16 @@ module Arbre
   module HTML
 
     class Element
-      include ::Arbre::HTML
-      include ::Arbre::HTML::BuilderMethods
+      include ::Arbre::Builder
+      include ::Arbre::Builder::BuilderMethods
 
       attr_accessor :parent
       attr_reader :children
 
       def self.builder_method(method_name)
-        ::Arbre::HTML::BuilderMethods.class_eval <<-EOF, __FILE__, __LINE__
+        ::Arbre::Builder::BuilderMethods.class_eval <<-EOF, __FILE__, __LINE__
           def #{method_name}(*args, &block)
-            insert_tag #{self.name}, *args, &block
+            insert_tag ::#{self.name}, *args, &block
           end
         EOF
       end
@@ -48,7 +48,7 @@ module Arbre
 
         # If its not an element, wrap it in a TextNode
         unless child.is_a?(Element)
-          child = TextNode.from_string(child)
+          child = Arbre::HTML::TextNode.from_string(child)
         end
 
         if child.respond_to?(:parent)
@@ -129,7 +129,7 @@ module Arbre
         case element
         when Element, Collection
         else
-          element = TextNode.from_string(element)
+          element = Arbre::HTML::TextNode.from_string(element)
         end
         Collection.new([self]) + element
       end

data/lib/active_admin/asset_registration.rb

@@ -29,6 +29,6 @@ module ActiveAdmin
     def clear_javascripts!
       @javascripts = []
     end
-    
+
   end
 end

data/lib/active_admin/callbacks.rb

@@ -58,12 +58,14 @@ module ActiveAdmin
       def define_active_admin_callbacks(*names)
         names.each do |name|
           [:before, :after].each do |type|
-            # Create an inheritable accessor array for the callbacks
-            class_inheritable_array "#{type}_#{name}_callbacks".to_sym
-            send("#{type}_#{name}_callbacks=".to_sym, [])
 
             # Define a method to set the callback
             class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+              # def self.before_create_callbacks
+              def self.#{type}_#{name}_callbacks
+                @#{type}_#{name}_callbacks ||= []
+              end
+
               # def self.before_create
               def self.#{type}_#{name}(method = nil, &block)
                 #{type}_#{name}_callbacks << (method || block)

data/lib/active_admin/comments.rb

@@ -6,7 +6,7 @@ require 'active_admin/comments/namespace_helper'
 require 'active_admin/comments/resource_helper'
 
 # Add the comments configuration
-ActiveAdmin.extend ActiveAdmin::Comments::Configuration
+ActiveAdmin::Application.send :include, ActiveAdmin::Comments::Configuration
 
 # Add the comments module to ActiveAdmin::Namespace
 ActiveAdmin::Namespace.send :include, ActiveAdmin::Comments::NamespaceHelper
@@ -15,7 +15,7 @@ ActiveAdmin::Namespace.send :include, ActiveAdmin::Comments::NamespaceHelper
 ActiveAdmin::Resource.send :include, ActiveAdmin::Comments::ResourceHelper
 
 # Add the module to the show page
-ActiveAdmin.view_factory.show_page.send :include, ActiveAdmin::Comments::ShowPageHelper
+ActiveAdmin.application.view_factory.show_page.send :include, ActiveAdmin::Comments::ShowPageHelper
 
 # Generate a Comment resource when namespaces are registered
 ActiveAdmin::Event.subscribe ActiveAdmin::Namespace::RegisterEvent do |namespace|
@@ -36,7 +36,7 @@ ActiveAdmin::Event.subscribe ActiveAdmin::Namespace::RegisterEvent do |namespace
 
       # Only view comments in this namespace
       scope :all, :default => true do |comments|
-        comments.where(:namespace => active_admin_config.namespace.name)
+        comments.where(:namespace => active_admin_config.namespace.name.to_s)
       end
 
       # Always redirect to the resource on show

data/lib/active_admin/comments/comment.rb

@@ -1,5 +1,10 @@
+require 'kaminari/models/active_record_extension'
+
 module ActiveAdmin
 
+  # manually initialize kaminari for this model
+  ::ActiveRecord::Base.send :include, Kaminari::ActiveRecordExtension
+
   class Comment < ActiveRecord::Base
     self.table_name = "active_admin_comments"
 
@@ -13,3 +18,4 @@ module ActiveAdmin
   end
 
 end
+