brisk-bills 0.7.0 → 0.8.1

data/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/pagination_helpers.rb

@@ -2,35 +2,61 @@ module ActiveScaffold
   module Helpers
     module PaginationHelpers
       def pagination_ajax_link(page_number, params)
+        url = url_for params.merge(:page => page_number)
         page_link = link_to_remote(page_number,
-                  { :url => params.merge(:page => page_number),
+                  { :url => url,
+                    :before => "addActiveScaffoldPageToHistory('#{url}', '#{controller_id}');",
                     :after => "$('#{loading_indicator_id(:action => :pagination)}').style.visibility = 'visible';",
                     :complete => "$('#{loading_indicator_id(:action => :pagination)}').style.visibility = 'hidden';",
-                    :update => active_scaffold_content_id,
                     :failure => "ActiveScaffold.report_500_response('#{active_scaffold_id}')",
                     :method => :get },
                   { :href => url_for(params.merge(:page => page_number)) })
       end
 
-      def pagination_ajax_links(current_page, params)
-        start_number = current_page.number - 2
-        end_number = current_page.number + 2
+      def pagination_ajax_links(current_page, params, window_size)
+        start_number = current_page.number - window_size
+        end_number = current_page.number + window_size
         start_number = 1 if start_number <= 0
-        end_number = current_page.pager.last.number if end_number > current_page.pager.last.number
+        if current_page.pager.infinite?
+          offsets = [20, 100]
+        else
+          end_number = current_page.pager.last.number if end_number > current_page.pager.last.number
+        end
 
         html = []
-        html << pagination_ajax_link(1, params) unless current_page.number <= 3
-        html << ".." unless current_page.number <= 4
+        unless start_number == 1
+          last_page = 1
+          html << pagination_ajax_link(last_page, params)
+          if current_page.pager.infinite?
+            offsets.reverse.each do |offset|
+              page = current_page.number - offset
+              if page < start_number && page > 1
+                html << '..' if page > last_page + 1
+                html << pagination_ajax_link(page, params)
+                last_page = page
+              end
+            end
+          end
+          html << ".." if start_number > last_page + 1
+        end
+
         start_number.upto(end_number) do |num|
           if current_page.number == num
-            html << num
+            html << content_tag(:span, num)
           else
             html << pagination_ajax_link(num, params)
           end
         end
-        html << ".." unless current_page.number >= current_page.pager.last.number - 3
-        html << pagination_ajax_link(current_page.pager.last.number, params) unless current_page.number >= current_page.pager.last.number - 2
-        html.join(' ')
+
+        if current_page.pager.infinite?
+          offsets.each do |offset|
+            html << '..' << pagination_ajax_link(current_page.number + offset, params)
+          end
+        else
+          html << ".." unless end_number >= current_page.pager.last.number - 1
+          html << pagination_ajax_link(current_page.pager.last.number, params) unless end_number == current_page.pager.last.number
+        end
+        html.join(' ').html_safe
       end
     end
   end

data/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -9,11 +9,7 @@ module ActiveScaffold
 
         # first, check if the dev has created an override for this specific field for search
         if override_search_field?(column)
-          send(override_search_field(column), @record, options[:name])
-
-        # first, check if the dev has created an override for this specific field
-        elsif override_form_field?(column)
-          send(override_form_field(column), @record, options[:name])
+          send(override_search_field(column), @record, options)
 
         # second, check if the dev has specified a valid search_ui for this column, using specific ui for searches
         elsif column.search_ui and override_search?(column.search_ui)
@@ -23,6 +19,10 @@ module ActiveScaffold
         elsif column.search_ui and override_input?(column.search_ui)
           send(override_input(column.search_ui), column, options)
 
+        # fourth, check if the dev has created an override for this specific field
+        elsif override_form_field?(column)
+          send(override_form_field(column), @record, options)
+
         # fallback: we get to make the decision
         else
           if column.association or column.virtual?
@@ -48,7 +48,7 @@ module ActiveScaffold
 
       # the standard active scaffold options used for class, name and scope
       def active_scaffold_search_options(column)
-        { :name => "search[#{column.name}]", :class => "#{column.name}-input", :id => "search_#{column.name}"}
+        { :name => "search[#{column.name}]", :class => "#{column.name}-input", :id => "search_#{column.name}", :value => field_search_params[column.name] }
       end
 
       ##
@@ -56,19 +56,20 @@ module ActiveScaffold
       ##
 
       def active_scaffold_search_multi_select(column, options)
-        associated_options = @record.send(column.association.name).collect {|r| [r.to_label, r.id]}
-        select_options = associated_options | options_for_association(column.association, true)
+        associated = options.delete :value
+        associated = [associated].compact unless associated.is_a? Array
+        associated.collect!(&:to_i)
+        select_options = options_for_association(column.association, true)
         return as_(:no_options) if select_options.empty?
 
         html = "<ul class=\"checkbox-list\" id=\"#{options[:id]}\">"
 
-        associated_ids = associated_options.collect {|a| a[1]}
+        options[:name] += '[]'
         select_options.each_with_index do |option, i|
           label, id = option
-          this_name = "#{options[:name]}[#{i}][id]"
           this_id = "#{options[:id]}_#{i}_id"
           html << "<li>"
-          html << check_box_tag(this_name, id, associated_ids.include?(id), :id => this_id)
+          html << check_box_tag(options[:name], id, associated.include?(id), :id => this_id)
           html << "<label for='#{this_id}'>"
           html << label
           html << "</label>"
@@ -80,21 +81,25 @@ module ActiveScaffold
         html
       end
 
-      def active_scaffold_search_select(column, options)
+      def active_scaffold_search_select(column, html_options)
+        associated = html_options.delete :value
         if column.association
-          associated = @record.send(column.association.name)
-          associated = associated.first if associated.is_a?(Array) # for columns with plural association
-
-          select_options = options_for_association(column.association, true)
-          select_options.unshift([ associated.to_label, associated.id ]) unless associated.nil? or select_options.find {|label, id| id == associated.id}
-
-          selected = associated.nil? ? nil : associated.id
+          associated = associated.is_a?(Array) ? associated.map(&:to_i) : associated.to_i unless associated.nil?
           method = column.association.macro == :belongs_to ? column.association.primary_key_name : column.name
-          options[:name] += '[id]'
-          select(:record, method, select_options.uniq, {:selected => selected, :include_blank => as_(:_select_)}, options)
+          options_for_select = options_for_association(column.association, true)
         else
-          select(:record, column.name, column.options, { :selected => @record.send(column.name) }, options)
+          method = column.name
+          options_for_select = active_scaffold_translated_options(column)
         end
+
+        options = { :selected => associated }.merge! column.options
+        html_options.merge! column.options[:html_options] || {}
+        if html_options[:multiple]
+          html_options[:name] += '[]'
+        else
+          options[:include_blank] ||= as_(:_select_) 
+        end
+        select(:record, method, options_for_select, options, html_options)
       end
 
       def active_scaffold_search_text(column, options)
@@ -109,32 +114,59 @@ module ActiveScaffold
         select_options << [as_(:true), true]
         select_options << [as_(:false), false]
 
-        select_tag(options[:name], options_for_select(select_options, @record.send(column.name)))
+        select_tag(options[:name], options_for_select(select_options, column.column.type_cast(field_search_params[column.name])))
       end
       # we can't use checkbox ui because it's not possible to decide whether search for this field or not
       alias_method :active_scaffold_search_checkbox, :active_scaffold_search_boolean
 
-      def active_scaffold_search_integer(column, options)
+      def field_search_params_range_values(column)
+        values = field_search_params[column.name]
+        return nil if values.nil?
+        return values[:opt], values[:from], values[:to]
+      end
+
+      def include_null_comparators?(column)
+        return column.options[:null_comparators] if column.options.has_key? :null_comparators
+        if column.association
+          column.association.macro != :belongs_to || active_scaffold_config.columns[column.association.primary_key_name].column.try(:null)
+        else
+          column.column.try(:null)
+        end
+      end
+
+      def active_scaffold_search_range(column, options)
+        opt_value, from_value, to_value = field_search_params_range_values(column)
+        select_options = ActiveScaffold::Finder::NumericComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]}
+        select_options.unshift *ActiveScaffold::Finder::StringComparators.collect {|title, comp| [as_(title), comp]} if column.options[:string_comparators] || column.column.try(:text?)
+        select_options += ActiveScaffold::Finder::NullComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]} if include_null_comparators? column
+
         html = []
         html << select_tag("#{options[:name]}[opt]",
-              options_for_select(ActiveScaffold::Finder::NumericComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]}),
+              options_for_select(select_options, opt_value),
               :id => "#{options[:id]}_opt",
               :onchange => "Element[this.value == 'BETWEEN' ? 'show' : 'hide']('#{options[:id]}_between');")
-        html << text_field_tag("#{options[:name]}[from]", nil, active_scaffold_input_text_options(:id => options[:id], :size => 10))
-        html << content_tag(:span, ' - ' + text_field_tag("#{options[:name]}[to]", nil,
+        html << text_field_tag("#{options[:name]}[from]", from_value, active_scaffold_input_text_options(:id => options[:id], :size => 10))
+        html << content_tag(:span, ' - ' + text_field_tag("#{options[:name]}[to]", to_value,
               active_scaffold_input_text_options(:id => "#{options[:id]}_to", :size => 10)),
               :id => "#{options[:id]}_between", :style => "display:none")
         html * ' '
       end
-      alias_method :active_scaffold_search_decimal, :active_scaffold_search_integer
-      alias_method :active_scaffold_search_float, :active_scaffold_search_integer
+      alias_method :active_scaffold_search_integer, :active_scaffold_search_range
+      alias_method :active_scaffold_search_decimal, :active_scaffold_search_range
+      alias_method :active_scaffold_search_float, :active_scaffold_search_range
+      alias_method :active_scaffold_search_string, :active_scaffold_search_range
 
+      def field_search_datetime_value(value)
+        DateTime.new(value[:year].to_i, value[:month].to_i, value[:day].to_i, value[:hour].to_i, value[:minute].to_i, value[:second].to_i) unless value.nil? || value[:year].blank?
+      end
+      
       def active_scaffold_search_datetime(column, options)
+        opt_value, from_value, to_value = field_search_params_range_values(column)
         options = column.options.merge(options)
         helper = "select_#{'date' unless options[:discard_date]}#{'time' unless options[:discard_time]}"
         html = []
-        html << send(helper, nil, {:include_blank => true, :prefix => "#{options[:name]}[from]"}.merge(options))
-        html << send(helper, nil, {:include_blank => true, :prefix => "#{options[:name]}[to]"}.merge(options))
+        html << send(helper, field_search_datetime_value(from_value), {:include_blank => true, :prefix => "#{options[:name]}[from]"}.merge(options))
+        html << send(helper, field_search_datetime_value(to_value), {:include_blank => true, :prefix => "#{options[:name]}[to]"}.merge(options))
         html * ' - '
       end
 
@@ -150,13 +182,20 @@ module ActiveScaffold
       ## Search column override signatures
       ##
 
-      def override_search_field?(column)
-        respond_to?(override_search_field(column))
+      def override_search_field(column)
+        method = override_search_field_name(column)
+        return method if respond_to?(method)
+        old_method = override_search_field_name(column, true)
+        if respond_to?(old_method)
+          ActiveSupport::Deprecation.warn("You are using an old naming schema for overrides, you should name the helper #{method} instead of #{old_method}")
+          old_method
+        end
       end
+      alias_method :override_search_field?, :override_search_field
 
       # the naming convention for overriding form fields with helpers
-      def override_search_field(column)
-        "#{column.name}_search_column"
+      def override_search_field_name(column, old = false)
+        "#{clean_class_name(column.active_record_class.name) + '_' unless old}#{clean_column_name(column.name)}_search_column"
       end
 
       def override_search?(search_ui)

data/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/show_column_helpers.rb

@@ -1,46 +1,53 @@
-module ActiveScaffold
-  module Helpers
-    # Helpers that assist with the rendering of a List Column
-    module ShowColumnHelpers
-      def show_column_value(record, column)
-        # check for an override helper
-        if show_column_override? column
-          # 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.
-          send(show_column_override(column), record)
-        # second, check if the dev has specified a valid list_ui for this column
-        elsif column.list_ui and override_show_column_ui?(column.list_ui)
-          send(override_show_column_ui(column.list_ui), column, record)
-        else
-          if override_show_column_ui?(column.column.type)
-            send(override_show_column_ui(column.column.type), column, record)
-          else
-            get_column_value(record, column)
-          end
-        end
-      end
-
-      def active_scaffold_show_text(column, record)
-        simple_format(get_column_value(record, column))
-      end
-
-      def show_column_override(column)
-        "#{column.name.to_s.gsub('?', '')}_show_column" # parse out any question marks (see issue 227)
-      end
-
-      def show_column_override?(column)
-        respond_to?(show_column_override(column))
-      end
-
-      def override_show_column_ui?(list_ui)
-        respond_to?(override_show_column_ui(list_ui))
-      end
-
-      # the naming convention for overriding show types with helpers
-      def override_show_column_ui(list_ui)
-        "active_scaffold_show_#{list_ui}"
-      end
-    end
-  end
-end
+module ActiveScaffold
+  module Helpers
+    # Helpers that assist with the rendering of a List Column
+    module ShowColumnHelpers
+      def show_column_value(record, column)
+        # check for an override helper
+        if show_column_override? column
+          # 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.
+          send(show_column_override(column), record)
+        # second, check if the dev has specified a valid list_ui for this column
+        elsif column.list_ui and override_show_column_ui?(column.list_ui)
+          send(override_show_column_ui(column.list_ui), column, record)
+        else
+          if column.column and override_show_column_ui?(column.column.type)
+            send(override_show_column_ui(column.column.type), column, record)
+          else
+            get_column_value(record, column)
+          end
+        end
+      end
+
+      def active_scaffold_show_text(column, record)
+        simple_format(clean_column_value(record.send(column.name)))
+      end
+
+      def show_column_override_name(column, old = false)
+        "#{clean_class_name(column.active_record_class.name) + '_' unless old}#{clean_column_name(column.name)}_show_column"
+      end
+
+      def show_column_override(column)
+        method = show_column_override_name(column)
+        return method if respond_to?(method)
+        old_method = show_column_override_name(column, true)
+        if respond_to?(old_method)
+          ActiveSupport::Deprecation.warn("You are using an old naming schema for overrides, you should name the helper #{method} instead of #{old_method}")
+          old_method
+        end
+      end
+      alias_method :show_column_override?, :show_column_override
+
+      def override_show_column_ui?(list_ui)
+        respond_to?(override_show_column_ui(list_ui))
+      end
+
+      # the naming convention for overriding show types with helpers
+      def override_show_column_ui(list_ui)
+        "active_scaffold_show_#{list_ui}"
+      end
+    end
+  end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/view_helpers.rb

@@ -10,6 +10,7 @@ module ActiveScaffold
       include ActiveScaffold::Helpers::ShowColumnHelpers
       include ActiveScaffold::Helpers::FormColumnHelpers
       include ActiveScaffold::Helpers::SearchColumnHelpers
+      include ActiveScaffold::Helpers::CountryHelpers
 
       ##
       ## Delegates
@@ -53,12 +54,8 @@ module ActiveScaffold
         # Polymorphic associations can't appear because they *might* be the reverse association, and because you generally don't assign an association from the polymorphic side ... I think.
         return false if column.polymorphic_association?
 
-        # We don't have the UI to currently handle habtm in subforms
-        return false if column.association.macro == :has_and_belongs_to_many
-
         # A column shouldn't be in the subform if it's the reverse association to the parent
         return false if column.association.reverse_for?(parent_record.class)
-        #return false if column.association.klass == parent_record.class
 
         return true
       end
@@ -73,9 +70,8 @@ module ActiveScaffold
         options[:target] = action_iframe_id(url_for_options)
         options[:multipart] = true
 
-        output=""
-        output << "<iframe id='#{action_iframe_id(url_for_options)}' name='#{action_iframe_id(url_for_options)}' style='display:none'></iframe>"
-        output << form_tag(url_for_options, options)
+        output = form_tag(url_for_options, options)
+        output << "<iframe id='#{action_iframe_id(url_for_options)}' name='#{action_iframe_id(url_for_options)}' style='display:none'></iframe>".html_safe
       end
 
       # Provides list of javascripts to include with +javascript_include_tag+
@@ -104,9 +100,11 @@ module ActiveScaffold
         js = javascript_include_tag(*active_scaffold_javascripts(frontend).push(options))
 
         css = stylesheet_link_tag(*active_scaffold_stylesheets(frontend).push(options))
+        options[:cache] += '_ie' if options[:cache].is_a? String
+        options[:concat] += '_ie' if options[:concat].is_a? String
         ie_css = stylesheet_link_tag(*active_scaffold_ie_stylesheets(frontend).push(options))
 
-        js + "\n" + css + "\n<!--[if IE]>" + ie_css + "<![endif]-->\n"
+        "#{js}\n#{css}\n<!--[if IE]>#{ie_css}<![endif]-->\n".html_safe
       end
 
       # a general-use loading indicator (the "stuff is happening, please wait" feedback)
@@ -125,14 +123,18 @@ module ActiveScaffold
         link_to_function link_text, "e = #{options[:of]}; e.toggle(); this.innerHTML = (e.style.display == 'none') ? '#{as_(:show)}' : '#{as_(:hide)}'", :class => 'visibility-toggle'
       end
 
-      def render_action_link(link, url_options)
+      def skip_action_link(link)
+        (link.security_method_set? or controller.respond_to? link.security_method) and !controller.send(link.security_method)
+      end
+
+      def render_action_link(link, url_options, record = nil, html_options = {})
         url_options = url_options.clone
         url_options[:action] = link.action
         url_options[:controller] = link.controller 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
 
-        html_options = link.html_options.merge({:class => link.action})
+        html_options.reverse_merge! link.html_options.merge(:class => link.action)
         if link.inline?
           # NOTE this is in url_options instead of html_options on purpose. the reason is that the client-side
           # action link javascript needs to submit the proper method, but the normal html_options[:method]
@@ -150,11 +152,11 @@ module ActiveScaffold
           html_options[:method] = link.method
         end
 
-        html_options[:confirm] = link.confirm if link.confirm?
+        html_options[:confirm] = link.confirm(record.try(:to_label)) if link.confirm?
         html_options[:position] = link.position if link.position and link.inline?
         html_options[:class] += ' action' if link.inline?
         html_options[:popup] = true if link.popup?
-        html_options[:id] = action_link_id(url_options[:action],url_options[:id] || url_options[:parent_id])
+        html_options[:id] = action_link_id("#{id_from_controller(url_options[:controller]) + '-' if url_options[:parent_controller]}" + "#{url_options[:associations].to_s + '-' if url_options[:associations]}" + url_options[:action].to_s,url_options[:id] || url_options[:parent_id])
 
         if link.dhtml_confirm?
           html_options[:class] += ' action' if !link.inline?
@@ -181,15 +183,47 @@ module ActiveScaffold
 
       def column_empty?(column_value)
         empty = column_value.nil?
-        empty ||= column_value.empty? if column_value.respond_to? :empty?
-        empty ||= (column_value == '&nbsp;')
-        empty ||= (column_value == active_scaffold_config.list.empty_field_text)
+        empty ||= column_value.blank? if column_value.respond_to? :blank?
+        empty ||= ['&nbsp;'.html_safe, active_scaffold_config.list.empty_field_text].include? column_value if String === column_value
         return empty
       end
 
       def column_calculation(column)
-        calculation = active_scaffold_config.model.calculate(column.calculate, column.name, :conditions => controller.send(:all_conditions),
-         :joins => controller.send(:joins_for_collection), :include => controller.send(:active_scaffold_joins))
+        conditions = controller.send(:all_conditions)
+        includes = active_scaffold_config.list.count_includes
+        includes ||= controller.send(:active_scaffold_includes) unless conditions.nil?
+        calculation = active_scaffold_config.model.calculate(column.calculate, column.name, :conditions => conditions,
+         :joins => controller.send(:joins_for_collection), :include => includes)
+      end
+
+      def render_column_calculation(column)
+        calculation = column_calculation(column)
+        override_formatter = "render_#{column.name}_#{column.calculate}"
+        calculation = send(override_formatter, calculation) if respond_to? override_formatter
+
+        "#{as_(column.calculate)}: #{format_column_value nil, column, calculation}"
+      end
+
+      def column_show_add_existing(column)
+        (column.allow_add_existing and options_for_association_count(column.association) > 0)
+      end
+
+      def column_show_add_new(column, associated, record)
+        value = column.plural_association? or (column.singular_association? and not associated.empty?)
+        value = false unless record.class.authorized_for?(:crud_type => :create)
+        value
+      end
+
+      def controller_class
+        "#{h params[:controller]}-view"
+      end
+
+      def clean_column_name(name)
+        name.to_s.gsub('?', '')
+      end
+
+      def clean_class_name(name)
+        name.underscore.gsub('/', '_')
       end
     end
   end