class ActiveAdmin::Views::PaginatedCollection


It will also generate pagination links.
* “Displaying Posts 1 - 30 of 31 in total”
* “Displaying all 10 Posts”
* “No Posts found”
posts in one of the following formats:
This will create a div with a sentence describing the number of
end
end
h2 “Inside the
div do
paginated_collection collection, entry_name: ”Post“ do
Example:
Wraps the content with pagination and available formats.

def add_child(*args, &block)

Override add_child to insert all children into the @contents div 
def add_child(*args, &block)
  if @built
    @contents.add_child(*args, &block)
  else
    super
  end
end

def build(collection, options = {})


download_links => Download links override (false or [:csv, :pdf])
param_name => Parameter name for page number in the links (:page by default)
params => Extra parameters for pagination (e.g. { anchor: 'details' })
entry_name => The name to display for this resource collection
options => These options will be passed to `page_entries_info`
collection => A paginated collection from kaminari

Builds a new paginated collection component 
def build(collection, options = {})
  @collection = collection
  @params = options.delete(:params)
  @param_name = options.delete(:param_name)
  @download_links = options.delete(:download_links)
  @display_total = options.delete(:pagination_total) { true }
  @per_page = options.delete(:per_page)
  unless collection.respond_to?(:total_pages)
    raise(StandardError, "Collection is not a paginated scope. Set collection.page(params[:page]).per(10) before calling :paginated_collection.")
  end
  @contents = div(class: "paginated_collection_contents")
  build_pagination_with_formats(options)
  @built = true
end

def build_pagination 

def build_pagination
  options = { theme: @display_total ? "active_admin" : "active_admin_countless" }
  options[:params] = @params if @params
  options[:param_name] = @param_name if @param_name
  if !@display_total
    # The #paginate method in kaminari will query the resource with a
    # count(*) to determine how many pages there should be unless
    # you pass in the :total_pages option. We issue a query to determine
    # if there is another page or not, but the limit/offset make this
    # query fast.
    offset = collection.offset(collection.current_page * collection.limit_value).limit(1).count
    options[:total_pages] = collection.current_page + offset
    options[:right] = 0
  end
  text_node paginate collection, **options
end

def build_pagination_with_formats(options) 

def build_pagination_with_formats(options)
  div id: "index_footer" do
    build_per_page_select if @per_page.is_a?(Array)
    build_pagination
    div(page_entries_info(options).html_safe, class: "pagination_information")
    formats = build_download_formats @download_links
    build_download_format_links formats if formats.any?
  end
end

def build_per_page_select 

def build_per_page_select
  div class: "pagination_per_page" do
    text_node I18n.t("active_admin.pagination.per_page")
    select do
      @per_page.each do |per_page|
        option(
          per_page,
          value: per_page,
          selected: collection.limit_value == per_page ? "selected" : nil
        )
      end
    end
  end
end

def page_entries_info(options = {})

modified from will_paginate 
def page_entries_info(options = {})
  if options[:entry_name]
    entry_name = options[:entry_name]
    entries_name = options[:entries_name] || entry_name.pluralize
  elsif collection_is_empty?
    entry_name = I18n.t "active_admin.pagination.entry", count: 1, default: "entry"
    entries_name = I18n.t "active_admin.pagination.entry", count: 2, default: "entries"
  else
    key = "activerecord.models." + collection.first.class.model_name.i18n_key.to_s
    entry_name = I18n.translate key, count: 1, default: collection.first.class.name.underscore.sub("_", " ")
    entries_name = I18n.translate key, count: collection.size, default: entry_name.pluralize
  end
  if @display_total
    if collection.total_pages < 2
      case collection_size
      when 0; I18n.t("active_admin.pagination.empty", model: entries_name)
      when 1; I18n.t("active_admin.pagination.one", model: entry_name)
      else; I18n.t("active_admin.pagination.one_page", model: entries_name, n: collection.total_count)
      end
    else
      offset = (collection.current_page - 1) * collection.limit_value
      total = collection.total_count
      I18n.t "active_admin.pagination.multiple",
             model: entries_name,
             total: total,
             from: offset + 1,
             to: offset + collection_size
    end
  else
    # Do not display total count, in order to prevent a `SELECT count(*)`.
    # To do so we must not call `collection.total_pages`
    offset = (collection.current_page - 1) * collection.limit_value
    I18n.t "active_admin.pagination.multiple_without_total",
           model: entries_name,
           from: offset + 1,
           to: offset + collection_size
  end
end