active_administration 0.0.1

data/lib/active_admin/views/index_as_grid.rb

@@ -0,0 +1,80 @@
+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.
+     #
+     # ```ruby
+     # index as: :grid do |product|
+     #   link_to image_tag(product.image_path), admin_product_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 columns that are rendered using the columns
+     # option:
+     #
+     # ```ruby
+     # index as: :grid, columns: 5 do |product|
+     #   link_to image_tag(product.image_path), admin_product_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,277 @@
+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:
+    #
+    # ```ruby
+    # index do
+    #   selectable_column
+    #   column :title
+    # end
+    # ```
+    #
+    # For association columns we make an educated guess on what to display by
+    # calling the following methods in the following order:
+    #
+    # ```ruby
+    # :display_name, :full_name, :name, :username, :login, :title, :email, :to_s
+    # ```
+    #
+    # This can be customized in `config/initializers/active_admin.rb`.
+    #
+    # If the default title does not work for you, pass it as the first argument:
+    #
+    # ```ruby
+    # index do
+    #   selectable_column
+    #   column "My Custom Title", :title
+    # end
+    # ```
+    #
+    # Sometimes that just isn't enough and you need to write some view-specific code.
+    # For example, say we wanted a "Title" column that links to the posts admin screen.
+    #
+    # `column` accepts a block that will be rendered for each of the objects in the collection.
+    # The block is called once for each resource, which is passed as an argument to the block.
+    #
+    # ```ruby
+    # index do
+    #   selectable_column
+    #   column "Title" do |post|
+    #     link_to post.title, admin_post_path(post)
+    #   end
+    # end
+    # ```
+    #
+    # To setup links to View, Edit and Delete a resource, use the `actions` method:
+    #
+    # ```ruby
+    # index do
+    #   selectable_column
+    #   column :title
+    #   actions
+    # end
+    # ```
+    #
+    # You can also append custom links to the default links:
+    #
+    # ```ruby
+    # index do
+    #   selectable_column
+    #   column :title
+    #   actions do |post|
+    #     link_to "Preview", admin_preview_post_path(post), class: "member_link"
+    #   end
+    # end
+    # ```
+    #
+    # Or forego the default links entirely:
+    #
+    # ```ruby
+    # index do
+    #   column :title
+    #   actions defaults: false 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.
+    #
+    # ```ruby
+    # index do
+    #   column :title, sortable: :title do |post|
+    #     link_to post.title, admin_post_path(post)
+    #   end
+    # end
+    # ```
+    #
+    # You can turn off sorting on any column by passing false:
+    #
+    # ```ruby
+    # index do
+    #   column :title, sortable: false
+    # end
+    # ```
+    #
+    # It's also possible to sort by PostgreSQL's hstore column key. You should set `sortable`
+    # option to a `column->'key'` value:
+    #
+    # ```ruby
+    # index do
+    #   column :keywords, sortable: "meta->'keywords'"
+    # end
+    # ```
+    #
+    # ## Associated Sorting
+    #
+    # You're normally able to sort columns alphabetically, but by default you
+    # can't sort by associated objects. Though with a few simple changes, you can.
+    #
+    # Assuming you're on the Books index page, and Book has_one Publisher:
+    #
+    # ```ruby
+    # controller do
+    #   def scoped_collection
+    #     super.includes :publisher # prevents N+1 queries to your database
+    #   end
+    # end
+    # ```
+    #
+    # Then it's simple to sort by any Publisher attribute from within the index table:
+    #
+    # ```ruby
+    # index do
+    #   column :publisher, sortable: 'publishers.name'
+    # 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:
+    #
+    # ```ruby
+    # index do
+    #   column :title, sortable: false
+    #   column :secret_data if can? :manage, Post
+    # 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
+          selectable_column
+          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' do |resource|
+            resource_selection_cell resource
+          end
+        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|
+            if controller.action_methods.include?('show')
+              link_to resource.id, resource_path(resource), class: "resource_id_link"
+            else
+              resource.id
+            end
+          end
+        end
+
+        # Add links to perform actions.
+        #
+        # ```ruby
+        # # 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
+      end # IndexTableFor
+
+    end # IndexAsTable
+  end
+end

data/lib/active_admin/views/pages/base.rb

@@ -0,0 +1,139 @@
+module ActiveAdmin
+  module Views
+    module Pages
+      class Base < Arbre::HTML::Document
+
+        def build(*args)
+          super
+          add_classes_to_body
+          build_active_admin_head
+          build_page
+        end
+
+        private
+
+        def add_classes_to_body
+          @body.add_class(params[:action])
+          @body.add_class(params[:controller].gsub('/', '_'))
+          @body.add_class("active_admin")
+          @body.add_class("logged_in")
+          @body.add_class(active_admin_namespace.name.to_s + "_namespace")
+        end
+
+        def build_active_admin_head
+          within @head do
+            insert_tag Arbre::HTML::Title, [title, render_or_call_method_or_proc_on(self, active_admin_application.site_title)].join(" | ")
+            active_admin_application.stylesheets.each do |style, options|
+              text_node stylesheet_link_tag(style, options).html_safe
+            end
+
+            active_admin_application.javascripts.each do |path|
+              text_node(javascript_include_tag(path))
+            end
+            
+            if active_admin_application.favicon
+              text_node(favicon_link_tag(active_admin_application.favicon))
+            end
+            
+            text_node csrf_meta_tag
+          end
+        end
+
+        def build_page
+          within @body do
+            div id: "wrapper" do
+              build_header
+              build_title_bar
+              build_page_content
+              build_footer
+            end
+          end
+        end
+
+        def build_header
+          insert_tag view_factory.header, active_admin_namespace, current_menu
+        end
+
+        def build_title_bar
+          insert_tag view_factory.title_bar, title, action_items_for_action
+        end
+
+
+        def build_page_content
+          build_flash_messages
+          div id: "active_admin_content", class: (skip_sidebar? ? "without_sidebar" : "with_sidebar") do
+            build_main_content_wrapper
+            build_sidebar unless skip_sidebar?
+          end
+        end
+
+        def build_flash_messages
+          if active_admin_flash_messages.any?
+            div class: 'flashes' do
+              active_admin_flash_messages.each do |type, message|
+                div message, class: "flash flash_#{type}"
+              end
+            end
+          end
+        end
+
+        def build_main_content_wrapper
+          div id: "main_content_wrapper" do
+            div id: "main_content" do
+              main_content
+            end
+          end
+        end
+
+        def main_content
+          I18n.t('active_admin.main_content', model: self.class.name).html_safe
+        end
+
+        def title
+          self.class.name
+        end
+
+        # Set's the page title for the layout to render
+        def set_page_title
+          set_ivar_on_view "@page_title", title
+        end
+
+        # Returns the sidebar sections to render for the current action
+        def sidebar_sections_for_action
+          if active_admin_config && active_admin_config.sidebar_sections?
+            active_admin_config.sidebar_sections_for(params[:action], self)
+          else
+            []
+          end
+        end
+
+        def action_items_for_action
+          if active_admin_config && active_admin_config.action_items?
+            active_admin_config.action_items_for(params[:action], self)
+          else
+            []
+          end
+        end
+
+        # Renders the sidebar
+        def build_sidebar
+          div id: "sidebar" do
+            sidebar_sections_for_action.collect do |section|
+              sidebar_section(section)
+            end
+          end
+        end
+
+        def skip_sidebar?
+          sidebar_sections_for_action.empty? || assigns[:skip_sidebar] == true
+        end
+
+        # Renders the content for the footer
+        def build_footer
+          insert_tag view_factory.footer
+        end
+
+      end
+    end
+  end
+end