aa-rails4 0.6.0

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

@@ -0,0 +1,34 @@
+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) : "".html_safe
+        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
+
+      # Override children? to only report children when the panel's
+      # contents have been added to. This ensures that the panel
+      # correcly appends string values, etc.
+      def children?
+        @contents.children?
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,27 @@
+module ActiveAdmin
+  module Views
+
+    class Popover < ActiveAdmin::Component
+      builder_method :popover
+
+      def build(options = {}, &block)
+        options           = options.dup
+        contents_root_tag = options.delete(:contents_root_tag) || :div
+        options[:style]   = "display: none"
+
+        super(options)
+
+        @contents_root = send(contents_root_tag, :class => "popover_contents")
+      end
+
+      def add_child(child)
+        if @contents_root
+          @contents_root << child
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'active_admin/helpers/collection'
+require 'active_admin/view_helpers/method_or_proc_helper'
+
+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
+
+      include ActiveAdmin::ScopeChain
+      include ::ActiveAdmin::Helpers::Collection
+
+
+      def default_class_name
+        "scopes table_tools_segmented_control"
+      end
+
+      def tag_name
+        'ul'
+      end
+
+      def build(scopes, options = {})
+        scopes.each do |scope|
+          build_scope(scope, options) if call_method_or_proc_on(self, scope.display_if_block)
+        end
+      end
+
+      protected
+
+      def build_scope(scope, options)
+        li :class => classes_for_scope(scope) do
+          scope_name = I18n.t("active_admin.scopes.#{scope.id}", :default => scope.name)
+
+          a :href => url_for(params.merge(:scope => scope.id, :page => 1)), :class => "table_tools_button" do
+            text_node scope_name
+            span :class => 'count' do
+              "(#{get_scope_count(scope)})"
+            end if options[:scope_count] && scope.show_count
+          end
+        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(self) == scope
+        end
+      end
+
+      # Return the count for the scope passed in.
+      def get_scope_count(scope)
+        collection_size(scope_chain(scope, collection_before_scope))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module ActiveAdmin
+  module Views
+
+    class SidebarSection < Panel
+      builder_method :sidebar_section
+
+      # Takes a ActiveAdmin::SidebarSection 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
+          render(@section.partial_name)
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,55 @@
+module ActiveAdmin
+  module Views
+
+    class SiteTitle < Component
+
+      def tag_name
+        'h1'
+      end
+
+      def build(namespace)
+        super(:id => "site_title")
+        @namespace = namespace
+
+        if site_title_link?
+          text_node site_title_with_link
+        else
+          text_node site_title_content
+        end
+      end
+
+      def site_title_link?
+        @namespace.site_title_link.present?
+      end
+
+      def site_title_image?
+        @namespace.site_title_image.present?
+      end
+
+      private
+
+      def site_title_with_link
+        helpers.link_to(site_title_content, @namespace.site_title_link)
+      end
+
+      def site_title_content
+        if site_title_image?
+          title_image
+        else
+          title_text
+        end
+      end
+
+      def title_text
+        helpers.render_or_call_method_or_proc_on(self, @namespace.site_title)
+      end
+
+      def title_image
+        path = helpers.render_or_call_method_or_proc_on(self, @namespace.site_title_image)
+        helpers.image_tag(path, :id => "site_title_image", :alt => @namespace.site_title)
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,56 @@
+module ActiveAdmin
+  module Views
+    # Build a StatusTag
+    class StatusTag < ActiveAdmin::Component
+      builder_method :status_tag
+
+      def tag_name
+        'span'
+      end
+
+      def default_class_name
+        'status_tag'
+      end
+
+      # @method status_tag(status, type = nil, options = {})
+      #
+      # @param [String] status the status to display. One of the span classes will be an underscored version of the status.
+      # @param [Symbol] type type of status. Will become a class of the span. ActiveAdmin provide style for :ok, :warning and :error.
+      # @param [Hash] options such as :class, :id and :label to override the default label
+      #
+      # @return [ActiveAdmin::Views::StatusTag]
+      #
+      # Examples:
+      #   status_tag('In Progress')
+      #   # => <span class='status_tag in_progress'>In Progress</span>
+      #
+      #   status_tag('active', :ok)
+      #   # => <span class='status_tag active ok'>Active</span>
+      #
+      #   status_tag('active', :ok, :class => 'important', :id => 'status_123', :label => 'on')
+      #   # => <span class='status_tag active ok important' id='status_123'>on</span>
+      #
+      def build(*args)
+        options = args.extract_options!
+        status = args[0]
+        type = args[1]
+        label = options.delete(:label)
+        classes = options.delete(:class)
+
+        content = label || status.titleize if status
+
+        super(content, options)
+
+        add_class(status_to_class(status)) if status
+        add_class(type.to_s) if type
+        add_class(classes) if classes
+      end
+
+      protected
+
+      def status_to_class(status)
+        status.titleize.gsub(/\s/, '').underscore
+      end
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+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.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
+
+      # 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)
+        classes = Arbre::HTML::ClassList.new
+        sort_key = sortable? && col.sortable? && col.sort_key
+
+        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.merge(:order => "#{sort_key}_#{order_for_sort_key(sort_key)}").except(:page))
+          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(elem)) }
+        end
+      end
+
+      def build_table_cell(col, item)
+        td(:class =>  col.html_class) 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 , :html_class
+
+        def initialize(*args, &block)
+          @options = args.extract_options!
+
+          @title = args[0]
+          @html_class = @options.delete(:class) || @title.to_s.downcase.underscore.gsub(/ +/,'_')
+          @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 =  @title.to_s.titleize
+            if @options[:i18n] && @options[:i18n].respond_to?(:human_attribute_name)
+              @title = @options[:i18n].human_attribute_name(@title, :default => default_title)
+            else
+              default_title
+            end
+          else
+            @title
+          end
+        end
+      end
+    end
+  end
+end