andrewroth_activeadmin 0.3.4

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

@@ -0,0 +1,193 @@
+module ActiveAdmin
+  module Views
+    class TableFor < Arbre::HTML::Table
+      builder_method :table_for
+
+      def tag_name
+        'table'
+      end
+
+      def build(collection, options = {})
+        @sortable = options.delete(:sortable)
+        @resource_class = options.delete(:i18n)
+        @collection = collection
+        @columns = []
+        build_table
+        super(options)
+      end
+
+      def column(*args, &block)
+        options = default_options.merge(args.last.is_a?(::Hash) ? args.pop : {})
+        title = args[0]
+        data  = args[1] || args[0]
+
+        col = Column.new(title, data, options, &block)
+        @columns << col
+
+        # Build our header item
+        within @header_row do
+          build_table_header(col)
+        end
+
+        # Add a table cell for each item
+        @collection.each_with_index do |item, i|
+          within @tbody.children[i] do
+            build_table_cell(col, item)
+          end
+        end
+      end
+
+      def sortable?
+        @sortable
+      end
+
+      # Returns the columns to display based on the conditional block
+      def visible_columns
+        @visible_columns ||= @columns.select{|col| col.display_column? }
+      end
+
+      protected
+
+      def build_table
+        build_table_head
+        build_table_body
+      end
+
+      def build_table_head
+        @thead = thead do
+          @header_row = tr
+        end
+      end
+
+      def build_table_header(col)
+        if sortable? && col.sortable?
+          build_sortable_header_for(col.title, col.sort_key)
+        else
+          th(col.title)
+        end
+      end
+
+      def build_sortable_header_for(title, sort_key)
+        classes = Arbre::HTML::ClassList.new(["sortable"])
+        if current_sort[0] == sort_key
+          classes << "sorted-#{current_sort[1]}"
+        end
+
+        th :class => classes do
+          link_to(title, params.merge(:order => "#{sort_key}_#{order_for_sort_key(sort_key)}").except(:page))
+        end
+      end
+
+      def build_table_body
+        @tbody = tbody do
+          # Build enough rows for our collection
+          @collection.each{|_| tr(:class => cycle('odd', 'even'), :id => dom_id(_)) }
+        end
+      end
+
+      def build_table_cell(col, item)
+        td do
+          rvalue = call_method_or_proc_on(item, col.data, :exec => false)
+          if col.data.is_a?(Symbol)
+            rvalue = pretty_format(rvalue)
+          end
+          rvalue
+        end
+      end
+
+      # Returns an array for the current sort order
+      #   current_sort[0] #=> sort_key
+      #   current_sort[1] #=> asc | desc
+      def current_sort
+        @current_sort ||= if params[:order] && params[:order] =~ /^([\w\_\.]+)_(desc|asc)$/
+          [$1,$2]
+        else
+          []
+        end
+      end
+
+      # Returns the order to use for a given sort key
+      #
+      # Default is to use 'desc'. If the current sort key is
+      # 'desc' it will return 'asc'
+      def order_for_sort_key(sort_key)
+        current_key, current_order = current_sort
+        return 'desc' unless current_key == sort_key
+        current_order == 'desc' ? 'asc' : 'desc'
+      end
+
+      def default_options
+        {
+          :i18n => @resource_class
+        }
+      end
+
+      class Column
+
+        attr_accessor :title, :data
+
+        def initialize(*args, &block)
+          @options = default_options.merge(args.last.is_a?(::Hash) ? args.pop : {})
+          @title = pretty_title args[0]
+          @data  = args[1] || args[0]
+          @data = block if block
+        end
+
+        def sortable?
+          if @data.is_a?(Proc)
+            [String, Symbol].include?(@options[:sortable].class)
+          else
+            @options[:sortable]
+          end
+        end
+
+        #
+        # Returns the key to be used for sorting this column
+        #
+        # Defaults to the column's method if its a symbol
+        #   column :username
+        #   # => Sort key will be set to 'username'
+        #
+        # You can set the sort key by passing a string or symbol
+        # to the sortable option:
+        #   column :username, :sortable => 'other_column_to_sort_on'
+        #
+        # If you pass a block to be rendered for this column, the column
+        # will not be sortable unless you pass a string to sortable to
+        # sort the column on:
+        #
+        #   column('Username', :sortable => 'login'){ @user.pretty_name }
+        #   # => Sort key will be 'login'
+        #
+        def sort_key
+          if @options[:sortable] == true || @options[:sortable] == false
+            @data.to_s
+          else
+            @options[:sortable].to_s
+          end
+        end
+
+        private
+
+        def pretty_title(raw)
+          if raw.is_a?(Symbol)
+            if @options[:i18n] && @options[:i18n].respond_to?(:human_attribute_name) && human_name = @options[:i18n].human_attribute_name(raw)
+              raw = human_name
+            end
+
+            raw.to_s.titleize
+          else
+            raw
+          end
+        end
+
+        def default_options
+          {
+            :sortable => true
+          }
+        end
+
+      end
+    end
+  end
+end

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
+        @section.name.to_s.titleize
+      end
+
+    end
+  end
+end

data/lib/active_admin/views/header_renderer.rb

@@ -0,0 +1,57 @@
+module ActiveAdmin
+  module Views
+
+    # Renderer for the header of the application. Includes the page
+    # title, global navigation and utility navigation.
+    class HeaderRenderer < ::ActiveAdmin::Renderer
+
+      def to_html
+        title + global_navigation + utility_navigation
+      end
+
+      protected
+
+      def title
+        if !active_admin_application.site_title_link || active_admin_application.site_title_link == ""
+          content_tag 'h1', active_admin_application.site_title, :id => 'site_title'
+        else
+          content_tag 'h1', link_to(active_admin_application.site_title, active_admin_application.site_title_link), :id => 'site_title'
+        end
+      end
+
+      # Renders the global navigation returned by
+      # ActiveAdmin::ResourceController#current_menu
+      #
+      # It uses the ActiveAdmin.tabs_renderer option
+      def global_navigation
+        render view_factory.global_navigation, current_menu
+      end
+
+      def utility_navigation
+        content_tag 'p', :id => "utility_nav" do
+          if current_active_admin_user?
+            html = content_tag(:span, display_name(current_active_admin_user), :class => "current_user")
+
+            if active_admin_application.logout_link_path
+              html << link_to(I18n.t('active_admin.logout'), logout_path, :method => logout_method)
+            end
+          end
+        end
+      end
+
+      # Returns the logout path from the application settings
+      def logout_path
+        if active_admin_application.logout_link_path.is_a?(Symbol)
+          send(active_admin_application.logout_link_path)
+        else
+          active_admin_application.logout_link_path
+        end
+      end
+
+      def logout_method
+        active_admin_application.logout_link_method || :get
+      end
+    end
+
+  end
+end

data/lib/active_admin/views/index_as_block.rb

@@ -0,0 +1,29 @@
+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
+    #         h2 auto_link(product.title)
+    #         div do
+    #           simple_format product.description
+    #         end
+    #       end
+    #     end
+    #
+    class IndexAsBlock < ActiveAdmin::Component
+
+      def build(page_config, collection)
+        collection.each do |obj|
+          instance_exec(obj, &page_config.block)
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/views/index_as_blog.rb

@@ -0,0 +1,129 @@
+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_config, collection)
+        @page_config = page_config
+        @collection = collection
+
+        # Call the block passed in. This will set the 
+        # title and body methods
+        instance_eval &page_config.block if page_config.block
+
+        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
+
+      private
+
+      def build_posts
+        @collection.each do |post|
+          build_post(post)
+        end
+      end
+
+      def build_post(post)
+        div :for => post do
+          build_title(post)
+          build_body(post)
+        end
+      end
+
+      def build_title(post)
+        if @title
+          h3 do
+            link_to(call_method_or_proc_on(post, @title), resource_path(post))
+          end
+        else
+          h3 do
+            auto_link(post)
+          end
+        end
+      end
+
+      def build_body(post)
+        if @body
+          div(call_method_or_proc_on(post, @body), :class => 'content')
+        end
+      end
+
+    end # Posts
+  end
+end

data/lib/active_admin/views/index_as_grid.rb

@@ -0,0 +1,70 @@
+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_config, collection)
+        @page_config = page_config
+        @collection = collection
+        build_table
+      end
+
+      def number_of_columns
+        @page_config[:columns] || default_number_of_columns
+      end
+
+      protected
+
+      def build_table
+        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_config.block)
+        end
+      end
+
+      def build_empty_cell
+        td '&nbsp;'.html_safe
+      end
+
+      def default_number_of_columns
+        3
+      end
+
+    end
+  end
+end