activeadmin_addons 1.7.0 → 1.9.0

data/vendor/bundle/ruby/2.3.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.3.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

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/scope.rb

@@ -1,56 +0,0 @@
-module ActiveAdmin
-  class Scope
-
-    attr_reader :scope_method, :id, :scope_block, :display_if_block, :show_count, :default_block
-
-    # Create a Scope
-    #
-    # Examples:
-    #
-    #   Scope.new(:published)
-    #   # => Scope with name 'Published' and scope method :published
-    #
-    #   Scope.new('Published', :public)
-    #   # => Scope with name 'Published' and scope method :public
-    #
-    #   Scope.new 'Published', :public, if: proc { current_admin_user.can? :manage, resource_class } do |articles|
-    #     articles.where published: true
-    #   end
-    #   # => Scope with name 'Published' and scope method :public, optionally displaying the scope per the :if block
-    #
-    #   Scope.new('Published') { |articles| articles.where(published: true) }
-    #   # => Scope with name 'Published' using a block to scope
-    #
-    #   Scope.new ->{Date.today.strftime '%A'}, :published_today
-    #   # => Scope with dynamic title using the :published_today scope method
-    #
-    def initialize(name, method = nil, options = {}, &block)
-      @name, @scope_method = name, method.try(:to_sym)
-
-      if name.is_a? Proc
-        raise "A string/symbol is required as the second argument if your label is a proc." unless method
-        @id = ActiveAdmin::Dependency.rails.parameterize method.to_s
-      else
-        @scope_method ||= name.to_sym
-        @id = ActiveAdmin::Dependency.rails.parameterize name.to_s
-      end
-
-      @scope_method               = nil        if @scope_method == :all
-      @scope_method, @scope_block = nil, block if block_given?
-
-      @localizer        = options[:localizer]
-      @show_count       = options.fetch(:show_count, true)
-      @display_if_block = options[:if]      || proc{ true }
-      @default_block    = options[:default] || proc{ false }
-    end
-
-    def name
-      case @name
-      when String then @name
-      when Symbol then @localizer ? @localizer.t(@name, scope: 'scopes') : @name.to_s.titleize
-      else @name
-      end
-    end
-
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/settings_node.rb

@@ -1,19 +0,0 @@
-module ActiveAdmin
-
-  class SettingsNode
-    class << self
-      # Never instantiated.  Variables are stored in the singleton_class.
-      private_class_method :new
-
-      # @return anonymous class with same accessors as the superclass.
-      def build(superclass = self)
-        Class.new(superclass)
-      end
-
-      def register(name, value)
-        class_attribute name
-        send "#{name}=", value
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/sidebar_section.rb

@@ -1,37 +0,0 @@
-module ActiveAdmin
-
-  class SidebarSection
-    include ActiveAdmin::OptionalDisplay
-
-    attr_accessor :name, :options, :block
-
-    def initialize(name, options = {}, &block)
-      @name, @options, @block = name.to_s, options, block
-      normalize_display_options!
-    end
-
-    # The id gets used for the div in the view
-    def id
-      "#{name.downcase.underscore}_sidebar_section".parameterize
-    end
-
-    # The title gets displayed within the section in the view
-    def title
-      I18n.t("active_admin.sidebars.#{name}", default: name.titlecase)
-    end
-
-    # If a block is not passed in, the name of the partial to render
-    def partial_name
-      options[:partial] || "#{name.downcase.tr(' ', '_')}_sidebar"
-    end
-
-    def custom_class
-      options[:class]
-    end
-
-    def priority
-      options[:priority] || 10
-    end
-  end
-
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/version.rb

@@ -1,3 +0,0 @@
-module ActiveAdmin
-  VERSION = '2.0.0.alpha'
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/view_factory.rb

@@ -1,27 +0,0 @@
-require 'active_admin/abstract_view_factory'
-
-module ActiveAdmin
-  class ViewFactory < AbstractViewFactory
-
-    # Register Helper Renderers
-    register  global_navigation:   ActiveAdmin::Views::TabbedNavigation,
-              utility_navigation:  ActiveAdmin::Views::TabbedNavigation,
-              site_title:          ActiveAdmin::Views::SiteTitle,
-              unsupported_browser: ActiveAdmin::Views::UnsupportedBrowser,
-              action_items:        ActiveAdmin::Views::ActionItems,
-              title_bar:           ActiveAdmin::Views::TitleBar,
-              header:              ActiveAdmin::Views::Header,
-              footer:              ActiveAdmin::Views::Footer,
-              index_scopes:        ActiveAdmin::Views::Scopes,
-              blank_slate:         ActiveAdmin::Views::BlankSlate
-
-    # Register All The Pages
-    register  index_page: ActiveAdmin::Views::Pages::Index,
-              show_page:  ActiveAdmin::Views::Pages::Show,
-              new_page:   ActiveAdmin::Views::Pages::Form,
-              edit_page:  ActiveAdmin::Views::Pages::Form,
-              layout:     ActiveAdmin::Views::Pages::Layout,
-              page:       ActiveAdmin::Views::Pages::Page
-
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/view_helpers/active_admin_application_helper.rb

@@ -1,12 +0,0 @@
-module ActiveAdmin
-  module ViewHelpers
-    module ActiveAdminApplicationHelper
-
-      # Returns the current Active Admin application instance
-      def active_admin_application
-        ActiveAdmin.application
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/view_helpers/auto_link_helper.rb

@@ -1,45 +0,0 @@
-module ActiveAdmin
-  module ViewHelpers
-    module AutoLinkHelper
-
-      # Automatically links objects to their resource controllers. If
-      # the resource has not been registered, a string representation of
-      # the object is returned.
-      #
-      # The default content in the link is returned from ActiveAdmin::ViewHelpers::DisplayHelper#display_name
-      #
-      # You can pass in the content to display
-      #   eg: auto_link(@post, "My Link")
-      #
-      def auto_link(resource, content = display_name(resource))
-        if url = auto_url_for(resource)
-          link_to content, url
-        else
-          content
-        end
-      end
-
-      # Like `auto_link`, except that it only returns a URL instead of a full <a> tag
-      def auto_url_for(resource)
-        config = active_admin_resource_for(resource.class)
-        return unless config
-
-        if config.controller.action_methods.include?("show") &&
-          authorized?(ActiveAdmin::Auth::READ, resource)
-          url_for config.route_instance_path resource, url_options
-        elsif config.controller.action_methods.include?("edit") &&
-          authorized?(ActiveAdmin::Auth::UPDATE, resource)
-          url_for config.route_edit_instance_path resource, url_options
-        end
-      end
-
-      # Returns the ActiveAdmin::Resource instance for a class
-      def active_admin_resource_for(klass)
-        if respond_to? :active_admin_namespace
-          active_admin_namespace.resource_for klass
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/view_helpers/breadcrumb_helper.rb

@@ -1,33 +0,0 @@
-module ActiveAdmin
-  module ViewHelpers
-    module BreadcrumbHelper
-
-      # Returns an array of links to use in a breadcrumb
-      def breadcrumb_links(path = request.path)
-        # remove leading "/" and split up the URL
-        # and remove last since it's used as the page title
-        parts = path.split('/').select(&:present?)[0..-2]
-
-        parts.each_with_index.map do |part, index|
-          # 1. try using `display_name` if we can locate a DB object
-          # 2. try using the model name translation
-          # 3. default to calling `titlecase` on the URL fragment
-          if part =~ /\A(\d+|[a-f0-9]{24}|(?:[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}))\z/ && parts[index-1]
-            parent = active_admin_config.belongs_to_config.try :target
-            config = parent && parent.resource_name.route_key == parts[index-1] ? parent : active_admin_config
-            name   = display_name config.find_resource part
-          end
-          name ||= I18n.t "activerecord.models.#{part.singularize}", count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT, default: part.titlecase
-
-          # Don't create a link if the resource's show action is disabled
-          if !config || config.defined_actions.include?(:show)
-            link_to name, '/' + parts[0..index].join('/')
-          else
-            name
-          end
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/view_helpers/display_helper.rb

@@ -1,95 +0,0 @@
-module ActiveAdmin
-  module ViewHelpers
-    module DisplayHelper
-
-      DISPLAY_NAME_FALLBACK = ->{
-        name, klass = "", self.class
-        name << klass.model_name.human         if klass.respond_to? :model_name
-        name << " ##{send(klass.primary_key)}" if klass.respond_to? :primary_key
-        name.present? ? name : to_s
-      }
-      def DISPLAY_NAME_FALLBACK.inspect
-        'DISPLAY_NAME_FALLBACK'
-      end
-
-      # Attempts to call any known display name methods on the resource.
-      # See the setting in `application.rb` for the list of methods and their priority.
-      def display_name(resource)
-        sanitize(render_in_context(resource, display_name_method_for(resource)).to_s) unless resource.nil?
-      end
-
-      # Looks up and caches the first available display name method.
-      # To prevent conflicts, we exclude any methods that happen to be associations.
-      # If no methods are available and we're about to use the Kernel's `to_s`, provide our own.
-      def display_name_method_for(resource)
-        @@display_name_methods_cache ||= {}
-        @@display_name_methods_cache[resource.class] ||= begin
-          methods = active_admin_application.display_name_methods - association_methods_for(resource)
-          method  = methods.detect{ |method| resource.respond_to? method }
-
-          if method != :to_s || resource.method(method).source_location
-            method
-          else
-            DISPLAY_NAME_FALLBACK
-          end
-        end
-      end
-
-      def association_methods_for(resource)
-        return [] unless resource.class.respond_to? :reflect_on_all_associations
-        resource.class.reflect_on_all_associations.map(&:name)
-      end
-
-      def format_attribute(resource, attr)
-        value = find_value resource, attr
-
-        if value.is_a?(Arbre::Element)
-          value
-        elsif boolean_attr?(resource, attr, value)
-          Arbre::Context.new { status_tag value }
-        else
-          pretty_format value
-        end
-      end
-
-      def find_value(resource, attr)
-        if attr.is_a? Proc
-          attr.call resource
-        elsif resource.respond_to? attr
-          resource.public_send attr
-        elsif resource.respond_to? :[]
-          resource[attr]
-        end
-      end
-
-      # Attempts to create a human-readable string for any object
-      def pretty_format(object)
-        case object
-        when String, Numeric, Symbol, Arbre::Element
-          object.to_s
-        when Date, Time
-          I18n.localize object, format: active_admin_application.localize_format
-        else
-          if defined?(::ActiveRecord) && object.is_a?(ActiveRecord::Base) ||
-             defined?(::Mongoid)      && object.class.include?(Mongoid::Document)
-            auto_link object
-          else
-            display_name object
-          end
-        end
-      end
-
-      def boolean_attr?(resource, attr, value)
-        case value
-        when TrueClass, FalseClass
-          true
-        else
-          if resource.class.respond_to? :columns_hash
-            column = resource.class.columns_hash[attr.to_s] and column.type == :boolean
-          end
-        end
-      end
-
-    end
-  end
-end