activeadmin-orac 1.0.0.pre4

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

@@ -0,0 +1,80 @@
+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
+
+      # @overload 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
+      #   @option options [String] :class to override the default class
+      #   @option options [String] :id to override the default id
+      #   @option options [String] :label to override the default label
+      #   @return [ActiveAdmin::Views::StatusTag]
+      #
+      # @example
+      #   status_tag('In Progress')
+      #   # => <span class='status_tag in_progress'>In Progress</span>
+      #
+      # @example
+      #   status_tag('active', :ok)
+      #   # => <span class='status_tag active ok'>Active</span>
+      #
+      # @example
+      #   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)
+        status = convert_to_boolean_status(status)
+
+        if status
+          content = label || if s = status.to_s and s.present?
+            I18n.t "active_admin.status_tag.#{s.downcase}", default: s.titleize
+          end
+        end
+
+        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 convert_to_boolean_status(status)
+        case status
+        when true, 'true'
+          'Yes'
+        when false, 'false', nil
+          'No'
+        else
+          status
+        end
+      end
+
+      def status_to_class(status)
+        case status
+        when String, Symbol
+          status.to_s.titleize.gsub(/\s/, '').underscore
+        else
+          ''
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,218 @@
+module ActiveAdmin
+  module Views
+    class TableFor < Arbre::HTML::Table
+      builder_method :table_for
+
+      def tag_name
+        'table'
+      end
+
+      def build(obj, *attrs)
+        options         = attrs.extract_options!
+        @sortable       = options.delete(:sortable)
+        @collection     = obj.respond_to?(:each) && !obj.is_a?(Hash) ? obj : [obj]
+        @resource_class = options.delete(:i18n)
+        @resource_class ||= @collection.klass if @collection.respond_to? :klass
+        @columns        = []
+        @row_class      = options.delete(:row_class)
+
+        build_table
+        super(options)
+        columns(*attrs)
+      end
+
+      def columns(*attrs)
+        attrs.each {|attr| column(attr) }
+      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 |resource, index|
+          within @tbody.children[index] do
+            build_table_cell col, resource
+          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 do |elem|
+            classes = [cycle('odd', 'even')]
+
+            if @row_class
+              classes << @row_class.call(elem)
+            end
+
+            tr(class: classes.flatten.join(' '), id: dom_id_for(elem))
+          end
+        end
+      end
+
+      def build_table_cell(col, resource)
+        td class: col.html_class do
+          html = format_attribute(resource, col.data)
+          # Don't add the same Arbre twice, while still allowing format_attribute to call status_tag
+          current_arbre_element << html unless current_arbre_element.children.include? html
+        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-#{ActiveAdmin::Dependency.rails.parameterize(@title.to_s)}"
+          end
+          @html_class = html_classes.join(' ')
+          @data = args[1] || args[0]
+          @data = block if block
+          @resource_class = args[2]
+        end
+
+        def sortable?
+          if @options.has_key?(:sortable)
+            !!@options[:sortable]
+          elsif @resource_class
+            @resource_class.column_names.include?(sort_column_name)
+          else
+            @title.present?
+          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
+            @data.to_s
+          elsif @options[:sortable].nil?
+            sort_column_name
+          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
+
+        private
+
+        def sort_column_name
+          @data.is_a?(Symbol) ? @data.to_s : @title.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module ActiveAdmin
+  module Views
+    class Tabs < ActiveAdmin::Component
+      builder_method :tabs
+
+      def tab(title, options = {}, &block)
+        title = title.to_s.titleize if title.is_a? Symbol
+        @menu << build_menu_item(title, options, &block)
+        @tabs_content << build_content_item(title, options, &block)
+      end
+
+      def build(&block)
+        @menu = ul(class: 'nav nav-tabs', role: "tablist")
+        @tabs_content = div(class: 'tab-content')
+      end
+
+      def build_menu_item(title, options, &block)
+        options = options.reverse_merge({})
+        li { link_to title, "##{title.parameterize}", options }
+      end
+
+      def build_content_item(title, options, &block)
+        options = options.reverse_merge(id: title.parameterize)
+        div(options, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module Views
+    class UnsupportedBrowser < Component
+      def build
+        h1 I18n.t("active_admin.unsupported_browser.headline").html_safe
+        para I18n.t("active_admin.unsupported_browser.recommendation").html_safe
+        para I18n.t("active_admin.unsupported_browser.turn_off_compatibility_view").html_safe
+      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.public_send proc
+        else
+          instance_exec post, &proc
+        end
+      end
+
+    end # Posts
+  end
+end