activeadmin 0.1.0

data/lib/active_admin/resource_controller.rb

@@ -0,0 +1,325 @@
+require 'inherited_views'
+require 'active_admin/pages'
+
+module ActiveAdmin
+  class ResourceController < ::InheritedViews::Base
+
+    # Add our views to the view path
+    ActionController::Base.append_view_path File.expand_path('../views', __FILE__)
+    self.default_views = 'active_admin_default'
+    
+    helper ::ActiveAdmin::ViewHelpers
+
+    layout 'active_admin'
+    
+    class_inheritable_accessor :form_config
+
+    include ActiveAdmin::Breadcrumbs
+    include ActiveAdmin::Sidebar
+    include ActiveAdmin::ActionItems
+    include ActiveAdmin::Filters
+    include ActiveAdmin::ActionBuilder
+
+    respond_to :html, :xml, :json
+    respond_to :csv, :only => :index
+
+    add_breadcrumb "Dashboard", "/admin"
+
+    before_filter :add_section_breadcrumb
+    before_filter :set_current_tab
+    before_filter :setup_pagination_for_csv
+
+    class << self
+      # Reference to the Resource object which initialized
+      # this controller
+      attr_accessor :active_admin_config
+      
+      def active_admin_config=(config)
+        @active_admin_config = config
+        defaults :resource_class => config.resource
+      end
+
+      def set_page_config(page, config)
+        active_admin_config.page_configs[page] = config
+      end
+
+      def get_page_config(page)
+        active_admin_config.page_configs[page]
+      end
+
+      def reset_page_config!(page)
+        active_admin_config.page_configs[page] = nil
+      end
+
+
+      # Setting the menu options
+      def menu(options = {})
+        active_admin_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
+
+        active_admin_config.scope_to = block_given? ? block : method
+        active_admin_config.scope_to_association_method = options[:association_method]
+      end
+     
+      #
+      # Index Config
+      #
+
+      # Configure the index page for the resource
+      def index(options = {}, &block)
+        options[:as] ||= :table
+        set_page_config :index, ActiveAdmin::PageConfig.new(options, &block)
+      end
+
+      # Configure the show page for the resource
+      def show(options = {}, &block)
+        set_page_config :show, ActiveAdmin::PageConfig.new(options, &block)
+      end
+
+      # Define the getting and re-setter for each configurable page
+      [:index, :show].each do |page|
+        # eg: index_config
+        define_method :"#{page}_config" do
+          get_page_config(page)
+        end
+
+        # eg: reset_index_config!
+        define_method :"reset_#{page}_config!" do
+          reset_page_config! page
+        end
+      end
+
+
+      #
+      # Form Config
+      #
+
+      def form(options = {}, &block)
+        options[:block] = block
+        self.form_config = options
+      end
+
+      def form_config
+        read_inheritable_attribute(:form_config) || default_form_config
+      end
+
+      def reset_form_config!
+        self.form_config = nil
+      end
+
+      def default_form_config
+        config = {}
+        config[:block] = lambda do |f|
+          f.inputs
+          f.buttons
+        end
+        config
+      end
+      
+    end
+
+    # Default Sidebar Sections
+    sidebar :filters, :only => :index do
+      active_admin_filters_form_for @search, filters_config
+    end
+
+    # Default Action Item Links
+    action_item :only => :show do
+      if controller.public_methods.include?('edit')
+        link_to "Edit #{active_admin_config.resource_name}", edit_resource_path(resource)
+      end
+    end
+
+    action_item :only => :show do
+      if controller.public_methods.include?("destroy")
+        link_to "Delete #{active_admin_config.resource_name}",
+          resource_path(resource), 
+          :method => :delete, :confirm => "Are you sure you want to delete this?"
+      end
+    end
+
+    action_item :except => [:new, :show] do
+      if controller.public_methods.include?('new')
+        link_to "New #{active_admin_config.resource_name}", new_resource_path
+      end
+    end
+
+    #
+    # Actions
+    #
+    
+    def index
+      index! do |format|
+        format.html { render_or_default 'index' }
+        format.csv { 
+          @csv_columns = resource_class.columns.collect{ |column| column.name.to_sym }
+          render_or_default 'index' 
+        }
+      end
+    end
+        
+    private
+
+    def collection
+      get_collection_ivar || set_collection_ivar(active_admin_collection)
+    end
+
+    def active_admin_collection
+      chain = scoped_collection
+      chain = sort_order(chain)
+      chain = search(chain)
+      chain = paginate(chain)
+      chain
+    end
+
+    # Override this method in your controllers to modify the start point
+    # of our searches and index.
+    #
+    # This method should return an ActiveRecord::Relation object so that
+    # the searching and filtering can be applied on top
+    def scoped_collection
+      end_of_association_chain
+    end
+
+    def begin_of_association_chain
+      return nil unless active_admin_config.scope_to
+      case active_admin_config.scope_to
+      when Proc
+        instance_eval &active_admin_config.scope_to
+      when Symbol
+        send active_admin_config.scope_to
+      else
+        raise ArgumentError, "#scope_to accepts a symbol or a block"
+      end
+    end
+
+    # Overriding from InheritedResources::BaseHelpers
+    #
+    # Returns the method for the association chain when using
+    # the scope_to option
+    def method_for_association_chain
+      active_admin_config.scope_to_association_method || super
+    end
+
+    # Allow more records for csv files
+    def setup_pagination_for_csv
+      @per_page = 10_000 if request.format == 'text/csv'
+    end
+
+    def paginate(chain)
+      chain.paginate(:page => params[:page], :per_page => @per_page || ActiveAdmin.default_per_page)
+    end
+
+    def sort_order(chain)
+      params[:order] ||= active_admin_config.sort_order
+      if params[:order] && params[:order] =~ /^([\w\_\.]+)_(desc|asc)$/
+        chain.order("#{$1} #{$2}")
+      else
+        chain # just return the chain
+      end
+    end
+
+    def search(chain)
+      @search = chain.search(clean_search_params(params[:q]))
+    end
+
+    def clean_search_params(search_params)
+      return {} unless search_params.is_a?(Hash)
+      search_params = search_params.dup
+      search_params.delete_if do |key, value|
+        value == ""
+      end
+      search_params
+    end
+    
+    # Gets called as a before filter to set the section's breadcrumb
+    def add_section_breadcrumb
+      add_breadcrumb active_admin_config.plural_resource_name, collection_path 
+    end
+
+    # Set's @current_tab to be name of the tab to mark as current
+    # Get's called through a before filter
+    def set_current_tab
+      @current_tab = active_admin_config.parent_menu_item_name || 
+                        active_admin_config.menu_item_name
+    end
+
+    def active_admin_config
+      self.class.active_admin_config
+    end
+    helper_method :active_admin_config
+
+    def index_config
+      @index_config ||= self.class.index_config
+    end
+    helper_method :index_config
+
+    def show_config
+      @show_config ||= self.class.show_config
+    end
+    helper_method :show_config
+
+    def form_config
+      @form_config ||= self.class.form_config
+    end
+    helper_method :form_config
+
+    def current_menu
+      active_admin_config.namespace.menu
+    end
+    helper_method :current_menu
+
+    def skip_sidebar!
+      @skip_sidebar = true
+    end
+    helper_method :skip_sidebar!
+
+    def skip_sidebar?
+      @skip_sidebar == true
+    end
+    helper_method :skip_sidebar?
+
+    # Returns the renderer class to use for the given action.
+    #
+    # TODO: This needs to be wrapped into a default config as well
+    # as overrideable on each controller
+    def renderer_for(action)
+      {
+        :index  => ::ActiveAdmin::Pages::Index,
+        :new    => ::ActiveAdmin::Pages::New,
+        :show   => ::ActiveAdmin::Pages::Show,
+        :edit   => ::ActiveAdmin::Pages::Edit
+      }[action]
+    end
+    helper_method :renderer_for
+
+  end
+end

data/lib/active_admin/sidebar.rb

@@ -0,0 +1,78 @@
+require 'active_admin/helpers/optional_display'
+
+module ActiveAdmin
+  module Sidebar
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.class_inheritable_accessor :sidebar_sections
+      base.sidebar_sections = []
+    end
+
+    module ClassMethods
+
+      def sidebar(name, options = {}, &block)
+        self.sidebar_sections << ActiveAdmin::Sidebar::Section.new(name, options, &block)
+      end
+
+      def clear_sidebar_sections!
+        self.sidebar_sections = []
+      end
+
+      def sidebar_sections_for(action)
+        sidebar_sections.select{|section| section.display_on?(action) }
+      end
+    end
+
+    class Section
+      include ActiveAdmin::OptionalDisplay
+  
+      attr_accessor :name, :options, :block
+
+      def initialize(name, options = {}, &block)
+        @name, @options, @block = name, options, block
+        normalize_display_options!
+      end
+
+      # The id gets used for the div in the view
+      def id
+        name.to_s.downcase.underscore + '_sidebar_section'
+      end
+
+      # The title gets displayed within the section in the view
+      def title
+        name.to_s.titlecase
+      end
+
+      # If a block is not passed in, the name of the partial to render
+      def partial_name
+        options[:partial] || "#{name.to_s.downcase.gsub(' ', '_')}_sidebar"
+      end
+    end
+
+    class Renderer < ActiveAdmin::Renderer
+      def to_html(sidebar_sections)
+        sidebar_sections.collect do |section|
+          title   = content_tag :h3, section.title
+          content = content_tag :div, sidebar_content(section)
+
+          content_tag :div, :class => 'sidebar_section', :id => section.id do
+            title + content
+          end
+        end.join
+      end
+
+      # If a block exists, render the block. Otherwise render a partial
+      def sidebar_content(section)
+        if section.block
+          instance_eval(&section.block)
+        else
+          capture do
+            render section.partial_name
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/active_admin/table_builder.rb

@@ -0,0 +1,162 @@
+module ActiveAdmin
+  class TableBuilder
+    
+    attr_reader :columns
+    
+    def initialize
+      @columns = []
+      yield self if block_given?
+    end
+    
+    def column(*args, &block)
+      @columns << Column.new(*args, &block)
+    end
+
+    # This method allows you to add many columns at
+    # once or returns the list of all columns.
+    # 
+    # TableBuilder.new do |t|
+    #   t.columns :first, :second, :third
+    # end
+    # 
+    # OR
+    #
+    # builder.columns #=> [:first, :second, :third]
+    def columns(first_column = nil, *more)
+      return @columns unless first_column 
+      [first_column, more].flatten.each do |c|
+        column(c)
+      end
+    end
+
+    # Helper method to quickly render a table builder
+    def to_html(view, collection, options)
+      Renderer.new(view).to_html(self, collection, options)
+    end
+
+    class Renderer < ActiveAdmin::Renderer
+      def to_html(builder, collection, options = {})
+        @builder, @collection = builder, collection
+        @sortable = options.delete(:sortable) || false
+        table_options = {
+          :border => 0, 
+          :cellpadding => 0, 
+          :cellspacing => 0            
+        }.merge(options)
+        content_tag :table, table_options do
+          table_head + table_body
+        end
+      end
+
+      def columns
+        @columns ||= @builder.columns.select do |column|
+          instance_eval &column.conditional_block
+        end
+      end
+
+      def sortable?
+        @sortable
+      end
+
+      def table_head
+        content_tag :thead do
+          columns.collect do |column|
+            if sortable? && column.sortable?
+              sortable_header_for column.title, column.sort_key
+            else
+              content_tag :th, column.title
+            end
+          end.join
+        end
+      end
+
+      def table_body
+        content_tag :tbody do
+          @collection.collect{|item| table_row(item) }.join
+        end
+      end
+
+      def table_row(item)
+        content_tag :tr, :class => cycle('odd', 'even') do
+          columns.collect{|column| table_cell(column, item) }.join
+        end
+      end
+
+      def resource
+        @resource
+      end
+
+      def table_cell(column, item)
+        row_content = call_method_or_proc_on(item, column.data) || ""
+        l(row_content) if [Date, DateTime, Time].include?(row_content)
+        content_tag :td, row_content
+      end
+
+    end
+
+    class Column
+      
+      attr_accessor :title, :data
+      
+      def initialize(*args, &block)
+        @options = default_options.merge(args.last.is_a?(::Hash) ? args.pop : {})
+        @title = pretty_title args[0]
+        @data  = args[1] || args[0]
+        @data = block if block
+      end
+
+      def sortable?
+        if @data.is_a?(Proc)
+          [String, Symbol].include?(@options[:sortable].class)
+        else
+          @options[:sortable]
+        end
+      end
+      
+      #
+      # Returns the key to be used for sorting this column
+      #
+      # Defaults to the column's method if its a symbol
+      #   column :username
+      #   # => Sort key will be set to 'username'
+      #
+      # You can set the sort key by passing a string or symbol
+      # to the sortable option:
+      #   column :username, :sortable => 'other_column_to_sort_on'
+      #
+      # If you pass a block to be rendered for this column, the column
+      # will not be sortable unless you pass a string to sortable to 
+      # sort the column on:
+      #
+      #   column('Username', :sortable => 'login'){ @user.pretty_name }
+      #   # => Sort key will be 'login'
+      #   
+      def sort_key
+        if @options[:sortable] == true || @options[:sortable] == false
+          @data.to_s
+        else
+          @options[:sortable].to_s
+        end
+      end
+
+      def conditional_block
+        @options[:if]
+      end
+      
+      private
+      
+      def pretty_title(raw)
+        raw.is_a?(Symbol) ? raw.to_s.split('_').collect{|s| s.capitalize }.join(' ') : raw
+      end
+
+      def default_options
+        {
+          :sortable => true,
+          :if => proc{ true }
+        }
+      end
+      
+    end
+        
+  end
+end