activeadmin 0.1.1 → 0.2.0

data/lib/active_admin/component.rb

@@ -0,0 +1,22 @@
+module ActiveAdmin
+  class Component < Arbre::HTML::Div
+
+    # By default components render a div
+    def tag_name
+      'div'
+    end
+
+    def initialize(*)
+      super
+      add_class default_class_name
+    end
+
+    protected
+
+    # By default, add a css class named after the ruby class
+    def default_class_name
+      self.class.name.demodulize.underscore
+    end
+
+  end
+end

data/lib/active_admin/controller_action.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  class ControllerAction
+    attr_reader :name
+    def initialize(name, options = {})
+      @name, @options = name, options
+    end
+
+    def http_verb
+      @options[:method] ||= :get
+    end
+  end
+end

data/lib/active_admin/dashboards.rb

@@ -2,9 +2,7 @@ module ActiveAdmin
   module Dashboards
 
     autoload :DashboardController,  'active_admin/dashboards/dashboard_controller'
-    autoload :Renderer,             'active_admin/dashboards/renderer'
     autoload :Section,              'active_admin/dashboards/section'
-    autoload :SectionRenderer,      'active_admin/dashboards/section_renderer'
 
     @@sections = {}
     mattr_accessor :sections

data/lib/active_admin/dashboards/dashboard_controller.rb

@@ -2,13 +2,16 @@ module ActiveAdmin
   module Dashboards
     class DashboardController < ResourceController
 
+      before_filter :skip_sidebar!
+
+      actions :index
+
       # Render from here if not overriden
       self.default_views = 'active_admin_dashboard'
 
       clear_action_items!
 
       def index
-        skip_sidebar!
         @dashboard_sections = find_sections
         render_or_default 'index'
       end
@@ -24,7 +27,12 @@ module ActiveAdmin
       end
 
       def namespace
-        self.class.name.split('::').first.underscore.to_sym
+        class_name = self.class.name
+        if class_name.include?('::')
+          self.class.name.split('::').first.underscore.to_sym
+        else
+          :root
+        end
       end
 
       # Return the current menu for the view. This is a helper method
@@ -32,9 +40,6 @@ module ActiveAdmin
         ActiveAdmin.namespaces[namespace].menu
       end
 
-      # Override to do nothing
-      def add_section_breadcrumb
-      end
     end
   end
 end

data/lib/active_admin/dashboards/section.rb

@@ -2,15 +2,10 @@ module ActiveAdmin
   module Dashboards
     class Section
 
-      @@renderers = {
-        :default => SectionRenderer
-      }
-      cattr_accessor :renderers
-
       DEFAULT_PRIORITY = 10
 
       attr_accessor :name, :block
-      attr_reader :namespace
+      attr_reader :namespace, :options
 
       def initialize(namespace, name, options = {}, &block)
         @namespace = namespace
@@ -23,6 +18,10 @@ module ActiveAdmin
         @options[:priority] || DEFAULT_PRIORITY
       end
 
+      def icon
+        @options[:icon]
+      end
+
       # Sort by priority then by name
       def <=>(other)
         result = priority <=> other.priority
@@ -30,14 +29,6 @@ module ActiveAdmin
         result
       end
 
-      # Returns the class to use as this sections renderer. Raises
-      # an exception if the renderer could not be found
-      def renderer
-        klass = Section.renderers[@options[:as] || :default]
-        raise StandardError, "Could not find the #{@options[:as].inspect} dashboard section renderer." unless klass
-        klass
-      end
-
     end
   end
 end

data/lib/active_admin/devise.rb

@@ -0,0 +1,43 @@
+require 'devise'
+
+module ActiveAdmin
+  module Devise
+
+    def self.config
+      {
+        :path => ActiveAdmin.default_namespace,
+        :controllers => ActiveAdmin::Devise.controllers,
+        :path_names => { :sign_in => 'login', :sign_out => "logout" }
+      }
+    end
+
+    def self.controllers
+      {
+        :sessions => "active_admin/devise/sessions",
+        :passwords => "active_admin/devise/passwords"
+      }
+    end
+
+    module Controller
+      extend ::ActiveSupport::Concern
+      included do
+        layout 'active_admin_logged_out'
+        helper ::ActiveAdmin::ViewHelpers
+      end
+
+      # Redirect to the default namespace on logout
+      def root_path
+        "/#{ActiveAdmin.default_namespace}"
+      end
+    end
+
+    class SessionsController < ::Devise::SessionsController
+      include ::ActiveAdmin::Devise::Controller
+    end
+
+    class PasswordsController < ::Devise::PasswordsController
+      include ::ActiveAdmin::Devise::Controller
+    end
+
+  end
+end

data/lib/active_admin/dsl.rb

@@ -0,0 +1,202 @@
+module ActiveAdmin
+
+  #
+  # The Active Admin DSL. This class is where all the registration blocks
+  # are instance eval'd. This is the central place for the API given to 
+  # users of Active Admin
+  #
+  class DSL
+
+    # Runs the registration block inside this object
+    def run_registration_block(config, &block)
+      @config = config
+      instance_eval &block
+    end
+
+    private
+
+    # The instance of ActiveAdmin::Resource that's being registered
+    # currently. You can use this within your registration blocks to
+    # modify options:
+    #
+    # eg:
+    #   
+    #   ActiveAdmin.register Post do
+    #     config.admin_notes = false
+    #   end
+    #
+    def config
+      @config
+    end
+
+    # Returns the controller for this resource. If you pass a
+    # block, it will be eval'd in the controller
+    #
+    # Example:
+    #   
+    #   ActiveAdmin.register Post do
+    #
+    #     controller do
+    #       def some_method_on_controller
+    #         # Method gets added to Admin::PostsController
+    #       end
+    #     end
+    #
+    #   end
+    #
+    def controller(&block)
+      @config.controller.class_eval(&block) if block_given?
+      @config.controller
+    end
+
+    def belongs_to(target, options = {})
+      config.belongs_to(target, options)
+    end
+
+    def menu(options = {})
+      config.menu(options)
+    end
+
+    # Scope this controller to some object which has a relation
+    # to the resource. Can either accept a block or a symbol 
+    # of a method to call.
+    #
+    # Eg:
+    #
+    #   ActiveAdmin.register Post do
+    #     scope_to :current_user
+    #   end
+    #
+    # Then every time we instantiate and object, it would call
+    #   
+    #   current_user.posts.build
+    #
+    # By default Active Admin will use the resource name to build a
+    # method to call as the association. If its different, you can 
+    # pass in the association_method as an option.
+    #
+    #   scope_to :current_user, :association_method => :blog_posts
+    #
+    # will result in the following
+    # 
+    #   current_user.blog_posts.build
+    #
+    def scope_to(*args, &block)
+      options = args.extract_options!
+      method = args.first
+
+      config.scope_to = block_given? ? block : method
+      config.scope_to_association_method = options[:association_method]
+    end
+
+    # Create a scope
+    def scope(*args, &block)
+      config.scope(*args, &block)
+    end
+
+    def action_item(options = {}, &block)
+      controller.action_item(options, &block)
+    end
+
+    # Configure the index page for the resource
+    def index(options = {}, &block)
+      options[:as] ||= :table
+      controller.set_page_config :index, options, &block
+    end
+
+    # Configure the show page for the resource
+    def show(options = {}, &block)
+      # TODO: controller.set_page_config just sets page_configs on the Resource (config) obj
+      controller.set_page_config :show, options, &block
+    end
+
+    def form(options = {}, &block)
+      options[:block] = block
+      controller.form_config = options
+    end
+
+    # Member Actions give you the functionality of defining both the
+    # action and the route directly from your ActiveAdmin registration
+    # block.
+    #
+    # For example:
+    #
+    #   ActiveAdmin.register Post do
+    #     member_action :comments do
+    #       @post = Post.find(params[:id]
+    #       @comments = @post.comments
+    #     end
+    #   end
+    #
+    # Will create a new controller action comments and will hook it up to
+    # the named route (comments_admin_post_path) /admin/posts/:id/comments
+    #
+    # You can treat everything within the block as a standard Rails controller
+    # action.
+    # 
+    def member_action(name, options = {}, &block)
+      config.member_actions << ControllerAction.new(name, options)
+      controller do
+        define_method(name, &block || Proc.new{})
+      end
+    end
+
+    def collection_action(name, options = {}, &block)
+      config.collection_actions << ControllerAction.new(name, options)
+      controller do
+        define_method(name, &block || Proc.new{})
+      end
+    end
+
+    # Defined Callbacks
+    #
+    # == After Build
+    # Called after the resource is built in the new and create actions.
+    #
+    # ActiveAdmin.register Post do
+    #   after_build do |post|
+    #     post.author = current_user
+    #   end
+    # end
+    #
+    # == Before / After Create
+    # Called before and after a resource is saved to the db on the create action.
+    #
+    # == Before / After Update
+    # Called before and after a resource is saved to the db on the update action.
+    #
+    # == Before / After Save
+    # Called before and after the object is saved in the create and update action.
+    # Note: Gets called after the create and update callbacks
+    #
+    # == Before / After Destroy
+    # Called before and after the object is destroyed from the database.
+    #
+    delegate :before_build,   :after_build,   :to => :controller
+    delegate :before_create,  :after_create,  :to => :controller
+    delegate :before_update,  :after_update,  :to => :controller
+    delegate :before_save,    :after_save,    :to => :controller
+    delegate :before_destroy, :after_destroy, :to => :controller
+
+    # Filters
+    delegate :filter, :to => :controller
+
+    # Sidebar
+    delegate :sidebar, :to => :controller
+
+    # Standard rails filters
+    delegate :before_filter, :after_filter, :around_filter, :to => :controller
+
+    # Specify which actions to create in the controller
+    #
+    # Eg:
+    #   
+    #   ActiveAdmin.register Post do
+    #     actions :index, :show
+    #   end
+    #
+    # Will only create the index and show actions (no create, update or delete)
+    delegate :actions, :to => :controller
+
+  end
+end

data/lib/active_admin/event.rb

@@ -0,0 +1,31 @@
+module ActiveAdmin
+
+  class EventDispatcher
+    def initialize
+      @events = {}
+    end
+
+    def clear_all_subscribers!
+      @events = {}
+    end
+
+    def subscribe(event, &block)
+      @events[event] ||= []
+      @events[event] << block
+    end
+
+    def subscribers(event)
+      @events[event] || []
+    end
+
+    def dispatch(event, *args)
+      subscribers(event).each do |subscriber|
+        subscriber.call(*args)
+      end
+    end
+  end
+
+  # ActiveAdmin::Event is set to a dispatcher
+  Event = EventDispatcher.new
+
+end

data/lib/active_admin/form_builder.rb

@@ -1,68 +1,55 @@
+require 'formtastic'
+
 module ActiveAdmin
   class FormBuilder < ::Formtastic::SemanticFormBuilder
+
+    attr_reader :form_buffers
     
     def initialize(*args)
       @form_buffers = ["".html_safe]
-      @skip_form_buffer = false
       super
     end
 
-    # Sets up buffering for this form which allows
-    # the entire form to be built in a block outside
-    # of the context of the view. Ie: you don't need
-    # to use erb tags.
-    def self.buffer_output_for(*method_names)
-      method_names.each do |method_name|
-        module_eval <<-EOF
-          def #{method_name}(*args)
-            content = block_given? ? with_new_form_buffer{ super } : super
-            return content if @skip_form_buffer
-            @form_buffers.last << content.html_safe
-          end
-        EOF
-      end
-    end
-
-    buffer_output_for   :submit,
-                        :label,
-                        :inputs_for_nested_attributes,
-                        :semantic_fields_for,
-                        :text_field,
-                        :text_area,
-                        :datetime_select,
-                        :time_select,
-                        :date_select,
-                        :radio_button,
-                        :file_field,
-                        :hidden_field,
-                        :select,
-                        :grouped_collection_select,
-                        :collection_select
-
     def inputs(*args, &block)
       # Store that we are creating inputs without a block
-      @inputs_with_no_block = true unless block_given?
+      @inputs_with_block = block_given? ? true : false
       content = with_new_form_buffer { super }
-      @form_buffers.last << content.html_safe
+      form_buffers.last << content.html_safe
     end
 
     # The input method returns a properly formatted string for
     # its contents, so we want to skip the internal buffering
     # while building up its contents
     def input(*args)
-      @skip_form_buffer = true
       content = with_new_form_buffer { super }
-      @skip_form_buffer = false
-      return content.html_safe if @inputs_with_no_block
-      @form_buffers.last << content.html_safe
+      return content.html_safe unless @inputs_with_block
+      form_buffers.last << content.html_safe
     end
 
     # The buttons method always needs to be wrapped in a new buffer
     def buttons(*args, &block)
-      content = with_new_form_buffer{ super }
-      @form_buffers.last << content.html_safe
+      content = with_new_form_buffer do
+        block_given? ? super : super { commit_button_with_cancel_link }
+      end
+      form_buffers.last << content.html_safe
     end
 
+    def commit_button(*args)
+      content = with_new_form_buffer{ super }
+      form_buffers.last << content.html_safe
+    end
+    
+    def cancel_link(url = nil, html_options = {}, li_attributes = {})
+      li_attributes[:class] ||= "cancel"
+      url ||= {:action => "index"}
+      template.content_tag(:li, (template.link_to ActiveAdmin::Iconic.icon(:x) + " Cancel", url, html_options), li_attributes)
+    end
+    
+    def commit_button_with_cancel_link
+      content = commit_button
+      content << cancel_link
+    end
+    
     def datepicker_input(method, options)
       options = options.dup
       options[:input_html] ||= {}
@@ -71,19 +58,50 @@ module ActiveAdmin
       string_input(method, options)
     end
 
-    private
+    def has_many(association, options = {}, &block)
+      options = { :for => association }.merge(options)
+      options[:class] ||= ""
+      options[:class] << "inputs has_many_fields"
 
-    def with_new_form_buffer
-      @form_buffers << "".html_safe
-      return_value = yield
-      @form_buffers.pop
-      return_value
+      # Add Delete Links
+      form_block = proc do |has_many_form|
+        block.call(has_many_form) + if has_many_form.object.new_record?
+                                      template.content_tag :li do
+                                        template.link_to "Delete", "#", :onclick => "$(this).closest('.has_many_fields').remove(); return false;", :class => "button"
+                                      end
+                                    else
+                                    end
+      end
+
+      content = with_new_form_buffer do
+        template.content_tag :div, :class => "has_many #{association}" do
+          form_buffers.last << template.content_tag(:h3, association.to_s.titlecase)
+          inputs options, &form_block
+
+          # Capture the ADD JS
+          js = with_new_form_buffer do
+            inputs_for_nested_attributes  :for => [association, object.class.reflect_on_association(association).klass.new],
+                                          :class => "inputs has_many_fields",
+                                          :for_options => {
+                                            :child_index => "NEW_RECORD"
+                                          }, &form_block
+          end
+
+          js = template.escape_javascript(js)
+          js = template.link_to "Add New #{association.to_s.singularize.titlecase}", "#", :onclick => "$(this).before('#{js}'.replace(/NEW_RECORD/g, new Date().getTime())); return false;", :class => "button"
+
+          form_buffers.last << js.html_safe
+        end
+      end
+      form_buffers.last << content.html_safe
     end
 
-    def skip_form_buffers
-      @skip_form_buffer = true
+    private
+
+    def with_new_form_buffer
+      form_buffers << "".html_safe
       return_value = yield
-      @skip_form_buffer = false
+      form_buffers.pop
       return_value
     end