yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/lib/active_admin/batch_actions.rb

@@ -13,5 +13,5 @@ ActiveAdmin.before_load do |app|
   require "active_admin/batch_actions/views/batch_action_selector"
 
   # Register the views with the view factory
-  app.view_factory.register :batch_action_selector => ActiveAdmin::BatchActions::BatchActionSelector
+  app.view_factory.register batch_action_selector: ActiveAdmin::BatchActions::BatchActionSelector
 end

data/lib/active_admin/batch_actions/controller.rb

@@ -2,11 +2,14 @@ module ActiveAdmin
   module BatchActions
     module Controller
 
-      # Controller Action that get's called when submitting the batch action form
+      # Controller action that is called when submitting the batch action form
       def batch_action
-        if selected_batch_action
-          selected_ids = params[:collection_selection] || []
-          instance_exec selected_ids, &selected_batch_action.block
+        if action_present?
+          selection  =            params[:collection_selection] ||  []
+          inputs     = JSON.parse params[:batch_action_inputs]  || '{}'
+          valid_keys = render_in_context(self, current_batch_action.inputs).try(:keys)
+          inputs     = inputs.with_indifferent_access.slice *valid_keys
+          instance_exec selection, inputs, &current_batch_action.block
         else
           raise "Couldn't find batch action \"#{params[:batch_action]}\""
         end
@@ -14,9 +17,12 @@ module ActiveAdmin
 
       protected
 
-      def selected_batch_action
-        return unless params[:batch_action].present?
-        active_admin_config.batch_actions.detect { |action| action.sym.to_s == params[:batch_action] }
+      def action_present?
+        params[:batch_action].present? && current_batch_action
+      end
+
+      def current_batch_action
+        active_admin_config.batch_actions.detect{ |action| action.sym.to_s == params[:batch_action] }
       end
 
     end

data/lib/active_admin/batch_actions/resource_extension.rb

@@ -5,7 +5,7 @@ module ActiveAdmin
       def initialize(*)
         super
         @batch_actions = {}
-        add_default_batch_actions
+        add_default_batch_action
       end
 
       # @return [Array] The set of batch actions for this resource
@@ -31,7 +31,8 @@ module ActiveAdmin
       # @param [Hash] options
       # => :if is a proc that will be called to determine if the BatchAction should be displayed
       # => :sort_order is used to sort the batch actions ascending
-      # => :confirm is a string which the user will have to accept in order to process the action
+      # => :confirm is a string to prompt the user with (or a boolean to use the default message)
+      # => :form is a Hash of form fields you want the user to fill out
       #
       def add_batch_action(sym, title, options = {}, &block)
         @batch_actions[sym] = ActiveAdmin::BatchAction.new(sym, title, options, &block)
@@ -39,7 +40,7 @@ module ActiveAdmin
 
       # Remove a batch action
       # @param [Symbol] sym
-      # @returns [ActiveAdmin::BatchAction] the batch action, if it was present
+      # @return [ActiveAdmin::BatchAction] the batch action, if it was present
       #
       def remove_batch_action(sym)
         @batch_actions.delete(sym.to_sym)
@@ -58,21 +59,21 @@ module ActiveAdmin
       private
 
       # @return [ActiveAdmin::BatchAction] The default "delete" action
-      def add_default_batch_actions
+      def add_default_batch_action
         destroy_options = {
-          :priority => 100,
-          :confirm => proc { I18n.t('active_admin.batch_actions.delete_confirmation', :plural_model => active_admin_config.plural_resource_label.downcase) },
-          :if => proc{ controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, active_admin_config.resource_class) }
+          priority: 100,
+          confirm: proc{ I18n.t('active_admin.batch_actions.delete_confirmation', plural_model: active_admin_config.plural_resource_label.downcase) },
+          if: proc{ controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, active_admin_config.resource_class) }
         }
 
         add_batch_action :destroy, proc { I18n.t('active_admin.delete') }, destroy_options do |selected_ids|
           active_admin_config.resource_class.find(selected_ids).each { |r| r.destroy }
 
           redirect_to active_admin_config.route_collection_path(params),
-                      :notice => I18n.t("active_admin.batch_actions.succesfully_destroyed",
-                                        :count => selected_ids.count,
-                                        :model => active_admin_config.resource_label.downcase,
-                                        :plural_model => active_admin_config.plural_resource_label(:count => selected_ids.count).downcase)
+                      notice: I18n.t("active_admin.batch_actions.succesfully_destroyed",
+                                        count: selected_ids.count,
+                                        model: active_admin_config.resource_label.downcase,
+                                        plural_model: active_admin_config.plural_resource_label(count: selected_ids.count).downcase)
         end
       end
 
@@ -83,7 +84,9 @@ module ActiveAdmin
 
     include Comparable
 
-    attr_reader :block, :title, :sym, :confirm
+    attr_reader :block, :title, :sym
+
+    DEFAULT_CONFIRM_MESSAGE = proc{ I18n.t 'active_admin.batch_actions.default_confirmation' }
 
     # Create a Batch Action
     #
@@ -92,24 +95,47 @@ module ActiveAdmin
     #   BatchAction.new :flag
     # => Will create an action that appears in the action list popover
     #
-    #   BatchAction.new( :flag ) { |selection| redirect_to collection_path, :notice => "#{selection.length} users flagged" }
+    #   BatchAction.new(:flag) { |selection| redirect_to collection_path, notice: "#{selection.length} users flagged" }
     # => Will create an action that uses a block to process the request (which receives one paramater of the selected objects)
     #
-    #   BatchAction.new( "Perform Long Operation on the" ) { |selection| }
+    #   BatchAction.new("Perform Long Operation on") { |selection| }
     # => You can create batch actions with a title instead of a Symbol
     #
-    #   BatchAction.new( :flag, :if => proc { can? :flag, AdminUser  } ) { |selection| }
-    # => You can provide an optional :if proc to optionally display the batch action
+    #   BatchAction.new(:flag, if: proc{ can? :flag, AdminUser }) { |selection| }
+    # => You can provide an `:if` proc to choose when the batch action should be displayed
+    #
+    #   BatchAction.new :flag, confirm: true
+    # => You can pass `true` to `:confirm` to use the default confirm message.
+    #
+    #   BatchAction.new(:flag, confirm: "Are you sure?") { |selection| }
+    # => You can pass a custom confirmation message through `:confirm`
+    #
+    #   BatchAction.new(:flag, form: {foo: :text, bar: :checkbox}) { |selection, inputs| }
+    # => You can pass a hash of options to `:form` that will be rendered as form input fields for the user to fill out.
     #
     def initialize(sym, title, options = {}, &block)
       @sym, @title, @options, @block, @confirm = sym, title, options, block, options[:confirm]
       @block ||= proc {}
     end
 
+    def confirm
+      if @confirm == true
+        DEFAULT_CONFIRM_MESSAGE
+      elsif !@confirm && @options[:form]
+        DEFAULT_CONFIRM_MESSAGE
+      else
+        @confirm
+      end
+    end
+
+    def inputs
+      @options[:form]
+    end
+
     # Returns the display if block. If the block was not explicitly defined
     # a default block always returning true will be returned.
     def display_if_block
-      @options[:if] || proc { true }
+      @options[:if] || proc{ true }
     end
 
     # Used for sorting

data/lib/active_admin/batch_actions/views/batch_action_form.rb

@@ -3,7 +3,7 @@ require 'active_admin/component'
 module ActiveAdmin
   module BatchActions
 
-    # Build an BatchActionForm
+    # Build a BatchActionForm
     class BatchActionForm < ActiveAdmin::Component
       builder_method :batch_action_form
 
@@ -12,9 +12,12 @@ module ActiveAdmin
       def build(options = {}, &block)
         options[:id] ||= "collection_selection"
 
-        # Open a form
-        text_node form_tag(active_admin_config.batch_action_path(params), :id => options[:id])
-        input(:name => :batch_action, :id => :batch_action, :type => :hidden)
+        # Open a form with two hidden input fields:
+        # batch_action        => name of the specific action called
+        # batch_action_inputs => a JSON string of any requested confirmation values
+        text_node form_tag active_admin_config.batch_action_path(params), id: options[:id]
+        input name: :batch_action,        id: :batch_action,        type: :hidden
+        input name: :batch_action_inputs, id: :batch_action_inputs, type: :hidden
 
         super(options)
       end

data/lib/active_admin/batch_actions/views/batch_action_popover.rb

@@ -13,12 +13,12 @@ module ActiveAdmin
 
       def action(batch_action, options = {})
         options[:class] ||= []
-        options[:class] += %w(batch_action)
+        options[:class] << "batch_action"
         options.merge! "data-action" => batch_action.sym,
                        "data-confirm" => batch_action.confirm
 
-        title = I18n.t("active_admin.batch_actions.labels.#{batch_action.sym}", :default => batch_action.title)
-        label = I18n.t("active_admin.batch_actions.action_label", :title => title)
+        title = I18n.t("active_admin.batch_actions.labels.#{batch_action.sym}", default: batch_action.title)
+        label = I18n.t("active_admin.batch_actions.action_label", title: title)
 
         super(label, "#", options)
       end

data/lib/active_admin/batch_actions/views/batch_action_selector.rb

@@ -24,20 +24,21 @@ module ActiveAdmin
 
       def build_drop_down
         dropdown_menu I18n.t("active_admin.batch_actions.button_label"),
-                      :id => "batch_actions_selector",
-                      :button => { :class => "disabled" } do
+                      class: "batch_actions_selector dropdown_menu",
+                      button: { class: "disabled" } do
           batch_actions_to_display.each do |batch_action|
             confirmation_text = render_or_call_method_or_proc_on(self, batch_action.confirm)
 
             options = {
-              :class => "batch_action",
-              "data-action" => batch_action.sym,
-              "data-confirm" => confirmation_text
+              :class         => "batch_action",
+              "data-action"  => batch_action.sym,
+              "data-confirm" => confirmation_text,
+              "data-inputs"  => render_in_context(self, batch_action.inputs).to_json
             }
 
             default_title = render_or_call_method_or_proc_on(self, batch_action.title)
-            title = I18n.t("active_admin.batch_actions.labels.#{batch_action.sym}", :default => default_title)
-            label = I18n.t("active_admin.batch_actions.action_label", :title => title)
+            title = I18n.t("active_admin.batch_actions.labels.#{batch_action.sym}", default: default_title)
+            label = I18n.t("active_admin.batch_actions.action_label", title: title)
 
             item label, "#", options
           end
@@ -51,16 +52,6 @@ module ActiveAdmin
         end
       end
 
-      # def build_batch_action_button
-      #   a :class => 'table_tools_button dropdown_button disabled', :href => "#batch_actions_popover", :id => "batch_actions_button" do
-      #     text_node I18n.t("active_admin.batch_actions.button_label")
-      #   end
-      # end
-
-      # def build_batch_action_popover
-      # end
-
     end
-
   end
 end

data/lib/active_admin/batch_actions/views/selection_cells.rb

@@ -8,7 +8,7 @@ module ActiveAdmin
       builder_method :resource_selection_toggle_cell
 
       def build
-        input( :type => "checkbox", :id => "collection_selection_toggle_all", :name => "collection_selection_toggle_all", :class => "toggle_all" )
+        input type: "checkbox", id: "collection_selection_toggle_all", name: "collection_selection_toggle_all", class: "toggle_all"
       end
     end
 
@@ -17,7 +17,7 @@ module ActiveAdmin
       builder_method :resource_selection_cell
 
       def build(resource)
-        input :type => "checkbox", :id => "batch_action_item_#{resource.id}", :value => resource.id, :class => "collection_selection", :name => "collection_selection[]"
+        input type: "checkbox", id: "batch_action_item_#{resource.id}", value: resource.id, class: "collection_selection", name: "collection_selection[]"
       end
     end
 
@@ -26,9 +26,9 @@ module ActiveAdmin
       builder_method :resource_selection_toggle_panel
 
       def build
-        super(:id => "collection_selection_toggle_panel")
+        super(id: "collection_selection_toggle_panel")
         resource_selection_toggle_cell
-        div(:id => "collection_selection_toggle_explaination" ) { I18n.t('active_admin.batch_actions.selection_toggle_explanation', :default => "(Toggle Selection)") }
+        div(id: "collection_selection_toggle_explaination" ) { I18n.t('active_admin.batch_actions.selection_toggle_explanation', default: "(Toggle Selection)") }
       end
 
     end

data/lib/active_admin/callbacks.rb

@@ -2,7 +2,7 @@ module ActiveAdmin
   module Callbacks
     extend ActiveSupport::Concern
 
-    protected
+    private
 
     # Simple callback system. Implements before and after callbacks for
     # use within the controllers.
@@ -11,7 +11,7 @@ module ActiveAdmin
     # passing in any arbitrary object into the callback method (which we
     # need to do)
 
-    def call_callback_with(method, *args)
+    def run_callback(method, *args)
       case method
       when Symbol
         send(method, *args)
@@ -24,6 +24,8 @@ module ActiveAdmin
 
     module ClassMethods
 
+      private
+
       # Define a new callback.
       #
       # Example:
@@ -56,32 +58,31 @@ module ActiveAdmin
       def define_active_admin_callbacks(*names)
         names.each do |name|
           [:before, :after].each do |type|
+            callback_name = "#{type}_#{name}_callbacks"
+            callback_ivar = "@#{callback_name}"
 
-            # Define a method to set the callback
-            class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-              # def self.before_create_callbacks
-              def self.#{type}_#{name}_callbacks
-                @#{type}_#{name}_callbacks ||= []
-              end
+            # def self.before_create_callbacks
+            singleton_class.send :define_method, callback_name do
+              instance_variable_get(callback_ivar) || instance_variable_set(callback_ivar, [])
+            end
+            singleton_class.send :private, callback_name
 
-              # def self.before_create
-              def self.#{type}_#{name}(method = nil, &block)
-                #{type}_#{name}_callbacks << (method || block)
-              end
-            EOS
+            # def self.before_create
+            singleton_class.send :define_method, "#{type}_#{name}" do |method = nil, &block|
+              send(callback_name).push method || block
+            end
           end
 
-          # Define a method to run the callbacks
-          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-            def run_#{name}_callbacks(*args)
-              self.class.before_#{name}_callbacks.each{|callback| call_callback_with(callback, *args)}
-              value = yield if block_given?
-              self.class.after_#{name}_callbacks.each{|callback| call_callback_with(callback, *args)}
-              return value
-            end
-            EOS
-         end
-       end
+          # def run_create_callbacks
+          define_method "run_#{name}_callbacks" do |*args, &block|
+            self.class.send("before_#{name}_callbacks").each{ |cbk| run_callback(cbk, *args) }
+            value = block.try :call
+            self.class.send("after_#{name}_callbacks").each { |cbk| run_callback(cbk, *args) }
+            return value
+          end
+          send :private, "run_#{name}_callbacks"
+        end
+      end
     end
   end
 end

data/lib/active_admin/cancan_adapter.rb

@@ -1,3 +1,7 @@
+unless ActiveAdmin::Dependency.cancan? || ActiveAdmin::Dependency.cancancan?
+  ActiveAdmin::Dependency.cancan!
+end
+
 require 'cancan'
 
 # Add a setting to the application to configure the ability
@@ -21,18 +25,10 @@ module ActiveAdmin
 
     private
 
-    # The setting allows the class to be stored as a string
-    # to enable reloading in development.
     def initialize_cancan_ability
-      ability_class_name = resource.namespace.cancan_ability_class
-
-      if ability_class_name.is_a?(String)
-        ability_class = ActiveSupport::Dependencies.constantize(ability_class_name)
-      else
-        ability_class = ability_class_name
-      end
-
-      ability_class.new(user)
+      klass = resource.namespace.cancan_ability_class
+      klass = klass.constantize if klass.is_a? String
+      klass.new user
     end
 
   end

data/lib/active_admin/csv_builder.rb

@@ -6,8 +6,11 @@ module ActiveAdmin
   #   csv_builder = CSVBuilder.new
   #   csv_builder.column :id
   #   csv_builder.column("Name") { |resource| resource.full_name }
+  #   csv_builder.column(:name, humanize: false)
+  #   csv_builder.column("name", humanize: false) { |resource| resource.full_name }
   #
-  #   csv_builder = CSVBuilder.new :col_sep => ";"
+  #   csv_builder = CSVBuilder.new col_sep: ";"
+  #   csv_builder = CSVBuilder.new humanize_name: false
   #   csv_builder.column :id
   #
   #
@@ -17,33 +20,107 @@ module ActiveAdmin
     # The CSVBuilder's columns would be Id followed by this
     # resource's content columns
     def self.default_for_resource(resource)
-      new.tap do |csv_builder|
-        csv_builder.column(:id)
-        resource.content_columns.each do |content_column|
-          csv_builder.column(content_column.name.to_sym)
-        end
+      new resource: resource do
+        column :id
+        resource.content_columns.each { |c| column c.name.to_sym }
       end
     end
 
-    attr_reader :columns, :options
+    attr_reader :columns, :options, :view_context
+
+    COLUMN_TRANSITIVE_OPTIONS = [:humanize_name].freeze
 
     def initialize(options={}, &block)
-      @columns, @options = [], options
-      instance_eval &block if block_given?
+      @resource = options.delete(:resource)
+      @columns, @options, @block = [], options, block
     end
 
-    # Add a column
-    def column(name, &block)
-      @columns << Column.new(name, block)
+    def column(name, options={}, &block)
+      @columns << Column.new(name, @resource, column_transitive_options.merge(options), block)
+    end
+
+    def build(controller, receiver)
+      @collection = controller.send(:collection)
+      options = ActiveAdmin.application.csv_options.merge self.options
+      columns = exec_columns controller.view_context
+
+      if byte_order_mark = options.delete(:byte_order_mark)
+        receiver << byte_order_mark
+      end
+
+      if options.delete(:column_names) { true }
+        receiver << CSV.generate_line(columns.map{ |c| encode c.name, options }, options)
+      end
+
+      (1..paginated_collection.total_pages).each do |page_no|
+        paginated_collection(page_no).each do |resource|
+           resource = controller.send :apply_decorator, resource
+           receiver << CSV.generate_line(build_row(resource, columns, options), options)
+        end
+      end
+    end
+
+    def exec_columns(view_context = nil)
+      @view_context = view_context
+      @columns = [] # we want to re-render these every instance
+      instance_exec &@block if @block.present?
+      columns
+    end
+
+    def build_row(resource, columns, options)
+      columns.map do |column|
+        encode call_method_or_proc_on(resource, column.data), options
+      end
+    end
+
+    def encode(content, options)
+      if options[:encoding]
+        content.to_s.encode! options[:encoding], options[:encoding_options]
+      else
+        content
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if @view_context.respond_to? method
+        @view_context.public_send method, *args, &block
+      else
+        super
+      end
     end
 
     class Column
-      attr_reader :name, :data
+      attr_reader :name, :data, :options
+
+      DEFAULT_OPTIONS = { humanize_name: true }
 
-      def initialize(name, block = nil)
-        @name = name.is_a?(Symbol) ? name.to_s.titleize : name
+      def initialize(name, resource = nil, options = {}, block = nil)
+        @options = options.reverse_merge(DEFAULT_OPTIONS)
+        @name = humanize_name(name, resource, @options[:humanize_name])
         @data = block || name.to_sym
       end
+
+      def humanize_name(name, resource, humanize_name_option)
+        if humanize_name_option
+          name.is_a?(Symbol) && resource.present? ? resource.human_attribute_name(name) : name.to_s.humanize
+        else
+          name.to_s
+        end
+      end
+    end
+
+    private
+
+    def column_transitive_options
+      @column_transitive_options ||= @options.slice(*COLUMN_TRANSITIVE_OPTIONS)
+    end
+
+    def paginated_collection(page_no = 1)
+      @collection.public_send(Kaminari.config.page_method_name, page_no).per(batch_size)
+    end
+
+    def batch_size
+      1000
     end
   end
 end