aa-rails4 0.6.0

data/lib/active_admin/views/dashboard_section_renderer.rb

@@ -0,0 +1,19 @@
+module ActiveAdmin
+  module Views
+    class DashboardSection < ActiveAdmin::Views::Panel
+
+      def build(section)
+        @section = section
+        super(title, :icon => @section.icon)
+        instance_eval &@section.block
+      end
+
+      protected
+
+      def title
+        I18n.t("active_admin.sections.#{@section.name.to_s}", :default => @section.name.to_s.titleize)
+      end
+
+    end
+  end
+end

data/lib/active_admin/views/footer.rb

@@ -0,0 +1,20 @@
+module ActiveAdmin
+  module Views
+    class Footer < Component
+
+      def build
+        super :id => "footer"
+        powered_by_message
+      end
+
+      private
+
+      def powered_by_message
+        para I18n.t('active_admin.powered_by',
+          :active_admin => link_to("Active Admin", "http://www.activeadmin.info"),
+          :version => ActiveAdmin::VERSION).html_safe
+      end
+
+    end
+  end
+end

data/lib/active_admin/views/header.rb

@@ -0,0 +1,32 @@
+module ActiveAdmin
+  module Views
+    class Header < Component
+
+      def build(namespace, menu)
+        super(:id => "header")
+
+        @namespace = namespace
+        @menu = menu
+        @utility_menu = @namespace.fetch_menu(:utility_navigation)
+
+        build_site_title
+        build_global_navigation
+        build_utility_navigation
+      end
+
+
+      def build_site_title
+        insert_tag view_factory.site_title, @namespace
+      end
+
+      def build_global_navigation
+        insert_tag view_factory.global_navigation, @menu, :class => 'header-item tabs'
+      end
+
+      def build_utility_navigation
+        insert_tag view_factory.utility_navigation, @utility_menu, :id => "utility_nav", :class => 'header-item tabs'
+      end
+
+    end
+  end
+end

data/lib/active_admin/views/index_as_block.rb

@@ -0,0 +1,36 @@
+module ActiveAdmin
+  module Views
+
+    # = Index as a Block
+    #
+    # If you want to fully customize the display of your resources on the index
+    # screen, Index as a Block allows you to render a block of content for each
+    # resource.
+    #
+    #     index :as => :block do |product|
+    #       div :for => product do
+    #         resource_selection_cell product
+    #         h2 auto_link(product.title)
+    #         div do
+    #           simple_format product.description
+    #         end
+    #       end
+    #     end
+    #
+    class IndexAsBlock < ActiveAdmin::Component
+
+      def build(page_presenter, collection)
+        add_class "index"
+        resource_selection_toggle_panel if active_admin_config.batch_actions.any?
+        collection.each do |obj|
+          instance_exec(obj, &page_presenter.block)
+        end
+      end
+
+      def self.index_name
+        "block"
+      end
+
+    end
+  end
+end

data/lib/active_admin/views/index_as_blog.rb

@@ -0,0 +1,150 @@
+module ActiveAdmin
+  module Views
+
+    # = Index as Blog
+    #
+    # Render your index page as a set of posts. The post has two main options:
+    # title and body.
+    #
+    #     index :as => :blog do
+    #       title :my_title # Calls #my_title on each resource
+    #       body  :my_body  # Calls #my_body on each resource
+    #     end
+    #
+    # == Post Title
+    #
+    # The title is the content that will be rendered within a link to the
+    # resource. There are two main ways to set the content for the title
+    #
+    # First, you can pass in a method to be called on your
+    # resource. For example:
+    #
+    #     index :as => :blog do
+    #       title :a_method_to_call
+    #     end
+    #
+    # This will result in the title of the post being the return value of
+    # Resource#a_method_to_call
+    #
+    # Second, you can pass a block to the tile option which will then be
+    # used as the contents fo the title. The resource being rendered
+    # is passed in to the block. For Example:
+    #
+    #     index :as => :blog do
+    #       title do |post|
+    #         span post.title, :class => 'title'
+    #         span post.created_at, :class => 'created_at'
+    #       end
+    #     end
+    #
+    # == Post Body
+    #
+    # The body is rendered underneath the title of each post. The same two
+    # style of options work as the Post Title above.
+    #
+    # Call a method on the resource as the body:
+    #
+    #     index :as => :blog do
+    #       title :my_title
+    #       body :my_body # Return value of #my_body will be the body
+    #     end
+    #
+    # Or, render a block as the body:
+    #
+    #     index :as => :blog do
+    #       title :my_title
+    #       body do |post|
+    #         div truncate(post.title)
+    #         div :class => 'meta' do
+    #           span "Post in #{post.categories.join(', ')}"
+    #         end
+    #       end
+    #     end
+    #
+    class IndexAsBlog < ActiveAdmin::Component
+
+      def build(page_presenter, collection)
+        @page_presenter = page_presenter
+        @collection = collection
+
+        # Call the block passed in. This will set the
+        # title and body methods
+        instance_eval &page_presenter.block if page_presenter.block
+
+        add_class "index"
+        build_posts
+      end
+
+      # Setter method for the configuration of the title
+      def title(method = nil, &block)
+        if block_given? || method
+          @title = block_given? ? block : method
+        end
+        @title
+      end
+
+
+      # Setter method for the configuration of the body
+      #
+      def body(method = nil, &block)
+        if block_given? || method
+          @body = block_given? ? block : method
+        end
+        @body
+      end
+
+      def self.index_name
+        "blog"
+      end
+
+      private
+
+      def build_posts
+        resource_selection_toggle_panel if active_admin_config.batch_actions.any?
+        @collection.each do |post|
+          build_post(post)
+        end
+      end
+
+      def build_post(post)
+        div :for => post do
+          resource_selection_cell(post) if active_admin_config.batch_actions.any?
+          build_title(post)
+          build_body(post)
+        end
+      end
+
+      def build_title(post)
+        if @title
+          h3 do
+            a(:href => resource_path(post)) do
+             render_method_on_post_or_call_proc post, @title
+            end
+          end
+        else
+          h3 do
+            auto_link(post)
+          end
+        end
+      end
+
+      def build_body(post)
+        if @body
+          div :class => 'content' do
+            render_method_on_post_or_call_proc post, @body
+          end
+        end
+      end
+
+      def render_method_on_post_or_call_proc(post, proc)
+        case proc
+        when String,Symbol
+          post.send proc
+        else
+          instance_exec post, &proc
+        end
+      end
+
+    end # Posts
+  end
+end

data/lib/active_admin/views/index_as_grid.rb

@@ -0,0 +1,76 @@
+module ActiveAdmin
+  module Views
+
+     # = Index as a Grid
+     #
+     # Sometimes you want to display the index screen for a set of resources as a grid
+     # (possibly a grid of thumbnail images). To do so, use the :grid option for the
+     # index block.
+     #
+     #     index :as => :grid do |product|
+     #       link_to(image_tag(product.image_path), admin_products_path(product))
+     #     end
+     #
+     # The block is rendered within a cell in the grid once for each resource in the
+     # collection. The resource is passed into the block for you to use in the view.
+     #
+     # You can customize the number of colums that are rendered using the columns
+     # option:
+     #
+     #     index :as => :grid, :columns => 5 do |product|
+     #       link_to(image_tag(product.image_path), admin_products_path(product))
+     #     end
+     #
+     class IndexAsGrid < ActiveAdmin::Component
+
+      def build(page_presenter, collection)
+        @page_presenter = page_presenter
+        @collection = collection
+        add_class "index"
+        build_table
+      end
+
+      def number_of_columns
+        @page_presenter[:columns] || default_number_of_columns
+      end
+
+      def self.index_name
+        "grid"
+      end
+
+      protected
+
+      def build_table
+        resource_selection_toggle_panel if active_admin_config.batch_actions.any?
+        table :class => "index_grid" do
+          collection.in_groups_of(number_of_columns).each do |group|
+            build_row(group)
+          end
+        end
+      end
+
+      def build_row(group)
+        tr do
+          group.each do |item|
+            item ? build_item(item) : build_empty_cell
+          end
+        end
+      end
+
+      def build_item(item)
+        td :for => item do
+          instance_exec(item, &@page_presenter.block)
+        end
+      end
+
+      def build_empty_cell
+        td '&nbsp;'.html_safe
+      end
+
+      def default_number_of_columns
+        3
+      end
+
+    end
+  end
+end

data/lib/active_admin/views/index_as_table.rb

@@ -0,0 +1,238 @@
+module ActiveAdmin
+  module Views
+
+    # = Index as a Table
+    #
+    # By default, the index page is a table with each of the models content columns and links to
+    # show, edit and delete the object. There are many ways to customize what gets
+    # displayed.
+    #
+    # == Defining Columns
+    #
+    # To display an attribute or a method on a resource, simply pass a symbol into the
+    # column method:
+    #
+    #     index do
+    #       selectable_column
+    #       column :title
+    #     end
+    #
+    # If the default title does not work for you, pass it as the first argument:
+    #
+    #     index do
+    #       selectable_column
+    #       column "My Custom Title", :title
+    #     end
+    #
+    # Sometimes calling methods just isn't enough and you need to write some view
+    # specific code. For example, say we wanted a colum called Title which holds a
+    # link to the posts admin screen.
+    #
+    # The column method accepts a block as an argument which will then be rendered
+    # within the context of the view for each of the objects in the collection.
+    #
+    #     index do
+    #       selectable_column
+    #       column "Title" do |post|
+    #         link_to post.title, admin_post_path(post)
+    #       end
+    #     end
+    #
+    # The block gets called once for each resource in the collection. The resource gets passed into
+    # the block as an argument.
+    #
+    # To setup links to View, Edit and Delete a resource, use the default_actions method:
+    #
+    #     index do
+    #       selectable_column
+    #       column :title
+    #       default_actions
+    #     end
+    #
+    # Alternatively, you can create a column with custom links:
+    #
+    #     index do
+    #       selectable_column
+    #       column :title
+    #       column "Actions" do |post|
+    #         link_to "View", admin_post_path(post)
+    #       end
+    #     end
+    #
+    #
+    # == Sorting
+    #
+    # When a column is generated from an Active Record attribute, the table is
+    # sortable by default. If you are creating a custom column, you may need to give
+    # Active Admin a hint for how to sort the table.
+    #
+    # If a column is defined using a block, you must pass the key to turn on sorting. The key
+    # is the attribute which gets used to sort objects using Active Record.
+    #
+    # By default, this is the column on the resource's table that the attribute corresponds to.
+    # Otherwise, any attribute that the resource collection responds to can be used.
+    #
+    #     index do
+    #       column "Title", :sortable => :title do |post|
+    #         link_to post.title, admin_post_path(post)
+    #       end
+    #     end
+    #
+    # You can also sort using an attribute on another table by passing the table name
+    # and the attribute separated by a dot:
+    #
+    #     index do
+    #       column :title, :sortable => 'categories.name'
+    #     end
+    #
+    # You can turn off sorting on any column by passing false:
+    #
+    #     index do
+    #       column :title, :sortable => false
+    #     end
+    #
+    # == Showing and Hiding Columns
+    #
+    # The entire index block is rendered within the context of the view, so you can
+    # easily do things that show or hide columns based on the current context.
+    #
+    # For example, if you were using CanCan:
+    #
+    #     index do
+    #       column :title, :sortable => false
+    #       if can? :manage, Post
+    #         column :some_secret_data
+    #       end
+    #     end
+    #
+    class IndexAsTable < ActiveAdmin::Component
+
+      def build(page_presenter, collection)
+        table_options = {
+          :id => "index_table_#{active_admin_config.resource_name.plural}",
+          :sortable => true,
+          :class => "index_table index",
+          :i18n => active_admin_config.resource_class,
+          :paginator => page_presenter[:paginator] != false
+        }
+
+        table_for collection, table_options do |t|
+          table_config_block = page_presenter.block || default_table
+          instance_exec(t, &table_config_block)
+        end
+      end
+
+      def table_for(*args, &block)
+        insert_tag IndexTableFor, *args, &block
+      end
+
+      def default_table
+        proc do
+          id_column
+          resource_class.content_columns.each do |col|
+            column col.name.to_sym
+          end
+          default_actions
+        end
+      end
+
+      def self.index_name
+        "table"
+      end
+
+      #
+      # Extend the default ActiveAdmin::Views::TableFor with some
+      # methods for quickly displaying items on the index page
+      #
+      class IndexTableFor < ::ActiveAdmin::Views::TableFor
+
+        # Display a column for checkbox
+        def selectable_column
+          return unless active_admin_config.batch_actions.any?
+          column( resource_selection_toggle_cell, { :class => "selectable" } ) { |resource| resource_selection_cell( resource ) }
+        end
+
+        # Display a column for the id
+        def id_column
+          column(resource_class.human_attribute_name(resource_class.primary_key), :sortable => resource_class.primary_key) do |resource|
+            link_to resource.id, resource_path(resource), :class => "resource_id_link"
+          end
+        end
+
+        # Add links to perform actions.
+        #
+        #   # Add default links.
+        #   actions
+        #
+        #   # Append some actions onto the end of the default actions.
+        #   actions do |admin_user|
+        #     link_to 'Grant Admin', grant_admin_admin_user_path(admin_user)
+        #   end
+        #
+        #   # Custom actions without the defaults.
+        #   actions :defaults => false do |admin_user|
+        #     link_to 'Grant Admin', grant_admin_admin_user_path(admin_user)
+        #   end
+        def actions(options = {}, &block)
+          options = {
+            :name => "",
+            :defaults => true
+          }.merge(options)
+          column options[:name] do |resource|
+            text_node default_actions(resource) if options[:defaults]
+            text_node instance_exec(resource, &block) if block_given?
+          end
+        end
+
+        def default_actions(*args)
+          links = proc do |resource|
+            links = ''.html_safe
+            if controller.action_methods.include?('show') && authorized?(ActiveAdmin::Auth::READ, resource)
+              links << link_to(I18n.t('active_admin.view'), resource_path(resource), :class => "member_link view_link")
+            end
+            if controller.action_methods.include?('edit') && authorized?(ActiveAdmin::Auth::UPDATE, resource)
+              links << link_to(I18n.t('active_admin.edit'), edit_resource_path(resource), :class => "member_link edit_link")
+            end
+            if controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, resource)
+              links << link_to(I18n.t('active_admin.delete'), resource_path(resource), :method => :delete, :data => {:confirm => I18n.t('active_admin.delete_confirmation')}, :class => "member_link delete_link")
+            end
+            links
+          end
+
+          options = args.extract_options!
+          if options.present? || args.empty?
+            actions options
+          else
+            links.call(args.first)
+          end
+        end
+
+        # Display A Status Tag Column
+        #
+        #   index do |i|
+        #     i.status_tag :state
+        #   end
+        #
+        #   index do |i|
+        #     i.status_tag "State", :status_name
+        #   end
+        #
+        #   index do |i|
+        #     i.status_tag do |post|
+        #       post.published? ? 'published' : 'draft'
+        #     end
+        #   end
+        #
+        def status_tag(*args, &block)
+          col = Column.new(*args, &block)
+          data = col.data
+          col.data = proc do |resource|
+            status_tag call_method_or_proc_on(resource, data)
+          end
+          add_column col
+        end
+      end # TableBuilder
+
+    end # Table
+  end
+end