admin_assistant 1.0.0 → 1.0.1

data/lib/admin_assistant/request/base.rb

@@ -1,14 +1,41 @@
 class AdminAssistant
   module Request
+    def self.dispatch(action_name, admin_assistant, controller)
+      class_name = action_name.to_s.capitalize
+      if [:create, :new].include?(action_name)
+        if admin_assistant.form_settings.multi?
+          class_name = "Multi#{class_name}"
+        else
+          class_name = "Single#{class_name}"
+        end
+      end
+      const_get(class_name).new(admin_assistant, controller).call
+    end
+    
     class Base
       def initialize(admin_assistant, controller)
         @admin_assistant, @controller = admin_assistant, controller
+        controller.instance_variable_set :@admin_assistant, admin_assistant
       end
   
       def action
         @controller.action_name
       end
       
+      def after_template_file(template_name)
+        File.join(
+          RAILS_ROOT, 'app/views/', @controller.controller_path, 
+          "_after_#{template_name}.html.erb"
+        )
+      end
+      
+      def before_template_file(template_name)
+        File.join(
+          RAILS_ROOT, 'app/views/', @controller.controller_path, 
+          "_before_#{template_name}.html.erb"
+        )
+      end
+      
       def model_class
         @admin_assistant.model_class
       end
@@ -17,34 +44,23 @@ class AdminAssistant
         model_class.name.underscore.to_sym
       end
       
-      def params_for_save
-        ParamsForSave.new(@controller, @record, model_class_symbol)
+      def origin
+        @controller.params[:origin] || @controller.request.referer ||
+            {:action => 'index'}
       end
       
-      def redirect_after_save
-        url_params = if @controller.respond_to?(:destination_after_save)
-          @controller.send(
-            :destination_after_save, @record, @controller.params
-          )
-        end
-        url_params ||= {:action => 'index'}
-        @controller.send :redirect_to, url_params
+      def render_single_form(record)
+        @controller.instance_variable_set :@record, record
+        @controller.instance_variable_set :@origin, origin
+        render_template_file 'form'
       end
       
-      def after_template_file(template_name)
-        File.join(
-          RAILS_ROOT, 'app/views/', @controller.controller_path, 
-          "_after_#{template_name}.html.erb"
-        )
+      def render_multi_form(records)
+        @controller.instance_variable_set :@records, records
+        @controller.instance_variable_set :@origin, origin
+        render_template_file 'multi_form'
       end
       
-      def before_template_file(template_name)
-        File.join(
-          RAILS_ROOT, 'app/views/', @controller.controller_path, 
-          "_before_#{template_name}.html.erb"
-        )
-      end
-
       def render_template_file(template_name = action, opts_plus = {})
         html = ''
         html << render_to_string_if_exists(
@@ -74,48 +90,54 @@ class AdminAssistant
           ''
         end
       end
-      
-      def save
-        if @controller.respond_to?(:before_save)
-          @controller.send(:before_save, @record)
-        end
-        result = @record.save
-        if result && @controller.respond_to?(:after_save)
-          @controller.send(:after_save, @record)
-        end
-        result
-      end
     end
     
     class ParamsForSave < Hash
-      def initialize(controller, record, model_class_symbol)
+      attr_reader :errors
+      
+      def initialize(controller, record, record_params=nil)
         super()
-        @controller, @record, @model_class_symbol =
-            controller, record, model_class_symbol
+        @controller, @record_params = controller, record_params
+        @model_class_symbol = record.class.name.underscore.to_sym
+        @record_params ||= @controller.params[@model_class_symbol]
+        @model_methods = record.methods
+        @model_columns = record.class.columns
+        @errors = Errors.new
         build_from_split_params
         destroy_params.each do |k,v|
-          if whole_params[k].blank?
-            self[k] = nil
-            mname = "destroy_#{k}_in_attributes"
-            if controller.respond_to?(mname)
-              controller.send(mname, self)
-            end
-          end
+          apply_destroy_param k, v
         end
         build_from_whole_params
       end
       
+      def apply_destroy_param(name, value)
+        if whole_params[name].blank?
+          self[name] = nil
+          mname = "destroy_#{name}_in_attributes"
+          if @controller.respond_to?(mname)
+            @controller.send(mname, self)
+          end
+        end
+      end
+      
       def build_from_split_params
-        bases = split_params.map { |k, v| k.gsub(/\([0-9]+i\)$/, '') }.uniq
+        bases = split_params.map { |k, v| k.gsub(split_param_regex, '') }.uniq
         bases.each do |b|
           h = {}
-          split_params.each { |k, v|
-            h[k] = split_params.delete(k) if k =~ /#{b}\([0-9]+i\)$/
-          }
           from_form_method = "#{b}_from_form".to_sym
           if @controller.respond_to?(from_form_method)
+            split_params.each { |k, v|
+              if k =~ /#{b}#{split_param_regex.source}/
+                h[$1] = split_params.delete(k)
+              end
+            }
             self[b] = @controller.send(from_form_method, h)
-          elsif @record.respond_to?("#{b}=")
+          elsif model_setter?(b)
+            split_params.each { |k, v|
+              if k =~ /#{b}#{split_param_regex.source}/
+                h[k] = split_params.delete(k)
+              end
+            }
             self.merge! h
           end
         end
@@ -125,20 +147,15 @@ class AdminAssistant
         whole_params.each do |k, v|
           from_form_method = "#{k}_from_form".to_sym
           if @controller.respond_to?(from_form_method)
-            self[k] = @controller.send(from_form_method, v)
-          elsif @record.respond_to?("#{k}=")
+            args = [v]
+            if @controller.method(from_form_method).arity >= 2
+              args << @record_params
+            end
+            args << @errors if @controller.method(from_form_method).arity >= 3
+            self[k] = @controller.send(from_form_method, *args)
+          elsif model_setter?(k)
             unless destroy_params[k] && v.blank?
-              column = @record.class.columns.detect { |c| c.name == k }
-              if column && column.type == :boolean
-                if v == '1'
-                  v = true
-                elsif v == '0'
-                 v = false
-                else
-                 v = nil
-               end
-              end
-              self[k] = v
+              self[k] = value_from_param(k, v)
             end
           end
         end
@@ -146,7 +163,7 @@ class AdminAssistant
       
       def destroy_params
         dp = {}
-        @controller.params[@model_class_symbol].each do |k,v|
+        @record_params.each do |k,v|
           if k =~ %r|(.*)\(destroy\)|
             dp[$1] = v
           end
@@ -154,23 +171,135 @@ class AdminAssistant
         dp
       end
       
+      def model_setter?(attr)
+        @model_columns.any? { |mc| mc.name.to_s == attr } or
+            @model_methods.include?("#{attr}=")
+      end
+      
+      def split_param_key?(key)
+        key =~ split_param_regex
+      end
+      
+      def split_param_regex
+        @split_param_regex ||= /\((.+i)\)$/
+      end
+      
       def split_params
         sp = {}
-        @controller.params[@model_class_symbol].each do |k,v|
-          sp[k] = v if k =~ /\([0-9]+i\)$/
-        end
+        @record_params.each do |k,v| sp[k] = v if split_param_key?(k); end
         sp
       end
       
+      def value_from_param(name, str)
+        column = @model_columns.detect { |c| c.name == name }
+        if column && column.type == :boolean
+          if str == '1'
+            true
+          elsif str == '0'
+            false
+          else
+            nil
+          end
+        else
+          str
+        end
+      end
+      
       def whole_params
         wp = {}
-        @controller.params[@model_class_symbol].each do |k,v|
-          unless k =~ /\([0-9]+i\)$/ || k =~ %r|(.*)\(destroy\)|
+        @record_params.each do |k,v|
+          unless split_param_key?(k) || k =~ %r|(.*)\(destroy\)|
             wp[k] = v
           end
         end
         wp
       end
+      
+      class Error
+        attr_reader :message
+        
+        def initialize(attribute, message, options)
+          @attribute, @message, @options = attribute, message, options
+        end
+      end
+      
+      class Errors
+        def initialize
+          @errors = Hash.new { |h,k| h[k] = []}
+        end
+        
+        def add(error_or_attr, message = nil, options = {})
+          error, attribute = error_or_attr.is_a?(Error) ? [error_or_attr, error_or_attr.attribute] : [nil, error_or_attr]
+          options[:message] = options.delete(:default) if options.has_key?(:default)
+    
+          @errors[attribute.to_s] << (error || Error.new(attribute, message, options))
+        end
+        
+        def each
+          @errors.each do |attr, ary|
+            ary.each do |error|
+              yield attr, error.message
+            end
+          end
+        end
+        
+        def each_attribute
+          @errors.keys.each do |key| yield key; end
+        end
+        
+        def empty?
+          @errors.empty?
+        end
+      end
+    end
+    
+    class AbstractSaving
+      attr_reader :record
+      
+      def initialize(record, controller)
+        @record, @controller = record, controller
+      end
+      
+      def params_for_save
+        ParamsForSave.new(@controller, @record)
+      end
+      
+      def record_and_associations_valid?
+        if @controller.respond_to?(:before_validation)
+          @controller.send(:before_validation, record)
+        end
+        params = params_for_save
+        prepare_record_to_receive_invalid_association_assignments
+        record.attributes = params
+        record.valid?
+        params.errors.each do |attr, msg| record.errors.add(attr, msg); end
+        if @controller.respond_to?(:validate)
+          @controller.send(:validate, record)
+        end
+        record.errors.empty?
+      end
+      
+      def redirect_after_save
+        url_params = if @controller.respond_to?(:destination_after_save)
+          @controller.send(
+            :destination_after_save, @record, @controller.params
+          )
+        end
+        url_params ||= @controller.params[:origin]
+        url_params ||= {:action => 'index'}
+        @controller.send :redirect_to, url_params
+      end
+      
+      def save
+        if @controller.respond_to?(:before_save)
+          @controller.send(:before_save, record)
+        end
+        result = record.save
+        if result && @controller.respond_to?(:after_save)
+          @controller.send(:after_save, record)
+        end
+        result
+      end
     end
   end
 end

data/lib/admin_assistant/request/create.rb

@@ -1,16 +1,64 @@
 class AdminAssistant
   module Request
-    class Create < Base
+    class SingleCreate < Base
       def call
-        @record = model_class.new
-        @record.attributes = params_for_save
-        if save
-          redirect_after_save
+        if @controller.request.get?
+          @controller.send :redirect_to, :action => 'new'
         else
-          @controller.instance_variable_set :@record, @record
-          render_template_file 'form'
+          saving = CreateSaving.new model_class.new, @controller
+          if saving.record_and_associations_valid?
+            saving.save
+            saving.redirect_after_save
+          else
+            render_single_form saving.record
+          end
         end
       end
+    end
+    
+    class MultiCreate < Base
+      def call
+        savings = ('a'..'j').map { |letter|
+          CreateSaving.new(model_class.new, @controller, letter)
+        }
+        non_blank_savings = savings.reject &:blank?
+        if non_blank_savings.map(&:record_and_associations_valid?).all?
+          non_blank_savings.each do |s| s.save; end
+          redirector = non_blank_savings.first || savings.first
+          redirector.redirect_after_save
+        else
+          render_multi_form(
+            savings.sort_by { |s| [(s.blank? ? 1 : 0), s.params_prefix] }.
+                    map(&:record)
+          )
+        end
+      end
+    end
+      
+    class CreateSaving < Request::AbstractSaving
+      attr_reader :params_prefix
+      
+      def initialize(record, controller, params_prefix = nil)
+        super record, controller
+        @params_prefix = params_prefix
+      end
+      
+      def blank?
+        raw_params.values.all? &:blank?
+      end
+      
+      def params_for_save
+        ParamsForSave.new @controller, @record, raw_params
+      end
+      
+      def prepare_record_to_receive_invalid_association_assignments
+        # no preparations necessary for creation
+      end
+      
+      def raw_params
+        model_class_symbol = @record.class.name.underscore.to_sym
+        @controller.params[model_class_symbol][@params_prefix]
+      end
       
       def save
         if @controller.respond_to?(:before_create)

data/lib/admin_assistant/request/edit.rb

@@ -3,8 +3,7 @@ class AdminAssistant
     class Edit < Base
       def call
         @record = model_class.find @controller.params[:id]
-        @controller.instance_variable_set :@record, @record
-        render_template_file 'form'
+        render_single_form @record
       end
     end
   end

data/lib/admin_assistant/request/index.rb

@@ -2,25 +2,32 @@ class AdminAssistant
   module Request
     class Index < Base
       def call
-        controller_methods = {}
-        possible_methods = [
-          :conditions_for_index, :extra_right_column_links_for_index
-        ]
-        possible_methods.each do |mname|
-          if @controller.respond_to?(mname)
-            controller_methods[mname] = @controller.method mname
-          end
-        end
         index = AdminAssistant::Index.new(
           @admin_assistant, @controller.params, controller_methods
         )
         @controller.instance_variable_set :@index, index
+        if @controller.respond_to?(:before_render_for_index)
+          @controller.send :before_render_for_index
+        end
         render_template_file
       end
       
       def columns
         @admin_assistant.index_settings.columns
       end
+      
+      def controller_methods
+        c_methods = {}
+        possible_methods = [
+          :conditions_for_index, :extra_right_column_links_for_index
+        ]
+        possible_methods.each do |mname|
+          if @controller.respond_to?(mname)
+            c_methods[mname] = @controller.method mname
+          end
+        end
+        c_methods
+      end
     end
   end
 end

data/lib/admin_assistant/request/new.rb

@@ -1,18 +1,30 @@
 class AdminAssistant
   module Request
-    class New < Base
-      def call
-        @record = model_class.new
+    class AbstractNew < Base
+      def new_saving
+        saving = CreateSaving.new model_class.new, @controller
         @admin_assistant.form_settings.columns_for_new.each do |column|
           if block = @admin_assistant.form_settings[column].default
-            @record.send("#{column}=", block.call(@controller))
+            saving.record.send("#{column}=", block.call(@controller))
           end
         end
         if @controller.params[model_class_symbol]
-          @record.attributes = params_for_save
+          saving.record.attributes = saving.params_for_save
         end
-        @controller.instance_variable_set :@record, @record
-        render_template_file 'form'
+        saving
+      end
+    end
+    
+    class SingleNew < AbstractNew
+      def call
+        render_single_form new_saving.record
+      end
+    end
+    
+    class MultiNew < AbstractNew
+      def call
+        records = (0..9).map { new_saving }.map(&:record)
+        render_multi_form records
       end
     end
   end

data/lib/admin_assistant/request/update.rb

@@ -2,21 +2,22 @@ class AdminAssistant
   module Request
     class Update < Base
       def call
-        @record = model_class.find @controller.params[:id]
-        @record.attributes = params_for_save
-        if save
+        saving = Update::Saving.new(
+          model_class.find(@controller.params[:id]), @controller
+        )
+        if saving.record_and_associations_valid?
+          saving.save
           if @controller.params[:from]
-            render_response_to_ajax_toggle
+            render_response_to_ajax_toggle saving.record
           else
-            redirect_after_save
+            saving.redirect_after_save
           end
         else
-          @controller.instance_variable_set :@record, @record
-          render_template_file 'form'
+          render_single_form saving.record
         end
       end
       
-      def render_response_to_ajax_toggle
+      def render_response_to_ajax_toggle(record)
         @controller.params[:from] =~ /#{model_class.name.underscore}_\d+_(.*)/
         field_name = $1
         index = AdminAssistant::Index.new @admin_assistant
@@ -28,16 +29,30 @@ class AdminAssistant
           :render,
           :inline => erb,
           :locals => {
-            :index => index, :field_name => field_name, :record => @record
+            :index => index, :field_name => field_name, :record => record
           }
         )
       end
       
-      def save
-        if @controller.respond_to?(:before_update)
-          @controller.send(:before_update, @record)
+      class Saving < Request::AbstractSaving
+        def prepare_record_to_receive_invalid_association_assignments
+          params_for_save.errors.each_attribute do |attr|
+            @record.instance_eval <<-EVAL
+              @attempted_attributes ||= {}
+              def #{attr}=(ary)
+                @attempted_attributes[#{attr.inspect}] = ary
+              end
+              def #{attr}; @attempted_attributes[#{attr.inspect}]; end
+            EVAL
+          end
+        end
+
+        def save
+          if @controller.respond_to?(:before_update)
+            @controller.send(:before_update, @record)
+          end
+          super
         end
-        super
       end
     end
   end

data/lib/admin_assistant/search.rb

@@ -8,7 +8,9 @@ class AdminAssistant
       @attributes = HashWithIndifferentAccess.new
       columns.each do |c|
         c.verify_for_search
-        c.attributes_for_search_object(@params).each do |key, value|
+        compare_to_range = compare_to_range?(c.name) if c.respond_to?(:name)
+        attributes = c.attributes_for_search_object(@params, compare_to_range)
+        attributes.each do |key, value|
           @attributes[key] = value
         end
       end
@@ -31,12 +33,16 @@ class AdminAssistant
       end
     end
     
+    def blank?(column_name)
+      @params["#{column_name}(blank)"] == '1'
+    end
+    
     def columns
       column_names = settings.column_names
       if column_names.empty?
         [DefaultSearchColumn.new(
           @admin_assistant.model_class,
-          :fields_to_include => settings.default_search_includes
+          :fields_to_match => @admin_assistant.default_search_matches_on
         )]
       else
         column_names.map { |column_name| 
@@ -51,6 +57,15 @@ class AdminAssistant
       }
     end
     
+    def comparator(column_name)
+      c = @params["#{column_name}(comparator)"]
+      c if %w(< <= = >= >).include?(c)
+    end
+    
+    def compare_to_range?(column_name)
+      settings[column_name].compare_to_range
+    end
+
     def id
       @attributes[:id] if @attributes.has_key?(:id)
     end

data/lib/admin_assistant/virtual_column.rb

@@ -13,7 +13,7 @@ class AdminAssistant
       end
     end
     
-    def attributes_for_search_object(search_params)
+    def attributes_for_search_object(search_params, compare_to_range)
       value = if search_params[@name.to_s] == 'true'
         true
       elsif search_params[@name.to_s] == 'false'
@@ -42,15 +42,23 @@ class AdminAssistant
       include AdminAssistant::Column::FormViewMethods
       
       def default_html(form)
+        object = form.object
         input_name = "#{@column.model_class.name.underscore}[#{name}]"
-        if @input
-          if @input == :check_box
-            fv = value form.object
-            check_box_and_hidden_tags(input_name, fv)
-          end
+        input = @input || :text_field
+        html = if input == :check_box
+          check_box_and_hidden_tags(input_name, value(object))
         else
-          @action_view.send(:text_field_tag, input_name, string(form.object))
+          @action_view.send("#{input}_tag", input_name, string(object))
         end
+        if has_matching_errors?(object)
+          html = "<div class=\"fieldWithErrors\">#{html}</div>"
+        end
+        html
+      end
+      
+      def has_matching_errors?(record)
+        record.respond_to?(:errors) && record.errors.respond_to?(:on) && 
+           record.errors.on(name)
       end
     end