admin_assistant 1.0.0 → 1.0.1

data/lib/admin_assistant/active_record_column.rb

@@ -5,54 +5,43 @@ class AdminAssistant
     end
     
     def add_to_query_condition(ar_query_condition, search)
-      table_name = search.model_class.table_name
-      if blank?(search)
-        ar_query_condition.add_condition do |sub_cond|
-          sub_cond.boolean_join = :or
-          sub_cond.sqls << "#{table_name}.#{name} is null"
-          sub_cond.sqls << "#{table_name}.#{name} = ''"
-        end
+      ConditionUpdate.new(ar_query_condition, search, name, field_type).run
+    end
+      
+    def attributes_for_search_object(search_params, compare_to_range)
+      attrs = {}
+      if compare_to_range
+        attrs[name] = range_attribute_for_search_object search_params[name]
       else
-        value_for_query = search.send(@ar_column.name)
-        unless value_for_query.nil?
-          comp = comparator(search)
-          unless %w(< <= = >= >).include?(comp)
-            comp = nil
-          end
-          if comp
-            ar_query_condition.sqls << "#{table_name}.#{name} #{comp} ?"
-            ar_query_condition.bind_vars << value_for_query
-          else
+        attrs[name] = if field_type == :datetime
+          datetime_attributes_for_search_object search_params, name
+        else
+          terms = search_params[@ar_column.name]
+          unless terms.blank?
             case field_type
-              when :boolean, :integer
-                ar_query_condition.sqls << "#{table_name}.#{name} = ?"
-                ar_query_condition.bind_vars << value_for_query
+              when :boolean
+                terms.blank? ? nil : (terms == 'true')
               else
-                ar_query_condition.sqls << "LOWER(#{table_name}.#{name}) like LOWER(?)"
-                ar_query_condition.bind_vars << "%#{value_for_query}%"
+                terms
             end
           end
         end
       end
-    end
-      
-    def attributes_for_search_object(search_params)
-      terms = search_params[@ar_column.name]
-      value = unless terms.blank?
-        case field_type
-          when :boolean
-            terms.blank? ? nil : (terms == 'true')
-          else
-            terms
-        end
-      end
-      {name => value}
+      attrs
     end
     
     def contains?(column_name)
       column_name.to_s == @ar_column.name
     end
     
+    def datetime_attributes_for_search_object(search_params, prefix)
+      begin
+        Time.utc(
+          *(1..5).to_a.map { |i| search_params["#{prefix}(#{i}i)"].to_i }
+        )
+      rescue ArgumentError; end
+    end
+    
     def field_type
       @ar_column.type
     end
@@ -61,6 +50,102 @@ class AdminAssistant
       @ar_column.name
     end
     
+    def range_attribute_for_search_object(column_params)
+      range = {}
+      if column_params
+        %w(gt lt).each do |comparator|
+          if column_params.keys.any? { |k| k.to_s =~ /^#{comparator}/ }
+            range[comparator.to_sym] = if field_type == :datetime
+              datetime_attributes_for_search_object(column_params, comparator)
+            else
+              column_params[comparator] unless column_params[comparator].blank?
+            end
+          end
+        end
+      end
+      range
+    end
+      
+    class ConditionUpdate
+      def initialize(ar_query_condition, search, name, field_type)
+        @ar_query_condition, @search, @name, @field_type =
+            ar_query_condition, search, name, field_type
+      end
+      
+      def add_blank_condition
+        @ar_query_condition.add_condition do |sub_cond|
+          sub_cond.boolean_join = :or
+          sub_cond.sqls << "#{table_name}.#{@name} is null"
+          sub_cond.sqls << "#{table_name}.#{@name} = ''"
+        end
+      end
+      
+      def add_case_insensitive_string_comparison
+        @ar_query_condition.sqls <<
+            "LOWER(#{table_name}.#{@name}) like LOWER(?)"
+        @ar_query_condition.bind_vars << "%#{value_for_query}%"
+      end
+      
+      def add_comparative_condition
+        @ar_query_condition.sqls << "#{table_name}.#{@name} #{comparator} ?"
+        @ar_query_condition.bind_vars << value_for_query
+      end
+      
+      def add_equality_condition
+        @ar_query_condition.sqls << "#{table_name}.#{@name} = ?"
+        @ar_query_condition.bind_vars << value_for_query
+      end
+      
+      def add_range_condition
+        if lower_limit = @search.send(@name)[:gt]
+          @ar_query_condition.sqls << "#{table_name}.#{@name} > ?"
+          @ar_query_condition.bind_vars << lower_limit
+        end
+        if upper_limit = @search.send(@name)[:lt]
+          @ar_query_condition.sqls << "#{table_name}.#{@name} < ?"
+          @ar_query_condition.bind_vars << upper_limit
+        end
+      end
+      
+      def compare_to_range?
+        @search.compare_to_range? @name
+      end
+      
+      def comparator
+        @search.comparator @name
+      end
+      
+      def column_is_a_string_type?
+        ![:boolean, :integer].include?(@field_type)
+      end
+      
+      def run
+        if @search.blank?(@name)
+          add_blank_condition
+        else
+          unless value_for_query.nil?
+            if comparator
+              add_comparative_condition
+            elsif compare_to_range?
+              add_range_condition
+            elsif column_is_a_string_type?
+              add_case_insensitive_string_comparison
+            else
+              add_equality_condition
+            end
+          end
+        end
+      end
+      
+      def table_name
+        @search.model_class.table_name
+      end
+      
+      def value_for_query
+        @search.send @name
+      end
+    end
+    
     class FormView < AdminAssistant::Column::View
       include AdminAssistant::Column::FormViewMethods
       
@@ -133,17 +218,20 @@ class AdminAssistant
       end
 
       def select_html(form)
-        # for now only used for boolean fields
-        value = form.object.send name
-        selected = if value
-          '1'
-        elsif value == false
-          '0'
+        if @select_choices
+          form.select name, @select_choices, @select_options
+        else
+          value = form.object.send name
+          selected = if value
+            '1'
+          elsif value == false
+            '0'
+          end
+          form.select(
+            name, [[true, '1'], [false, '0']],
+            @select_options.merge(:selected => selected)
+          )
         end
-        form.select(
-          name, [[true, '1'], [false, '0']],
-          @select_options.merge(:selected => selected)
-        )
       end
       
       def text_area_html(form)

data/lib/admin_assistant/association_target.rb

@@ -24,9 +24,22 @@ class AdminAssistant
       
     def options_for_select
       records = @associated_class.find(:all)
-      if default_name_method
-        records.sort_by { |model| model.send(default_name_method) }.
-                map { |model| [model.send(default_name_method), model.id] }
+      name_method = default_name_method
+      if name_method.nil? and
+         records.first.respond_to?(:name_for_admin_assistant)
+        name_method = :name_for_admin_assistant
+      end
+      sort_value_method = nil
+      if records.first.respond_to?(:sort_value_for_admin_assistant)
+        sort_value_method = :sort_value_for_admin_assistant
+      else
+        sort_value_method = name_method
+      end
+      if sort_value_method
+        records = records.sort_by { |model| model.send(sort_value_method) }
+      end
+      if name_method
+        records.map { |model| [model.send(name_method), model.id] }
       else
         records.map &:id
       end

data/lib/admin_assistant/belongs_to_column.rb

@@ -46,7 +46,7 @@ class AdminAssistant
           @belongs_to_assoc.association_foreign_key
     end
       
-    def attributes_for_search_object(search_params)
+    def attributes_for_search_object(search_params, compare_to_range)
       atts = {}
       if @match_text_fields_in_search
         atts[name.to_sym] = search_params[name]
@@ -127,21 +127,29 @@ class AdminAssistant
       
       def default_html(form)
         if associated_class.count > 15
-          @action_view.send(
-            :render,
-            :file => AdminAssistant.template_file('_restricted_autocompleter'),
-            :use_full_path => false,
-            :locals => {
-              :form => form, :column => @column,
-              :select_options => @select_options
-            }
-          )
+          render_autocompleter form
         else
           form.select(
             association_foreign_key, options_for_select, @select_options
           )
         end
       end
+      
+      def errors(record)
+        record.errors.on @column.association_foreign_key
+      end
+      
+      def render_autocompleter(form)
+        @action_view.send(
+          :render,
+          :file => AdminAssistant.template_file('_restricted_autocompleter'),
+          :use_full_path => false,
+          :locals => {
+            :form => form, :column => @column,
+            :select_options => @select_options
+          }
+        )
+      end
     end
 
     class IndexView < View

data/lib/admin_assistant/builder.rb

@@ -59,7 +59,7 @@ class AdminAssistant
           match = $1.to_sym
         end
         setting = @settingses.detect { |setting|
-          setting.column_config_args.keys.include?(match)
+          setting.column_config_fields.keys.include?(match)
         }
         if setting
           setting[@column_name].send(meth, *args)
@@ -71,29 +71,33 @@ class AdminAssistant
   end
   
   class ColumnConfig
-    def initialize(fields_config)
-      @fields_config = fields_config
+    def initialize(fields)
+      @fields = {}
+      fields.each do |fn, value|
+        @fields[fn] = value.is_a?(Array) ? value : [value, nil]
+      end
       @values = {}
     end
     
     def method_missing_matching_fields_config(meth, block, *args)
-      field_type = @fields_config[meth]
+      field_type = @fields[meth].first
       if field_type == :accessor
-        @values[meth]
+        default_val_or_proc = @fields[meth].last
+        if default_val_or_proc.respond_to?(:call)
+          default_val_or_proc.call @values[meth]
+        else
+          @values[meth].nil? ? default_val_or_proc : @values[meth]
+        end
       elsif field_type == :boolean
         @values[meth] = true
       elsif field_type == :block
-        if block
-          @values[meth] = block
-        else
-          @values[meth]
-        end
+        block ? (@values[meth] = block) : @values[meth]
       end
     end
     
     def find_field_from_method(meth, target_field_type, &block)
-      @fields_config.detect { |fn, ft|
-        meth.to_s =~ block.call(fn) && ft == target_field_type
+      @fields.detect { |fn, tuple|
+        meth.to_s =~ block.call(fn) && tuple.first == target_field_type
       }.first
     end
     
@@ -103,7 +107,7 @@ class AdminAssistant
     end
     
     def method_missing(meth, *args, &block)
-      if @fields_config[meth]
+      if @fields[meth]
         return method_missing_matching_fields_config(meth, block, *args)
       elsif meth.to_s =~ /=$/
         result = method_missing_maybe_setter(meth, *args)
@@ -124,7 +128,7 @@ class AdminAssistant
     def initialize(admin_assistant)
       @admin_assistant = admin_assistant
       @column_configs = HashWithIndifferentAccess.new { |h, k|
-        h[k] = ColumnConfig.new(column_config_args)
+        h[k] = ColumnConfig.new(column_config_fields)
       }
     end
     
@@ -142,27 +146,40 @@ class AdminAssistant
       @column_configs.values.map(&:polymorphic_types).flatten.compact
     end
     
-    def column_config_args
+    def column_config_fields
       {:boolean_labels => :accessor, :label => :accessor,
-       :polymorphic_types => :accessor}
+       :polymorphic_types => :accessor, :strftime_format => :accessor}
     end
   end
   
   class FormSettings < AbstractSettings
+    attr_writer :multi
     attr_reader :submit_buttons
     
     def initialize(admin_assistant)
       super
       @submit_buttons = []
+      @multi = false
     end
     
-    def column_config_args
-      {:clear_link => :accessor, :datetime_select_options => :accessor,
-       :date_select_options => :accessor, :default => :block,
+    def column_config_fields
+      {:clear_link => :accessor,
+       :datetime_select_options => [:accessor, {}],
+       :date_select_options => [:accessor, {}], :default => :block,
        :description => :accessor, :exclude_blank => :boolean,
        :image_size => :accessor, :input => :accessor,
-       :read_only => :boolean, :select_options => :accessor,
-       :text_area_options => :accessor, :write_once => :boolean
+       :read_only => :boolean, :select_choices => :accessor,
+       :select_options => [
+        :accessor,
+        Proc.new { |v|
+          v ||= {}
+          unless v.has_key?(:include_blank)
+            v[:include_blank] = true
+          end
+          v
+        }
+       ],
+       :text_area_options => [:accessor, {}], :write_once => :boolean
       }
     end
     
@@ -185,6 +202,10 @@ class AdminAssistant
     def column_names
       @column_names || @admin_assistant.default_column_names
     end
+    
+    def multi?
+      @multi
+    end
   end
   
   class IndexSettings < AbstractSettings
@@ -197,11 +218,16 @@ class AdminAssistant
       @search_fields = []
       @search_settings = SearchSettings.new @admin_assistant
       @sort_by = "#{admin_assistant.model_class.table_name}.id desc"
+      @per_page = 25
     end
     
-    def column_config_args
-      {:image_size => :accessor, :link_to_args => :block,
-       :sort_by => :accessor}
+    def cache_total_entries(time_span = nil)
+      time_span ? (@cache_total_entries = time_span) : @cache_total_entries
+    end
+    
+    def column_config_fields
+      {:ajax_toggle => :accessor, :image_size => :accessor,
+       :link_to_args => :block, :sort_by => :accessor}
     end
     
     def conditions(str = nil, &block)
@@ -226,6 +252,14 @@ class AdminAssistant
       end
     end
     
+    def per_page(*args)
+      if args.empty?
+        @per_page
+      else
+        @per_page = args.first
+      end
+    end
+    
     def search(*columns)
       if block_given?
         yield @search_settings
@@ -249,17 +283,20 @@ class AdminAssistant
     end
     
     class SearchSettings < AbstractSettings
+      attr_accessor :include_params_in_form
       attr_reader :column_names
       
       def initialize(admin_assistant)
         super
         @column_names = []
         @default_search_includes = []
+        @include_params_in_form = false
       end
       
-      def column_config_args
+      def column_config_fields
         {:blank_checkbox => :accessor, :comparators => :accessor,
-         :conditions => :block, :field_type => :accessor,
+         :compare_to_range => :accessor, :conditions => :block,
+         :field_type => :accessor,
          :match_text_fields_for_association => :boolean}
       end
       
@@ -267,11 +304,11 @@ class AdminAssistant
         @column_names = c
       end
     
-      def default_search_includes(*includes)
+      def default_search_matches_on(*includes)
         if includes.empty?
-          @default_search_includes
+          @admin_assistant.default_search_matches_on
         else
-          @default_search_includes = includes
+          @admin_assistant.default_search_matches_on = includes
         end
       end
     end
@@ -280,7 +317,7 @@ class AdminAssistant
   class ShowSettings < AbstractSettings
     attr_reader :model_class_name_block
     
-    def column_config_args
+    def column_config_fields
       {}
     end