activeadmin 0.3.4 → 0.4.0

data/lib/active_admin/view_helpers/breadcrumb_helper.rb

@@ -2,27 +2,31 @@ module ActiveAdmin
   module ViewHelpers
     module BreadcrumbHelper
 
-      # Returns an array of links to use in a breadcrumb
-      def breadcrumb_links(path = nil)
-        path ||= request.fullpath
-        parts = path.gsub(/^\//, '').split('/')
-        parts.pop unless %w{ create update }.include?(params[:action])
-        crumbs = []
-        parts.each_with_index do |part, index|
-          name = ""
-          if part =~ /^\d/ && parent = parts[index - 1]
-            begin
-              parent_class = parent.singularize.camelcase.constantize
-              obj = parent_class.find(part.to_i)
-              name = obj.display_name if obj.respond_to?(:display_name)
-            rescue
-            end
-          end
-          name = part.titlecase if name == ""
-          crumbs << link_to(name, "/" + parts[0..index].join('/'))
-        end
-        crumbs
-      end
+			# Returns an array of links to use in a breadcrumb
+			def breadcrumb_links(path = nil)
+				path ||= request.fullpath
+				parts = path.gsub(/^\//, '').split('/')
+				parts.pop unless %w{ create update }.include?(params[:action])
+				crumbs = []
+				parts.each_with_index do |part, index|
+					name = ""
+					if part =~ /^\d/ && parent = parts[index - 1]
+						begin
+							parent_class = parent.singularize.camelcase.constantize
+							obj = parent_class.find(part.to_i)
+							name = obj.display_name if obj.respond_to?(:display_name)
+						rescue
+						end
+					end
+					name = part.titlecase if name == ""
+					begin
+						crumbs << link_to( I18n.translate!("activerecord.models.#{part.singularize}", :count => 2), "/" + parts[0..index].join('/'))
+					rescue I18n::MissingTranslationData
+						crumbs << link_to( name, "/" + parts[0..index].join('/'))
+					end
+				end
+				crumbs
+			end
 
     end
   end

data/lib/active_admin/view_helpers/filter_form_helper.rb

@@ -33,154 +33,4 @@ module ActiveAdmin
     end
   end
 
-  # This form builder defines methods to build filter forms such
-  # as the one found in the sidebar of the index page of a standard resource.
-  class FilterFormBuilder < FormBuilder
-
-    def filter(method, options = {})
-      return "" if method.nil? || method == ""
-      options[:as] ||= default_filter_type(method)
-      return "" unless options[:as]
-      field_type = options.delete(:as)
-      options[:label] ||= default_filter_label(method)
-      content = with_new_form_buffer do
-        send("filter_#{field_type}_input", method, options)
-      end
-      @form_buffers.last << template.content_tag(:div, content, :class => "filter_form_field filter_#{field_type}")
-    end
-
-    protected
-
-    def filter_string_input(method, options = {})
-      field_name = "#{method}_contains"
-
-      [ label(field_name, I18n.t('active_admin.search_field', :field => options[:label])),
-        text_field(field_name)
-      ].join("\n").html_safe
-    end
-
-    def filter_date_range_input(method, options = {})
-      gt_field_name = "#{method}_gte"
-      lt_field_name = "#{method}_lte"
-
-      [ label(gt_field_name, options[:label]),
-        filter_date_text_field(gt_field_name),
-        template.content_tag(:span, "-", :class => "seperator"),
-        filter_date_text_field(lt_field_name)
-      ].join("\n").html_safe
-    end
-
-    def filter_date_text_field(method)
-      current_value = @object.send(method)
-      text_field(method, :size => 12, :class => "datepicker", :max => 10, :value => current_value.respond_to?(:strftime) ? current_value.strftime("%Y-%m-%d") : "")
-    end
-
-    def filter_numeric_input(method, options = {})
-      filters = numeric_filters_for_method(method, options.delete(:filters) || default_numeric_filters)
-      current_filter = current_numeric_scope(filters)
-      filter_select = @template.select_tag '', @template.options_for_select(filters, current_filter),
-                                  :onchange => "document.getElementById('#{method}_numeric').name = 'q[' + this.value + ']';"
-      filter_input = text_field current_filter, :size => 10, :id => "#{method}_numeric"
-
-      [ label(method, options[:label]),
-        filter_select,
-        " ",
-        filter_input
-      ].join("\n").html_safe
-    end
-
-    def numeric_filters_for_method(method, filters)
-      filters.collect{|scope| [scope[0], [method,scope[1]].join("_") ] }
-    end
-
-    # Returns the scope for which we are currently searching. If no search is available
-    # it returns the first scope
-    def current_numeric_scope(filters)
-      filters[1..-1].inject(filters.first){|a,b| object.send(b[1].to_sym) ? b : a }[1]
-    end
-
-    def default_numeric_filters
-      [[I18n.t('active_admin.equal_to'), 'eq'], [I18n.t('active_admin.greater_than'), 'gt'], [I18n.t('active_admin.less_than'), 'lt']]
-    end
-
-    def filter_select_input(method, options = {})
-      association_name = method.to_s.gsub(/_id$/, '').to_sym
-      input_name = (generate_association_input_name(method).to_s + "_eq").to_sym
-      collection = find_collection_for_column(association_name, options)
-
-      [ label(input_name, options[:label]),
-        select(input_name, collection, options.merge(:include_blank => I18n.t('active_admin.any')))
-      ].join("\n").html_safe
-    end
-
-    def filter_check_boxes_input(method, options = {})
-      input_name = (generate_association_input_name(method).to_s + "_in").to_sym
-      collection = find_collection_for_column(method, options)
-      selected_values = @object.send(input_name) || []
-      checkboxes = template.content_tag :div, :class => "check_boxes_wrapper" do
-        collection.map do |c|
-          label = c.is_a?(Array) ? c.first : c
-          value = c.is_a?(Array) ? c.last : c
-          "<label><input type=\"checkbox\" name=\"q[#{input_name}][]\" value=\"#{value}\" #{selected_values.include?(value) ? "checked" : ""}/> #{label}</label>"
-        end.join("\n").html_safe
-      end
-
-      [ label(input_name, options[:label]),
-        checkboxes
-      ].join("\n").html_safe
-    end
-
-    # Override the standard finder to accept a proc
-    def find_collection_for_column(method, options = {})
-      options = options.dup
-      case options[:collection]
-      when Proc
-        options[:collection] = options[:collection].call
-      end
-      super(method, options)
-    end
-
-    # Returns the default filter type for a given attribute
-    def default_filter_type(method)
-      if column = column_for(method)
-        case column.type
-        when :date, :datetime
-          return :date_range
-        when :string, :text
-          return :string
-        when :integer
-          return :select if reflection_for(method.to_s.gsub('_id','').to_sym)
-          return :numeric
-        when :float, :decimal
-          return :numeric
-        end
-      end
-
-      if reflection = reflection_for(method)
-        return :select if reflection.macro == :belongs_to && !reflection.options[:polymorphic]
-      end
-    end
-
-    # Returns the default label for a given attribute
-    # Will use ActiveModel I18n if possible
-    def default_filter_label(method)
-      if @object.base.respond_to?(:human_attribute_name)
-        @object.base.human_attribute_name(method)
-      else
-        method.to_s.titlecase
-      end
-    end
-
-    # Returns the column for an attribute on the object being searched
-    # if it exists. Otherwise returns nil
-    def column_for(method)
-      @object.base.columns_hash[method.to_s] if @object.base.respond_to?(:columns_hash)
-    end
-
-    # Returns the association reflection for the method if it exists
-    def reflection_for(method)
-      @object.base.reflect_on_association(method) if @object.base.respond_to?(:reflect_on_association)
-    end
-
-  end
 end

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

@@ -45,7 +45,7 @@ module ActiveAdmin
       def content_for(attr_or_proc)
         value = case attr_or_proc
                 when Proc
-                  attr_or_proc.call
+                  attr_or_proc.call(@record)
                 else
                   content_for_attribute(attr_or_proc)
                 end

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

@@ -14,6 +14,10 @@ module ActiveAdmin
         calculate_columns!
       end
 
+      def to_s
+        super.to_s + "<div style=\"clear:both;\"></div>".html_safe
+      end
+
       protected
 
       def margin_size
@@ -35,10 +39,6 @@ module ActiveAdmin
         end
       end
 
-      def to_html
-        super.to_s + "<div style=\"clear:both;\"></div>".html_safe
-      end
-
     end
 
     class Column < ActiveAdmin::Component

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

@@ -23,6 +23,7 @@ module ActiveAdmin
     class PaginatedCollection < ActiveAdmin::Component
       builder_method :paginated_collection
 
+      attr_reader :collection
 
       # Builds a new paginated collection component
       #
@@ -30,12 +31,21 @@ module ActiveAdmin
       # @param [Hash]  options     These options will be passed on to the page_entries_info
       #                            method.
       #                            Useful keys:
-      #                             :entry_name - The name to display for this resource collection
+      #                              :entry_name - The name to display for this resource collection
+      #                              :param_name - Parameter name for page number in the links (:page by default)
+      #                              :download_links - Set to false to skip download format links
       def build(collection, options = {})
         @collection = collection
-        div(page_entries_info(options).html_safe, :class => "pagination_information")
+        @param_name     = options.delete(:param_name)
+        @download_links = options.delete(:download_links)
+
+        unless collection.respond_to?(:num_pages)
+          raise(StandardError, "Collection is not a paginated scope. Set collection.page(params[:page]).per(10) before calling :paginated_collection.")
+        end
+        
+      
         @contents = div(:class => "paginated_collection_contents")
-        build_pagination_with_formats
+        build_pagination_with_formats(options)
         @built = true
       end
 
@@ -50,15 +60,19 @@ module ActiveAdmin
 
       protected
 
-      def build_pagination_with_formats
+      def build_pagination_with_formats(options)
         div :id => "index_footer" do
-          build_download_format_links
           build_pagination
+          div(page_entries_info(options).html_safe, :class => "pagination_information")
+          build_download_format_links unless @download_links == false
         end
       end
 
       def build_pagination
-        text_node paginate(collection)
+        options =  request.query_parameters.except(:commit, :format)
+        options[:param_name] = @param_name if @param_name
+
+        text_node paginate(collection, options.symbolize_keys)
       end
 
       # TODO: Refactor to new HTML DSL
@@ -66,24 +80,39 @@ module ActiveAdmin
         links = formats.collect do |format|
           link_to format.to_s.upcase, { :format => format}.merge(request.query_parameters.except(:commit, :format))
         end
-        text_node [I18n.t('active_admin.download'), links].flatten.join("&nbsp;").html_safe
+        div :class => "download_links" do
+		  text_node [I18n.t('active_admin.download'), links].flatten.join("&nbsp;").html_safe
+        end
       end
 
       # modified from will_paginate
       def page_entries_info(options = {})
-        entry_name = options[:entry_name] ||
-          (collection.empty?? 'entry' : collection.first.class.name.underscore.sub('_', ' '))
+        if options[:entry_name]
+          entry_name = options[:entry_name]
+          entries_name = options[:entries_name]
+        elsif collection.empty?
+          entry_name = I18n.translate("active_admin.pagination.entry", :count => 1, :default => 'entry')
+          entries_name = I18n.translate("active_admin.pagination.entry", :count => 2, :default => 'entries')
+        else
+          begin
+            entry_name = I18n.translate!("activerecord.models.#{collection.first.class.model_name.i18n_key}", :count => 1)
+            entries_name = I18n.translate!("activerecord.models.#{collection.first.class.model_name.i18n_key}", :count => collection.size)
+          rescue I18n::MissingTranslationData
+            entry_name = collection.first.class.name.underscore.sub('_', ' ')
+          end
+        end
+        entries_name = entry_name.pluralize unless entries_name
 
         if collection.num_pages < 2
           case collection.size
-          when 0; I18n.t('active_admin.pagination.empty', :model => entry_name.pluralize)
+          when 0; I18n.t('active_admin.pagination.empty', :model => entries_name)
           when 1; I18n.t('active_admin.pagination.one', :model => entry_name)
-          else;   I18n.t('active_admin.pagination.one_page', :model => entry_name.pluralize, :n => collection.size)
+          else;   I18n.t('active_admin.pagination.one_page', :model => entries_name, :n => collection.total_count)
           end
         else
-          offset = collection.current_page * active_admin_application.default_per_page
+          offset = collection.current_page * collection.size
           total  = collection.total_count
-          I18n.t('active_admin.pagination.multiple', :model => entry_name.pluralize, :from => (offset - active_admin_application.default_per_page + 1), :to => offset > total ? total : offset, :total => total)
+          I18n.t('active_admin.pagination.multiple', :model => entries_name, :from => (offset - collection.size + 1), :to => offset > total ? total : offset, :total => total)
         end
       end
 

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

@@ -20,6 +20,14 @@ module ActiveAdmin
           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

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

@@ -6,30 +6,40 @@ module ActiveAdmin
     class Scopes < ActiveAdmin::Component
       builder_method :scopes_renderer
 
+      include ActiveAdmin::ScopeChain
+
+      def default_class_name
+        "scopes table_tools_segmented_control"
+      end
+
+      def tag_name
+        'ul'
+      end
+
       def build(scopes)
-        scopes.each do |scope|
-          build_scope(scope)
+        unless current_filter_search_empty?
+          scopes.each do |scope|
+            build_scope(scope) if call_method_or_proc_on(self, scope.display_if_block)
+          end
         end
       end
 
       protected
 
       def build_scope(scope)
-        span :class => classes_for_scope(scope) do
+        li :class => classes_for_scope(scope) do
           begin
-            scope_name = I18n.t!("active_admin.scopes.#{scope.scope_method}")
+            scope_name = I18n.t!("active_admin.scopes.#{scope.id}")
           rescue I18n::MissingTranslationData
             scope_name = scope.name
           end
 
-          if current_scope?(scope)
-            em(scope_name)
-          else
-            a(scope_name, :href => url_for(params.merge(:scope => scope.id, :page => 1)))
+          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).to_s + ")"
+            end
           end
-          text_node(" ")
-          scope_count(scope)
-          text_node(" ")
         end
       end
 
@@ -47,21 +57,17 @@ module ActiveAdmin
         end
       end
 
-      def scope_count(scope)
-        span :class => 'count' do
-          "(" + get_scope_count(scope).to_s + ")"
-        end
+      def current_filter_search_empty?
+        collection.empty? && params.include?(:q)
       end
 
-      include ActiveAdmin::ScopeChain
-
       # Return the count for the scope passed in.
       def get_scope_count(scope)
         scope_chain(scope, scoping_class).count
       end
 
       def scoping_class
-        assigns["before_scope_collection"] || active_admin_config.resource
+        assigns["before_scope_collection"] || active_admin_config.resource_class
       end
 
     end

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

@@ -16,7 +16,7 @@ module ActiveAdmin
       #
       # @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 etc
+      # @param [Hash] options such as :class, :id and :label to override the default label
       #
       # @return [ActiveAdmin::Views::StatusTag]
       #
@@ -27,18 +27,19 @@ module ActiveAdmin
       #   status_tag('active', :ok)
       #   # => <span class='status active ok'>Active</span>
       #
-      #   status_tag('active', :ok, :class => 'important', :id => 'status_123')
-      #   # => <span class='status active ok important' id='status_123'>Active</span>
+      #   status_tag('active', :ok, :class => 'important', :id => 'status_123', :label => 'on')
+      #   # => <span class='status 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 = status.titleize if status
+        content = label || status.titleize if status
 
-        super(status, options)
+        super(content, options)
 
         add_class(status_to_class(status)) if status
         add_class(type.to_s) if type