saulolso-activeadmin 0.2.2

data/lib/active_admin/csv_builder.rb

@@ -0,0 +1,45 @@
+module ActiveAdmin
+  # CSVBuilder stores CSV configuration
+  #
+  # Usage example:
+  #
+  #   csv_builder = CSVBuilder.new
+  #   csv_builder.column :id
+  #   csv_builder.column("Name") { |resource| resource.full_name }
+  #
+  class CSVBuilder
+
+    # Return a default CSVBuilder for a resource
+    # The CSVBuilder's columns would be Id followed by this
+    # resource's content columns
+    def self.default_for_resource(resource)
+      new.tap do |csv_builder|
+        csv_builder.column(:id)
+        resource.content_columns.each do |content_column|
+          csv_builder.column(content_column.name.to_sym)
+        end
+      end
+    end
+
+    attr_reader :columns
+
+    def initialize(&block)
+      @columns = []
+      instance_eval &block if block_given?
+    end
+
+    # Add a column
+    def column(name, &block)
+      @columns << Column.new(name, block)
+    end
+
+    class Column
+      attr_reader :name, :data
+      
+      def initialize(name, block = nil)
+        @name = name.is_a?(Symbol) ? name.to_s.titleize : name
+        @data = block || name.to_sym
+      end
+    end
+  end
+end

data/lib/active_admin/dashboards/dashboard_controller.rb

@@ -0,0 +1,47 @@
+module ActiveAdmin
+  module Dashboards
+    class DashboardController < ResourceController
+
+      before_filter :skip_sidebar!
+
+      actions :index
+
+      clear_action_items!
+
+      def index
+        @dashboard_sections = find_sections
+      end
+
+      protected
+
+      # Override _prefix so we force ActionController to render
+      # the views from active_admin/dashboard instead of default path.
+      def _prefix
+        'active_admin/dashboard'
+      end
+
+      def set_current_tab
+        @current_tab = "Dashboard"
+      end
+
+      def find_sections
+        ActiveAdmin::Dashboards.sections_for_namespace(namespace)
+      end
+
+      def namespace
+        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
+      def current_menu
+        ActiveAdmin.application.namespaces[namespace].menu
+      end
+
+    end
+  end
+end

data/lib/active_admin/dashboards/section.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  module Dashboards
+    class Section
+
+      DEFAULT_PRIORITY = 10
+
+      attr_accessor :name, :block
+      attr_reader :namespace, :options
+
+      def initialize(namespace, name, options = {}, &block)
+        @namespace = namespace
+        @name = name
+        @options = options
+        @block = block
+      end
+
+      def priority
+        @options[:priority] || DEFAULT_PRIORITY
+      end
+
+      def icon
+        @options[:icon]
+      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
+
+    end
+  end
+end

data/lib/active_admin/dashboards.rb

@@ -0,0 +1,48 @@
+module ActiveAdmin
+  module Dashboards
+
+    autoload :DashboardController,  'active_admin/dashboards/dashboard_controller'
+    autoload :Section,              'active_admin/dashboards/section'
+
+    @@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.application.default_namespace || :root
+        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/devise.rb

@@ -0,0 +1,43 @@
+require 'devise'
+
+module ActiveAdmin
+  module Devise
+
+    def self.config
+      {
+        :path => ActiveAdmin.application.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.application.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,215 @@
+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
+
+    # 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
+
+    # 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

@@ -0,0 +1,109 @@
+require 'formtastic'
+
+module ActiveAdmin
+  class FormBuilder < ::Formtastic::SemanticFormBuilder
+
+    attr_reader :form_buffers
+
+    def initialize(*args)
+      @form_buffers = ["".html_safe]
+      super
+    end
+
+    def inputs(*args, &block)
+      # Store that we are creating inputs without a block
+      @inputs_with_block = block_given? ? true : false
+      content = with_new_form_buffer { super }
+      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)
+      content = with_new_form_buffer { super }
+      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 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 I18n.t('active_admin.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] ||= {}
+      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] ||= ""
+      options[:class] << "inputs has_many_fields"
+
+      # 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 I18n.t('active_admin.has_many_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 I18n.t('active_admin.has_many_new', :model => 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
+
+    private
+
+    def with_new_form_buffer
+      form_buffers << "".html_safe
+      return_value = yield
+      form_buffers.pop
+      return_value
+    end
+
+  end
+end

data/lib/active_admin/helpers/optional_display.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  
+  # Shareable module to give a #display_on?(action) method
+  # which returns true or false depending on an options hash.
+  #
+  # The options hash accepts:
+  #
+  # :only => :index
+  # :only => [:index, :show]
+  # :except => :index
+  # :except => [:index, :show]
+  #
+  # call #normalize_display_options! after @options has been set
+  # to ensure that the display options are setup correctly
+
+  module OptionalDisplay
+    def display_on?(action)
+      return @options[:only].include?(action.to_sym) if @options[:only]
+      return !@options[:except].include?(action.to_sym) if @options[:except]
+      true
+    end
+
+    private
+
+    def normalize_display_options!
+      if @options[:only]
+        @options[:only] = @options[:only].is_a?(Array) ? @options[:only] : [@options[:only]]
+      end
+      if @options[:except]
+        @options[:except] = @options[:except].is_a?(Array) ? @options[:except] : [@options[:except]]
+      end
+    end
+  end
+end