activeadmin 0.3.4 → 0.4.0

data/lib/active_admin/page.rb

@@ -0,0 +1,65 @@
+module ActiveAdmin
+  # Page is the primary data storage for page configuration in Active Admin
+  #
+  # When you register a page (ActiveAdmin.page "Status") you are actually creating
+  # a new Page instance within the given Namespace.
+  #
+  # The instance of the current page is available in PageController and views
+  # by calling the #active_admin_config method.
+  #
+  class Page
+
+    # The namespace this config belongs to
+    attr_reader :namespace
+
+    # The name of the page
+    attr_reader :name
+
+    module Base
+      def initialize(namespace, name, options)
+        @namespace = namespace
+        @name = name
+        @options = options
+      end
+    end
+
+    include Base
+    include Resource::Controllers
+    include Resource::PagePresenters
+    include Resource::Sidebars
+    include Resource::ActionItems
+    include Resource::Menu
+    include Resource::Naming
+
+    # plural_resource_name is singular
+    def resource_name
+      name
+    end
+
+    def safe_resource_name
+      name
+    end
+
+
+    # Force plural to be singular
+    def plural_resource_name
+      name
+    end
+
+    # Force plural to be singular
+    def plural_safe_resource_name
+      name
+    end
+
+    def belongs_to?
+      false
+    end
+
+    def add_default_action_items
+    end
+
+    def add_default_sidebar_sections
+    end
+
+  end
+end

data/lib/active_admin/page_controller.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+
+  # All Pages controllers inherit from this controller.
+  class PageController < BaseController
+
+    # Pages::Page subclasses Page::Base which implements the layout code
+    layout false
+
+    actions :index
+
+    def index(options={}, &block)
+      render "active_admin/page/index"
+    end
+  end
+end

data/lib/active_admin/page_dsl.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  # This is the class where all the register_page blocks are instance eval'd
+  class PageDSL < DSL
+
+    # Page content.
+    #
+    # The block should define the view using Arbre.
+    #
+    # Example:
+    #
+    #   ActiveAdmin.register "My Page" do
+    #     content do
+    #       para "Sweet!"
+    #     end
+    #   end
+    #
+    def content(options = {}, &block)
+      config.set_page_presenter :index, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+  end
+end

data/lib/active_admin/page_presenter.rb

@@ -0,0 +1,30 @@
+module ActiveAdmin
+
+  # A simple object that gets used to present different aspects of views
+  #
+  # Initialize with a set of options and a block. The options become
+  # available using hash style syntax.
+  #
+  # Usage:
+  #
+  #     presenter = PagePresenter.new :as => :table do
+  #       # some awesome stuff
+  #     end
+  #
+  #     presenter[:as]    #=> :table
+  #     presenter.block   #=> The block passed in to new
+  #
+  class PagePresenter
+
+    attr_reader :block, :options
+
+    def initialize(options = {}, &block)
+      @options, @block = options, block
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+  end
+end

data/lib/active_admin/reloader.rb

@@ -1,63 +1,130 @@
 module ActiveAdmin
 
-  class FileUpdateChecker < ::ActiveSupport::FileUpdateChecker
+  module Reloader
 
-    # Over-ride the default #updated_at to support the deletion of files
-    def updated_at
-      paths.map { |path| File.mtime(path) rescue Time.now }.max
+    # Builds the proper Reloader implementation class given the
+    # current version of Rails.
+    #
+    # @param [Rails::Application] rails_app The current rails application
+    # @param [ActiveAdmin::Application] active_admin_app The current Active Admin app
+    # @param [String] rails_version The version of Rails we're using. 
+    #
+    # @returns A concrete subclass of AbstractReloader
+    def self.build(rails_app, active_admin_app, rails_version)
+      reloader_class = rails_version[0..2] == "3.2" ? Rails32Reloader : RailsLessThan31Reloader
+      reloader_class.new(rails_app, active_admin_app, rails_version)
     end
 
-  end
+    class AbstractReloader
 
-  # Deals with reloading Active Admin on each request in 
-  # development and once in production.
-  class Reloader
+      attr_reader :active_admin_app, :rails_app, :rails_version
 
-    attr_reader :active_admin_app, 
-                :rails_app,
-                :file_update_checker
+      def initialize(rails_app, active_admin_app, rails_version)
+        @rails_app = rails_app
+        @active_admin_app = active_admin_app
+        @rails_version = rails_version.to_s
+      end
 
-    # @param [ActiveAdmin::Application] app
-    # @param [String] rails_version The version of Rails we're using. 
-    #                 We use this to switch between the correcrt Rails reloader class.
-    def initialize(rails_app, active_admin_app, rails_version)
-      @rails_app = rails_app
-      @active_admin_app = active_admin_app
-      @rails_version = rails_version.to_s
-      @file_update_checker = FileUpdateChecker.new(watched_paths) do
-        reload!
+      def attach!
+        raise "Please implement #{self.class}#attach!"
+      end
+
+      def reload!
+        active_admin_app.unload!
+        rails_app.reload_routes!
+      end
+
+      def major_rails_version
+        @rails_version[0..2]
       end
-    end
 
-    def reload!
-      active_admin_app.unload!
-      rails_app.reload_routes!
-      file_update_checker.paths.clear
-      watched_paths.each{|path| file_update_checker.paths << path }
     end
 
-    # Attach to Rails and perform the reload on each request.
-    def attach!
-      # Bring the checker into local scope for the ruby block
-      checker = file_update_checker
+    # Reloads the application when using Rails 3.2
+    #
+    # 3.2 introduced a to_prepare block that only gets called when
+    # files have actually changed. ActiveAdmin had built this functionality
+    # in to speed up applications. So in Rails >= 3.2, we can now piggy
+    # back off the existing reloader. This simplifies our duties... which is
+    # nice.
+    class Rails32Reloader < AbstractReloader
+
+      # Attach to Rails and perform the reload on each request.
+      def attach!
+        active_admin_app.load_paths.each do |path|
+          rails_app.config.watchable_dirs[path] = [:rb]
+        end
 
-      reloader_class.to_prepare do
-        checker.execute_if_updated
+        reloader = self
+
+        ActionDispatch::Reloader.to_prepare do
+          reloader.reload!
+        end
       end
-    end
 
-    def watched_paths
-      paths = active_admin_app.load_paths
-      active_admin_app.load_paths.each{|path| paths += Dir[File.join(path, "**", "*.rb")]}
-      paths
     end
 
-    def reloader_class
-      if @rails_version[0..2] == '3.1'
-        ActionDispatch::Reloader
-      else
-        ActionDispatch::Callbacks
+    # Deals with reloading Active Admin on each request in 
+    # development and once in production in Rails < 3.2.
+    class RailsLessThan31Reloader < AbstractReloader
+
+      class FileUpdateChecker < ::ActiveSupport::FileUpdateChecker
+        def paths
+          Rails.logger.info [@files, @paths].inspect
+          # hack to support both Rails 3.1 and 3.2
+          @files || @paths
+        end
+
+        # Over-ride the default #updated_at to support the deletion of files
+        def updated_at
+          paths.map { |path| File.mtime(path) rescue Time.now }.max
+        end
+
+        def execute_if_updated
+          super
+        end
       end
+
+      attr_reader :file_update_checker
+
+      def initialize(rails_app, active_admin_app, rails_version)
+        super
+        @file_update_checker = FileUpdateChecker.new(watched_paths) do
+          reload!
+        end
+      end
+
+      def reload!
+        super
+        file_update_checker.paths.clear
+        watched_paths.each{|path| file_update_checker.paths << path }
+      end
+
+
+      # Attach to Rails and perform the reload on each request.
+      def attach!
+        # Bring the checker into local scope for the ruby block
+        checker = file_update_checker
+
+        reloader_class.to_prepare do
+          checker.execute_if_updated
+        end
+      end
+
+      def watched_paths
+        paths = active_admin_app.load_paths
+        active_admin_app.load_paths.each{|path| paths += Dir[File.join(path, "**", "*.rb")]}
+        paths
+      end
+
+      def reloader_class
+        if major_rails_version == "3.1"
+          ActionDispatch::Reloader
+        else
+          ActionDispatch::Callbacks
+        end
+      end
+
     end
 
   end

data/lib/active_admin/resource.rb

@@ -1,8 +1,11 @@
 require 'active_admin/resource/action_items'
+require 'active_admin/resource/controllers'
 require 'active_admin/resource/menu'
+require 'active_admin/resource/page_presenters'
 require 'active_admin/resource/naming'
 require 'active_admin/resource/scopes'
 require 'active_admin/resource/sidebars'
+require 'active_admin/resource/belongs_to'
 
 module ActiveAdmin
 
@@ -19,17 +22,11 @@ module ActiveAdmin
     # Event dispatched when a new resource is registered
     RegisterEvent = 'active_admin.resource.register'.freeze
 
-    autoload :BelongsTo, 'active_admin/resource/belongs_to'
-
-    # The namespace this resource belongs to
+    # The namespace this config belongs to
     attr_reader :namespace
 
-    # The class this resource wraps. If you register the Post model, Resource#resource
-    # will point to the Post class
-    attr_reader :resource
-
-    # A hash of page configurations for the controller indexed by action name
-    attr_reader :page_configs
+    # The name of the resource class
+    attr_reader :resource_class_name
 
     # An array of member actions defined for this resource
     attr_reader :member_actions
@@ -46,68 +43,55 @@ module ActiveAdmin
     # If we're scoping resources, use this method on the parent to return the collection
     attr_accessor :scope_to_association_method
 
-    # Set to false to turn off admin notes
-    attr_accessor :admin_notes
-
     # Set the configuration for the CSV
     attr_writer :csv_builder
 
     module Base
-      def initialize(namespace, resource, options = {})
+      def initialize(namespace, resource_class, options = {})
         @namespace = namespace
-        @resource = resource
+        @resource_class_name = "::#{resource_class.name}"
         @options = default_options.merge(options)
         @sort_order = @options[:sort_order]
-        @page_configs = {}
         @member_actions, @collection_actions = [], []
       end
     end
 
     include Base
+    include Controllers
+    include PagePresenters
     include ActionItems
-    include Menu
     include Naming
     include Scopes
     include Sidebars
+    include Menu
 
-
-    def resource_table_name
-      resource.quoted_table_name
-    end
-
-    # Returns a properly formatted controller name for this
-    # resource within its namespace
-    def controller_name
-      [namespace.module_name, camelized_resource_name.pluralize + "Controller"].compact.join('::')
+    # The class this resource wraps. If you register the Post model, Resource#resource_class
+    # will point to the Post class
+    def resource_class
+      ActiveSupport::Dependencies.constantize(resource_class_name)
     end
 
-    # Returns the controller for this resource
-    def controller
-      @controller ||= controller_name.constantize
+    def resource_table_name
+      resource_class.quoted_table_name
     end
 
-    # Returns the routes prefix for this resource
-    def route_prefix
-      namespace.module_name.try(:underscore)
+    # Returns the named route for an instance of this resource
+    def route_instance_path
+      [route_prefix, controller.resources_configuration[:self][:route_instance_name], 'path'].compact.join('_').to_sym
     end
 
     # Returns a symbol for the route to use to get to the
     # collection of this resource
     def route_collection_path
-      route = [route_prefix, controller.resources_configuration[:self][:route_collection_name]]
+      route = super
 
+      # Handle plural resources.
       if controller.resources_configuration[:self][:route_collection_name] ==
-          controller.resources_configuration[:self][:route_instance_name]
-        route << "index"
+            controller.resources_configuration[:self][:route_instance_name]
+        route = route.to_s.gsub('_path', '_index_path').to_sym
       end
 
-      route << 'path'
-      route.compact.join('_').to_sym
-    end
-
-    # Returns the named route for an instance of this resource
-    def route_instance_path
-      [route_prefix, controller.resources_configuration[:self][:route_instance_name], 'path'].compact.join('_').to_sym
+      route
     end
 
     # Clears all the member actions this resource knows about
@@ -138,22 +122,32 @@ module ActiveAdmin
       !belongs_to_config.nil?
     end
 
+    def include_in_menu?
+      super && !(belongs_to? && !belongs_to_config.optional?)
+    end
+
     # The csv builder for this resource
     def csv_builder
       @csv_builder || default_csv_builder
     end
 
+    # @deprecated
+    def resource
+      resource_class
+    end
+    ActiveAdmin::Deprecation.deprecate self, :resource,
+      "ActiveAdmin::Resource#resource is deprecated. Please use #resource_class instead."
+
     private
 
     def default_options
       {
-        :namespace  => ActiveAdmin.application.default_namespace,
-        :sort_order => "#{resource.respond_to?(:primary_key) ? resource.primary_key : 'id'}_desc"
+        :sort_order => "#{resource_class.respond_to?(:primary_key) ? resource_class.primary_key : 'id'}_desc"
       }
     end
 
     def default_csv_builder
-      @default_csv_builder ||= CSVBuilder.default_for_resource(resource)
+      @default_csv_builder ||= CSVBuilder.default_for_resource(resource_class)
     end
   end # class Resource
 end # module ActiveAdmin