activeadmin 0.1.1 → 0.2.0

data/lib/active_admin/views.rb

@@ -0,0 +1,8 @@
+module ActiveAdmin
+  module Views
+
+    # Loads all the classes in views/*.rb
+    Dir[File.expand_path('../views', __FILE__) + "/**/*.rb"].sort.each{ |f| require f }
+
+  end
+end

data/lib/active_admin/views/action_items.rb

@@ -0,0 +1,17 @@
+module ActiveAdmin
+  module Views
+
+    class ActionItems < ActiveAdmin::Component
+
+      def build(action_items)
+        action_items.each do |action_item|
+          span :class => "action_item" do
+            instance_eval(&action_item.block)
+          end
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,66 @@
+module ActiveAdmin
+  module Views
+
+    class AttributesTable < ActiveAdmin::Component
+      builder_method :attributes_table_for
+
+      attr_reader :resource
+
+      def build(record, *attrs)
+        @record = record
+        super(:for => @record)
+        @table = table
+        rows(*attrs)
+      end
+
+      def rows(*attrs)
+        attrs.each {|attr| row(attr) }
+      end
+
+      def row(attr, &block)
+        @table << tr do
+          th do
+            header_content_for(attr)
+          end
+          td do
+            content_for(block || attr)
+          end
+        end
+      end
+
+      protected
+
+      def default_id_for_prefix
+        'attributes_table'
+      end
+
+      def header_content_for(attr)
+        attr.to_s.titleize
+      end
+
+      def empty_value
+        span "Empty", :class => "empty"
+      end
+
+      def content_for(attr_or_proc)
+        value = case attr_or_proc
+                when Proc
+                  attr_or_proc.call
+                else
+                  content_for_attribute(attr_or_proc)
+                end
+        value = pretty_format(value)
+        value == "" || value == nil ? empty_value : value
+      end
+
+      def content_for_attribute(attr)
+        if attr.to_s =~ /^([\w]+)_id$/ && @record.respond_to?($1.to_sym)
+          content_for_attribute($1)
+        else
+          @record.send(attr.to_sym)
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,49 @@
+module ActiveAdmin
+  module Views
+
+    class Columns < ActiveAdmin::Component
+      builder_method :columns
+
+      def column(*args, &block)
+        insert_tag Column, *args, &block
+      end
+
+      # Override add child to set widths
+      def add_child(*)
+        super
+        calculate_columns!
+      end
+
+      protected
+
+      def margin_size
+        2
+      end
+
+      def calculate_columns!
+        # Calculate our columns sizes and margins
+        count = children.size
+        margins_width = margin_size * (count - 1)
+        column_width = (100.00 - margins_width) / count
+
+        # Convert to an integer if its not a float
+        column_width = column_width.to_i == column_width ? column_width.to_i : column_width
+
+        children.each_with_index do |col, i|
+          col.set_attribute :style, "width: #{column_width}%;"
+          col.attr(:style) << " margin-right: #{margin_size}%;" unless i == (count - 1)
+        end
+      end
+
+      def to_html
+        html = super
+        p html
+        html.to_s + "<div style=\"clear:both;\"></div>".html_safe
+      end
+
+    end
+
+    class Column < ActiveAdmin::Component
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module ActiveAdmin
+  module Views
+
+    # Wraps the content with pagination and available formats.
+    #
+    # *Example:*
+    #
+    #   paginated_collection collection, :entry_name => "Post" do
+    #     div do
+    #       h2 "Inside the 
+    #     end
+    #   end
+    #
+    # This will create a div with a sentence describing the number of
+    # posts in one of the following formats:
+    #
+    # * "No Posts found"
+    # * "Displaying all 10 Posts"
+    # * "Displaying Posts 1 - 30 of 31 in total"
+    #
+    # It will also generate pagination links.
+    #
+    class PaginatedCollection < ActiveAdmin::Component
+      builder_method :paginated_collection
+
+
+      # Builds a new paginated collection component
+      #
+      # @param [Array] collection  A "paginated" collection from will_paginate
+      # @param [Hash]  options     These options will be passed on to the page_entries_info
+      #                            method supplied in will_paginate.
+      #                            Useful keys:
+      #                             :entry_name - The name to dislpay for this resource collection
+      def build(collection, options = {})
+        @collection = collection
+        div(page_entries_info(@collection, options), :class => "pagination_information")
+        @contents = div(:class => "paginated_collection_contents")
+        build_pagination_with_formats
+        @built = true
+      end
+
+      # 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
+
+      protected
+
+      def build_pagination_with_formats
+        div :id => "index_footer" do
+          build_download_format_links
+          build_pagination
+        end
+      end
+
+      def build_pagination
+        text_node will_paginate(collection, :previous_label => "Previous", :next_label => "Next")
+      end
+
+      # TODO: Refactor to new HTML DSL
+      def build_download_format_links(formats = [:csv, :xml, :json])
+        links = formats.collect do |format|
+          link_to format.to_s.upcase, { :format => format}.merge(request.query_parameters.except(:commit, :format)) 
+        end
+        text_node ["Download:", links].flatten.join("&nbsp;").html_safe
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ActiveAdmin
+  module Views
+
+    class Panel < ActiveAdmin::Component
+      builder_method :panel
+
+      def build(title, attributes = {})
+        icon_name = attributes.delete(:icon)
+        icn = icon_name ? icon(icon_name) : ""
+        super(attributes)
+        add_class "panel"
+        @title = h3(icn + title.to_s)
+        @contents = div(:class => "panel_contents")
+      end
+
+      def add_child(child)
+        if @contents
+          @contents << child
+        else
+          super
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,64 @@
+module ActiveAdmin
+  module Views
+
+    # Renders a collection of ActiveAdmin::Scope objects as a
+    # simple list with a seperator
+    class Scopes < ActiveAdmin::Component
+      builder_method :scopes_renderer
+
+      def build(scopes)
+        scopes.each do |scope|
+          build_scope(scope)
+        end
+      end
+
+      protected
+
+      def build_scope(scope)
+        span :class => classes_for_scope(scope) do
+          if current_scope?(scope) 
+            em(scope.name)
+          else
+            a(scope.name, :href => url_for(params.merge(:scope => scope.id, :page => 1)))
+          end
+          text_node(" ")
+          scope_count(scope)
+          text_node(" ")
+        end
+      end
+
+      def classes_for_scope(scope)
+        classes = ["scope", scope.id]
+        classes << "selected" if current_scope?(scope)
+        classes.join(" ")
+      end
+
+      def current_scope?(scope)
+        if params[:scope]
+          params[:scope] == scope.id
+        else
+          active_admin_config.default_scope == scope
+        end
+      end
+
+      def scope_count(scope)
+        span :class => 'count' do
+          "(" + get_scope_count(scope).to_s + ")"
+        end
+      end
+
+      def get_scope_count(scope)
+        if scope.scope_method
+          scoping_class.send(scope.scope_method).count
+        else
+          instance_exec(scoping_class, &scope.scope_block).count
+        end
+      end
+
+      def scoping_class
+        assigns["before_scope_collection"] || active_admin_config.resource
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module ActiveAdmin
+  module Views
+
+    class SidebarSection < Panel
+      builder_method :sidebar_section
+
+      # Takes a ActiveAdmin::Sidebar::Section instance
+      def build(section)
+        @section = section
+        super(@section.title, :icon => @section.icon)
+        self.id = @section.id
+        build_sidebar_content
+      end
+
+      protected
+
+      def build_sidebar_content
+        if @section.block
+          rvalue = instance_eval(&@section.block)
+          self << rvalue if rvalue.is_a?(String)
+        else
+          self << capture do
+            render @section.partial_name
+          end
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,174 @@
+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)
+        @collection = collection
+        @columns = []
+        build_table
+        super(options)
+      end
+
+      def column(*args, &block)
+        col = Column.new(*args, &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, request.query_parameters.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', 'event')) }
+        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
+
+      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)
+          raw.is_a?(Symbol) ? raw.to_s.titleize : raw
+        end
+
+        def default_options
+          {
+            :sortable => true
+          }
+        end
+
+      end
+    end
+  end
+end