lalala 4.0.0.dev.141 → 4.0.0.dev.144

data/vendor/deps/active_admin/lib/active_admin/base_controller/authorization.rb

@@ -1,153 +0,0 @@
-module ActiveAdmin
-
-  # Exception class to raise when there is an authorized access
-  # exception thrown. The exception has a few goodies that may 
-  # be useful for capturing / recognizing security issues.
-  class AccessDenied < StandardError
-    attr_reader :user, :action, :subject
-
-    def initialize(user, action, subject)
-      @user, @action, @subject = user, action, subject
-
-      super()
-    end
-
-    def message
-      I18n.t("active_admin.access_denied.message")
-    end
-  end
-
-
-  class BaseController < ::InheritedResources::Base
-    module Authorization
-      include MethodOrProcHelper
-      extend ActiveSupport::Concern
-
-      ACTIONS_DICTIONARY = {
-        :index   => ActiveAdmin::Authorization::READ,
-        :show    => ActiveAdmin::Authorization::READ,
-        :new     => ActiveAdmin::Authorization::CREATE,
-        :create  => ActiveAdmin::Authorization::CREATE,
-        :edit    => ActiveAdmin::Authorization::UPDATE,
-        :update  => ActiveAdmin::Authorization::UPDATE,
-        :destroy => ActiveAdmin::Authorization::DESTROY
-      }
-
-      included do
-        rescue_from ActiveAdmin::AccessDenied, :with => :dispatch_active_admin_access_denied
-
-        helper_method :authorized?
-        helper_method :authorize!
-      end
-
-      protected
-
-      # Authorize the action and subject. Available in the controller
-      # as well as all the views. 
-      #
-      # @param [Symbol] action The action to check if the user has permission
-      #                 to perform on the subject.
-      #
-      # @param [any] subject The subject that the user is trying to perform
-      #                 the action on.
-      #
-      # @returns [Boolean]
-      #
-      def authorized?(action, subject = nil)
-        active_admin_authorization.authorized?(action, subject)
-      end
-
-
-      # Authorize the action and subject. Available in the controller
-      # as well as all the views. If the action is not allowd, it raises
-      # an ActiveAdmin::AccessDenied exception.
-      #
-      # @param [Symbol] action The action to check if the user has permission
-      #                 to perform on the subject.
-      #
-      # @param [any] subject The subject that the user is trying to perform
-      #                 the action on.
-      #
-      # @returns [Boolean] True if authorized, otherwise raises
-      #                 an ActiveAdmin::AccessDenied.
-      def authorize!(action, subject = nil)
-        unless authorized? action, subject
-          raise ActiveAdmin::AccessDenied.new(current_active_admin_user,
-                                              action,
-                                              subject)
-        end
-      end
-
-      # Performs authorization on the resource using the current controller
-      # action as the permission action.
-      #
-      def authorize_resource!(resource)
-        permission = action_to_permission(params[:action])
-        authorize! permission, resource
-      end
-
-      # Retrieve or instantiate the authorization instance for this resource
-      #
-      # @returns [ActiveAdmin::AuthorizationAdapter]
-      def active_admin_authorization
-        @active_admin_authorization ||= active_admin_authorization_adapter.new(active_admin_config, current_active_admin_user)
-      end
-
-      # Returns the class to be used as the authorization adapter
-      #
-      # @returns [Class]
-      def active_admin_authorization_adapter
-        if active_admin_namespace.authorization_adapter.is_a?(String)
-          ActiveSupport::Dependencies.constantize(active_admin_namespace.authorization_adapter)
-        else
-          active_admin_namespace.authorization_adapter
-        end
-      end
-
-      # Converts a controller action into one of the correct Active Admin
-      # authorization names. Uses the ACTIONS_DICTIONARY to convert the
-      # action name to permission.
-      #
-      # @param [String, Symbol] action The controller action name.
-      #
-      # @returns [Symbol] The permission name to use.
-      def action_to_permission(action)
-        return nil unless action
-
-        action = action.to_sym
-
-        if Authorization::ACTIONS_DICTIONARY.has_key?(action)
-          Authorization::ACTIONS_DICTIONARY[action]
-        else
-          action
-        end
-      end
-
-      def dispatch_active_admin_access_denied(exception)
-        call_method_or_exec_proc active_admin_namespace.on_unauthorized_access, exception
-      end
-
-      def rescue_active_admin_access_denied(exception)
-        error_message = exception.message
-
-        respond_to do |format|
-          format.html do
-            flash[:error] = error_message
-
-            if request.headers.keys.include?("HTTP_REFERER")
-              redirect_to :back
-            else
-              controller, action = active_admin_namespace.root_to.split("#")
-              redirect_to :controller => controller, :action => action
-            end
-          end
-
-          format.csv { render :text => error_message, :status => :unauthorized}
-          format.json { render :json => { :error => error_message }, :status => :unauthorized}
-          format.xml { render :xml => "<error>#{error_message}</error>", :status => :unauthorized}
-        end
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/base_controller/menu.rb

@@ -1,34 +0,0 @@
-module ActiveAdmin
-  class BaseController < ::InheritedResources::Base
-    module Menu
-      extend ActiveSupport::Concern
-
-      included do
-        before_filter :set_current_tab
-        helper_method :current_menu
-      end
-
-      protected
-
-      def current_menu
-        active_admin_config.navigation_menu
-      end
-
-      # Set's @current_tab to be name of the tab to mark as current
-      # Get's called through a before filter
-      def set_current_tab
-        @current_tab = if current_menu && active_admin_config.belongs_to? && parent?
-          parent_item = active_admin_config.belongs_to_config.target.menu_item
-          if current_menu.include? parent_item
-            parent_item
-          else
-            active_admin_config.menu_item
-          end
-        else
-          active_admin_config.menu_item
-        end
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/base_controller.rb

@@ -1,78 +0,0 @@
-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.nil?
-    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/vendor/deps/active_admin/lib/active_admin/batch_actions/controller.rb

@@ -1,25 +0,0 @@
-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]
-          selected_ids ||= []
-          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.select { |action| action.sym == params[:batch_action].to_sym }.first
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/lib/active_admin/batch_actions/resource_extension.rb

@@ -1,126 +0,0 @@
-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 collection_path, :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.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/vendor/deps/active_admin/lib/active_admin/batch_actions/views/batch_action_form.rb

@@ -1,35 +0,0 @@
-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/vendor/deps/active_admin/lib/active_admin/batch_actions/views/batch_action_popover.rb

@@ -1,28 +0,0 @@
-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/vendor/deps/active_admin/lib/active_admin/batch_actions/views/batch_action_selector.rb

@@ -1,66 +0,0 @@
-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/vendor/deps/active_admin/lib/active_admin/batch_actions/views/selection_cells.rb

@@ -1,37 +0,0 @@
-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/vendor/deps/active_admin/lib/active_admin/batch_actions.rb

@@ -1,17 +0,0 @@
-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/vendor/deps/active_admin/lib/active_admin/callbacks.rb

@@ -1,87 +0,0 @@
-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