activeadmin_addons 1.4.0 → 1.8.2

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/resource_controller/resource_class_methods.rb

@@ -1,26 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-    module ResourceClassMethods
-
-      # Override the default `resource_class` class and instance
-      # methods to only return the class defined in the instance
-      # of ActiveAdmin::Resource
-      def override_resource_class_methods!
-        class_exec do
-          def self.resource_class=(klass); end
-
-          def self.resource_class
-            @active_admin_config ? @active_admin_config.resource_class : nil
-          end
-
-          private
-
-          def resource_class
-            self.class.resource_class
-          end
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/resource_controller/scoping.rb

@@ -1,31 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    # This module deals with scoping entire controllers to a relation
-    module Scoping
-      extend ActiveSupport::Concern
-
-      protected
-
-      # Override the default InheritedResource #begin_of_association_chain to allow
-      # the scope to be defined in the active admin configuration.
-      #
-      # If scope_to is a proc, we eval it, otherwise we call the method on the controller.
-      #
-      # Collection can be scoped conditionally with an :if or :unless proc.
-      def begin_of_association_chain
-        return nil unless active_admin_config.scope_to?(self)
-        StringSymbolOrProcSetting.new(active_admin_config.scope_to_method).value(self)
-      end
-
-      # Overriding from InheritedResources::BaseHelpers
-      #
-      # Returns the method for the association chain when using
-      # the scope_to option
-      def method_for_association_chain
-        active_admin_config.scope_to_association_method || super
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/resource_controller/sidebars.rb

@@ -1,18 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    module Sidebars
-
-      protected
-
-      def skip_sidebar!
-        @skip_sidebar = true
-      end
-
-      def skip_sidebar?
-        @skip_sidebar == true
-      end
-    end
-
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/resource_controller/streaming.rb

@@ -1,43 +0,0 @@
-require 'csv'
-
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    # This module overrides CSV responses to allow large data downloads.
-    # Could be expanded to JSON and XML in the future.
-    #
-    module Streaming
-
-      def index
-        super do |format|
-          format.csv { stream_csv }
-          yield(format) if block_given?
-        end
-      end
-
-      protected
-
-      def stream_resource(&block)
-        headers['X-Accel-Buffering'] = 'no'
-        headers['Cache-Control'] = 'no-cache'
-
-        if ActiveAdmin.application.disable_streaming_in.include? Rails.env
-          self.response_body = block['']
-        else
-          self.response_body = Enumerator.new &block
-        end
-      end
-
-      def csv_filename
-        "#{resource_collection_name.to_s.gsub('_', '-')}-#{Time.zone.now.to_date.to_s(:default)}.csv"
-      end
-
-      def stream_csv
-        headers['Content-Type'] = 'text/csv; charset=utf-8' # In Rails 5 it's set to HTML??
-        headers['Content-Disposition'] = %{attachment; filename="#{csv_filename}"}
-        stream_resource &active_admin_config.csv_builder.method(:build).to_proc.curry[self]
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/resource_dsl.rb

@@ -1,224 +0,0 @@
-module ActiveAdmin
-  # This is the class where all the register blocks are evaluated.
-  class ResourceDSL < DSL
-
-    private
-
-    # Redefine sort behaviour for column
-    #
-    # For example:
-    #
-    #   # nulls last
-    #   order_by(:age) do |order_clause|
-    #     [order_clause.to_sql, 'NULLS LAST'].join(' ')  if order_clause.order == 'desc'
-    #   end
-    #
-    #   # by last_name but in the case that there is no last name, by first_name.
-    #   order_by(:full_name) do |order_clause|
-    #     ['COALESCE(NULLIF(last_name, ''), first_name), first_name', order_clause.order].join(' ')
-    #   end
-    #
-    #
-    def order_by(column, &block)
-      config.ordering[column] = block
-    end
-
-    def belongs_to(target, options = {})
-      config.belongs_to(target, options)
-    end
-
-    # Scope collection to a relation
-    def scope_to(*args, &block)
-      config.scope_to(*args, &block)
-    end
-
-    # Create a scope
-    def scope(*args, &block)
-      config.scope(*args, &block)
-    end
-
-    # Store relations that should be included
-    def includes(*args)
-      config.includes.push *args
-    end
-
-    #
-    # Keys included in the `permitted_params` setting are automatically whitelisted.
-    #
-    # Either
-    #
-    #   permit_params :title, :author, :body, tags: []
-    #
-    # Or
-    #
-    #   permit_params do
-    #     defaults = [:title, :body]
-    #     if current_user.admin?
-    #       defaults + [:author]
-    #     else
-    #       defaults
-    #     end
-    #   end
-    #
-    def permit_params(*args, &block)
-      param_key = config.param_key.to_sym
-      belongs_to_param = config.belongs_to_param
-      create_another_param = :create_another if config.create_another
-
-      controller do
-        define_method :permitted_params do
-          permitted_params =
-            active_admin_namespace.permitted_params +
-              Array.wrap(belongs_to_param) +
-              Array.wrap(create_another_param)
-
-          params.permit(*permitted_params, param_key => block ? instance_exec(&block) : args)
-        end
-
-        private :permitted_params
-      end
-    end
-
-    # Configure the index page for the resource
-    def index(options = {}, &block)
-      options[:as] ||= :table
-      config.set_page_presenter :index, ActiveAdmin::PagePresenter.new(options, &block)
-    end
-
-    # Configure the show page for the resource
-    def show(options = {}, &block)
-      config.set_page_presenter :show, ActiveAdmin::PagePresenter.new(options, &block)
-    end
-
-    def form(options = {}, &block)
-      config.set_page_presenter :form, ActiveAdmin::PagePresenter.new(options, &block)
-    end
-
-    # Configure the CSV format
-    #
-    # For example:
-    #
-    #   csv do
-    #     column :name
-    #     column("Author") { |post| post.author.full_name }
-    #   end
-    #
-    #   csv col_sep: ";", force_quotes: true do
-    #     column :name
-    #   end
-    #
-    def csv(options = {}, &block)
-      options[:resource] = config
-
-      config.csv_builder = CSVBuilder.new(options, &block)
-    end
-
-    # Member Actions give you the functionality of defining both the
-    # action and the route directly from your ActiveAdmin registration
-    # block.
-    #
-    # For example:
-    #
-    #   ActiveAdmin.register Post do
-    #     member_action :comments do
-    #       @post = Post.find(params[:id]
-    #       @comments = @post.comments
-    #     end
-    #   end
-    #
-    # Will create a new controller action comments and will hook it up to
-    # the named route (comments_admin_post_path) /admin/posts/:id/comments
-    #
-    # You can treat everything within the block as a standard Rails controller
-    # action.
-    #
-    def action(set, name, options = {}, &block)
-      warn "Warning: method `#{name}` already defined" if controller.method_defined?(name)
-
-      set << ControllerAction.new(name, options)
-      title = options.delete(:title)
-
-      controller do
-        before_action(only: [name]) { @page_title = title } if title
-        define_method(name, &block || Proc.new{})
-      end
-    end
-
-    def member_action(name, options = {}, &block)
-      action config.member_actions, name, options, &block
-    end
-
-    def collection_action(name, options = {}, &block)
-      action config.collection_actions, name, options, &block
-    end
-
-    def decorate_with(decorator_class)
-      # Force storage as a string. This will help us with reloading issues.
-      # Assuming decorator_class.to_s will return the name of the class allows
-      # us to handle a string or a class.
-      config.decorator_class_name = "::#{ decorator_class }"
-    end
-
-    # Defined Callbacks
-    #
-    # == After Build
-    # Called after the resource is built in the new and create actions.
-    #
-    # ActiveAdmin.register Post do
-    #   after_build do |post|
-    #     post.author = current_user
-    #   end
-    # end
-    #
-    # == Before / After Create
-    # Called before and after a resource is saved to the db on the create action.
-    #
-    # == Before / After Update
-    # Called before and after a resource is saved to the db on the update action.
-    #
-    # == Before / After Save
-    # Called before and after the object is saved in the create and update action.
-    # Note: Gets called after the create and update callbacks
-    #
-    # == Before / After Destroy
-    # Called before and after the object is destroyed from the database.
-    #
-    delegate :before_build,   :after_build,   to: :controller
-    delegate :before_create,  :after_create,  to: :controller
-    delegate :before_update,  :after_update,  to: :controller
-    delegate :before_save,    :after_save,    to: :controller
-    delegate :before_destroy, :after_destroy, to: :controller
-
-    # This code defines both *_filter and *_action for Rails 4.0 to Rails 5 and  *_action for Rails >= 5.1
-    phases = [
-      :before, :skip_before,
-      :after,  :skip_after,
-      :around, :skip
-    ]
-    keywords = if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR >= 1
-                 [:action]
-               else
-                 [:action, :filter]
-               end
-
-    keywords.each do |name|
-      phases.each do |action|
-       define_method "#{action}_#{name}" do |*args, &block|
-         controller.public_send "#{action}_action", *args, &block
-       end
-     end
-    end
-
-    # Specify which actions to create in the controller
-    #
-    # Eg:
-    #
-    #   ActiveAdmin.register Post do
-    #     actions :index, :show
-    #   end
-    #
-    # Will only create the index and show actions (no create, update or delete)
-    delegate :actions, to: :controller
-
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/router.rb

@@ -1,113 +0,0 @@
-module ActiveAdmin
-  # @private
-  class Router
-    attr_reader :namespaces, :router
-
-    def initialize(router:, namespaces:)
-      @router, @namespaces = router, namespaces
-    end
-
-    def apply
-      define_root_routes
-      define_resources_routes
-    end
-
-    private
-
-    def define_root_routes
-      namespaces.each do |namespace|
-        if namespace.root?
-          router.root namespace.root_to_options.merge(to: namespace.root_to)
-        else
-          router.namespace namespace.name, namespace.route_options.dup do
-            router.root namespace.root_to_options.merge(to: namespace.root_to, as: :root)
-          end
-        end
-      end
-    end
-
-    # Defines the routes for each resource
-    def define_resources_routes
-      resources = namespaces.flat_map{ |n| n.resources.values }
-      resources.each do |config|
-        define_resource_routes(config)
-      end
-    end
-
-    def define_resource_routes(config)
-      if config.namespace.root?
-        define_routes(config)
-      else
-        # Add on the namespace if required
-        define_namespace(config)
-      end
-    end
-
-    def define_routes(config)
-      if config.belongs_to?
-        define_belongs_to_routes(config)
-      else
-        page_or_resource_routes(config)
-      end
-    end
-
-    def page_or_resource_routes(config)
-      config.is_a?(Page) ? page_routes(config) : resource_routes(config)
-    end
-
-    def resource_routes(config)
-      router.resources config.resource_name.route_key, only: config.defined_actions do
-        define_actions(config)
-      end
-    end
-
-    def page_routes(config)
-      page = config.underscored_resource_name
-      router.get "/#{page}" => "#{page}#index"
-      config.page_actions.each do |action|
-        Array.wrap(action.http_verb).each do |verb|
-          build_route(verb, "/#{page}/#{action.name}" => "#{page}##{action.name}")
-        end
-      end
-    end
-
-    # Defines member and collection actions
-    def define_actions(config)
-      router.member do
-        config.member_actions.each { |action| build_action(action) }
-      end
-
-      router.collection do
-        config.collection_actions.each { |action| build_action(action) }
-        router.post :batch_action if config.batch_actions_enabled?
-      end
-    end
-
-    # Deals with +ControllerAction+ instances
-    # Builds one route for each HTTP verb passed in
-    def build_action(action)
-      build_route(action.http_verb, action.name)
-    end
-
-    def build_route(verbs, *args)
-      Array.wrap(verbs).each { |verb| router.send(verb, *args) }
-    end
-
-    def define_belongs_to_routes(config)
-      # If it's optional, make the normal resource routes
-      page_or_resource_routes(config) if config.belongs_to_config.optional?
-
-      # Make the nested belongs_to routes
-      # :only is set to nothing so that we don't clobber any existing routes on the resource
-      router.resources config.belongs_to_config.target.resource_name.plural, only: [] do
-        page_or_resource_routes(config)
-      end
-    end
-
-    def define_namespace(config)
-      router.namespace config.namespace.name, config.namespace.route_options.dup do
-        define_routes(config)
-      end
-    end
-  end
-end