activeadmin_addons 0.12.0 → 1.0.0

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/views/components/table_for.rb

@@ -0,0 +1,237 @@
+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 |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 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, 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.public_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? :has_attribute?
+          item.has_attribute?(data) &&
+            item.column_for_attribute(data) &&
+            item.column_for_attribute(data).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 @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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/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/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/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