activeadmin 0.1.0

data/lib/active_admin/action_builder.rb

@@ -0,0 +1,60 @@
+module ActiveAdmin
+
+  # 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.
+  # 
+  module ActionBuilder
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def member_action(name, options = {}, &block)
+        active_admin_config.member_actions << ControllerAction.new(name, options)
+        define_method(name, &block || Proc.new{})
+      end
+
+      def clear_member_actions!
+        active_admin_config.clear_member_actions!
+      end
+
+
+      def collection_action(name, options = {}, &block)
+        active_admin_config.collection_actions << ControllerAction.new(name, options)
+        define_method(name, &block || Proc.new{})
+      end
+
+      def clear_collection_actions!
+        active_admin_config.clear_collection_actions!
+      end
+    end
+
+    class ControllerAction
+      attr_reader :name
+      def initialize(name, options = {})
+        @name, @options = name, options
+      end
+
+      def http_verb
+        @options[:method] ||= :get
+      end
+    end
+  end
+end

data/lib/active_admin/action_items.rb

@@ -0,0 +1,48 @@
+require 'active_admin/helpers/optional_display'
+
+module ActiveAdmin
+  module ActionItems
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.class_inheritable_accessor :action_items
+      base.action_items = []
+    end
+
+    module ClassMethods
+      def action_item(options = {}, &block)
+        self.action_items << ActiveAdmin::ActionItems::ActionItem.new(options, &block)
+      end
+
+      def clear_action_items!
+        self.action_items = []
+      end
+
+      def action_items_for(action)
+        action_items.select{|item| item.display_on?(action) }
+      end
+    end
+
+    class ActionItem
+      include ActiveAdmin::OptionalDisplay
+
+      attr_accessor :block
+
+      def initialize(options = {}, &block)
+        @options, @block = options, block
+        normalize_display_options!
+      end
+    end
+
+    class Renderer < ActiveAdmin::Renderer
+      def to_html(action_items)
+        content_tag :div, :class => 'action_items' do
+          action_items.collect do |action_item|
+            instance_eval(&action_item.block)
+          end.join(" ")
+        end
+      end
+    end
+
+  end
+end

data/lib/active_admin/asset_registration.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  module AssetRegistration
+
+    # Stylesheets
+
+    def register_stylesheet(name)
+      stylesheets << name
+    end
+
+    def stylesheets
+      @stylesheets ||= []
+    end
+
+    def clear_stylesheets!
+      @stylesheets = []
+    end
+
+
+    # Javascripts
+
+    def register_javascript(name)
+      javascripts << name
+    end
+
+    def javascripts
+      @javascripts ||= []
+    end
+
+    def clear_javascripts!
+      @javascripts = []
+    end
+    
+  end
+end

data/lib/active_admin/breadcrumbs.rb

@@ -0,0 +1,26 @@
+module ActiveAdmin
+  module Breadcrumbs
+    
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+      
+    protected
+
+    def add_breadcrumb(name, url = '')
+      @breadcrumbs ||= []
+      url = send(url) if url.is_a?(Symbol)
+      @breadcrumbs << [name, url]
+    end
+
+    module ClassMethods
+
+      def add_breadcrumb(name, url, options = {})
+        before_filter options do |controller|
+          controller.send(:add_breadcrumb, name, url)
+        end
+      end
+    
+    end
+  end
+end

data/lib/active_admin/dashboards.rb

@@ -0,0 +1,50 @@
+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
+
+    class << self
+
+      # Eval an entire block in the context of this module to build 
+      # dashboards quicker. 
+      #
+      # Example:
+      #
+      #   ActiveAdmin::Dashboards.build do
+      #     section "Recent Post" do
+      #       # return a list of posts
+      #     end
+      #   end
+      #
+      def build(&block)
+        module_eval(&block)
+      end
+
+      # Add a new dashboard section to a namespace. If no namespace is given
+      # it will be added to the default namespace.
+      def add_section(name, options = {}, &block)
+        namespace = options.delete(:namespace) || ActiveAdmin.default_namespace
+        self.sections[namespace] ||= [] 
+        self.sections[namespace] << Section.new(namespace, name, options, &block)
+        self.sections[namespace].sort!
+      end
+      alias_method :section, :add_section
+
+      def sections_for_namespace(namespace)
+        @@sections[namespace] || []
+      end
+
+      def clear_all_sections!
+        @@sections = {}
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/dashboards/dashboard_controller.rb

@@ -0,0 +1,40 @@
+module ActiveAdmin
+  module Dashboards
+    class DashboardController < ResourceController
+
+      # 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
+
+      protected
+
+      def set_current_tab
+        @current_tab = "Dashboard"
+      end
+
+      def find_sections
+        ActiveAdmin::Dashboards.sections_for_namespace(namespace)
+      end
+
+      def namespace
+        self.class.name.split('::').first.underscore.to_sym
+      end
+
+      # Return the current menu for the view. This is a helper method
+      def current_menu
+        ActiveAdmin.namespaces[namespace].menu
+      end
+
+      # Override to do nothing
+      def add_section_breadcrumb
+      end
+    end
+  end
+end

data/lib/active_admin/dashboards/renderer.rb

@@ -0,0 +1,45 @@
+module ActiveAdmin
+  module Dashboards
+    class Renderer < ::ActiveAdmin::Pages::Base
+
+      def main_content
+        if @dashboard_sections && @dashboard_sections.any?
+          render_sections(@dashboard_sections)
+        else
+          default_welcome_section
+        end
+      end
+
+      protected
+
+      def title
+        "Dashboard"
+      end
+
+      def render_sections(sections)
+        content_tag :table, :class => "dashboard" do
+          sections.in_groups_of(3, false).collect do |row|
+            content_tag :tr do
+              row.collect do |section| 
+                content_tag :td, render_section(section)
+              end.join
+            end
+          end.join
+        end
+      end
+
+      # Renders each section using their renderer
+      def render_section(section)
+        renderer = section.renderer.new(self)
+        renderer.to_html(section)
+      end
+
+      def default_welcome_section
+        content_tag :p, :id => "dashboard_default_message" do
+          "Welcome to Active Admin. This is the default dashboard page. To add dashboard sections, checkout 'app/admin/dashboards.rb'"
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/dashboards/section.rb

@@ -0,0 +1,43 @@
+module ActiveAdmin
+  module Dashboards
+    class Section
+
+      @@renderers = {
+        :default => SectionRenderer
+      }
+      cattr_accessor :renderers
+
+      DEFAULT_PRIORITY = 10
+
+      attr_accessor :name, :block
+      attr_reader :namespace
+
+      def initialize(namespace, name, options = {}, &block)
+        @namespace = namespace
+        @name = name
+        @options = options
+        @block = block
+      end
+
+      def priority
+        @options[:priority] || DEFAULT_PRIORITY
+      end
+
+      # Sort by priority then by name
+      def <=>(other)
+        result = priority <=> other.priority
+        result = name.to_s <=> other.name.to_s if result == 0
+        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/dashboards/section_renderer.rb

@@ -0,0 +1,28 @@
+module ActiveAdmin
+  module Dashboards
+    class SectionRenderer < ::ActiveAdmin::Renderer
+
+      def to_html(section)
+        @section = section
+        content_tag :div, title_wrapped + content_wrapped, :class => 'dashboard_section', :id => "#{section.name.to_s.downcase.gsub(' ', '_')}_dashboard_section"
+      end
+
+      def title_wrapped
+        content_tag :h3, title
+      end
+
+      def title
+        @section.name.to_s.titleize
+      end
+
+      def content_wrapped
+        content_tag :div, content, :class => 'dashboard_section_content'
+      end
+
+      def content
+        instance_eval(&@section.block)
+      end
+
+    end
+  end
+end

data/lib/active_admin/filters.rb

@@ -0,0 +1,189 @@
+module ActiveAdmin
+  module Filters
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :helper_method, :filters_config
+    end
+
+    module ClassMethods
+      def filter(attribute, options = {})
+        return false if attribute.nil?
+        @filters ||= []
+        @filters << options.merge(:attribute => attribute)
+      end
+
+      def filters_config
+        @filters && @filters.any? ? @filters : default_filters_config
+      end
+
+      def reset_filters!
+        @filters = []
+      end
+
+      # Returns a sane set of filters by default for the object
+      def default_filters_config
+        default_association_filters + default_content_filters
+      end
+
+      # Returns a default set of filters for the associations
+      def default_association_filters
+        if resource_class.respond_to?(:reflections)
+          resource_class.reflections.collect{|name, r| { :attribute => name }}
+        else
+          []
+        end
+      end
+
+      # Returns a default set of filters for the content columns
+      def default_content_filters
+        if resource_class.respond_to?(:content_columns)
+          resource_class.content_columns.collect{|c| { :attribute => c.name.to_sym } }
+        else
+          []
+        end
+      end
+    end
+
+
+    def filters_config
+      self.class.filters_config
+    end
+
+
+    class FormBuilder < FormBuilder
+    
+      def filter(method, options = {})
+        return "" if method.nil? || method == ""
+        options[:as] ||= default_filter_type(method)
+        return "" unless options[:as]
+        content = skip_form_buffers do
+          send("filter_#{options.delete(:as)}_input", method, options)
+        end
+        @form_buffers.last << template.content_tag(:div, content, :class => "filter-form-field")
+      end
+
+      protected
+
+      def filter_string_input(method, options = {})
+        field_name = "#{method}_contains"
+
+        [ label(field_name, "Search #{method.to_s.titlecase}"),
+          text_field(field_name)
+        ].join("\n").html_safe
+      end
+
+      def filter_date_range_input(method, options = {})
+        gt_field_name = "#{method}_gte"
+        lt_field_name = "#{method}_lte"
+
+        [ label(gt_field_name, method.to_s.titlecase),
+          filter_date_text_field(gt_field_name),
+          " - ",
+          filter_date_text_field(lt_field_name)
+        ].join("\n").html_safe
+      end
+
+      def filter_date_text_field(method)
+        current_value = @object.send(method)
+        text_field(method, :size => 12, :class => "datepicker", :max => 10, :value => current_value.respond_to?(:strftime) ? current_value.strftime("%Y-%m-%d") : "")
+      end
+
+      def filter_numeric_input(method, options = {})
+        filters = numeric_filters_for_method(method, options.delete(:filters) || default_numeric_filters)
+        current_filter = current_numeric_scope(filters)
+        filter_select = @template.select_tag '', @template.options_for_select(filters, current_filter), 
+                                    :onchange => "document.getElementById('#{method}_numeric').name = 'q[' + this.value + ']';"
+        filter_input = text_field current_filter, :size => 10, :id => "#{method}_numeric"
+
+        [ label(method),
+          filter_select,
+          " ",
+          filter_input
+        ].join("\n").html_safe
+      end
+      
+      def numeric_filters_for_method(method, filters)
+        filters.collect{|scope| [scope[0], [method,scope[1]].join("_") ] }
+      end
+
+      # Returns the scope for which we are currently searching. If no search is available
+      # it returns the first scope
+      def current_numeric_scope(filters)
+        filters[1..-1].inject(filters.first){|a,b| object.send(b[1].to_sym) ? b : a }[1]
+      end
+
+      def default_numeric_filters
+        [['Equal To', 'eq'], ['Greater Than', 'gt'], ['Less Than', 'lt']]
+      end
+
+      def filter_select_input(method, options = {})
+        association_name = method.to_s.gsub(/_id$/, '').to_sym
+        input_name = (generate_association_input_name(method).to_s + "_eq").to_sym
+        collection = find_collection_for_column(association_name, options)
+
+        [ label(input_name, method.to_s.titlecase),
+          select(input_name, collection, options.merge(:include_blank => 'Any'))
+        ].join("\n").html_safe
+      end
+
+      def filter_check_boxes_input(method, options = {})
+        input_name = (generate_association_input_name(method).to_s + "_in").to_sym
+        collection = find_collection_for_column(method, options)
+        selected_values = @object.send(input_name) || []
+        checkboxes = collection.map do |c|
+          label = c.is_a?(Array) ? c.first : c
+          value = c.is_a?(Array) ? c.last : c
+          "<label><input type=\"checkbox\" name=\"q[#{input_name}][]\" value=\"#{value}\" #{selected_values.include?(value) ? "checked" : ""}/> #{label}</label>"
+        end.join("\n").html_safe
+
+        [ label(input_name, method.to_s.titlecase),
+          checkboxes
+        ].join("\n").html_safe
+      end
+
+      # Override the standard finder to accept a proc
+      def find_collection_for_column(method, options = {})
+        options = options.dup
+        case options[:collection]
+        when Proc
+          options[:collection] = options[:collection].call
+        end
+        super(method, options)
+      end
+
+      # Returns the default filter type for a given attribute
+      def default_filter_type(method)
+        if column = column_for(method)
+          case column.type
+          when :date, :datetime
+            return :date_range
+          when :string, :text
+            return :string
+          when :integer
+            return :select if method.to_s =~ /_id$/
+            return :numeric
+          when :float, :decimal
+            return :numeric
+          end
+        end
+
+        if reflection = reflection_for(method)
+          return :select if reflection.macro == :belongs_to
+        end
+      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
+end