activeadmin 0.3.4 → 0.4.0

data/lib/active_admin/comments/comment.rb

@@ -11,10 +11,21 @@ module ActiveAdmin
     belongs_to :resource, :polymorphic => true
     belongs_to :author, :polymorphic => true
 
-    validates_presence_of :resource_id
-    validates_presence_of :resource_type
+    validates_presence_of :resource
     validates_presence_of :body
     validates_presence_of :namespace
+
+    # @returns [String] The name of the record to use for the polymorphic relationship
+    def self.resource_type(record)
+      record.class.base_class.name.to_s
+    end
+
+    def self.find_for_resource_in_namespace(resource, namespace)
+      where(:resource_type => resource_type(resource),
+            :resource_id => resource.id, 
+            :namespace => namespace.to_s)
+    end
+
   end
 
 end

data/lib/active_admin/comments/namespace_helper.rb

@@ -5,7 +5,7 @@ module ActiveAdmin
 
       # Returns true of the namespace allows comments
       def comments?
-        application.allow_comments_in && application.allow_comments_in.include?(name)
+        allow_comments == true
       end
 
     end

data/lib/active_admin/comments/views/active_admin_comments.rb

@@ -21,7 +21,7 @@ module ActiveAdmin
         end
 
         def record_comments
-          @record_comments ||= @record.active_admin_comments.where(:namespace => active_admin_namespace.name.to_s)
+          @record_comments ||= ActiveAdmin::Comment.find_for_resource_in_namespace(@record, active_admin_namespace.name)
         end
 
         def build_comments
@@ -56,13 +56,17 @@ module ActiveAdmin
         end
 
         def comment_form_url
-          send(:"#{active_admin_namespace.name}_comments_path")
+          if active_admin_namespace.root?
+            comments_path
+          else
+            send(:"#{active_admin_namespace.name}_comments_path")
+          end
         end
 
         def build_comment_form
           self << active_admin_form_for(ActiveAdmin::Comment.new, :url => comment_form_url, :html => {:class => "inline_form"}) do |form|
             form.inputs do
-              form.input :resource_type, :value => @record.class.base_class.name.to_s, :as => :hidden
+              form.input :resource_type, :value => ActiveAdmin::Comment.resource_type(@record), :as => :hidden
               form.input :resource_id, :value => @record.id, :as => :hidden
               form.input :body, :input_html => {:size => "80x8"}, :label => false
             end

data/lib/active_admin/dashboards.rb

@@ -26,6 +26,10 @@ module ActiveAdmin
 
       # Add a new dashboard section to a namespace. If no namespace is given
       # it will be added to the default namespace.
+      #
+      # Options include:
+      #   :namespace => only display for specified namespace.
+      #   :if        => specify a method or block to determine whether the section is rendered at run time.
       def add_section(name, options = {}, &block)
         namespace = options.delete(:namespace) || ActiveAdmin.application.default_namespace || :root
         self.sections[namespace] ||= [] 

data/lib/active_admin/dashboards/dashboard_controller.rb

@@ -6,19 +6,31 @@ module ActiveAdmin
 
       def index
         @dashboard_sections = find_sections
-        render 'active_admin/dashboard/index.html.arb'
+        render 'active_admin/dashboard/index'
       end
 
-      protected
+      private
 
       def set_current_tab
         @current_tab = I18n.t("active_admin.dashboard")
       end
 
       def find_sections
-        ActiveAdmin::Dashboards.sections_for_namespace(namespace)
+        sections = ActiveAdmin::Dashboards.sections_for_namespace(namespace)        
+        sections.select do |section|
+          if section.options.has_key?(:if)
+            symbol_or_proc = section.options[:if]
+            case symbol_or_proc
+            when Symbol, String then self.send(symbol_or_proc)
+            when Proc           then instance_exec(&symbol_or_proc)
+            else symbol_or_proc
+            end
+          else
+            true
+          end
+        end
       end
-
+      
       def namespace
         class_name = self.class.name
         if class_name.include?('::')
@@ -30,7 +42,11 @@ module ActiveAdmin
 
       # Return the current menu for the view. This is a helper method
       def current_menu
-        ActiveAdmin.application.namespaces[namespace].menu
+        active_admin_namespace.menu
+      end
+
+      def active_admin_namespace
+        ActiveAdmin.application.namespace(namespace)
       end
 
     end

data/lib/active_admin/dsl.rb

@@ -15,14 +15,14 @@ module ActiveAdmin
 
     private
 
-    # The instance of ActiveAdmin::Resource that's being registered
+    # The instance of ActiveAdmin::Config 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
+    #     config.sort_order = "id_desc"
     #   end
     #
     def config
@@ -33,7 +33,7 @@ module ActiveAdmin
     # block, it will be eval'd in the controller
     #
     # Example:
-    #   
+    #
     #   ActiveAdmin.register Post do
     #
     #     controller do
@@ -49,51 +49,6 @@ module ActiveAdmin
       @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
-
     # Add a new action item to the resource
     #
     # @param [Hash] options valid keys include:
@@ -105,120 +60,12 @@ module ActiveAdmin
       config.add_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
+    def menu(options = {})
+      config.menu(options)
     end
 
     def sidebar(name, options = {}, &block)
       config.sidebar_sections << ActiveAdmin::SidebarSection.new(name, options, &block)
     end
-
-    # Configure the CSV format
-    #
-    # For example:
-    #
-    #   csv do
-    #     column :name
-    #     column("Author") { |post| post.author.full_name }
-    #   end
-    #
-    def csv(&block)
-      config.csv_builder = CSVBuilder.new(&block)
-    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
-
-
-    # Standard rails filters
-    delegate :before_filter, :skip_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

@@ -9,9 +9,11 @@ module ActiveAdmin
       @events = {}
     end
 
-    def subscribe(event, &block)
-      @events[event] ||= []
-      @events[event] << block
+    def subscribe(*event_names, &block)
+      event_names.each do |event|
+        @events[event] ||= []
+        @events[event] << block
+      end
     end
 
     def subscribers(event)

data/lib/active_admin/filter_form_builder.rb

@@ -0,0 +1,53 @@
+module ActiveAdmin
+  # This form builder defines methods to build filter forms such
+  # as the one found in the sidebar of the index page of a standard resource.
+  class FilterFormBuilder < FormBuilder
+
+    def filter(method, options = {})
+      return "" if method.nil? || method == ""
+      options[:as] ||= default_input_type(method)
+      return "" unless options[:as]
+      content = input(method, options)
+      form_buffers.last << content.html_safe if content
+    end
+
+    protected
+
+    # Returns the default filter type for a given attribute
+    def default_input_type(method, options = {})
+      if column = column_for(method)
+        case column.type
+        when :date, :datetime
+          return :date_range
+        when :string, :text
+          return :string
+        when :integer
+          return :select if reflection_for(method.to_s.gsub('_id','').to_sym)
+          return :numeric
+        when :float, :decimal
+          return :numeric
+        end
+      end
+
+      if reflection = reflection_for(method)
+        return :select if reflection.macro == :belongs_to && !reflection.options[:polymorphic]
+      end
+    end
+
+    def custom_input_class_name(as)
+      "ActiveAdmin::Inputs::Filter#{as.to_s.camelize}Input"
+    end
+
+    # Returns the column for an attribute on the object being searched
+    # if it exists. Otherwise returns nil
+    def column_for(method)
+      @object.base.columns_hash[method.to_s] if @object.base.respond_to?(:columns_hash)
+    end
+
+    # Returns the association reflection for the method if it exists
+    def reflection_for(method)
+      @object.base.reflect_on_association(method) if @object.base.respond_to?(:reflect_on_association)
+    end
+
+  end
+end

data/lib/active_admin/form_builder.rb

@@ -1,7 +1,5 @@
-require 'formtastic'
-
 module ActiveAdmin
-  class FormBuilder < ::Formtastic::SemanticFormBuilder
+  class FormBuilder < ::Formtastic::FormBuilder
 
     attr_reader :form_buffers
 
@@ -21,8 +19,6 @@ module ActiveAdmin
     # its contents, so we want to skip the internal buffering
     # while building up its contents
     def input(method, *args)
-      return if polymorphic_belongs_to_association?(method)
-      
       content = with_new_form_buffer { super }
       return content.html_safe unless @inputs_with_block
       form_buffers.last << content.html_safe
@@ -52,14 +48,6 @@ module ActiveAdmin
       content << cancel_link
     end
 
-    def datepicker_input(method, options)
-      options = options.dup
-      options[:input_html] ||= {}
-      options[:input_html][:class] = [options[:input_html][:class], "datepicker"].compact.join(' ')
-      options[:input_html][:size] ||= "10"
-      string_input(method, options)
-    end
-
     def has_many(association, options = {}, &block)
       options = { :for => association }.merge(options)
       options[:class] ||= ""
@@ -98,15 +86,33 @@ module ActiveAdmin
       form_buffers.last << content.html_safe
     end
 
-    private
+    protected
 
-    # Pass in a method to check if it's a polymorphic association
-    def polymorphic_belongs_to_association?(method)
-      reflection = reflection_for(method)
-      
-      reflection && reflection.macro == :belongs_to && reflection.options[:polymorphic]
+    def active_admin_input_class_name(as)
+      "ActiveAdmin::Inputs::#{as.to_s.camelize}Input"
     end
 
+    def input_class(as)
+      @input_classes_cache ||= {}
+      @input_classes_cache[as] ||= begin
+        begin
+          begin
+            custom_input_class_name(as).constantize
+          rescue NameError
+            begin
+              active_admin_input_class_name(as).constantize
+            rescue NameError
+              standard_input_class_name(as).constantize
+            end
+          end
+        rescue NameError
+          raise Formtastic::UnknownInputError
+        end
+      end
+    end
+
+    private
+
     def with_new_form_buffer
       form_buffers << "".html_safe
       return_value = yield