activeadministration 0.0.1

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

@@ -0,0 +1,212 @@
+module ActiveAdmin
+  module Views
+    class TableFor < Arbre::HTML::Table
+      builder_method :table_for
+
+      def tag_name
+        'table'
+      end
+
+      def build(obj, options = {})
+        @sortable       = options.delete(:sortable)
+        @resource_class = options.delete(:i18n)
+        @collection     = obj.respond_to?(:each) && !obj.is_a?(Hash) ? obj : [obj]
+        @columns        = []
+        build_table
+        super(options)
+      end
+
+      def column(*args, &block)
+        options = default_options.merge(args.extract_options!)
+        title = args[0]
+        data  = args[1] || args[0]
+
+        col = Column.new(title, data, @resource_class, 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
+
+      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)
+        classes  = Arbre::HTML::ClassList.new
+        sort_key = sortable? && col.sortable? && col.sort_key
+        params   = request.query_parameters.except :page, :order, :commit, :format
+
+        classes << 'sortable'                         if sort_key
+        classes << "sorted-#{current_sort[1]}"        if sort_key && current_sort[0] == sort_key
+        classes << col.html_class
+
+        if sort_key
+          th class: classes do
+            link_to col.pretty_title, params: params, order: "#{sort_key}_#{order_for_sort_key(sort_key)}"
+          end
+        else
+          th col.pretty_title, class: classes
+        end
+      end
+
+      def build_table_body
+        @tbody = tbody do
+          # Build enough rows for our collection
+          @collection.each{ |elem| tr class: cycle('odd', 'even'), id: dom_id_for(elem) }
+        end
+      end
+
+      def build_table_cell(col, item)
+        td class: col.html_class do
+          render_data col.data, item
+        end
+      end
+
+      def render_data(data, item)
+        value = if data.is_a? Proc
+          data.call item
+        elsif item.respond_to? data
+          item.send data
+        elsif item.respond_to? :[]
+          item[data]
+        end
+        value = pretty_format(value) if data.is_a?(Symbol)
+        value = status_tag value     if is_boolean? data, item
+        value
+      end
+
+      def is_boolean?(data, item)
+        if item.respond_to? :column_for_attribute
+          attr = item.column_for_attribute(data) and attr.type == :boolean 
+        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 ||= begin
+          order_clause = OrderClause.new params[:order]
+          
+          if order_clause.valid?
+            [order_clause.field, order_clause.order]
+          else
+            []
+          end
+        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 , :html_class
+
+        def initialize(*args, &block) 
+          @options = args.extract_options!
+
+          @title = args[0]
+          html_classes = [:col]
+          if @options.has_key?(:class)
+            html_classes << @options.delete(:class)
+          elsif @title.present?
+            html_classes << "col-#{@title.to_s.parameterize('_')}"
+          end
+          @html_class = html_classes.join(' ')
+          @data = args[1] || args[0]
+          @data = block if block
+          @resource_class = args[2]
+        end
+
+        def sortable?
+          if @data.is_a?(Proc)
+            [String, Symbol].include?(@options[:sortable].class)
+          elsif @options.has_key?(:sortable)
+            @options[:sortable]
+          elsif @data.respond_to?(:to_sym) && @resource_class
+            !@resource_class.reflect_on_association(@data.to_sym)
+          else
+            true
+          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 boolean or nil, use the default sort key.
+          if @options[:sortable] == true || @options[:sortable] == false || @options[:sortable].nil?
+            @data.to_s
+          else
+            @options[:sortable].to_s
+          end
+        end
+
+        def pretty_title
+          if @title.is_a? Symbol
+            default = @title.to_s.titleize
+            if @options[:i18n].respond_to? :human_attribute_name
+              @title = @options[:i18n].human_attribute_name @title, default: default
+            else
+              default
+            end
+          else
+            @title
+          end
+        end
+      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.
+    #
+    # ```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,156 @@
+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 fo 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.send proc
+        else
+          instance_exec post, &proc
+        end
+      end
+
+    end # Posts
+  end
+end