activeadmin_addons 1.1.2 → 1.2.0

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/inputs/filters/date_range_input.rb

@@ -1,36 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    module Filters
-      class DateRangeInput < ::Formtastic::Inputs::StringInput
-        include Base
-
-        def to_html
-          input_wrapping do
-            [ label_html,
-              builder.text_field(gt_input_name, input_html_options(gt_input_name)),
-              template.content_tag(:span, "-", class: "seperator"),
-              builder.text_field(lt_input_name, input_html_options(lt_input_name)),
-            ].join("\n").html_safe
-          end
-        end
-
-        def gt_input_name
-          "#{method}_gteq"
-        end
-        alias :input_name :gt_input_name
-
-        def lt_input_name
-          "#{method}_lteq"
-        end
-
-        def input_html_options(input_name = gt_input_name)
-          current_value = @object.public_send input_name
-          { size: 12,
-            class: "datepicker",
-            maxlength: 10,
-            value: current_value.respond_to?(:strftime) ? current_value.strftime("%Y-%m-%d") : "" }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/inputs/filters/select_input.rb

@@ -1,54 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    module Filters
-      class SelectInput < ::Formtastic::Inputs::SelectInput
-        include Base
-
-        def input_name
-          return method if seems_searchable?
-
-          searchable_method_name.concat multiple? ? '_in' : '_eq'
-        end
-
-        def searchable_method_name
-          if searchable_has_many_through?
-            "#{reflection.through_reflection.name}_#{reflection.foreign_key}"
-          else
-            name = method.to_s
-            name.concat '_id' if reflection
-            name
-          end
-        end
-
-        # Provide the AA translation to the blank input field.
-        def include_blank
-          I18n.t 'active_admin.any' if super
-        end
-
-        def input_html_options_name
-          "#{object_name}[#{input_name}]" # was "#{object_name}[#{association_primary_key}]"
-        end
-
-        # Would normally return true for has_many and HABTM, which would subsequently
-        # cause the select field to be multi-select instead of a dropdown.
-        def multiple_by_association?
-          false
-        end
-
-        # Provides an efficient default lookup query if the attribute is a DB column.
-        def collection
-          if !options[:collection] && column
-            pluck_column
-          else
-            super
-          end
-        end
-
-        def pluck_column
-          klass.reorder("#{method} asc").uniq.pluck method
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-module ActiveAdmin
-
-  # Each Namespace builds up it's own menu as the global navigation
-  #
-  # To build a new menu:
-  #
-  #   menu = Menu.new do |m|
-  #     m.add label: 'Dashboard', url: '/'
-  #     m.add label: 'Users',     url: '/users'
-  #   end
-  #
-  # If you're interested in configuring a menu item, take a look at the
-  # options available in `ActiveAdmin::MenuItem`
-  #
-  class Menu
-
-    def initialize
-      super # MenuNode
-      yield(self) if block_given?
-    end
-
-    module MenuNode
-      def initialize
-        @children = {}
-      end
-
-      def [](id)
-        @children[normalize_id(id)]
-      end
-
-      def []=(id, child)
-        @children[normalize_id(id)] = child
-      end
-
-      # Recursively builds any given menu items. There are two syntaxes supported,
-      # as shown in the below examples. Both create an identical menu structure.
-      #
-      # Example 1:
-      #   menu = Menu.new
-      #   menu.add label: 'Dashboard' do |dash|
-      #     dash.add label: 'My Child Dashboard'
-      #   end
-      #
-      # Example 2:
-      #   menu = Menu.new
-      #   menu.add label:  'Dashboard'
-      #   menu.add parent: 'Dashboard', label: 'My Child Dashboard'
-      #
-      def add(options)
-        item = if parent = options.delete(:parent)
-          (self[parent] || add(label: parent)).add options
-        else
-          _add options.merge parent: self
-        end
-
-        yield(item) if block_given?
-
-        item
-      end
-
-      # Whether any children match the given item.
-      def include?(item)
-        @children.values.include? item
-      end
-
-      # Used in the UI to visually distinguish which menu item is selected.
-      def current?(item)
-        self == item || include?(item)
-      end
-
-      # Returns sorted array of menu items that should be displayed in this context.
-      # Sorts by priority first, then alphabetically by label if needed.
-      def items(context = nil)
-        @children.values.select{ |i| i.display?(context) }.sort do |a,b|
-          result = a.priority       <=> b.priority
-          result = a.label(context) <=> b.label(context) if result == 0
-          result
-        end
-      end
-
-      attr_reader :children
-      private
-      attr_writer :children
-
-      # The method that actually adds new menu items. Called by the public method.
-      # If this ID is already taken, transfer the children of the existing item to the new item.
-      def _add(options)
-        item = ActiveAdmin::MenuItem.new(options)
-        item.send :children=, self[item.id].children if self[item.id]
-        self[item.id] = item
-      end
-
-      def normalize_id(id)
-        case id
-        when String, Symbol, ActiveModel::Name
-          id.to_s.downcase.tr ' ', '_'
-        when ActiveAdmin::Resource::Name
-          id.param_key
-        else
-          raise TypeError, "#{id.class} isn't supported as a Menu ID"
-        end
-      end
-    end
-
-    include MenuNode
-
-  end
-end

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

@@ -1,93 +0,0 @@
-module ActiveAdmin
-
-  DEFAULT_MENU = :default
-
-  # A MenuCollection stores multiple menus for any given namespace. Namespaces delegate
-  # the addition of menu items to this class.
-  class MenuCollection
-    def initialize
-      @menus = {}
-      @build_callbacks = []
-      @built = false
-    end
-
-    # Add a new menu item to a menu in the collection
-    def add(menu_name, menu_item_options = {})
-      menu = find_or_create(menu_name)
-
-      menu.add menu_item_options
-    end
-
-    def clear!
-      @menus = {}
-      @built = false
-    end
-
-    def exists?(menu_name)
-      @menus.keys.include? menu_name
-    end
-
-    def fetch(menu_name)
-      build_menus!
-
-      @menus[menu_name] or
-        raise NoMenuError, "No menu by the name of #{menu_name.inspect} in available menus: #{@menus.keys.join(", ")}"
-    end
-
-    # Add callbacks that will be run when the menu is going to be built. This
-    # helps use with reloading and allows configurations to add items to menus.
-    #
-    # @param [Proc] block A block which will be ran when the menu is built. The
-    #                   will have the menu collection yielded.
-    def on_build(&block)
-      @build_callbacks << block
-    end
-
-    # Add callbacks that will be run before the menu is built
-    def before_build(&block)
-      @build_callbacks.unshift(block)
-    end
-
-    def menu(menu_name)
-      menu = find_or_create(menu_name)
-
-      yield(menu) if block_given?
-
-      menu
-    end
-
-    private
-
-    def built?
-      @built
-    end
-
-    def build_menus!
-      return if built?
-
-      build_default_menu
-      run_on_build_callbacks
-
-      @built = true
-    end
-
-    def run_on_build_callbacks
-      @build_callbacks.each do |callback|
-        callback.call(self)
-      end
-    end
-
-    def build_default_menu
-      find_or_create DEFAULT_MENU
-    end
-
-    def find_or_create(menu_name)
-      menu_name ||= DEFAULT_MENU
-      @menus[menu_name] ||= ActiveAdmin::Menu.new
-    end
-
-
-
-  end
-
-end

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

@@ -1,97 +0,0 @@
-require 'active_admin/view_helpers/method_or_proc_helper'
-
-module ActiveAdmin
-  class MenuItem
-    include Menu::MenuNode
-    include MethodOrProcHelper
-
-    attr_reader :html_options, :parent, :priority
-
-    # Builds a new menu item
-    #
-    # @param [Hash] options The options for the menu
-    #
-    # @option options [String, Symbol, Proc] :label
-    #         The label to display for this menu item.
-    #         Default: Titleized Resource Name
-    #
-    # @option options [String] :id
-    #         A custom id to reference this menu item with.
-    #         Default: underscored_resource_name
-    #
-    # @option options [String, Symbol, Proc] :url
-    #         The URL this item will link to.
-    #
-    # @option options [Integer] :priority
-    #         The lower the priority, the earlier in the menu the item will be displayed.
-    #         Default: 10
-    #
-    # @option options [Symbol, Proc] :if
-    #         This decides whether the menu item will be displayed. Evaluated on each request.
-    #
-    # @option options [Hash] :html_options
-    #         A hash of options to pass to `link_to` when rendering the item
-    #
-    # @option [ActiveAdmin::MenuItem] :parent
-    #         This menu item's parent. It will be displayed nested below its parent.
-    #
-    # NOTE: for :label, :url, and :if
-    # These options are evaluated in the view context at render time. Symbols are called
-    # as methods on `self`, and Procs are exec'd within `self`.
-    # Here are some examples of what you can do:
-    #
-    #   menu if:  :admin?
-    #   menu url: :new_book_path
-    #   menu url: :awesome_helper_you_defined
-    #   menu label: ->{ User.some_method }
-    #   menu label: ->{ I18n.t 'menus.user' }
-    #
-    def initialize(options = {})
-      super() # MenuNode
-      @label          = options[:label]
-      @dirty_id       = options[:id]           || options[:label]
-      @url            = options[:url]          || '#'
-      @priority       = options[:priority]     || 10
-      @html_options   = options[:html_options] || {}
-      @should_display = options[:if]           || proc{true}
-      @parent         = options[:parent]
-
-      yield(self) if block_given? # Builder style syntax
-    end
-
-    def id
-      @id ||= normalize_id @dirty_id
-    end
-
-    def label(context = nil)
-      render_in_context context, @label
-    end
-
-    def url(context = nil)
-      render_in_context context, @url
-    end
-
-    # Don't display if the :if option passed says so
-    # Don't display if the link isn't real, we have children, and none of the children are being displayed.
-    def display?(context = nil)
-      return false unless render_in_context(context, @should_display)
-      return false if     !real_url?(context) && @children.any? && !items(context).any?
-      true
-    end
-
-    # Returns an array of the ancestry of this menu item.
-    # The first item is the immediate parent of the item.
-    def ancestors
-      parent ? [parent, parent.ancestors].flatten : []
-    end
-
-    private
-
-    # URL is not nil, empty, or '#'
-    def real_url?(context = nil)
-      url = url context
-      url.present? && url != '#'
-    end
-
-  end
-end

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

@@ -1,247 +0,0 @@
-require 'active_admin/resource_collection'
-
-module ActiveAdmin
-
-  # Namespaces are the basic organizing principle for resources within Active Admin
-  #
-  # Each resource is registered into a namespace which defines:
-  #   * the namespaceing for routing
-  #   * the module to namespace controllers
-  #   * the menu which gets displayed (other resources in the same namespace)
-  #
-  # For example:
-  #
-  #   ActiveAdmin.register Post, namespace: :admin
-  #
-  # Will register the Post model into the "admin" namespace. This will namespace the
-  # urls for the resource to "/admin/posts" and will set the controller to
-  # Admin::PostsController
-  #
-  # You can also register to the "root" namespace, which is to say no namespace at all.
-  #
-  #   ActiveAdmin.register Post, namespace: false
-  #
-  # This will register the resource to an instantiated namespace called :root. The
-  # resource will be accessible from "/posts" and the controller will be PostsController.
-  #
-  class Namespace
-    RegisterEvent = 'active_admin.namespace.register'.freeze
-
-    attr_reader :application, :resources, :name, :menus
-
-    def initialize(application, name)
-      @application = application
-      @name = name.to_s.underscore.to_sym
-      @resources = ResourceCollection.new
-      register_module unless root?
-      build_menu_collection
-    end
-
-    # Register a resource into this namespace. The preffered method to access this is to
-    # use the global registration ActiveAdmin.register which delegates to the proper
-    # namespace instance.
-    def register(resource_class, options = {}, &block)
-      config = find_or_build_resource(resource_class, options)
-
-      # Register the resource
-      register_resource_controller(config)
-      parse_registration_block(config, resource_class, &block) if block_given?
-      reset_menu!
-
-      # Dispatch a registration event
-      ActiveSupport::Notifications.publish ActiveAdmin::Resource::RegisterEvent, config
-
-      # Return the config
-      config
-    end
-
-    def register_page(name, options = {}, &block)
-      config = build_page(name, options)
-
-      # Register the resource
-      register_page_controller(config)
-      parse_page_registration_block(config, &block) if block_given?
-      reset_menu!
-
-      config
-    end
-
-    def root?
-      name == :root
-    end
-
-    # Returns the name of the module if required. Will be nil if none
-    # is required.
-    #
-    # eg:
-    #   Namespace.new(:admin).module_name # => 'Admin'
-    #   Namespace.new(:root).module_name # => nil
-    #
-    def module_name
-      return nil if root?
-      @module_name ||= name.to_s.camelize
-    end
-
-    # Unload all the registered resources for this namespace
-    def unload!
-      unload_resources!
-      reset_menu!
-    end
-
-    # Returns the first registered ActiveAdmin::Resource instance for a given class
-    def resource_for(klass)
-      resources[klass]
-    end
-
-    # Override from ActiveAdmin::Settings to inherit default attributes
-    # from the application
-    def read_default_setting(name)
-      application.public_send name
-    end
-
-    def fetch_menu(name)
-      @menus.fetch(name)
-    end
-
-    def reset_menu!
-      @menus.clear!
-    end
-
-    # Add a callback to be ran when we build the menu
-    #
-    # @param [Symbol] name The name of the menu. Default: :default
-    # @yield [ActiveAdmin::Menu] The block to be ran when the menu is built
-    #
-    # @return [void]
-    def build_menu(name = DEFAULT_MENU)
-      @menus.before_build do |menus|
-        menus.menu name do |menu|
-          yield menu
-        end
-      end
-    end
-
-    # The default logout menu item
-    #
-    # @param [ActiveAdmin::MenuItem] menu The menu to add the logout link to
-    # @param [Fixnum] priority The numeric priority for the order in which it appears
-    # @param [Hash] html_options An options hash to pass along to link_to
-    #
-    def add_logout_button_to_menu(menu, priority = 20, html_options = {})
-      if logout_link_path
-        html_options = html_options.reverse_merge(method: logout_link_method || :get)
-        menu.add id: 'logout', priority: priority, html_options: html_options,
-          label: ->{ I18n.t 'active_admin.logout' },
-          url:   ->{ render_or_call_method_or_proc_on self, active_admin_namespace.logout_link_path },
-          if:    :current_active_admin_user?
-      end
-    end
-
-    # The default user session menu item
-    #
-    # @param [ActiveAdmin::MenuItem] menu The menu to add the logout link to
-    # @param [Fixnum] priority The numeric priority for the order in which it appears
-    # @param [Hash] html_options An options hash to pass along to link_to
-    #
-    def add_current_user_to_menu(menu, priority = 10, html_options = {})
-      if current_user_method
-        menu.add id: 'current_user', priority: priority, html_options: html_options,
-          label: -> { display_name current_active_admin_user },
-          url:   -> { auto_url_for(current_active_admin_user) },
-          if:    :current_active_admin_user?
-      end
-    end
-
-    protected
-
-    def build_menu_collection
-      @menus = MenuCollection.new
-
-      @menus.on_build do
-        build_default_utility_nav
-
-        resources.each do |resource|
-          resource.add_to_menu(@menus)
-        end
-      end
-    end
-
-    # Builds the default utility navigation in top right header with current user & logout button
-    def build_default_utility_nav
-      return if @menus.exists? :utility_navigation
-      @menus.menu :utility_navigation do |menu|
-        add_current_user_to_menu menu
-        add_logout_button_to_menu menu
-      end
-    end
-
-    # Either returns an existing Resource instance or builds a new one.
-    def find_or_build_resource(resource_class, options)
-      resources.add Resource.new(self, resource_class, options)
-    end
-
-    def build_page(name, options)
-      resources.add Page.new(self, name, options)
-    end
-
-    # TODO: replace `eval` with `Class.new`
-    def register_page_controller(config)
-      eval "class ::#{config.controller_name} < ActiveAdmin::PageController; end"
-      config.controller.active_admin_config = config
-    end
-
-    def unload_resources!
-      resources.each do |resource|
-        parent = (module_name || 'Object').constantize
-        name   = resource.controller_name.split('::').last
-        parent.send(:remove_const, name) if parent.const_defined? name
-
-        # Remove circular references
-        resource.controller.active_admin_config = nil
-        if resource.is_a?(Resource) && resource.dsl
-          resource.dsl.run_registration_block { @config = nil }
-        end
-      end
-      @resources = ResourceCollection.new
-    end
-
-    # Creates a ruby module to namespace all the classes in if required
-    def register_module
-      unless Object.const_defined? module_name
-        Object.const_set module_name, Module.new
-      end
-    end
-
-    # TODO replace `eval` with `Class.new`
-    def register_resource_controller(config)
-      eval "class ::#{config.controller_name} < ActiveAdmin::ResourceController; end"
-      config.controller.active_admin_config = config
-    end
-
-    def parse_registration_block(config, resource_class, &block)
-      config.dsl = ResourceDSL.new(config, resource_class)
-      config.dsl.run_registration_block(&block)
-    end
-
-    def parse_page_registration_block(config, &block)
-      PageDSL.new(config).run_registration_block(&block)
-    end
-
-    class Store
-      include Enumerable
-      delegate :[], :[]=, :empty?, to: :@namespaces
-
-      def initialize
-        @namespaces = {}
-      end
-
-      def each(&block)
-        @namespaces.values.each(&block)
-      end
-
-      def names
-        @namespaces.keys
-      end
-    end
-  end
-end