activeadmin_addons 1.1.2 → 1.2.0

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/resource/action_items.rb

@@ -1,108 +0,0 @@
-require 'active_admin/helpers/optional_display'
-
-module ActiveAdmin
-
-  class Resource
-    module ActionItems
-
-      # Adds the default action items to a resource when it's initialized
-      def initialize(*args)
-        super
-        add_default_action_items
-      end
-
-      # @return [Array] The set of action items for this resource
-      def action_items
-        @action_items ||= []
-      end
-
-      # Add a new action item to a resource
-      #
-      # @param [Symbol] name
-      # @param [Hash] options valid keys include:
-      #                 :only:  A single or array of controller actions to display
-      #                         this action item on.
-      #                 :except: A single or array of controller actions not to
-      #                          display this action item on.
-      def add_action_item(name, options = {}, &block)
-        self.action_items << ActiveAdmin::ActionItem.new(name, options, &block)
-      end
-
-      def remove_action_item(name)
-        self.action_items.delete_if { |item| item.name == name }
-      end
-
-      # Returns a set of action items to display for a specific controller action
-      #
-      # @param [String, Symbol] action the action to retrieve action items for
-      #
-      # @return [Array] Array of ActionItems for the controller actions
-      def action_items_for(action, render_context = nil)
-        action_items.select{ |item| item.display_on? action, render_context }
-      end
-
-      # Clears all the existing action items for this resource
-      def clear_action_items!
-        @action_items = []
-      end
-
-      # Used by active_admin Base view
-      def action_items?
-        !!@action_items && @action_items.any?
-      end
-
-      private
-
-      # Adds the default action items to each resource
-      def add_default_action_items
-        add_default_new_action_item
-        add_default_edit_action_item
-        add_default_show_action_item
-      end
-
-      # Adds the default New link on index
-      def add_default_new_action_item
-        add_action_item :new, only: :index do
-          if controller.action_methods.include?('new') && authorized?(ActiveAdmin::Auth::CREATE, active_admin_config.resource_class)
-            link_to I18n.t('active_admin.new_model', model: active_admin_config.resource_label), new_resource_path
-          end
-        end
-      end
-
-      # Adds the default Edit link on show
-      def add_default_edit_action_item
-        add_action_item :edit, only: :show do
-          if controller.action_methods.include?('edit') && authorized?(ActiveAdmin::Auth::UPDATE, resource)
-            link_to I18n.t('active_admin.edit_model', model: active_admin_config.resource_label), edit_resource_path(resource)
-          end
-        end
-      end
-
-      # Adds the default Destroy link on show
-      def add_default_show_action_item
-        add_action_item :destroy, only: :show do
-          if controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, resource)
-            link_to I18n.t('active_admin.delete_model', model: active_admin_config.resource_label), resource_path(resource),
-              method: :delete, data: {confirm: I18n.t('active_admin.delete_confirmation')}
-          end
-        end
-      end
-
-    end
-  end
-
-  # Model class to store the data for ActionItems
-  class ActionItem
-    include ActiveAdmin::OptionalDisplay
-
-    attr_accessor :block, :name
-
-    def initialize(name, options = {}, &block)
-      @name = name
-      @options = options
-      @block = block
-      normalize_display_options!
-    end
-  end
-
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/resource/belongs_to.rb

@@ -1,44 +0,0 @@
-require 'active_admin/resource'
-
-module ActiveAdmin
-  class Resource
-    class BelongsTo
-
-      class TargetNotFound < StandardError
-        def initialize(key, namespace)
-          super "Could not find #{key} in #{namespace.name} " +
-                "with #{namespace.resources.map(&:resource_name)}"
-        end
-      end
-
-      # The resource which initiated this relationship
-      attr_reader :owner
-
-      def initialize(owner, target_name, options = {})
-        @owner, @target_name, @options = owner, target_name, options
-      end
-
-      # Returns the target resource class or raises an exception if it doesn't exist
-      def target
-        resource or raise TargetNotFound.new (@options[:class_name] || @target_name.to_s.camelize), namespace
-      end
-
-      def resource
-        namespace.resources[@options[:class_name]] ||
-          namespace.resources[@target_name.to_s.camelize]
-      end
-
-      def namespace
-        @owner.namespace
-      end
-
-      def optional?
-        @options[:optional]
-      end
-
-      def required?
-        !optional?
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/resource/menu.rb

@@ -1,64 +0,0 @@
-module ActiveAdmin
-  class Resource
-
-    module Menu
-
-      # Set the menu options.
-      # To disable this menu item, call `menu(false)` from the DSL
-      def menu_item_options=(options)
-        if options == false
-          @include_in_menu   = false
-          @menu_item_options = {}
-        else
-          @navigation_menu_name = options[:menu_name]
-          @menu_item_options    = default_menu_options.merge options
-        end
-      end
-
-      def menu_item_options
-        @menu_item_options ||= default_menu_options
-      end
-
-      def default_menu_options
-        # These local variables are accessible to the procs.
-        menu_resource_class = respond_to?(:resource_class) ? resource_class : self
-        resource = self
-        {
-          id: resource_name.plural,
-          label: proc{ resource.plural_resource_label },
-          url:   proc{ resource.route_collection_path(params) },
-          if:    proc{ authorized?(:read, menu_resource_class) }
-        }
-      end
-
-      attr_writer :navigation_menu_name
-
-      def navigation_menu_name
-        case @navigation_menu_name ||= DEFAULT_MENU
-        when Proc
-          controller.instance_exec(&@navigation_menu_name).to_sym
-        else
-          @navigation_menu_name
-        end
-      end
-
-      def navigation_menu
-        namespace.fetch_menu(navigation_menu_name)
-      end
-
-      def add_to_menu(menu_collection)
-        if include_in_menu?
-          @menu_item = menu_collection.add navigation_menu_name, menu_item_options
-        end
-      end
-
-      attr_reader :menu_item
-
-      # Should this resource be added to the menu system?
-      def include_in_menu?
-        @include_in_menu != false
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/resource/page_presenters.rb

@@ -1,82 +0,0 @@
-module ActiveAdmin
-  class Resource
-    module PagePresenters
-
-      # for setting default css class in admin ui
-      def default_index_class
-        @default_index
-      end
-
-      # A hash of page configurations for the controller indexed by action name
-      def page_presenters
-        @page_presenters ||= {}
-      end
-
-      # Sets a page config for a given action
-      #
-      # @param [String, Symbol] action The action to store this configuration for
-      # @param [PagePresenter] page_presenter The instance of PagePresenter to store
-      def set_page_presenter(action, page_presenter)
-
-        if action.to_s == "index" && page_presenter[:as]
-          index_class = find_index_class(page_presenter[:as])
-          page_presenter_key = index_class.index_name.to_sym
-          set_index_presenter page_presenter_key, page_presenter
-        else
-          page_presenters[action.to_sym] = page_presenter
-        end
-
-      end
-
-      # Returns a stored page config
-      #
-      # @param [Symbol, String] action The action to get the config for
-      # @param [String] type The string specified in the presenters index_name method
-      # @return [PagePresenter, nil]
-      def get_page_presenter(action, type=nil)
-
-        if action.to_s == "index" && type && page_presenters[:index].kind_of?(Hash)
-          page_presenters[:index][type.to_sym]
-        elsif action.to_s == "index" && page_presenters[:index].kind_of?(Hash)
-          page_presenters[:index].default
-        else
-          page_presenters[action.to_sym]
-        end
-
-      end
-
-      protected
-
-      # Stores a config for all index actions supplied
-      #
-      # @param [Symbol] index_as The index type to store in the configuration
-      # @param [PagePresenter] page_presenter The intance of PagePresenter to store
-      def set_index_presenter(index_as, page_presenter)
-        page_presenters[:index] ||= {}
-
-        #set first index as default value or the index with default param set to to true
-        if page_presenters[:index].empty? || page_presenter[:default] == true
-          page_presenters[:index].default = page_presenter
-          @default_index = find_index_class(page_presenter[:as])
-        end
-
-        page_presenters[:index][index_as] = page_presenter
-      end
-
-      # Returns the actual class for renderering the main content on the index
-      # page. To set this, use the :as option in the page_presenter block.
-      #
-      # @param [Symbol, Class] symbol_or_class The component symbol or class
-      # @return [Class]
-      def find_index_class(symbol_or_class)
-        case symbol_or_class
-        when Symbol
-          ::ActiveAdmin::Views.const_get("IndexAs" + symbol_or_class.to_s.camelcase)
-        when Class
-          symbol_or_class
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/resource/routes.rb

@@ -1,115 +0,0 @@
-module ActiveAdmin
-  class Resource
-    module Routes
-      # @param params [Hash] of params: { study_id: 3 }
-      # @return [String] the path to this resource collection page
-      # @example "/admin/posts"
-      def route_collection_path(params = {})
-        RouteBuilder.new(self).collection_path(params)
-      end
-
-      # @param resource [ActiveRecord::Base] the instance we want the path of
-      # @return [String] the path to this resource collection page
-      # @example "/admin/posts/1"
-      def route_instance_path(resource)
-        RouteBuilder.new(self).instance_path(resource)
-      end
-
-      def route_edit_instance_path(resource)
-        RouteBuilder.new(self).edit_instance_path(resource)
-      end
-
-      # Returns the routes prefix for this config
-      def route_prefix
-        namespace.module_name.try(:underscore)
-      end
-
-      def route_uncountable?
-        config = resources_configuration[:self]
-
-        config[:route_collection_name] == config[:route_instance_name]
-      end
-
-      private
-
-      class RouteBuilder
-        def initialize(resource)
-          @resource = resource
-        end
-
-        def collection_path(params)
-          route_name = route_name(
-            resource.resources_configuration[:self][:route_collection_name],
-            suffix: (resource.route_uncountable? ? "index_path" : "path")
-          )
-
-          routes.public_send route_name, *route_collection_params(params)
-        end
-
-        # @return [String] the path to this resource collection page
-        # @param instance [ActiveRecord::Base] the instance we want the path of
-        # @example "/admin/posts/1"
-        def instance_path(instance)
-          route_name = route_name(resource.resources_configuration[:self][:route_instance_name])
-
-          routes.public_send route_name, *route_instance_params(instance)
-        end
-
-        # @return [String] the path to the edit page of this resource
-        # @param instance [ActiveRecord::Base] the instance we want the path of
-        # @example "/admin/posts/1/edit"
-        def edit_instance_path(instance)
-          path = resource.resources_configuration[:self][:route_instance_name]
-          route_name = route_name(path, action: :edit)
-
-          routes.public_send route_name, *route_instance_params(instance)
-        end
-
-        private
-
-        attr_reader :resource
-
-        def route_name(resource_path_name, options = {})
-          suffix = options[:suffix] || "path"
-          route = []
-
-          route << options[:action]           # "edit" or "new"
-          route << resource.route_prefix      # "admin"
-          route << belongs_to_name if nested? # "category"
-          route << resource_path_name         # "posts" or "post"
-          route << suffix                     # "path" or "index path"
-
-          route.compact.join('_').to_sym      # :admin_category_posts_path
-        end
-
-
-        # @return params to pass to instance path
-        def route_instance_params(instance)
-          if nested?
-            [instance.public_send(belongs_to_name).to_param, instance.to_param]
-          else
-            instance.to_param
-          end
-        end
-
-        def route_collection_params(params)
-          if nested?
-            params[:"#{belongs_to_name}_id"]
-          end
-        end
-
-        def nested?
-          resource.belongs_to? && resource.belongs_to_config.required?
-        end
-
-        def belongs_to_name
-          resource.belongs_to_config.target.resource_name.singular if nested?
-        end
-
-        def routes
-          Helpers::Routes
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/resource/scopes.rb

@@ -1,50 +0,0 @@
-module ActiveAdmin
-  class Resource
-    module Scopes
-
-      # Return an array of scopes for this resource
-      def scopes
-        @scopes ||= []
-      end
-
-      # Returns a scope for this object by its identifier
-      def get_scope_by_id(id)
-        id = id.to_s
-        scopes.find{|s| s.id == id }
-      end
-
-      def default_scope(context = nil)
-        scopes.detect do |scope|
-          if scope.default_block.is_a?(Proc)
-            render_in_context(context, scope.default_block)
-          else
-            scope.default_block
-          end
-        end
-      end
-
-      # Create a new scope object for this resource.
-      # If you want to internationalize the scope name, you can add
-      # to your i18n files a key like "active_admin.scopes.scope_method".
-      def scope(*args, &block)
-        options = args.extract_options!
-        title = args[0] rescue nil
-        method = args[1] rescue nil
-
-        scope = ActiveAdmin::Scope.new(title, method, options, &block)
-
-        # Finds and replaces a scope by the same name if it already exists
-        existing_scope_index = scopes.index{|existing_scope| existing_scope.id == scope.id }
-        if existing_scope_index
-          scopes.delete_at(existing_scope_index)
-          scopes.insert(existing_scope_index, scope)
-        else
-          self.scopes << scope
-        end
-
-        scope
-      end
-
-    end
-  end
-end