andrewroth_activeadmin 0.3.4 → 0.3.4.1

data/lib/active_admin/router.rb

@@ -28,27 +28,33 @@ module ActiveAdmin
 
       # Now define the routes for each resource
       router.instance_exec(@application.namespaces) do |namespaces|
-        resources = namespaces.values.collect{|n| n.resources.values }.flatten
+        resources = namespaces.values.collect{|n| n.resources.resources }.flatten
         resources.each do |config|
 
           # Define the block the will get eval'd within the namespace
           route_definition_block = Proc.new do
-            resources config.underscored_resource_name.pluralize do
-
-              # Define any member actions
-              member do
-                config.member_actions.each do |action|
-                  # eg: get :comment
-                  send(action.http_verb, action.name)
+            case config
+            when Resource
+              resources config.underscored_resource_name.pluralize do
+                # Define any member actions
+                member do
+                  config.member_actions.each do |action|
+                    # eg: get :comment
+                    send(action.http_verb, action.name)
+                  end
                 end
-              end
 
-              # Define any collection actions
-              collection do
-                config.collection_actions.each do |action|
-                  send(action.http_verb, action.name)
+                # Define any collection actions
+                collection do
+                  config.collection_actions.each do |action|
+                    send(action.http_verb, action.name)
+                  end
                 end
               end
+            when Page
+              match "/#{config.underscored_resource_name}" => "#{config.underscored_resource_name}#index"
+            else
+              raise "Unsupported config class: #{config.class}"
             end
           end
 
@@ -60,7 +66,8 @@ module ActiveAdmin
               instance_eval &routes_for_belongs_to if config.belongs_to_config.optional?
 
               # Make the nested belongs_to routes
-              resources config.belongs_to_config.target.underscored_resource_name.pluralize do
+              # :only is set to nothing so that we don't clobber any existing routes on the resource
+              resources config.belongs_to_config.target.underscored_resource_name.pluralize, :only => [] do
                 instance_eval &routes_for_belongs_to
               end
             end

data/lib/active_admin/scope.rb

@@ -1,7 +1,7 @@
 module ActiveAdmin
   class Scope
 
-    attr_reader :name, :scope_method, :id, :scope_block
+    attr_reader :name, :scope_method, :id, :scope_block, :display_if_block
 
     # Create a Scope
     #
@@ -13,11 +13,14 @@ module ActiveAdmin
     #   Scope.new('Published', :public)
     #   # => Scope with name 'Published' and scope method :public
     #
+    #   Scope.new('Published', :public, :if => proc { current_admin_user.can?( :manage, active_admin_config.resource_class ) } ) { |articles| articles.where(:published => true) }
+    #   # => Scope with name 'Published' and scope method :public, optionally displaying the scope per the :if block, using a block
+    #
     #   Scope.new('Published') { |articles| articles.where(:published => true) }
     #   # => Scope with name 'Published' using a block to scope
     #
-    def initialize(name, method = nil, &block)
-      @name = name.to_s.titleize
+    def initialize(name, method = nil, options = {}, &block)
+      @name = name.is_a?( String ) ? name : name.to_s.titleize
       @scope_method = method
       # Scope ':all' means no scoping
       @scope_method ||= name.to_sym unless name.to_sym == :all
@@ -26,6 +29,15 @@ module ActiveAdmin
         @scope_method = nil
         @scope_block = block
       end
+
+      @display_if_block = options[:if]
     end
+
+    # Returns the display if block. If the block was not explicitly defined
+    # a default block always returning true will be returned.
+    def display_if_block
+      @display_if_block || proc{ true }
+    end
+
   end
 end

data/lib/active_admin/version.rb

@@ -1,3 +1,3 @@
 module ActiveAdmin
-  VERSION = '0.3.4'
+  VERSION = '0.3.4.1'
 end

data/lib/active_admin/view_factory.rb

@@ -15,9 +15,10 @@ module ActiveAdmin
     register  :dashboard_page     => ActiveAdmin::Views::Pages::Dashboard,
               :index_page         => ActiveAdmin::Views::Pages::Index,
               :show_page          => ActiveAdmin::Views::Pages::Show,
-              :new_page           => ActiveAdmin::Views::Pages::New,
-              :edit_page          => ActiveAdmin::Views::Pages::Edit,
-              :layout             => ActiveAdmin::Views::Pages::Layout
+              :new_page           => ActiveAdmin::Views::Pages::Form,
+              :edit_page          => ActiveAdmin::Views::Pages::Form,
+              :layout             => ActiveAdmin::Views::Pages::Layout,
+              :page               => ActiveAdmin::Views::Pages::Page
 
   end
 end

data/lib/active_admin/view_helpers/auto_link_helper.rb

@@ -24,19 +24,10 @@ module ActiveAdmin
 
       # Returns the ActiveAdmin::Resource instance for a class
       def active_admin_resource_for(klass)
+        return nil unless respond_to?(:active_admin_namespace)
         active_admin_namespace.resource_for(klass)
       end
 
-      # Returns the current Active Admin namespace
-      def active_admin_namespace
-        if respond_to?(:active_admin_config) && active_admin_config
-          active_admin_config.namespace
-        else
-          # Return a default namespace if none exists
-          active_admin_application.find_or_create_namespace(active_admin_application.default_namespace)
-        end
-      end
-
     end
   end
 end

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/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.size)
           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