active_scaffold_batch_vho 3.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 vhochstein
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+require './lib/active_scaffold_batch/version.rb'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "active_scaffold_batch_vho"
+  gem.version = ActiveScaffoldBatch::Version::STRING
+  gem.homepage = "http://github.com/vhochstein/active_scaffold_batch"
+  gem.license = "MIT"
+  gem.summary = %Q{Batch Processing for ActiveScaffold}
+  gem.description = %Q{You want to destroy/update many records at once with activescaffold?}
+  gem.email = "activescaffold@googlegroups.com"
+  gem.authors = ["Volker Hochstein"]
+  gem.add_runtime_dependency 'active_scaffold_vho', '~> 3.0'
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "active_scaffold_batch #{ActiveScaffoldBatch::Version::STRING}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/frontends/default/views/_batch_update_form.html.erb

@@ -0,0 +1,7 @@
+<%= render :partial => "base_form", :locals => {:xhr => xhr ||= nil,
+                                                :form_action => form_action ||= :batch_update,
+                                                :method => method ||= :post,
+                                                :cancel_link => cancel_link ||= true,
+                                                :body_partial => 'batch_update_form_body',
+                                                :headline => headline ||= active_scaffold_config.batch_update.label} %>
+

data/frontends/default/views/_batch_update_form_attribute.html.erb

@@ -0,0 +1,12 @@
+<% scope ||= nil %>
+<dl>
+  <dt>
+    <label for="<%= active_scaffold_input_options(column, scope)[:id] %>"><%= column.label %></label>
+  </dt>
+  <dd>
+    <%= active_scaffold_update_for column, scope %>
+    <% if column.description -%>
+      <span class="description"><%= column.description %></span>
+    <% end -%>
+  </dd>
+</dl>

data/frontends/default/views/_batch_update_form_attribute_scope.html.erb

@@ -0,0 +1,9 @@
+<% scope ||= nil %>
+<dl>
+  <dt>
+    <label for="record_batch_scope"><%= as_(:records) %></label>
+  </dt>
+  <dd>
+    <%= active_scaffold_update_scope_select %>
+  </dd>
+</dl>

data/frontends/default/views/_batch_update_form_body.html.erb

@@ -0,0 +1,25 @@
+<% subsection_id ||= nil %>
+<ol class="form" <%= "id=#{subsection_id}" unless subsection_id.nil? %>  <%= 'style="display: none;"' if columns.collapsed -%>>
+  <li class="form-element">
+    <%= render :partial => 'batch_update_form_attribute_scope' -%>
+  </li>
+  <% columns.each :for => @record do |column| %>
+  <% next if column.plural_association? || (column.association && [:has_one].include?(column.association.macro)) %>
+  <% renders_as = column_renders_as(column) %>
+  <% if renders_as == :subsection -%>
+    <% subsection_id = sub_section_id(:sub_section => column.label) %>
+  <li class="sub-section">
+    <h5><%= column.label %></h5>
+    <%= render :partial => 'form', :locals => { :columns => column, :subsection_id => subsection_id} %>
+    <%= link_to_visibility_toggle(subsection_id, {:default_visible => !column.collapsed}) -%>
+  </li>
+  <% elsif column.readonly_association?
+    next %>
+  <% else
+    renders_as = :field if renders_as == :subform -%>
+  <li class="form-element <%= column.css_class unless column.css_class.nil? %>">
+    <%= render :partial => 'batch_update_form_attribute', :locals => { :column => column } -%>
+  </li>
+  <% end -%>
+  <% end -%>
+</ol>

data/frontends/default/views/batch_update.html.erb

@@ -0,0 +1,5 @@
+<div class="active-scaffold">
+  <div class="batch-update-view <%= "#{params[:controller]}-view" %> view">
+    <%= render :partial => 'batch_update_form' -%>
+  </div>
+</div>

data/frontends/default/views/on_batch_base.js.rjs

@@ -0,0 +1,6 @@
+unless @error_records.empty?
+  flash[:error] = @error_records.collect do |record|
+    active_scaffold_error_messages_for(record, :object_name => "#{record.class.model_name.human.downcase}#{record.new_record? ? '' : ": #{record.to_label}"}", :header_message => '', :message => "#{record.class.model_name.human.downcase}#{record.new_record? ? '' : ": #{record.to_label}"}", :container_tag => nil, :list_type => :br)
+  end.join.html_safe
+end
+page.call 'ActiveScaffold.replace_html', active_scaffold_content_id, render(:partial => 'list', :layout => false)

data/frontends/default/views/on_batch_update.js.rjs

@@ -0,0 +1,10 @@
+form_selector = "#{element_form_id(:action => :batch_update)}"
+
+if controller.send :batch_successful?
+  page.call 'ActiveScaffold.replace_html', active_scaffold_content_id, render(:partial => 'list', :layout => false)
+  page << "ActiveScaffold.find_action_link('#{form_selector}').close();"
+else
+  page << "ActiveScaffold.find_action_link('#{form_selector}').update_flash_messages('#{escape_javascript(render(:partial => 'messages').strip)}');"
+  page.call 'ActiveScaffold.replace', form_selector, render(:partial => 'batch_update_form', :locals => {:xhr => true})
+  page.call 'ActiveScaffold.scroll_to', form_selector
+end

data/init.rb

@@ -0,0 +1,9 @@
+ACTIVE_SCAFFOLD_BATCH_INSTALLED = :plugin
+
+require 'active_scaffold_batch'
+
+begin
+  ActiveScaffoldAssets.copy_to_public(ActiveScaffoldBatch.root)
+rescue
+  raise $! unless Rails.env == 'production'
+end

data/lib/active_scaffold/actions/batch_base.rb

@@ -0,0 +1,118 @@
+module ActiveScaffold::Actions
+  module BatchBase
+
+    def self.included(base)
+      base.add_active_scaffold_path File.join(ActiveScaffold::Config::BatchBase.plugin_directory, 'frontends', 'default' , 'views')
+      base.helper_method :batch_scope
+    end
+
+    protected
+
+    def batch_action(batch_action = :batch_base)
+      process_action_link_action(batch_action) do
+        process_batch
+      end
+    end
+
+    def process_batch
+      do_batch
+      do_search if respond_to? :do_search
+      do_list
+    end
+
+    def batch_scope
+      if params[:batch_scope]
+        @batch_scope = params[:batch_scope] if ['LISTED', 'MARKED'].include?(params[:batch_scope])
+        params.delete :batch_scope
+      end if @batch_scope.nil?
+      @batch_scope
+    end
+
+    def error_records
+      @error_records ||= []
+    end
+
+     # in case of an error we have to prepare @record object to have assigned all
+    # defined batch_update values, however, do not set those ones with an override
+    # these ones will manage on their own
+    def prepare_error_record
+    end
+
+    def batch_successful?
+      error_records.empty?
+    end
+
+    def do_batch
+      send("before_do_#{action_name}") if respond_to?("before_do_#{action_name}")
+      send("#{action_name}_#{batch_scope.downcase}") if !batch_scope.nil? && respond_to?("#{action_name}_#{batch_scope.downcase}")
+      prepare_error_record unless batch_successful?
+    end
+
+    def authorized_for_job?(record)
+      if record.authorized_for?(:crud_type => active_scaffold_config.send(action_name).crud_type)
+        true
+      else
+        record.errors.add(:base, as_(:no_authorization_for_action, :action => action_name))
+        error_records << record
+        false
+      end
+    end
+
+    def batch_base_respond_to_html
+      if respond_to? "#{action_name}_respond_to_html"
+        send("#{action_name}_respond_to_html")
+      else
+        if params[:iframe]=='true' # was this an iframe post ?
+          responds_to_parent do
+            render :action => 'on_batch_base.js', :layout => false
+          end
+        else # just a regular post
+          if batch_successful?
+            flash[:info] = as_(:batch_processing_successful)
+          end
+          return_to_main
+        end
+      end
+    end
+
+    def batch_base_respond_to_js
+      if respond_to? "#{action_name}_respond_to_js"
+        send("#{action_name}_respond_to_js")
+      else  
+        render :action => "on_batch_base"
+      end
+    end
+
+    def batch_base_respond_to_xml
+      if respond_to? "#{action_name}_respond_to_xml"
+        send("#{action_name}_respond_to_xml")
+      else
+        render :xml => response_object.to_xml(:only => active_scaffold_config.send(action_name).columns.names), :content_type => Mime::XML, :status => response_status
+      end
+    end
+
+    def batch_base_respond_to_json
+      if respond_to? "#{action_name}_respond_to_json"
+        send("#{action_name}_respond_to_json")
+      else
+        render :text => response_object.to_json(:only => active_scaffold_config.send(action_name).columns.names), :content_type => Mime::JSON, :status => response_status
+      end
+    end
+
+    def batch_base_respond_to_yaml
+      if respond_to? "#{action_name}_respond_to_yaml"
+        send("#{action_name}_respond_to_yaml")
+      else
+        render :text => Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.send(action_name).columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
+      end
+    end
+
+    def batch_base_formats
+      if respond_to? "#{action_name}_formats"
+        send("#{action_name}_formats")
+      else
+        (default_formats + active_scaffold_config.formats + active_scaffold_config.send(action_name).formats).uniq
+      end
+    end
+  end
+end

data/lib/active_scaffold/actions/batch_destroy.rb

@@ -0,0 +1,72 @@
+module ActiveScaffold::Actions
+  module BatchDestroy
+
+    def self.included(base)
+      base.before_filter :batch_destroy_authorized_filter, :only => [:batch_destroy]
+    end
+
+    def batch_destroy
+      batch_action
+    end
+    
+    protected
+
+    def batch_destroy_listed
+      case active_scaffold_config.batch_destroy.process_mode
+      when :delete then
+        each_record_in_scope do |record|
+          destroy_record(record) if authorized_for_job?(record)
+        end
+      when :delete_all then
+        do_search if respond_to? :do_search
+        active_scaffold_config.model.delete_all(all_conditions)
+      else
+        Rails.logger.error("Unknown process_mode: #{active_scaffold_config.batch_destroy.process_mode} for action batch_destroy")
+      end
+      
+    end
+
+    def batch_destroy_marked
+      case active_scaffold_config.batch_destroy.process_mode
+      when :delete then
+        active_scaffold_config.model.marked.each do |record|
+          destroy_record(record) if authorized_for_job?(record)
+        end
+      when :delete_all then
+        active_scaffold_config.model.marked.delete_all
+        do_demark_all
+      else
+        Rails.logger.error("Unknown process_mode: #{active_scaffold_config.batch_destroy.process_mode} for action batch_destroy")
+      end
+    end
+
+    def destroy_record(record)
+      @successful = nil
+      @record = record
+
+      do_destroy
+      if successful?
+        @record.marked = false if batch_scope == 'MARKED'
+      else
+        error_records << @record
+      end
+    end
+
+    # The default security delegates to ActiveRecordPermissions.
+    # You may override the method to customize.
+    def batch_destroy_authorized?(record = nil)
+      authorized_for?(:crud_type => :delete)
+    end
+
+    def batch_destroy_marked_ignore?(record = nil)
+      !active_scaffold_config.list.columns.include? :marked
+    end
+
+    private
+
+    def batch_destroy_authorized_filter
+      link = active_scaffold_config.batch_destroy.link || active_scaffold_config.batch_destroy.class.link
+      raise ActiveScaffold::ActionNotAllowed unless self.send(link.first.security_method)
+    end
+  end
+end

data/lib/active_scaffold/actions/batch_update.rb

@@ -0,0 +1,320 @@
+module ActiveScaffold::Actions
+  module BatchUpdate
+
+    GenericOperators = [
+      'NO_UPDATE',
+      'REPLACE'
+    ]
+    NumericOperators = [
+      'PLUS',
+      'MINUS',
+      'TIMES',
+      'DIVISION'
+    ]
+    NumericOptions = [
+      'ABSOLUTE',
+      'PERCENT'
+    ]
+
+    DateOperators = [
+      'PLUS',
+      'MINUS'
+    ]
+    
+    def self.included(base)
+      base.before_filter :batch_update_authorized_filter, :only => [:batch_edit, :batch_update]
+      base.verify :method => [:post, :put],
+                  :only => :batch_update,
+                  :redirect_to => { :action => :index }
+      base.helper_method :batch_update_values
+    end
+
+    def batch_edit
+      do_batch_edit
+      respond_to_action(:batch_edit)
+    end
+
+    def batch_update
+      batch_action
+    end
+
+    
+    protected
+    def batch_edit_respond_to_html
+      if batch_successful?
+        render(:action => 'batch_update')
+      else
+        return_to_main
+      end
+    end
+
+    def batch_edit_respond_to_js
+      render(:partial => 'batch_update_form')
+    end
+
+    def selected_columns
+      if @selected_columns.nil?
+        @selected_columns = []
+        if params[:record] && params[:record].is_a?(Hash)
+          params[:record].each do |key, value|
+            @selected_columns << key.to_sym if value[:operator] != 'NO_UPDATE'
+          end
+        end
+      end
+      @selected_columns
+    end
+
+    
+    def batch_update_values
+      @batch_update_values || {}
+    end
+
+    def batch_update_respond_to_html
+      if params[:iframe]=='true' # was this an iframe post ?
+        responds_to_parent do
+          render :action => 'on_batch_update.js', :layout => false
+        end
+      else # just a regular post
+        if batch_successful?
+          flash[:info] = as_(:updated_model, :model => @record.to_label)
+          return_to_main
+        else
+          render(:action => 'batch_update')
+        end
+      end
+    end
+
+    def batch_update_respond_to_js
+      render :action => 'on_batch_update'
+    end
+
+    def do_batch_edit
+      self.successful = true
+      do_new
+    end
+
+    def before_do_batch_update
+      update_columns = active_scaffold_config.batch_update.columns
+      @batch_update_values = attribute_values_from_params(update_columns, params[:record])
+    end
+
+    # in case of an error we have to prepare @record object to have assigned all
+    # defined batch_update values, however, do not set those ones with an override
+    # these ones will manage on their own
+    def prepare_error_record
+      do_new
+      batch_update_values.each do |attribute, value|
+        form_ui = colunm_form_ui(value[:column])
+        set_record_attribute(value[:column], attribute, value[:value]) unless form_ui && override_batch_update_value?(form_ui)
+      end
+    end
+
+    def batch_update_listed
+      case active_scaffold_config.batch_update.process_mode
+      when :update then
+        each_record_in_scope {|record| update_record(record) if authorized_for_job?(record)}
+      when :update_all then
+        updates = updates_for_update_all
+        unless updates.first.empty?
+          do_search if respond_to? :do_search
+          # all_conditions might fail cause joins are not working in update_all
+          active_scaffold_config.model.update_all(updates, all_conditions)
+        end
+      else
+        Rails.logger.error("Unknown process_mode: #{active_scaffold_config.batch_update.process_mode} for action batch_update")
+      end
+      
+    end
+
+    def batch_update_marked
+      case active_scaffold_config.batch_update.process_mode
+      when :update then
+        active_scaffold_config.model.marked.each {|record| update_record(record) if authorized_for_job?(record)}
+      when :update_all then
+        updates = updates_for_update_all
+        unless updates.first.empty?
+          active_scaffold_config.model.marked.update_all(updates)
+          do_demark_all
+        end
+      else
+        Rails.logger.error("Unknown process_mode: #{active_scaffold_config.batch_update.process_mode} for action batch_update")
+      end
+    end
+
+    def updates_for_update_all()
+      update_all = [[]]
+      batch_update_values.each do |attribute, value|
+        sql_set, value = get_update_all_attribute(value[:column], attribute, value[:value])
+        unless sql_set.nil?
+          update_all.first << sql_set
+          update_all << value if sql_set.include?('?')
+        end
+      end
+      update_all[0] = update_all.first.join(',')
+      update_all
+    end
+
+    def update_record(record)
+      @successful = nil
+      @record = record
+
+      batch_update_values.each do |attribute, value|
+        set_record_attribute(value[:column], attribute, value[:value])
+      end
+      
+      update_save
+      if successful?
+        @record.marked = false if batch_scope == 'MARKED'
+      else
+        error_records << @record
+      end
+    end
+
+    def set_record_attribute(column, attribute, value)
+      form_ui = colunm_form_ui(column)
+      if form_ui && override_batch_update_value?(form_ui)
+        @record.send("#{attribute}=", send(override_batch_update_value(form_ui), column, @record, value))
+      else
+        @record.send("#{attribute}=", value[:operator] == 'NULL' ? nil : value[:value])
+      end
+    end
+
+    def colunm_form_ui(column)
+      form_ui = column.form_ui
+      form_ui = column.column.type if form_ui.nil? && column.column
+    end
+
+    def get_update_all_attribute(column, attribute, value)
+      form_ui = column.form_ui
+      form_ui = column.column.type if form_ui.nil? && column.column
+      
+      if form_ui && override_batch_update_all_value?(form_ui)
+        update_value =  send(override_batch_update_all_value(form_ui), column, value)
+        if update_value.nil?
+          sql_set = nil
+        else
+          sql_set = "#{attribute} = #{update_value}"
+          update_value = nil
+        end
+      else
+        sql_set = "#{attribute} = ?"
+        update_value = value[:operator] == 'NULL' ? nil : value[:value]
+      end
+      
+      return sql_set, update_value
+    end
+
+    def attribute_values_from_params(columns, attributes)
+      values = {}
+      columns.each :for => active_scaffold_config.model.new, :crud_type => :update, :flatten => true do |column|
+        values[column.name] = {:column => column, :value => attributes[column.name].merge(:value => column_value_from_param_value(nil, column, attributes[column.name][:value]))} if selected_columns.include? column.name
+      end
+      values
+    end
+
+    
+    # The default security delegates to ActiveRecordPermissions.
+    # You may override the method to customize.
+    def batch_update_authorized?(record = nil)
+      authorized_for?(:crud_type => :update)
+    end
+
+    def batch_update_value_for_numeric(column, record, calculation_info)
+      current_value = record.send(column.name)
+      if ActiveScaffold::Actions::BatchUpdate::GenericOperators.include?(calculation_info[:operator]) || ActiveScaffold::Actions::BatchUpdate::NumericOperators.include?(calculation_info[:operator])
+        operand = self.class.condition_value_for_numeric(column, calculation_info[:value])
+        operand = current_value / 100 * operand  if calculation_info[:opt] == 'PERCENT'
+        case calculation_info[:operator]
+        when 'REPLACE' then operand
+        when 'NULL' then nil
+        when 'PLUS' then current_value.present? ? current_value + operand : nil
+        when 'MINUS' then current_value.present? ? current_value - operand : nil
+        when 'TIMES' then current_value.present? ? current_value * operand : nil
+        when 'DIVISION' then current_value.present? ? current_value / operand : nil
+        else
+          current_value
+        end
+      else
+        current_value
+      end
+    end
+    alias_method :batch_update_value_for_integer, :batch_update_value_for_numeric
+    alias_method :batch_update_value_for_decimal, :batch_update_value_for_numeric
+    alias_method :batch_update_value_for_float, :batch_update_value_for_numeric
+
+    def batch_update_all_value_for_numeric(column, calculation_info)
+      if ActiveScaffold::Actions::BatchUpdate::GenericOperators.include?(calculation_info[:operator]) || ActiveScaffold::Actions::BatchUpdate::NumericOperators.include?(calculation_info[:operator])
+        operand =  active_scaffold_config.model.quote_value(self.class.condition_value_for_numeric(column, calculation_info[:value]))
+        if calculation_info[:opt] == 'PERCENT'#
+          operand = "#{active_scaffold_config.model.connection.quote_column_name(column.name)} / 100.0 * #{operand}"
+        end
+        case calculation_info[:operator]
+        when 'REPLACE' then operand
+        when 'NULL' then active_scaffold_config.model.quote_value(nil)
+        when 'PLUS' then "#{active_scaffold_config.model.connection.quote_column_name(column.name)} + #{operand}"
+        when 'MINUS' then "#{active_scaffold_config.model.connection.quote_column_name(column.name)} - #{operand}"
+        when 'TIMES' then "#{active_scaffold_config.model.connection.quote_column_name(column.name)} * #{operand}"
+        when 'DIVISION' then "#{active_scaffold_config.model.connection.quote_column_name(column.name)} / #{operand}"
+        else
+          nil
+        end
+      else
+        nil
+      end
+    end
+    alias_method :batch_update_all_value_for_integer, :batch_update_all_value_for_numeric
+    alias_method :batch_update_all_value_for_decimal, :batch_update_all_value_for_numeric
+    alias_method :batch_update_all_value_for_float, :batch_update_all_value_for_numeric
+
+    def batch_update_value_for_date_picker(column, record, calculation_info)
+      current_value = record.send(column.name)
+      {"number"=>"", "unit"=>"DAYS", "value"=>"November 16, 2010", "operator"=>"REPLACE"}
+      if ActiveScaffold::Actions::BatchUpdate::GenericOperators.include?(calculation_info[:operator]) || ActiveScaffold::Actions::BatchUpdate::DateOperators.include?(calculation_info[:operator])
+        operand = self.class.condition_value_for_datetime(calculation_info[:value], column.column.type == :date ? :to_date : :to_time)
+        case calculation_info[:operator]
+        when 'REPLACE' then operand
+        when 'NULL' then nil
+        when 'PLUS' then
+          trend_number = [calculation_info['number'].to_i,  1].max
+          current_value.in((trend_number).send(calculation_info['unit'].downcase.singularize.to_sym))
+        when 'MINUS' then
+          trend_number = [calculation_info['number'].to_i,  1].max
+          current_value.ago((trend_number).send(calculation_info['unit'].downcase.singularize.to_sym))
+        else
+          current_value
+        end
+      else
+        current_value
+      end
+    end
+    alias_method :batch_update_value_for_calendar_date_select, :batch_update_value_for_date_picker
+
+
+
+    def override_batch_update_value?(form_ui)
+      respond_to?(override_batch_update_value(form_ui))
+    end
+
+    def override_batch_update_value(form_ui)
+      "batch_update_value_for_#{form_ui}"
+    end
+
+    def override_batch_update_all_value?(form_ui)
+      respond_to?(override_batch_update_all_value(form_ui))
+    end
+
+    def override_batch_update_all_value(form_ui)
+      "batch_update_all_value_for_#{form_ui}"
+    end
+
+    private
+
+    def batch_update_authorized_filter
+      link = active_scaffold_config.batch_update.link || active_scaffold_config.batch_update.class.link
+      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+    end
+    def batch_edit_formats
+      (default_formats + active_scaffold_config.formats).uniq
+    end
+  end
+end

data/lib/active_scaffold/config/batch_base.rb

@@ -0,0 +1,11 @@
+module ActiveScaffold::Config
+  class BatchBase < ActiveScaffold::Config::Base
+    def initialize(core_config)
+      @core = core_config
+    end
+
+    # configures where the plugin itself is located. there is no instance version of this.
+    cattr_accessor :plugin_directory
+    @@plugin_directory = File.expand_path(__FILE__).match(%{(^.*)/lib/active_scaffold/config/batch_base.rb})[1]
+  end
+end

data/lib/active_scaffold/config/batch_destroy.rb

@@ -0,0 +1,54 @@
+module ActiveScaffold::Config
+  class BatchDestroy < ActiveScaffold::Config::Base
+    self.crud_type = :delete
+    
+    def initialize(core_config)
+      @core = core_config
+
+      # start with the ActionLink defined globally
+      @link = self.class.link
+      @action_group = self.class.action_group.clone if self.class.action_group
+      @action_group ||= 'collection.batch.destroy'
+      @process_mode = self.class.process_mode
+    end
+
+    # global level configuration
+    # --------------------------
+    # the ActionLink for this action
+    def self.link
+      @@link
+    end
+    def self.link=(val)
+      @@link = val
+    end
+    @@link = [ ActiveScaffold::DataStructures::ActionLink.new('batch_destroy', :label => :listed, :type => :collection, :method => :delete, :position => false, :crud_type => :delete, :confirm => :are_you_sure_to_delete, :parameters => {:batch_scope => 'LISTED'},:security_method => :batch_destroy_authorized?),
+               ActiveScaffold::DataStructures::ActionLink.new('batch_destroy', :label => :marked, :type => :collection, :method => :delete, :position => false, :crud_type => :delete, :confirm => :are_you_sure_to_delete, :parameters => {:batch_scope => 'MARKED'}, :security_method => :batch_destroy_authorized?, :ignore_method => :batch_destroy_marked_ignore?)]
+
+    # configures where the plugin itself is located. there is no instance version of this.
+    cattr_accessor :plugin_directory
+    @@plugin_directory = File.expand_path(__FILE__).match(/vendor\/plugins\/([^\/]*)/)[1]
+
+    # configures how batch updates should be processed
+    # :delete => standard activerecord delete including validations
+    # :delete_all => updating in one sql call without activerecord instantiation and validation
+    cattr_accessor :process_mode
+    @@process_mode = :delete
+
+
+    # instance-level configuration
+    # ----------------------------
+
+    # see class accessor
+    attr_accessor :process_mode
+
+    # the ActionLink for this action
+    attr_accessor :link
+
+    # the label= method already exists in the Form base class
+    def label(model = nil)
+      model ||= @core.label(:count => 2)
+      @label ? as_(@label) : as_(:deleted_model, :model => model)
+    end
+
+  end
+end

data/lib/active_scaffold/config/batch_update.rb

@@ -0,0 +1,45 @@
+module ActiveScaffold::Config
+  class BatchUpdate < ActiveScaffold::Config::Form
+    self.crud_type = :update
+    def initialize(*args)
+      super
+      @process_mode = self.class.process_mode
+      @action_group ||= 'collection.batch'
+    end
+
+    # global level configuration
+    # --------------------------
+    # the ActionLink for this action
+    def self.link
+      @@link
+    end
+    def self.link=(val)
+      @@link = val
+    end
+    @@link = ActiveScaffold::DataStructures::ActionLink.new('batch_edit', :label => :edit, :type => :collection, :security_method => :batch_update_authorized?)
+
+    # configures where the plugin itself is located. there is no instance version of this.
+    cattr_accessor :plugin_directory
+    @@plugin_directory = File.expand_path(__FILE__).match(/vendor\/plugins\/([^\/]*)/)[1]
+
+    # configures how batch updates should be processed
+    # :update => standard activerecord update including validations
+    # :update_all => updating in one sql call without activerecord instantiation and validation
+    cattr_accessor :process_mode
+    @@process_mode = :update
+
+
+    # instance-level configuration
+    # ----------------------------
+
+    # see class accessor
+    attr_accessor :process_mode
+
+
+    # the label= method already exists in the Form base class
+    def label(model = nil)
+      model ||= @core.label(:count => 2)
+      @label ? as_(@label) : as_(:update_model, :model => model)
+    end
+  end
+end

data/lib/active_scaffold/helpers/calendar_date_select_update_column_helpers.rb

@@ -0,0 +1,33 @@
+module ActiveScaffold
+  module Helpers
+    module CalendarDateSelectUpdateColumnHelpers
+      def active_scaffold_update_calendar_date_select(column, options)
+        current_params = {:value => nil, :number => nil, :unit => nil, :operator => 'NO_UPDATE'}
+        current_params.merge!(batch_update_values[column.name][:value].symbolize_keys) if batch_update_values[column.name] && batch_update_values[column.name][:value]
+        Rails.logger.info("update_date column: #{column.name}: #{current_params[:value].inspect}, class: #{current_params[:value].class}")
+        Rails.logger.info("update_date column: #{column.name}: options #{options.inspect}")
+        current_params[:value] = nil if current_params[:value].is_a?(String)
+        Rails.logger.info("update_date2 column: #{column.name}: #{current_params[:value].inspect}, class: #{current_params[:value].class}")
+        operator_options = active_scaffold_update_generic_operators(column)
+        operator_options.concat(ActiveScaffold::Actions::BatchUpdate::DateOperators.collect {|comp| [as_(comp.downcase.to_sym), comp]}) if active_scaffold_config.batch_update.process_mode == :update
+        options = options.merge(:show => ['PLUS', 'MINUS'].exclude?(current_params[:operator]))
+        tags = []
+        tags << select_tag("[record][#{column.name}][operator]",
+                options_for_select(operator_options, current_params[:operator]),
+                  :id => "#{options[:id]}_operator",
+                  :class => "text-input as_update_date_operator")
+        tags << active_scaffold_search_date_bridge_calendar_control(column, options, current_params[:value], 'value')
+        tags << active_scaffold_update_date_bridge_trend_tag(column, current_params, options)
+        tags.join("&nbsp;").html_safe
+      end
+
+      def active_scaffold_update_date_bridge_trend_tag(column, current_params, options)
+        active_scaffold_date_bridge_trend_tag(column, options,
+                                             {:name_prefix => '[record]',
+                                              :number_value => current_params[:number],
+                                              :unit_value => current_params[:unit],
+                                              :show => ['PLUS','MINUS'].include?(current_params[:operator])})
+      end
+    end
+  end
+end

data/lib/active_scaffold/helpers/datepicker_update_column_helpers.rb

@@ -0,0 +1,29 @@
+module ActiveScaffold
+  module Helpers
+    module DatepickerUpdateColumnHelpers
+      def active_scaffold_update_date_picker(column, options)
+        current_params = {:value => nil, :number => nil, :unit => nil, :operator => 'NO_UPDATE'}
+        current_params.merge!(batch_update_values[column.name][:value].symbolize_keys) if batch_update_values[column.name] && batch_update_values[column.name][:value]
+        operator_options = active_scaffold_update_generic_operators(column)
+        operator_options.concat(ActiveScaffold::Actions::BatchUpdate::DateOperators.collect {|comp| [as_(comp.downcase.to_sym), comp]}) if active_scaffold_config.batch_update.process_mode == :update
+        options = options.merge(:show => ['PLUS', 'MINUS'].exclude?(current_params[:operator]))
+        tags = []
+        tags << select_tag("[record][#{column.name}][operator]",
+                options_for_select(operator_options, current_params[:operator]),
+                  :id => "#{options[:id]}_operator",
+                  :class => "text-input as_update_date_operator")
+        tags << active_scaffold_search_date_bridge_calendar_control(column, options, current_params[:value], 'value')
+        tags << active_scaffold_update_date_bridge_trend_tag(column, current_params, options)
+        tags.join("&nbsp;").html_safe
+      end
+
+      def active_scaffold_update_date_bridge_trend_tag(column, current_params, options)
+        active_scaffold_date_bridge_trend_tag(column, options,
+                                             {:name_prefix => '[record]',
+                                              :number_value => current_params[:number],
+                                              :unit_value => current_params[:unit],
+                                              :show => ['PLUS','MINUS'].include?(current_params[:operator])})
+      end
+    end
+  end
+end

data/lib/active_scaffold/helpers/update_column_helpers.rb

@@ -0,0 +1,91 @@
+module ActiveScaffold
+  module Helpers
+    # Helpers that assist with the rendering of a Form Column
+    module UpdateColumnHelpers
+      # This method decides which input to use for the given column.
+      # It does not do any rendering. It only decides which method is responsible for rendering.
+      def active_scaffold_update_for(column, scope = nil, options = {})
+        options = active_scaffold_input_options(column, scope, options)
+
+        # first, check if the dev has created an override for this specific field for search
+        if override_update_field?(column)
+          send(override_update_field(column), @record, options)
+        # second, check if the dev has specified a valid form_ui for this column, using specific ui for searches
+        elsif column.form_ui and override_update?(column.form_ui)
+          send(override_update(column.form_ui), column, options)
+       elsif column.column and override_update?(column.column.type)
+          send(override_update(column.column.type), column, options)
+        else
+          active_scaffold_update_generic_operators_select(column, options)<< ' ' << active_scaffold_render_input(column, options.merge(:name => "record[#{column.name}][value]"))
+        end
+      end
+
+      def active_scaffold_update_generic_operators(column)
+        operators = ActiveScaffold::Actions::BatchUpdate::GenericOperators.collect {|comp| [as_(comp.downcase.to_sym), comp]}
+        if column.column.nil? || column.column.null
+          operators << [as_(:null), 'NULL']
+        end
+        operators
+      end
+
+      def active_scaffold_update_generic_operators_select(column, options)
+        current = {:operator => 'NO_UPDATE'}
+        current.merge!(batch_update_values[column.name][:value].symbolize_keys) if batch_update_values[column.name] && batch_update_values[column.name][:value]
+        select_tag("[record][#{column.name}][operator]",
+              options_for_select(active_scaffold_update_generic_operators(column), current[:operator]),
+              :id => "#{options[:id]}_operator",
+              :class => "as_batch_update_operator text_input")
+      end
+
+      def active_scaffold_update_numeric(column, options)
+        current = {:value => nil, :opt => 'ABSOLUTE', :operator => 'NO_UPDATE'}
+        current.merge!(batch_update_values[column.name][:value].symbolize_keys) if batch_update_values[column.name] && batch_update_values[column.name][:value]
+        operator_options = active_scaffold_update_generic_operators(column) + ActiveScaffold::Actions::BatchUpdate::NumericOperators.collect {|comp| [as_(comp.downcase.to_sym), comp]}
+        select_options = ActiveScaffold::Actions::BatchUpdate::NumericOptions.collect {|comp| [as_(comp.downcase.to_sym), comp]}
+        html = select_tag("[record][#{column.name}][operator]",
+              options_for_select(operator_options, current[:operator]),
+              :id => "#{options[:id]}_operator",
+              :class => "as_update_numeric_option")
+        html << ' ' << text_field_tag("[record][#{column.name}][value]", current[:value], active_scaffold_input_text_options)
+        html << ' ' << select_tag("[record][#{column.name}][opt]",
+              options_for_select(select_options, current[:opt]),
+              :id => "#{options[:id]}_opt",
+              :class => "as_update_numeric_option")
+        html
+      end
+      alias_method :active_scaffold_update_integer, :active_scaffold_update_numeric
+      alias_method :active_scaffold_update_decimal, :active_scaffold_update_numeric
+      alias_method :active_scaffold_update_float, :active_scaffold_update_numeric
+
+      def active_scaffold_update_scope_select
+        select_options = [[as_(:listed), 'LISTED']]
+        select_options << [as_(:marked), 'MARKED'] if active_scaffold_config.actions.include?(:mark)
+        select_tag("batch_scope",
+                   options_for_select(select_options, batch_scope || select_options.last[1]),
+                   :class => "text_input")
+      end
+
+      ##
+      ## Search column override signatures
+      ##
+
+      def override_update_field?(column)
+        respond_to?(override_update_field(column))
+      end
+
+      # the naming convention for overriding form fields with helpers
+      def override_update_field(column)
+        "#{column.name}_update_column"
+      end
+
+      def override_update?(update_ui)
+        respond_to?(override_update(update_ui))
+      end
+
+      # the naming convention for overriding search input types with helpers
+      def override_update(update_ui)
+        "active_scaffold_update_#{update_ui}"
+      end
+    end
+  end
+end

data/lib/active_scaffold/helpers/view_helpers_override.rb

@@ -0,0 +1,8 @@
+ActionView::Base.class_eval do
+  include ActiveScaffold::Helpers::UpdateColumnHelpers
+  if ActiveScaffold.js_framework == :jquery
+    include ActiveScaffold::Helpers::DatepickerUpdateColumnHelpers
+  elsif ActiveScaffold.js_framework == :prototype
+    include ActiveScaffold::Helpers::CalendarDateSelectUpdateColumnHelpers
+  end
+end

data/lib/active_scaffold_batch/config/core.rb

@@ -0,0 +1,10 @@
+# Need to open the AS module carefully due to Rails 2.3 lazy loading
+ActiveScaffold::Config::Core.class_eval do
+  ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection][:batch_edit] = :get
+  ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection][:batch_update] = :post
+  #not working because routing picks show route instead
+  #ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection][:batch_destroy] = :get
+  #you may define a route for your controller before resource routes
+  #match 'players/batch_destroy' => 'players#batch_destroy', :via => [:get]
+  ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection][:batch_destroy] = :delete
+end

data/lib/active_scaffold_batch/version.rb

@@ -0,0 +1,9 @@
+module ActiveScaffoldBatch
+  module Version
+    MAJOR = 3
+    MINOR = 0
+    PATCH = 0
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end

data/lib/active_scaffold_batch.rb

@@ -0,0 +1,27 @@
+# Make sure that ActiveScaffold has already been included
+ActiveScaffold rescue throw "should have included ActiveScaffold plug in first.  Please make sure that this overwrite plugging comes alphabetically after the ActiveScaffold plug in"
+
+# Load our overrides
+require "#{File.dirname(__FILE__)}/active_scaffold_batch/config/core.rb"
+require "#{File.dirname(__FILE__)}/active_scaffold/config/batch_update.rb"
+require "#{File.dirname(__FILE__)}/active_scaffold/actions/batch_update.rb"
+require "#{File.dirname(__FILE__)}/active_scaffold/helpers/view_helpers_override.rb"
+
+module ActiveScaffoldBatch
+  def self.root
+    File.dirname(__FILE__) + "/.."
+  end
+end
+
+
+##
+## Run the install assets script, too, just to make sure
+## But at least rescue the action in production
+##
+Rails::Application.initializer("active_scaffold_batch.install_assets") do
+  begin
+    ActiveScaffoldAssets.copy_to_public(ActiveScaffoldBatch.root)
+  rescue
+    raise $! unless Rails.env == 'production'
+  end
+end unless defined?(ACTIVE_SCAFFOLD_BATCH_INSTALLED) && ACTIVE_SCAFFOLD_BATCH_INSTALLED == :plugin

data/lib/active_scaffold_batch_vho.rb

@@ -0,0 +1,2 @@
+ACTIVE_SCAFFOLD_BATCH_INSTALLED = :gem
+require 'active_scaffold_batch'

data/uninstall.rb

@@ -0,0 +1 @@
+# see active_scaffold/uninstall.rb

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification 
+name: active_scaffold_batch_vho
+version: !ruby/object:Gem::Version 
+  hash: 7
+  prerelease: false
+  segments: 
+  - 3
+  - 0
+  - 0
+  version: 3.0.0
+platform: ruby
+authors: 
+- Volker Hochstein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: shoulda
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id003
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rcov
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: active_scaffold_vho
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  requirement: *id005
+  type: :runtime
+description: You want to destroy/update many records at once with activescaffold?
+email: activescaffold@googlegroups.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README
+files: 
+- .document
+- LICENSE.txt
+- README
+- Rakefile
+- frontends/default/views/_batch_update_form.html.erb
+- frontends/default/views/_batch_update_form_attribute.html.erb
+- frontends/default/views/_batch_update_form_attribute_scope.html.erb
+- frontends/default/views/_batch_update_form_body.html.erb
+- frontends/default/views/batch_update.html.erb
+- frontends/default/views/on_batch_base.js.rjs
+- frontends/default/views/on_batch_update.js.rjs
+- init.rb
+- lib/active_scaffold/actions/batch_base.rb
+- lib/active_scaffold/actions/batch_destroy.rb
+- lib/active_scaffold/actions/batch_update.rb
+- lib/active_scaffold/config/batch_base.rb
+- lib/active_scaffold/config/batch_destroy.rb
+- lib/active_scaffold/config/batch_update.rb
+- lib/active_scaffold/helpers/calendar_date_select_update_column_helpers.rb
+- lib/active_scaffold/helpers/datepicker_update_column_helpers.rb
+- lib/active_scaffold/helpers/update_column_helpers.rb
+- lib/active_scaffold/helpers/view_helpers_override.rb
+- lib/active_scaffold_batch.rb
+- lib/active_scaffold_batch/config/core.rb
+- lib/active_scaffold_batch/version.rb
+- lib/active_scaffold_batch_vho.rb
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/vhochstein/active_scaffold_batch
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Batch Processing for ActiveScaffold
+test_files: []
+