yousty-activeadmin 1.0.0.pre

data/lib/active_admin/base_controller.rb

@@ -0,0 +1,78 @@
+require 'inherited_resources'
+
+require 'active_admin/base_controller/authorization'
+require 'active_admin/base_controller/menu'
+
+module ActiveAdmin
+  # BaseController for ActiveAdmin.
+  # It implements ActiveAdmin controllers core features.
+  class BaseController < ::InheritedResources::Base
+    helper ::ActiveAdmin::ViewHelpers
+
+    layout :determine_active_admin_layout
+
+    before_filter :only_render_implemented_actions
+    before_filter :authenticate_active_admin_user
+
+    class << self
+      # Ensure that this method is available for the DSL
+      public :actions
+
+      # Reference to the Resource object which initialized
+      # this controller
+      attr_accessor :active_admin_config
+    end
+
+    # By default Rails will render un-implemented actions when the view exists. Becuase Active
+    # Admin allows you to not render any of the actions by using the #actions method, we need
+    # to check if they are implemented.
+    def only_render_implemented_actions
+      raise AbstractController::ActionNotFound unless action_methods.include?(params[:action])
+    end
+
+    include Menu
+    include Authorization
+
+    private
+
+    # Calls the authentication method as defined in ActiveAdmin.authentication_method
+    def authenticate_active_admin_user
+      send(active_admin_namespace.authentication_method) if active_admin_namespace.authentication_method
+    end
+
+    def current_active_admin_user
+      send(active_admin_namespace.current_user_method) if active_admin_namespace.current_user_method
+    end
+    helper_method :current_active_admin_user
+
+    def current_active_admin_user?
+      !!current_active_admin_user
+    end
+    helper_method :current_active_admin_user?
+
+    def active_admin_config
+      self.class.active_admin_config
+    end
+    helper_method :active_admin_config
+
+    def active_admin_namespace
+      active_admin_config.namespace
+    end
+    helper_method :active_admin_namespace
+
+
+    ACTIVE_ADMIN_ACTIONS = [:index, :show, :new, :create, :edit, :update, :destroy]
+
+    # Determine which layout to use.
+    #
+    #   1.  If we're rendering a standard Active Admin action, we want layout(false)
+    #       because these actions are subclasses of the Base page (which implements
+    #       all the required layout code)
+    #   2.  If we're rendering a custom action, we'll use the active_admin layout so
+    #       that users can render any template inside Active Admin.
+    def determine_active_admin_layout
+      ACTIVE_ADMIN_ACTIONS.include?(params[:action].to_sym) ? false : 'active_admin'
+    end
+
+  end
+end

data/lib/active_admin/batch_actions/controller.rb

@@ -0,0 +1,24 @@
+module ActiveAdmin
+  module BatchActions
+    module Controller
+
+      # Controller Action that get's 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
+        else
+          raise "Couldn't find batch action \"#{params[:batch_action]}\""
+        end
+      end
+
+      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] }
+      end
+
+    end
+  end
+end

data/lib/active_admin/batch_actions/resource_extension.rb

@@ -0,0 +1,127 @@
+module ActiveAdmin
+
+  module BatchActions
+    module ResourceExtension
+      def initialize(*)
+        super
+        @batch_actions = {}
+        add_default_batch_actions
+      end
+
+      # @return [Array] The set of batch actions for this resource
+      def batch_actions
+        batch_actions_enabled? ? @batch_actions.values.sort : []
+      end
+
+      # @return [Boolean] If batch actions are enabled for this resource
+      def batch_actions_enabled?
+        # If the resource config has been set, use it. Otherwise
+        # return the namespace setting
+        @batch_actions_enabled.nil? ? namespace.batch_actions : @batch_actions_enabled
+      end
+
+      # Disable or Enable batch actions for this resource
+      # Set to `nil` to inherit the setting from the namespace
+      def batch_actions=(bool)
+        @batch_actions_enabled = bool
+      end
+
+      # Add a new batch item to a resource
+      # @param [String] title
+      # @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
+      #
+      def add_batch_action(sym, title, options = {}, &block)
+        @batch_actions[sym] = ActiveAdmin::BatchAction.new(sym, title, options, &block)
+      end
+
+      # Remove a batch action
+      # @param [Symbol] sym
+      # @returns [ActiveAdmin::BatchAction] the batch action, if it was present
+      #
+      def remove_batch_action(sym)
+        @batch_actions.delete(sym.to_sym)
+      end
+
+      # Clears all the existing batch actions for this resource
+      def clear_batch_actions!
+        @batch_actions = {}
+      end
+
+      # Path to the batch action itself
+      def batch_action_path(params = {})
+        [route_collection_path(params), "batch_action"].join("/")
+      end
+
+      private
+
+      # @return [ActiveAdmin::BatchAction] The default "delete" action
+      def add_default_batch_actions
+        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) }
+        }
+
+        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)
+        end
+      end
+
+    end
+  end
+
+  class BatchAction
+
+    include Comparable
+
+    attr_reader :block, :title, :sym, :confirm
+
+    # Create a Batch Action
+    #
+    # Examples:
+    #
+    #   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" }
+    # => 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| }
+    # => 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
+    #
+    def initialize(sym, title, options = {}, &block)
+      @sym, @title, @options, @block, @confirm = sym, title, options, block, options[:confirm]
+      @block ||= proc {}
+    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 }
+    end
+
+    # Used for sorting
+    def priority
+      @options[:priority] || 10
+    end
+
+    # sort operator
+    def <=>(other)
+      self.priority <=> other.priority
+    end
+
+  end
+
+end

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

@@ -0,0 +1,35 @@
+require 'active_admin/component'
+
+module ActiveAdmin
+  module BatchActions
+
+    # Build an BatchActionForm
+    class BatchActionForm < ActiveAdmin::Component
+      builder_method :batch_action_form
+
+      attr_reader :prefix_html
+
+      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)
+
+        super(options)
+      end
+
+      # Override the default to_s to include a closing form tag
+      def to_s
+        content + closing_form_tag
+      end
+
+      private
+
+      def closing_form_tag
+        '</form>'.html_safe
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'active_admin/views/components/action_list_popover'
+
+module ActiveAdmin
+  module BatchActions
+    # Build an BatchActionPopover
+    class BatchActionPopover < ActiveAdmin::Views::ActionListPopover
+      builder_method :batch_action_popover
+
+      def build(options = {}, &block)
+        options[:id] ||= "batch_actions_popover"
+        super(options)
+      end
+
+      def action(batch_action, options = {})
+        options[:class] ||= []
+        options[:class] += %w(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)
+
+        super(label, "#", options)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'active_admin/component'
+
+module ActiveAdmin
+  module BatchActions
+
+    class BatchActionSelector < ActiveAdmin::Component
+      builder_method :batch_action_selector
+
+      # Build a new batch actions selector
+      #
+      # @param [Array] batch_actions An array of batch actions
+      def build(batch_actions)
+        @batch_actions = Array(batch_actions)
+        @drop_down = build_drop_down
+      end
+
+      # We don't want to wrap the action list (or any other children) in
+      # an unecessary div, so instead we just return the children
+      def to_s
+        children.to_s
+      end
+
+      private
+
+      def build_drop_down
+        dropdown_menu I18n.t("active_admin.batch_actions.button_label"),
+                      :id => "batch_actions_selector",
+                      :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
+            }
+
+            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)
+
+            item label, "#", options
+          end
+        end
+      end
+
+      # Return the set of batch actions that should be displayed
+      def batch_actions_to_display
+        @batch_actions.select do |batch_action|
+          call_method_or_proc_on(self, batch_action.display_if_block)
+        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

@@ -0,0 +1,37 @@
+require 'active_admin/component'
+
+module ActiveAdmin
+  module BatchActions
+
+    # Creates the toggle checkbox used to toggle the collection selection on/off
+    class ResourceSelectionToggleCell < ActiveAdmin::Component
+      builder_method :resource_selection_toggle_cell
+
+      def build
+        input( :type => "checkbox", :id => "collection_selection_toggle_all", :name => "collection_selection_toggle_all", :class => "toggle_all" )
+      end
+    end
+
+    # Creates the checkbox used to select a resource in the collection selection
+    class ResourceSelectionCell < ActiveAdmin::Component
+      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[]"
+      end
+    end
+
+    # Creates a wrapper panel for all index pages, except for the table, as the table has the checkbox in the thead
+    class ResourceSelectionTogglePanel < ActiveAdmin::Component
+      builder_method :resource_selection_toggle_panel
+
+      def build
+        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)") }
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/batch_actions.rb

@@ -0,0 +1,17 @@
+ActiveAdmin.before_load do |app|
+  require "active_admin/batch_actions/resource_extension"
+  require "active_admin/batch_actions/controller"
+
+  # Add our Extensions
+  ActiveAdmin::Resource.send :include, ActiveAdmin::BatchActions::ResourceExtension
+  ActiveAdmin::ResourceController.send :include, ActiveAdmin::BatchActions::Controller
+
+  # Require all the views
+  require "active_admin/batch_actions/views/batch_action_form"
+  require "active_admin/batch_actions/views/batch_action_popover"
+  require "active_admin/batch_actions/views/selection_cells"
+  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
+end

data/lib/active_admin/callbacks.rb

@@ -0,0 +1,87 @@
+module ActiveAdmin
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    protected
+
+    # Simple callback system. Implements before and after callbacks for
+    # use within the controllers.
+    #
+    # We didn't use the ActiveSupport callbacks becuase they do not support
+    # passing in any arbitrary object into the callback method (which we
+    # need to do)
+
+    def call_callback_with(method, *args)
+      case method
+      when Symbol
+        send(method, *args)
+      when Proc
+        instance_exec(*args, &method)
+      else
+        raise "Please register with callbacks using a symbol or a block/proc."
+      end
+    end
+
+    module ClassMethods
+
+      # Define a new callback.
+      #
+      # Example:
+      #
+      #   class MyClassWithCallbacks
+      #     include ActiveAdmin::Callbacks
+      #
+      #     define_active_admin_callbacks :save
+      #
+      #     before_save do |arg1, arg2|
+      #       # runs before save
+      #     end
+      #
+      #     after_save :call_after_save
+      #
+      #     def save
+      #       # Will run before, yield, then after
+      #       run_save_callbacks :arg1, :arg2 do
+      #         save!
+      #       end
+      #     end
+      #
+      #     protected
+      #
+      #     def call_after_save(arg1, arg2)
+      #       # runs after save
+      #     end
+      #   end
+      #
+      def define_active_admin_callbacks(*names)
+        names.each do |name|
+          [:before, :after].each do |type|
+
+            # 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
+              def self.#{type}_#{name}(method = nil, &block)
+                #{type}_#{name}_callbacks << (method || block)
+              end
+            EOS
+          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
+    end
+  end
+end

data/lib/active_admin/cancan_adapter.rb

@@ -0,0 +1,40 @@
+require 'cancan'
+
+# Add a setting to the application to configure the ability
+ActiveAdmin::Application.inheritable_setting :cancan_ability_class, "Ability"
+
+module ActiveAdmin
+
+  class CanCanAdapter < AuthorizationAdapter
+
+    def authorized?(action, subject = nil)
+      cancan_ability.can?(action, subject)
+    end
+
+    def cancan_ability
+      @cancan_ability ||= initialize_cancan_ability
+    end
+
+    def scope_collection(collection, action = ActiveAdmin::Auth::READ)
+      collection.accessible_by(cancan_ability, action)
+    end
+
+    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)
+    end
+
+  end
+
+end

data/lib/active_admin/component.rb

@@ -0,0 +1,5 @@
+module ActiveAdmin
+  class Component < Arbre::Component
+
+  end
+end

data/lib/active_admin/controller_action.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  class ControllerAction
+    attr_reader :name
+    def initialize(name, options = {})
+      @name, @options = name, options
+    end
+
+    def http_verb
+      @options[:method] ||= :get
+    end
+  end
+end

data/lib/active_admin/csv_builder.rb

@@ -0,0 +1,49 @@
+module ActiveAdmin
+  # CSVBuilder stores CSV configuration
+  #
+  # Usage example:
+  #
+  #   csv_builder = CSVBuilder.new
+  #   csv_builder.column :id
+  #   csv_builder.column("Name") { |resource| resource.full_name }
+  #
+  #   csv_builder = CSVBuilder.new :col_sep => ";"
+  #   csv_builder.column :id
+  #
+  #
+  class CSVBuilder
+
+    # Return a default CSVBuilder for a resource
+    # 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
+      end
+    end
+
+    attr_reader :columns, :options
+
+    def initialize(options={}, &block)
+      @columns, @options = [], options
+      instance_eval &block if block_given?
+    end
+
+    # Add a column
+    def column(name, &block)
+      @columns << Column.new(name, block)
+    end
+
+    class Column
+      attr_reader :name, :data
+
+      def initialize(name, block = nil)
+        @name = name.is_a?(Symbol) ? name.to_s.titleize : name
+        @data = block || name.to_sym
+      end
+    end
+  end
+end

data/lib/active_admin/deprecation.rb

@@ -0,0 +1,36 @@
+module ActiveAdmin
+  module Deprecation
+    module_function
+
+    def warn(message, callstack = caller)
+      ActiveSupport::Deprecation.warn "Active Admin: #{message}", callstack
+    end
+
+    # Deprecate a method.
+    #
+    # @param [Module] klass the Class or Module to deprecate the method on
+    # @param [Symbol] method the method to deprecate
+    # @param [String] message the message to display to the end user
+    #
+    # Example:
+    #
+    #     class MyClass
+    #       def my_method
+    #         # ...
+    #       end
+    #       ActiveAdmin::Deprecation.deprecate self, :my_method,
+    #         "MyClass#my_method is being removed in the next release"
+    #     end
+    #
+    def deprecate(klass, method, message)
+      klass.class_eval <<-EOC, __FILE__, __LINE__ + 1
+        alias_method :deprecated_#{method}, :#{method}
+        def #{method}(*args)
+          ActiveAdmin::Deprecation.warn('#{message}', caller)
+          send(:deprecated_#{method}, *args)
+        end
+      EOC
+    end
+
+  end
+end