admin_assistant 1.0.0 → 1.0.1

data/lib/admin_assistant/column.rb

@@ -1,13 +1,5 @@
 class AdminAssistant
-  class Column
-    def blank?(search)
-      search.params["#{name}(blank)"] == '1'
-    end
-
-    def comparator(search)
-      search.params["#{name}(comparator)"]
-    end
-    
+  class Column    
     def form_view(action_view, admin_assistant, opts = {})
       view 'FormView', action_view, admin_assistant, opts
     end
@@ -38,10 +30,6 @@ class AdminAssistant
     end
     
     module FormViewMethods
-      def description
-        @description
-      end
-      
       def after_html(rails_form)
         after = render_from_custom_template("_after_#{name}_input", rails_form)
         if after
@@ -53,9 +41,13 @@ class AdminAssistant
           end
         end
       end
-    
-      def controller
-        @action_view.controller
+      
+      def description
+        @description
+      end
+      
+      def errors(record)
+        record.errors.on name
       end
 
       def html(rails_form)
@@ -82,50 +74,41 @@ class AdminAssistant
         end
       end
       
+      def field_id
+        "#{@model_class.name.underscore}_#{name}"
+      end
+      
       def render_from_custom_template(slug, rails_form)
-        abs_template_file = File.join(
-          RAILS_ROOT, 'app/views', controller.controller_path, 
-          "#{slug}.html.erb"
-        )
-        if File.exist?(abs_template_file)
-          template = if RAILS_GEM_VERSION == '2.1.0'
-            File.join(controller.controller_path, "#{slug}.html.erb")
-          else
-            abs_template_file
-          end
+        if File.exist?(custom_template_file_path(slug))
           varname = @model_class.name.underscore
           @action_view.instance_variable_set(
             "@#{varname}".to_sym, rails_form.object
           )
+          locals = {varname.to_sym => rails_form.object, :form => rails_form}
+          if rails_form.respond_to?(:prefix)
+            locals[:prefix] = rails_form.prefix
+            @action_view.instance_variable_set(:@prefix, rails_form.prefix)
+          end
           @action_view.render(
-            :file => template,
-            :locals => {
-              varname.to_sym => rails_form.object,
-              :form => rails_form
-            }
+            :file => file_option_for_custom_template_render(slug),
+            :locals => locals
           )
         end
       end
       
       def set_instance_variables_from_options(admin_assistant, opts)
         setting = admin_assistant.form_settings[name.to_sym]
-        @clear_link = setting.clear_link
-        @description = setting.description
-        @datetime_select_options = setting.datetime_select_options || {}
-        @date_select_options = setting.date_select_options || {}
-        fum_name = name + '_url'
-        if @action_view.respond_to?(fum_name)
-          @file_url_method = @action_view.method(fum_name)
+        ivars = %w(
+          clear_link datetime_select_options date_select_options description
+          image_size input select_choices select_options text_area_options
+        )
+        ivars.each do |ivar|
+          instance_variable_set "@#{ivar}".to_sym, setting.send(ivar)
         end
-        @image_size = setting.image_size
-        @input = setting.input
-        @polymorphic_types = admin_assistant[name.to_sym].polymorphic_types
-        @read_only = setting.read_only?
-        @select_options = setting.select_options || {}
-        unless @select_options.has_key?(:include_blank)
-          @select_options[:include_blank] = true
+        if @action_view.respond_to?(name + '_url')
+          @file_url_method = @action_view.method(name + '_url')
         end
-        @text_area_options = setting.text_area_options || {}
+        @read_only = setting.read_only?
         @write_once = setting.write_once?
       end
     end
@@ -134,15 +117,7 @@ class AdminAssistant
       def header_css_class
         "sort #{sort_order}" if sort_order
       end
-      
-      def td_css_class
-        'sort' if sort_order
-      end
-      
-      def unconfigured_html(record)
-        @action_view.send(:h, string(record))
-      end
-      
+            
       def html(record)
         html_for_index_method = "#{name}_html_for_index"
         html = if @action_view.respond_to?(html_for_index_method)
@@ -181,7 +156,22 @@ class AdminAssistant
         @link_to_args = setting.link_to_args
         @sort_order = index.sort_order if name == index.sort
         @image_size = setting.image_size
-        @ajax_toggle_allowed = admin_assistant.update?
+        @ajax_toggle_allowed =
+            admin_assistant.update? && setting.ajax_toggle != false
+      end
+      
+      def td_css_classes(column, record)
+        css_classes = []
+        css_classes << 'sort' if sort_order
+        td_css_class_for_index_method = "#{name}_css_class_for_index_td"
+        if @action_view.respond_to?(td_css_class_for_index_method)
+          css_classes << @action_view.send(td_css_class_for_index_method, record)
+        end
+        css_classes.reject{ |c| c.blank? }.join(' ')
+      end
+      
+      def unconfigured_html(record)
+        @action_view.send(:h, string(record))
       end
     end
     
@@ -193,12 +183,19 @@ class AdminAssistant
         end
         @search = opts[:search]
         @blank_checkbox = setting.blank_checkbox
+        @compare_to_range = setting.compare_to_range
       end
     end
     
     module SimpleColumnSearchViewMethods
       include SearchViewMethods
       
+      def blank_checkbox_html(form)
+        check_box_and_hidden_tags(
+          "search[#{name}(blank)]", form.object.blank?(@column.name)
+        ) + "is blank"
+      end
+      
       def boolean_input(form)
         opts = [['', nil]]
         if @boolean_labels
@@ -212,7 +209,7 @@ class AdminAssistant
       end
       
       def comparator_html(search)
-        selected_comparator = @column.comparator(search) || '='
+        selected_comparator = search.comparator(@column.name) || '='
         option_tags = comparator_opts.map { |text, value|
           opt = "<option value=\"#{value}\""
           if selected_comparator == value
@@ -233,22 +230,69 @@ class AdminAssistant
         ]
       end
       
+      def datetime_input(form)
+        input = ''
+        if @compare_to_range
+          input = datetime_range_input(form)
+        else
+          input << comparator_html(form.object) << ' ' if @comparators == :all
+          input << form.datetime_select(name, :include_blank => true)
+          input << @action_view.send(
+            :link_to_function, 'Clear',
+            "AdminAssistant.clear_datetime_select('search_#{name.underscore}')"
+          )
+        end
+        input
+      end
+      
+      def datetime_range_end_point_input(form, comparator, label)
+        input = "#{label} "
+        input << DateTimeRangeEndPointSelector.new(
+          form.object.send(name)[comparator],
+          :prefix => "search", :field_name => comparator.to_s,
+          :include_position => true, :index => name, :include_blank => true,
+          :datetime_separator => ' &mdash; ', :time_separator => ' : '
+        ).select_datetime
+        input << @action_view.send(
+          :link_to_function, 'Clear',
+          "AdminAssistant.clear_datetime_select('search_#{name.underscore}_#{comparator}')"
+        )
+        input
+      end
+      
+      def datetime_range_input(form)
+        input = ''
+        input << datetime_range_end_point_input(form, :gt, 'After')
+        input << "&nbsp;&nbsp;&nbsp;"
+        input << datetime_range_end_point_input(form, :lt, 'Before')
+        input
+      end
+      
       def html(form)
         input = ''
-        case @column.field_type
-          when :boolean
-            input = boolean_input form
+        if @column.field_type == :boolean
+          input = boolean_input form
+        elsif @column.field_type == :datetime
+          input = datetime_input form
+        else
+          if @compare_to_range
+            input << "Greater than "
+            input << @action_view.send(
+              :text_field_tag, "search[#{name}][gt]",
+              form.object.send(name)[:gt]
+            )
+            input << "&nbsp;&nbsp;&nbsp;Less than "
+            input << @action_view.send(
+              :text_field_tag, "search[#{name}][lt]",
+              form.object.send(name)[:lt]
+            )
           else
             if @column.field_type == :integer && @comparators == :all
               input << comparator_html(form.object) << ' '
             end
             input << form.text_field(name)
-            if @blank_checkbox
-              input << check_box_and_hidden_tags(
-                "search[#{name}(blank)]", @column.blank?(form.object)
-              )
-              input << "is blank"
-            end
+            input << blank_checkbox_html(form) if @blank_checkbox
+          end
         end
         "<p><label>#{label}</label> <br/>#{input}</p>"
       end
@@ -256,7 +300,18 @@ class AdminAssistant
     
     module ShowViewMethods
       def html(record)
-        @action_view.send(:h, value(record))
+        slug = "_#{name}_for_show"
+        if File.exist?(custom_template_file_path(slug))
+          varname = @model_class.name.underscore
+          @action_view.instance_variable_set("@#{varname}".to_sym, record)
+          locals = {varname.to_sym => record}
+          @action_view.render(
+            :file => file_option_for_custom_template_render(slug),
+            :locals => locals
+          )
+        else
+          @action_view.send(:h, string(record))
+        end
       end
     end
 
@@ -268,6 +323,7 @@ class AdminAssistant
         @model_class = admin_assistant.model_class
         base_setting = admin_assistant[name]
         @boolean_labels = base_setting.boolean_labels
+        @strftime_format = base_setting.strftime_format
         fem_name = name + '_exists?'
         if @action_view.respond_to?(fem_name)
           @file_exists_method = @action_view.method(fem_name)
@@ -283,11 +339,30 @@ class AdminAssistant
         # Rails 2.3 wants the hidden tag to come before the checkbox, but it's
         # the opposite for Rails 2.2 and 2.1
         if RAILS_GEM_VERSION =~ /^2.3/
-          @action_view.send(:hidden_field_tag, input_name, '0') +
+          @action_view.send(:hidden_field_tag, input_name, '0', :id => "#{input_name}_hidden") +
               @action_view.send(:check_box_tag, input_name, '1', value)
         else
           @action_view.send(:check_box_tag, input_name, '1', value) +
-              @action_view.send(:hidden_field_tag, input_name, '0')
+              @action_view.send(:hidden_field_tag, input_name, '0', :id => "#{input_name}_hidden")
+        end
+      end
+    
+      def controller
+        @action_view.controller
+      end
+      
+      def custom_template_file_path(slug)
+        File.join(
+          RAILS_ROOT, 'app/views', controller.controller_path, 
+          "#{slug}.html.erb"
+        )
+      end
+      
+      def file_option_for_custom_template_render(slug)
+        if RAILS_GEM_VERSION == '2.1.0'
+          File.join(controller.controller_path, "#{slug}.html.erb")
+        else
+          custom_template_file_path slug
         end
       end
       
@@ -322,6 +397,8 @@ class AdminAssistant
           value = value(record)
           if @boolean_labels
             value ? @boolean_labels.first : @boolean_labels.last
+          elsif value.respond_to?(:strftime) && @strftime_format
+            value.strftime @strftime_format
           else
             value.to_s
           end
@@ -329,12 +406,17 @@ class AdminAssistant
       end
       
       def value(record)
-        record.send(name) if record.respond_to?(name)
+        value_method = "#{name}_value"
+        if @action_view.respond_to?(value_method)
+          @action_view.send value_method, record
+        else
+          record.send(name) if record.respond_to?(name)
+        end
       end
     end
     
     class FormView < View
-      include IndexViewMethods
+      include FormViewMethods
     end
 
     class IndexView < View

data/lib/admin_assistant/date_time_range_end_point_selector.rb

@@ -0,0 +1,340 @@
+class AdminAssistant
+  # Copied (and then streamlined) from Rails 2.3.5 in an effort to provide 
+  # consistent functionality all the way back to Rails 2.1.0
+  class DateTimeRangeEndPointSelector
+    include ActionView::Helpers::TagHelper
+
+    DEFAULT_PREFIX = 'date'.freeze unless const_defined?('DEFAULT_PREFIX')
+    POSITION = {
+      :year => 1, :month => 2, :day => 3, :hour => 4, :minute => 5, :second => 6
+    }.freeze unless const_defined?('POSITION')
+
+    def initialize(datetime, options = {}, html_options = {})
+      @options      = options.dup
+      @html_options = html_options.dup
+      @datetime     = datetime
+    end
+
+    def select_datetime
+      # TODO: Remove tag conditional
+      # Ideally we could just join select_date and select_date for the tag case
+      if @options[:tag] && @options[:ignore_date]
+        select_time
+      elsif @options[:tag]
+        order = date_order.dup
+        order -= [:hour, :minute, :second]
+
+        @options[:discard_year]   ||= true unless order.include?(:year)
+        @options[:discard_month]  ||= true unless order.include?(:month)
+        @options[:discard_day]    ||= true if @options[:discard_month] || !order.include?(:day)
+        @options[:discard_minute] ||= true if @options[:discard_hour]
+        @options[:discard_second] ||= true unless @options[:include_seconds] && !@options[:discard_minute]
+
+        # If the day is hidden and the month is visible, the day should be set to the 1st so all month choices are
+        # valid (otherwise it could be 31 and february wouldn't be a valid date)
+        if @datetime && @options[:discard_day] && !@options[:discard_month]
+          @datetime = @datetime.change(:day => 1)
+        end
+
+        [:day, :month, :year].each { |o| order.unshift(o) unless order.include?(o) }
+        order += [:hour, :minute, :second] unless @options[:discard_hour]
+
+        build_selects_from_types(order)
+      else
+        "#{select_date}#{@options[:datetime_separator]}#{select_time}"
+      end
+    end
+
+    def select_date
+      order = date_order.dup
+
+      # TODO: Remove tag conditional
+      if @options[:tag]
+        @options[:discard_hour]     = true
+        @options[:discard_minute]   = true
+        @options[:discard_second]   = true
+
+        @options[:discard_year]   ||= true unless order.include?(:year)
+        @options[:discard_month]  ||= true unless order.include?(:month)
+        @options[:discard_day]    ||= true if @options[:discard_month] || !order.include?(:day)
+
+        # If the day is hidden and the month is visible, the day should be set to the 1st so all month choices are
+        # valid (otherwise it could be 31 and february wouldn't be a valid date)
+        if @datetime && @options[:discard_day] && !@options[:discard_month]
+          @datetime = @datetime.change(:day => 1)
+        end
+      end
+
+      [:day, :month, :year].each { |o| order.unshift(o) unless order.include?(o) }
+
+      build_selects_from_types(order)
+    end
+
+    def select_time
+      order = []
+
+      # TODO: Remove tag conditional
+      if @options[:tag]
+        @options[:discard_month]    = true
+        @options[:discard_year]     = true
+        @options[:discard_day]      = true
+        @options[:discard_second] ||= true unless @options[:include_seconds]
+
+        order += [:year, :month, :day] unless @options[:ignore_date]
+      end
+
+      order += [:hour, :minute]
+      order << :second if @options[:include_seconds]
+
+      build_selects_from_types(order)
+    end
+
+    def select_second
+      if @options[:use_hidden] || @options[:discard_second]
+        build_hidden(:second, sec) if @options[:include_seconds]
+      else
+        build_options_and_select(:second, sec)
+      end
+    end
+
+    def select_minute
+      if @options[:use_hidden] || @options[:discard_minute]
+        build_hidden(:minute, min)
+      else
+        build_options_and_select(:minute, min, :step => @options[:minute_step])
+      end
+    end
+
+    def select_hour
+      if @options[:use_hidden] || @options[:discard_hour]
+        build_hidden(:hour, hour)
+      else
+        build_options_and_select(:hour, hour, :end => 23)
+      end
+    end
+
+    def select_day
+      if @options[:use_hidden] || @options[:discard_day]
+        build_hidden(:day, day)
+      else
+        build_options_and_select(:day, day, :start => 1, :end => 31, :leading_zeros => false)
+      end
+    end
+
+    def select_month
+      if @options[:use_hidden] || @options[:discard_month]
+        build_hidden(:month, month)
+      else
+        month_options = []
+        1.upto(12) do |month_number|
+          options = { :value => month_number }
+          options[:selected] = "selected" if month == month_number
+          month_options << content_tag(:option, month_name(month_number), options) + "\n"
+        end
+        build_select(:month, month_options.join)
+      end
+    end
+
+    def select_year
+      if !@datetime || @datetime == 0
+        val = ''
+        middle_year = Date.today.year
+      else
+        val = middle_year = year
+      end
+
+      if @options[:use_hidden] || @options[:discard_year]
+        build_hidden(:year, val)
+      else
+        options                 = {}
+        options[:start]         = @options[:start_year] || middle_year - 5
+        options[:end]           = @options[:end_year] || middle_year + 5
+        options[:step]          = options[:start] < options[:end] ? 1 : -1
+        options[:leading_zeros] = false
+
+        build_options_and_select(:year, val, options)
+      end
+    end
+
+    private
+      %w( sec min hour day month year ).each do |method|
+        define_method(method) do
+          @datetime.kind_of?(Fixnum) ? @datetime : @datetime.send(method) if @datetime
+        end
+      end
+
+      # Returns translated month names, but also ensures that a custom month
+      # name array has a leading nil element
+      def month_names
+        month_names = @options[:use_month_names] || translated_month_names
+        month_names.unshift(nil) if month_names.size < 13
+        month_names
+      end
+
+      # Returns translated month names
+      #  => [nil, "January", "February", "March",
+      #           "April", "May", "June", "July",
+      #           "August", "September", "October",
+      #           "November", "December"]
+      #
+      # If :use_short_month option is set
+      #  => [nil, "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+      #           "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+      def translated_month_names
+        if @options[:use_short_month]
+          [nil, "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
+           "Oct", "Nov", "Dec"]
+        else
+          [nil, "January", "February", "March", "April", "May", "June", "July",
+           "August", "September", "October", "November", "December"]
+        end
+      end
+
+      # Lookup month name for number
+      #  month_name(1) => "January"
+      #
+      # If :use_month_numbers option is passed
+      #  month_name(1) => 1
+      #
+      # If :add_month_numbers option is passed
+      #  month_name(1) => "1 - January"
+      def month_name(number)
+        if @options[:use_month_numbers]
+          number
+        elsif @options[:add_month_numbers]
+          "#{number} - #{month_names[number]}"
+        else
+          month_names[number]
+        end
+      end
+
+      def date_order
+        @options[:order] || translated_date_order
+      end
+
+      def translated_date_order
+        [:year, :month, :day]
+      end
+
+      # Build full select tag from date type and options
+      def build_options_and_select(type, selected, options = {})
+        build_select(type, build_options(selected, options))
+      end
+
+      # Build select option html from date value and options
+      #  build_options(15, :start => 1, :end => 31)
+      #  => "<option value="1">1</option>
+      #      <option value=\"2\">2</option>
+      #      <option value=\"3\">3</option>..."
+      def build_options(selected, options = {})
+        start         = options.delete(:start) || 0
+        stop          = options.delete(:end) || 59
+        step          = options.delete(:step) || 1
+        leading_zeros = options.delete(:leading_zeros).nil? ? true : false
+
+        select_options = []
+        start.step(stop, step) do |i|
+          value = leading_zeros ? sprintf("%02d", i) : i
+          tag_options = { :value => value }
+          tag_options[:selected] = "selected" if selected == i
+          select_options << content_tag(:option, value, tag_options)
+        end
+        select_options.join("\n") + "\n"
+      end
+
+      # Builds select tag from date type and html select options
+      #  build_select(:month, "<option value="1">January</option>...")
+      #  => "<select id="post_written_on_2i" name="post[written_on(2i)]">
+      #        <option value="1">January</option>...
+      #      </select>"
+      def build_select(type, select_options_as_html)
+        select_options = {
+          :id => input_id_from_type(type),
+          :name => input_name_from_type(type)
+        }.merge(@html_options)
+        select_options.merge!(:disabled => 'disabled') if @options[:disabled]
+
+        select_html = "\n"
+        select_html << content_tag(:option, '', :value => '') + "\n" if @options[:include_blank]
+        select_html << prompt_option_tag(type, @options[:prompt]) + "\n" if @options[:prompt]
+        select_html << select_options_as_html.to_s
+
+        content_tag(:select, select_html, select_options) + "\n"
+      end
+
+      # Builds a prompt option tag with supplied options or from default options
+      #  prompt_option_tag(:month, :prompt => 'Select month')
+      #  => "<option value="">Select month</option>"
+      def prompt_option_tag(type, options)
+        default_options = {:year => false, :month => false, :day => false, :hour => false, :minute => false, :second => false}
+
+        case options
+        when Hash
+          prompt = default_options.merge(options)[type.to_sym]
+        when String
+          prompt = options
+        else
+          prompt = I18n.translate(('datetime.prompts.' + type.to_s).to_sym, :locale => @options[:locale])
+        end
+
+        prompt ? content_tag(:option, prompt, :value => '') : ''
+      end
+
+      # Builds hidden input tag for date part and value
+      #  build_hidden(:year, 2008)
+      #  => "<input id="post_written_on_1i" name="post[written_on(1i)]" type="hidden" value="2008" />"
+      def build_hidden(type, value)
+        tag(:input, {
+          :type => "hidden",
+          :id => input_id_from_type(type),
+          :name => input_name_from_type(type),
+          :value => value
+        }) + "\n"
+      end
+
+      # Returns the name attribute for the input tag
+      #  => post[written_on(1i)]
+      def input_name_from_type(type)
+        prefix = @options[:prefix] || DEFAULT_PREFIX
+        prefix += "[#{@options[:index]}]" if @options.has_key?(:index)
+
+        field_name = @options[:field_name] || type
+        if @options[:include_position]
+          field_name += "(#{POSITION[type]}i)"
+        end
+
+        @options[:discard_type] ? prefix : "#{prefix}[#{field_name}]"
+      end
+
+      # Returns the id attribute for the input tag
+      #  => "post_written_on_1i"
+      def input_id_from_type(type)
+        input_name_from_type(type).gsub(/([\[\(])|(\]\[)/, '_').gsub(/[\]\)]/, '')
+      end
+
+      # Given an ordering of datetime components, create the selection HTML
+      # and join them with their appropriate separators.
+      def build_selects_from_types(order)
+        select = ''
+        order.reverse.each do |type|
+          separator = separator(type) unless type == order.first # don't add on last field
+          select.insert(0, separator.to_s + send("select_#{type}").to_s)
+        end
+        select
+      end
+
+      # Returns the separator for a given datetime component
+      def separator(type)
+        case type
+          when :month, :day
+            @options[:date_separator]
+          when :hour
+            (@options[:discard_year] && @options[:discard_day]) ? "" : @options[:datetime_separator]
+          when :minute
+            @options[:time_separator]
+          when :second
+            @options[:include_seconds] ? @options[:time_separator] : ""
+        end
+      end
+  end
+end