activeadmin-rb 1.4.0

data/lib/active_admin/views/components/tabs.rb

@@ -0,0 +1,31 @@
+module ActiveAdmin
+  module Views
+    class Tabs < ActiveAdmin::Component
+      builder_method :tabs
+
+      def tab(title, options = {}, &block)
+        title = title.to_s.titleize if title.is_a? Symbol
+        @menu << build_menu_item(title, options, &block)
+        @tabs_content << build_content_item(title, options, &block)
+      end
+
+      def build(&block)
+        @menu = ul(class: 'nav nav-tabs', role: "tablist")
+        @tabs_content = div(class: 'tab-content')
+      end
+
+      def build_menu_item(title, options, &block)
+        fragment = options.fetch(:id, title.parameterize)
+        html_options = options.fetch(:html_options, {})
+        li html_options do
+          link_to title, "##{fragment}"
+        end
+      end
+
+      def build_content_item(title, options, &block)
+        options = options.reverse_merge(id: title.parameterize)
+        div(options, &block)
+      end
+    end
+  end
+end

data/lib/active_admin/views/components/unsupported_browser.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module Views
+    class UnsupportedBrowser < Component
+      def build
+        h1 I18n.t("active_admin.unsupported_browser.headline").html_safe
+        para I18n.t("active_admin.unsupported_browser.recommendation").html_safe
+        para I18n.t("active_admin.unsupported_browser.turn_off_compatibility_view").html_safe
+      end
+    end
+  end
+end

data/lib/active_admin/views/footer.rb

@@ -0,0 +1,30 @@
+module ActiveAdmin
+  module Views
+    class Footer < Component
+
+      def build(namespace)
+        super id: "footer"
+        @namespace = namespace
+
+        if footer_text.present?
+          para footer_text
+        else
+          para powered_by_message
+        end
+      end
+
+      private
+
+      def footer_text
+        @footer_text ||= @namespace.footer(self)
+      end
+
+      def powered_by_message
+        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,19 @@
+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)
+
+        site_title @namespace
+        global_navigation @menu, class: 'header-item tabs'
+        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.
+    #
+    # ```ruby
+    # index as: :block do |product|
+    #   div for: product do
+    #     resource_selection_cell product
+    #     h2  auto_link     product.title
+    #     div simple_format product.description
+    #   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,155 @@
+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.
+    #
+    # ```ruby
+    # 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:
+    #
+    # ```ruby
+    # index as: :blog do
+    #   title :a_method_to_call
+    # end
+    # ```
+    #
+    # Second, you can pass a block to the tile option which will then be
+    # used as the contents of the title. The resource being rendered
+    # is passed in to the block. For Example:
+    #
+    # ```ruby
+    # 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:
+    #
+    # ```ruby
+    # index as: :blog do
+    #   title :my_title
+    #   body :my_body
+    # end
+    # ```
+    #
+    # Or, render a block as the body:
+    #
+    # ```ruby
+    # 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_exec &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.public_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,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.to_a
+        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,389 @@
+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
+    # ```
+    #
+    # ## Defining Actions
+    #
+    # 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|
+    #     item "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|
+    #     item "View", admin_post_path(post)
+    #   end
+    # end
+    # ```
+    #
+    # Or append custom action with custom html via arbre:
+    #
+    # ```ruby
+    # index do
+    #   column :title
+    #   actions do |post|
+    #     a "View", href: admin_post_path(post)
+    #   end
+    # end
+    # ```
+    #
+    # In case you prefer to list actions links in a dropdown menu:
+    #
+    # ```ruby
+    # index do
+    #   selectable_column
+    #   column :title
+    #   actions dropdown: true do |post|
+    #     item "Preview", admin_preview_post_path(post)
+    #   end
+    # end
+    # ```
+    #
+    # In addition, you can insert the position of the row in the greater collection by using the index_column special command:
+    #
+    # ```ruby
+    # index do
+    #   selectable_column
+    #   index_column
+    #   column :title
+    # end
+    # ```
+    #
+    # index_column take an optional offset parameter to allow a developer to set the starting number for the index (default is 1).
+    #
+    # ## 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.
+    #
+    # You can pass the key specifying 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
+    # ```
+    #
+    # ## Custom sorting
+    #
+    # It is also possible to use database specific expressions and options for sorting by column
+    #
+    # ```ruby
+    # order_by(:title) do |order_clause|
+    #    if order_clause.order == 'desc'
+    #      [order_clause.to_sql, 'NULLS LAST'].join(' ')
+    #    else
+    #      [order_clause.to_sql, 'NULLS FIRST'].join(' ')
+    #    end
+    # end
+    #
+    # index do
+    #   column :title
+    # 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
+    # ```
+    #
+    # ## Custom row class
+    #
+    # In order to add special class to table rows pass the proc object as a `:row_class` option
+    # of the `index` method.
+    #
+    # ```ruby
+    # index row_class: ->elem { 'active' if elem.active? } do
+    #   # columns
+    # 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,
+          row_class: page_presenter[:row_class]
+        }
+
+        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 if resource_class.primary_key
+          active_admin_config.resource_columns.each do |attribute|
+            column attribute
+          end
+          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: 'col-selectable', sortable: false do |resource|
+            resource_selection_cell resource
+          end
+        end
+
+        def index_column(start_value = 1)
+          column '#', class: 'col-index', sortable: false do |resource|
+            @collection.offset_value + @collection.index(resource) + start_value
+          end
+        end
+
+        # Display a column for the id
+        def id_column
+          raise "#{resource_class.name} has no primary_key!" unless resource_class.primary_key
+          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"
+            elsif controller.action_methods.include?('edit')
+              link_to resource.id, edit_resource_path(resource), class: "resource_id_link"
+            else
+              resource.id
+            end
+          end
+        end
+
+        def default_actions
+          raise '`default_actions` is no longer provided in ActiveAdmin 1.x. Use `actions` instead.'
+        end
+
+        # Add links to perform actions.
+        #
+        # ```ruby
+        # # Add default links.
+        # actions
+        #
+        # # Add default links with a custom column title (empty by default).
+        # actions name: 'A title!'
+        #
+        # # Append some actions onto the end of the default actions.
+        # actions do |admin_user|
+        #   item 'Grant Admin', grant_admin_admin_user_path(admin_user)
+        #   item 'Grant User', grant_user_admin_user_path(admin_user)
+        # end
+        #
+        # # Append some actions onto the end of the default actions using arbre dsl.
+        # actions do |admin_user|
+        #   a 'Grant Admin', href: grant_admin_admin_user_path(admin_user)
+        # end
+        #
+        # # Custom actions without the defaults.
+        # actions defaults: false do |admin_user|
+        #   item 'Grant Admin', grant_admin_admin_user_path(admin_user)
+        # end
+        #
+        # # Append some actions onto the end of the default actions displayed in a Dropdown Menu
+        # actions dropdown: true do |admin_user|
+        #   item 'Grant Admin', grant_admin_admin_user_path(admin_user)
+        # end
+        #
+        # # Custom actions without the defaults displayed in a Dropdown Menu.
+        # actions defaults: false, dropdown: true, dropdown_name: 'Additional actions' do |admin_user|
+        #   item 'Grant Admin', grant_admin_admin_user_path(admin_user)
+        # end
+        #
+        # ```
+        def actions(options = {}, &block)
+          name          = options.delete(:name)     { '' }
+          defaults      = options.delete(:defaults) { true }
+          dropdown      = options.delete(:dropdown) { false }
+          dropdown_name = options.delete(:dropdown_name) { I18n.t 'active_admin.dropdown_actions.button_label', default: 'Actions' }
+
+          options[:class] ||= 'col-actions'
+
+          column name, options do |resource|
+            if dropdown
+              dropdown_menu dropdown_name do
+                defaults(resource) if defaults
+                instance_exec(resource, &block) if block_given?
+              end
+            else
+              table_actions do
+                defaults(resource, css_class: :member_link) if defaults
+                if block_given?
+                  block_result = instance_exec(resource, &block)
+                  text_node block_result unless block_result.is_a? Arbre::Element
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def defaults(resource, options = {})
+          if controller.action_methods.include?('show') && authorized?(ActiveAdmin::Auth::READ, resource)
+            item I18n.t('active_admin.view'), resource_path(resource), class: "view_link #{options[:css_class]}", title: I18n.t('active_admin.view')
+          end
+          if controller.action_methods.include?('edit') && authorized?(ActiveAdmin::Auth::UPDATE, resource)
+            item I18n.t('active_admin.edit'), edit_resource_path(resource), class: "edit_link #{options[:css_class]}", title: I18n.t('active_admin.edit')
+          end
+          if controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, resource)
+            item I18n.t('active_admin.delete'), resource_path(resource), class: "delete_link #{options[:css_class]}", title: I18n.t('active_admin.delete'),
+              method: :delete, data: {confirm: I18n.t('active_admin.delete_confirmation')}
+          end
+        end
+
+        class TableActions < ActiveAdmin::Component
+          builder_method :table_actions
+
+          def item *args
+            text_node link_to *args
+          end
+        end
+      end # IndexTableFor
+
+    end
+  end
+end