active_scaffold 3.2.20 → 3.3.0.rc

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -61,7 +61,7 @@ module ActiveScaffold
         associated.collect!(&:to_i)
         
         if column.association
-          select_options = options_for_association(column.association, false)
+          select_options = sorted_association_options_find(column.association).collect {|r| [r.to_label, r.id]}
         else
           select_options = column.options[:options].collect do |text, value|
             active_scaffold_translated_option(column, text, value)
@@ -77,7 +77,7 @@ module ActiveScaffold
         if column.association
           associated = associated.is_a?(Array) ? associated.map(&:to_i) : associated.to_i unless associated.nil?
           method = column.association.macro == :belongs_to ? column.association.foreign_key : column.name
-          select_options = options_for_association(column.association, true)
+          select_options = sorted_association_options_find(column.association, false)
         else
           method = column.name
           select_options = column.options[:options].collect do |text, value|
@@ -92,7 +92,14 @@ module ActiveScaffold
         else
           options[:include_blank] ||= as_(:_select_) 
         end
-        select(:record, method, select_options, options, html_options)
+        
+        if optgroup = options.delete(:optgroup)
+          select(:record, method, grouped_options_for_select(column, select_options, optgroup), options, html_options)
+        elsif column.association
+          collection_select(:record, method, select_options, :id, :to_label, options, html_options)
+        else
+          select(:record, method, select_options, options, html_options)
+        end
       end
 
       def active_scaffold_search_text(column, options)

data/lib/active_scaffold/helpers/show_column_helpers.rb

@@ -8,25 +8,20 @@ module ActiveScaffold
           # we only pass the record as the argument. we previously also passed the formatted_value,
           # but mike perham pointed out that prohibited the usage of overrides to improve on the
           # performance of our default formatting. see issue #138.
-          if method(method).arity == 1
-            ActiveSupport::Deprecation.warn("Add column argument to field override, signature is unified with list_ui")
-            send(method, record)
-          else
-            send(method, record, column)
-          end
+          send(method, record, column)
         # second, check if the dev has specified a valid list_ui for this column
         elsif column.list_ui and (method = override_show_column_ui(column.list_ui))
-          send(method, column, record)
+          send(method, record, column)
         else
           if column.column and (method = override_show_column_ui(column.column.type))
-            send(method, column, record)
+            send(method, record, column)
           else
             get_column_value(record, column)
           end
         end
       end
 
-      def active_scaffold_show_text(column, record)
+      def active_scaffold_show_text(record, column)
         simple_format(clean_column_value(record.send(column.name)))
       end
 

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -3,6 +3,7 @@ module ActiveScaffold
     # All extra helpers that should be included in the View.
     # Also a dumping ground for uncategorized helpers.
     module ViewHelpers
+      NESTED_PARAMS = [:eid, :association, :parent_scaffold]
       include ActiveScaffold::Helpers::IdHelpers
       include ActiveScaffold::Helpers::AssociationHelpers
       include ActiveScaffold::Helpers::PaginationHelpers
@@ -99,61 +100,243 @@ module ActiveScaffold
         javascript_tag("ActiveScaffold.create_visibility_toggle('#{id}', #{options.to_json});")
       end
 
-      def skip_action_link(link, *args)
-        (!link.ignore_method.nil? && controller.respond_to?(link.ignore_method) && controller.send(link.ignore_method, *args)) || ((link.security_method_set? or controller.respond_to? link.security_method) and !controller.send(link.security_method, *args))
+      def skip_action_link?(link, *args)
+        !link.ignore_method.nil? && controller.respond_to?(link.ignore_method) && controller.send(link.ignore_method, *args)
       end
 
-      def render_action_link(link, url_options, record = nil, html_options = {})
-        url_options = action_link_url_options(link, url_options, record)
-        html_options = action_link_html_options(link, url_options, record, html_options)
-        action_link_html(link, url_options, html_options, record)
+      def action_link_authorized?(link, *args)
+        security_method = link.security_method_set? || controller.respond_to?(link.security_method)
+        authorized = if security_method
+          controller.send(link.security_method, *args)
+        else
+          args.empty? ? true : args.first.authorized_for?(:crud_type => link.crud_type, :action => link.action)
+        end
+      end
+
+      def display_action_links(action_links, record, options, &block)
+        options[:level_0_tag] ||= nil
+        options[:options_level_0_tag] ||= nil
+        options[:level] ||= 0
+        options[:first_action] = true
+        output = ActiveSupport::SafeBuffer.new
+
+        action_links.each(:reverse => options.delete(:reverse), :groups => true) do |link|
+          if link.is_a? ActiveScaffold::DataStructures::ActionLinks
+            unless link.empty?
+              options[:level] += 1
+              content = display_action_links(link, record, options, &block)
+              options[:level] -= 1
+              if content.present?
+                output << display_action_link(link, content, record, options)
+                options[:first_action] = false
+              end
+            end
+          elsif !skip_action_link?(link, *Array(options[:for]))
+            authorized = action_link_authorized?(link, *Array(options[:for]))
+            next if !authorized && options[:skip_unauthorized]
+            output << display_action_link(link, nil, record, options.merge(:authorized => authorized))
+            options[:first_action] = false
+          end
+        end
+        output
+      end
+
+      def display_action_link(link, content, record, options)
+        if content
+          html_classes = hover_via_click? ? 'hover_click ' : ''
+          if options[:level] == 0
+            html_classes << 'action_group'
+            group_tag = :div
+          else
+            html_classes << 'top' if options[:first_action]
+            group_tag = :li
+          end
+          content = content_tag(group_tag, :class => (html_classes if html_classes.present?), :onclick => ('' if hover_via_click?)) do
+            content_tag(:div, as_(link.name), :class => link.name.to_s.downcase) << content_tag(:ul, content)
+          end
+        else
+          content = render_action_link(link, record, options)
+          content = content_tag(:li, content, :class => ('top' if options[:first_action])) unless options[:level] == 0
+        end
+        content = content_tag(options[:level_0_tag], content, options[:options_level_0_tag]) if options[:level] == 0 && options[:level_0_tag]
+        content
+      end
+
+      def render_action_link(link, record = nil, options = {})
+        if link.action.nil? || link.column.try(:polymorphic_association?)
+          link = action_link_to_inline_form(link, record)
+          options[:authorized] = false if link.action.nil? || link.controller.nil?
+          options.delete :link if link.crud_type == :create
+        end
+        if link.action.nil? || (link.type == :member && options.has_key?(:authorized) && !options[:authorized])
+          action_link_html(link, nil, options.merge(:class => "disabled #{link.action}#{" #{link.html_options[:class]}" unless link.html_options[:class].blank?}"), record)
+        else
+          url = action_link_url(link, record)
+          html_options = action_link_html_options(link, record, options)
+          action_link_html(link, url, html_options, record)
+        end
+      end
+
+      # setup the action link to inline form
+      def action_link_to_inline_form(link, record)
+        link = link.clone
+        associated = record.send(link.column.association.name)
+        if link.column.polymorphic_association?
+          link.controller = controller_path_for_activerecord(associated.class)
+          return link if link.controller.nil?
+        end
+        link = configure_column_link(link, record, associated) if link.action.nil?
+        link
       end
 
-      def render_group_action_link(link, url_options, options, record = nil)
-        if link.type == :member && !options[:authorized]
-          action_link_html(link, nil, {:class => "disabled #{link.action}#{link.html_options[:class].blank? ? '' : (' ' + link.html_options[:class])}"}, record)
+      def configure_column_link(link, record, associated, actions = nil)
+        actions ||= link.column.actions_for_association_links
+        if column_empty?(associated) # if association is empty, we only can link to create form
+          if actions.include?(:new)
+            link.action = 'new'
+            link.crud_type = :create
+            link.label ||= as_(:create_new)
+          end
+        elsif actions.include?(:edit)
+          link.action = 'edit'
+          link.crud_type = :update
+        elsif actions.include?(:show)
+          link.action = 'show'
+          link.crud_type = :read
+        elsif actions.include?(:list)
+          link.action = 'index'
+          link.crud_type = :read
+        end
+        
+        unless column_link_authorized?(link, link.column, record, associated)
+          link.action = nil
+          # if action is edit and is not authorized, fallback to show if it's enabled
+          if link.crud_type == :update && actions.include?(:show)
+            link = configure_column_link(link, record, associated, [:show])
+          end
+        end
+        link
+      end
+
+      def column_link_authorized?(link, column, record, associated)
+        if column.association
+          associated_for_authorized = if column.plural_association? || (associated.respond_to?(:blank?) && associated.blank?)
+            column.association.klass
+          else
+            associated
+          end
+          authorized = associated_for_authorized.authorized_for?(:crud_type => link.crud_type)
+          authorized = authorized and record.authorized_for?(:crud_type => :update, :column => column.name) if link.crud_type == :create
+          authorized
         else
-          render_action_link(link, url_options, record)
+          record.authorized_for?(:crud_type => link.crud_type)
         end
       end
+
+      def action_link_url(link, record)
+        url = (@action_links_urls ||= {})[link.name_to_cache_link_url]
+        url ||= begin
+          url_options = action_link_url_options(link, record)
+          if active_scaffold_config.cache_action_link_urls
+            url = url_for(url_options)
+            @action_links_urls[link.name_to_cache_link_url] = url unless link.dynamic_parameters.is_a?(Proc)
+            url
+          else
+            url_for(params_for(url_options))
+          end
+        end
+        
+        url = record ? url.sub('--ID--', record.id.to_s) : url.clone
+        if link.column.try(:singular_association?)
+          url = url.sub('--CHILD_ID--', record.send(link.column.association.name).try(:id).to_s) 
+        elsif nested?
+          url = url.sub('--CHILD_ID--', params[nested.param_name].to_s)
+        end
+
+        if active_scaffold_config.cache_action_link_urls
+          query_string, non_nested_query_string = query_string_for_action_links(link)
+          if query_string || (!link.nested_link? && non_nested_query_string)
+            url << (url.include?('?') ? '&' : '?')
+            url << query_string if query_string
+            url << non_nested_query_string if !link.nested_link? && non_nested_query_string
+          end
+        end
+        url
+      end
+
+      def query_string_for_action_links(link)
+        if defined?(@query_string) && link.parameters.none? { |k, v| @query_string_params.include? k }
+          return [@query_string, @non_nested_query_string]
+        end
+        keep = true
+        @query_string_params ||= Set.new
+        query_string_for_all = nil
+        query_string_options = []
+        non_nested_query_string_options = []
+        
+        params_for.except(:controller, :action, :id).each do |key, value|
+          @query_string_params << key
+          if link.parameters.include? key
+            keep = false
+            next
+          end
+          qs = "#{key}=#{value}"
+          if NESTED_PARAMS.include?(key) || conditions_from_params.include?(key) || (nested? && nested.param_name == key)
+            non_nested_query_string_options << qs
+          else
+            query_string_options << qs
+          end
+        end
+        
+        query_string = URI.escape(query_string_options.join('&')) if query_string_options.present?
+        if non_nested_query_string_options.present?
+          non_nested_query_string = "#{'&' if query_string}#{URI.escape(non_nested_query_string_options.join('&'))}"
+        end
+        if keep
+          @query_string = query_string
+          @non_nested_query_string = non_nested_query_string
+        end
+        [query_string, non_nested_query_string]
+      end
       
-      def action_link_url_options(link, url_options, record, options = {})
-        url_options = url_options.clone
-        url_options[:action] = link.action
+      def action_link_url_options(link, record)
+        url_options = {:action => link.action}
+        url_options[:id] = '--ID--' unless record.nil?
         url_options[:controller] = link.controller.to_s if link.controller
-        url_options.delete(:search) if link.controller and link.controller.to_s != params[:controller]
         url_options.merge! link.parameters if link.parameters
         if link.dynamic_parameters.is_a?(Proc)
           if record.nil?
             url_options.merge! link.dynamic_parameters.call
-          elsif link.dynamic_parameters.arity == 0
-            ActiveSupport::Deprecation.warn("dynamic_parameters must be a block with an argument for member action links, instead of using @link_record")
-            @link_record = record
-            url_options.merge! self.instance_eval(&(link.dynamic_parameters))
-            @link_record = nil
           else
             url_options.merge! link.dynamic_parameters.call(record)
           end
         end
-        url_options_for_nested_link(link.column, record, link, url_options, options) if link.nested_link?
-        url_options_for_sti_link(link.column, record, link, url_options, options) unless record.nil? || active_scaffold_config.sti_children.nil?
+        if link.nested_link?
+          url_options_for_nested_link(link.column, record, link, url_options)
+        elsif nested?
+          url_options[nested.param_name] = '--CHILD_ID--'
+        end
+        url_options_for_sti_link(link.column, record, link, url_options) unless record.nil? || active_scaffold_config.sti_children.nil?
         url_options[:_method] = link.method if !link.confirm? && link.inline? && link.method != :get
         url_options
       end
       
-      def action_link_html_options(link, url_options, record, html_options)
-        link_id = get_action_link_id(url_options, record, link.column)
+      def action_link_html_options(link, record, html_options)
+        link_id = get_action_link_id(link, record)
         html_options.reverse_merge! link.html_options.merge(:class => link.action.to_s)
 
         # Needs to be in html_options to as the adding _method to the url is no longer supported by Rails        
         html_options[:method] = link.method if link.method != :get
 
-        html_options[:class] += ' as_action' if link.inline?
         html_options[:data] = {}
         html_options[:data][:confirm] = link.confirm(record.try(:to_label)) if link.confirm?
-        html_options[:data][:position] = link.position if link.position and link.inline?
-        html_options[:data][:action] = link.action if link.inline?
-        html_options[:data][:'cancel-refresh'] = true if link.inline? and link.refresh_on_close
+        if link.inline?
+          html_options[:class] += ' as_action'
+          html_options[:data][:position] = link.position if link.position
+          html_options[:data][:action] = link.action
+          html_options[:data][:cancel_refresh] = true if link.refresh_on_close
+          html_options[:data][:keep_open] = true if link.keep_open?
+        end
         if link.popup?
           html_options[:data][:popup] = true
           html_options[:target] = '_blank'
@@ -161,8 +344,10 @@ module ActiveScaffold
         html_options[:id] = link_id
         html_options[:remote] = true unless link.page? || link.popup?
         if link.dhtml_confirm?
-          html_options[:class] += ' as_action' if !link.inline?
-          html_options[:page_link] = 'true' if !link.inline?
+          unless link.inline?
+            html_options[:class] += ' as_action'
+            html_options[:page_link] = 'true'
+          end
           html_options[:dhtml_confirm] = link.dhtml_confirm.value
           html_options[:onclick] = link.dhtml_confirm.onclick_function(controller, link_id)
         end
@@ -170,48 +355,49 @@ module ActiveScaffold
         html_options
       end
 
-      def get_action_link_id(url_options, record = nil, column = nil)
-        id = url_options[:id] || url_options[:parent_id]
-        id = "#{column.association.name}-#{record.id}" if column && column.plural_association?
-        if record.try(column.association.name.to_sym).present?
-          id = "#{column.association.name}-#{record.send(column.association.name).id}-#{record.id}"
-        else
-          id = "#{column.association.name}-#{record.id}" unless record.nil?
-        end if column && column.singular_association?
-        id = "#{id}-#{url_options[:batch_scope].downcase}" if url_options[:batch_scope]
-        action_id = "#{id_from_controller(url_options[:controller]) + '-' if url_options[:parent_controller] || url_options[:controller] != controller.controller_path}#{url_options[:action].to_s}"
+      def get_action_link_id(link, record = nil, column = nil)
+        column ||= link.column
+        id = record ? record.id.to_s : (nested? ? nested.parent_id : '')
+        if column && column.plural_association?
+          id = "#{column.association.name}-#{record.id}"
+        elsif column && column.singular_association?
+          if record.try(column.association.name.to_sym).present?
+            id = "#{column.association.name}-#{record.send(column.association.name).id}-#{record.id}"
+          else
+            id = "#{column.association.name}-#{record.id}" unless record.nil?
+          end
+        end
+        action_id = "#{id_from_controller("#{link.controller}-") if params[:parent_controller] || link.controller != controller.controller_path}#{link.action}"
         action_link_id(action_id, id)
       end
       
       def action_link_html(link, url, html_options, record)
-        # issue 260, use url_options[:link] if it exists. This prevents DB data from being localized.
-        label = url.delete(:link) if url.is_a?(Hash) 
+        label = html_options.delete(:link)
         label ||= link.label
-        if link.image.nil?
-          html = link_to(label, url, html_options)
+        label = image_tag(link.image[:name], :size => link.image[:size], :alt => label, :title => label) if link.image
+        if url.nil?
+          content_tag(:a, label, html_options)
         else
-          html = link_to(image_tag(link.image[:name], :size => link.image[:size], :alt => label, :title => label), url, html_options)
+          link_to(label, url, html_options)
         end
-        # if url is nil we would like to generate an anchor without href attribute
-        url.nil? ? html.sub(/href=".*?"/, '').html_safe : html.html_safe
       end
       
-      def url_options_for_nested_link(column, record, link, url_options, options = {})
+      def url_options_for_nested_link(column, record, link, url_options)
         if column && column.association
           url_options[:parent_scaffold] = controller_path
           url_options[column.association.active_record.name.foreign_key.to_sym] = url_options.delete(:id)
-          url_options[:id] = record.send(column.association.name).id if column.singular_association? && record.send(column.association.name).present?
-          url_options[:eid] = nil # needed for nested scaffolds open from an embedded scaffold
+          if column.singular_association? && url_options[:action].to_sym != :index
+            url_options[:id] = '--CHILD_ID--'
+          else
+            url_options[:id] = nil
+          end
         elsif link.parameters && link.parameters[:named_scope]
           url_options[:parent_scaffold] = controller_path
           url_options[active_scaffold_config.model.name.foreign_key.to_sym] = url_options.delete(:id)
-          url_options[:eid] = nil # needed for nested scaffolds open from an embedded scaffold
         end
-        url_options.except! *params_conditions
-        url_options.except! *nested.constrained_fields if nested?
       end
 
-      def url_options_for_sti_link(column, record, link, url_options, options = {})
+      def url_options_for_sti_link(column, record, link, url_options)
         #need to find out controller of current record type
         #and set parameters
         # its quite difficult to detect an sti link
@@ -226,9 +412,15 @@ module ActiveScaffold
         end
       end
 
-      def list_row_class(record)
+      def list_row_class_method(record)
+        return @_list_row_class_method if defined? @_list_row_class_method
         class_override_helper = :"#{clean_class_name(record.class.name)}_list_row_class"
-        respond_to?(class_override_helper) ? send(class_override_helper, record) : ''
+        @_list_row_class_method = (class_override_helper if respond_to?(class_override_helper))
+      end
+
+      def list_row_class(record)
+        class_override_helper = list_row_class_method(record)
+        class_override_helper ? send(class_override_helper, record) : ''
       end
 
       def column_attributes(column, record)
@@ -238,39 +430,39 @@ module ActiveScaffold
       end
 
       def column_class(column, column_value, record)
-        classes = []
-        classes << "#{column.name}-column"
+        @_column_classes ||= {}
+        @_column_classes[column.name] ||= begin
+          classes = "#{column.name}-column "
+          classes << 'sorted ' if active_scaffold_config.list.user.sorting.sorts_on?(column)
+          classes << 'numeric ' if column.column and [:decimal, :float, :integer].include?(column.column.type)
+          classes << column.css_class unless column.css_class.nil? || column.css_class.is_a?(Proc)
+        end
+        classes = "#{@_column_classes[column.name]} "
+        classes << 'empty ' if column_empty? column_value
+        classes << 'in_place_editor_field ' if inplace_edit?(record, column) or column.list_ui == :marked
         if column.css_class.is_a?(Proc)
           css_class = column.css_class.call(column_value, record)
           classes << css_class unless css_class.nil?
-        else
-          classes << column.css_class
-        end unless column.css_class.nil?
-         
-        classes << 'empty' if column_empty? column_value
-        classes << 'sorted' if active_scaffold_config.list.user.sorting.sorts_on?(column)
-        classes << 'numeric' if column.column and [:decimal, :float, :integer].include?(column.column.type)
-        classes << 'in_place_editor_field' if inplace_edit?(record, column) or column.list_ui == :marked
-        classes.join(' ').rstrip
+        end
+        classes
       end
       
       def column_heading_class(column, sorting)
-        classes = []
-        classes << "#{column.name}-column_heading"
-        classes << "sorted #{sorting.direction_of(column).downcase}" if sorting.sorts_on? column
+        classes = "#{column.name}-column_heading "
+        classes << "sorted #{sorting.direction_of(column).downcase} " if sorting.sorts_on? column
         classes << column.css_class unless column.css_class.nil? || column.css_class.is_a?(Proc)
-        classes.join(' ')
+        classes
       end
 
       def as_main_div_class
-        classes = ["active-scaffold", "active-scaffold-#{controller_id}", "#{id_from_controller params[:controller]}-view", "#{active_scaffold_config.theme}-theme"]
-        classes << "as_touch" if touch_device?
-        classes.join(' ')
+        classes = "active-scaffold active-scaffold-#{controller_id}  #{id_from_controller params[:controller]}-view #{active_scaffold_config.theme}-theme"
+        classes << " as_touch" if touch_device?
+        classes
       end
 
       def column_empty?(column_value)
         empty = column_value.nil?
-        empty ||= column_value.blank? if column_value.respond_to? :blank?
+        empty ||= column_value.blank?
         empty ||= ['&nbsp;', active_scaffold_config.list.empty_field_text].include? column_value if String === column_value
         return empty
       end
@@ -315,10 +507,18 @@ module ActiveScaffold
       end
 
       def override_helper(column, suffix)
-        method_with_class = override_helper_name(column, suffix, true)
-        return method_with_class if respond_to?(method_with_class)
-        method = override_helper_name(column, suffix)
-        method if respond_to?(method)
+        @_override_helpers ||= {}
+        @_override_helpers[suffix] ||= {}
+        return @_override_helpers[suffix][column.name] if @_override_helpers[suffix].include? column.name
+        @_override_helpers[suffix][column.name] = begin
+          method_with_class = override_helper_name(column, suffix, true)
+          if respond_to?(method_with_class)
+            method_with_class
+          else
+            method = override_helper_name(column, suffix)
+            method if respond_to?(method)
+          end
+        end
       end
 
       def display_message(message)