activeadmin_addons 1.4.0 → 1.8.2

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/inputs/filters/numeric_input.rb

@@ -1,12 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    module Filters
-      class NumericInput < ::Formtastic::Inputs::NumberInput
-        include Base
-        include Base::SearchMethodSelect
-
-        filter :equals, :greater_than, :less_than
-      end
-    end
-  end
-end

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

@@ -1,58 +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 + (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 "_#{reflection.association_primary_key}" if reflection_searchable?
-            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").distinct.pluck method
-        end
-
-        def reflection_searchable?
-          reflection && !reflection.polymorphic?
-        end
-
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/inputs/filters/string_input.rb

@@ -1,26 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    module Filters
-      class StringInput < ::Formtastic::Inputs::StringInput
-        include Base
-        include Base::SearchMethodSelect
-
-        filter :contains, :equals, :starts_with, :ends_with
-
-        # If the filter method includes a search condition, build a normal string search field.
-        # Else, build a search field with a companion dropdown to choose a search condition from.
-        def to_html
-          if seems_searchable?
-            input_wrapping do
-              label_html <<
-              builder.text_field(method, input_html_options)
-            end
-          else
-            super # SearchMethodSelect#to_html
-          end
-        end
-
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/inputs/filters/text_input.rb

@@ -1,25 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    module Filters
-      class TextInput < ::Formtastic::Inputs::TextInput
-        include Base
-        include Base::SearchMethodSelect
-
-        def input_html_options
-          {
-            cols: builder.default_text_area_width,
-            rows: builder.default_text_area_height
-          }.merge(super)
-        end
-
-        def to_html
-          input_wrapping do
-            label_html <<
-            builder.text_area(method, input_html_options)
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-require 'active_admin/localizers/resource_localizer'
-
-module ActiveAdmin
-  module Localizers
-    class << self
-      def resource(active_admin_config)
-        ResourceLocalizer.from_resource(active_admin_config)
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module ActiveAdmin
-  module Localizers
-    class ResourceLocalizer
-      class << self
-        def from_resource(resource_config)
-          new(resource_config.resource_name.i18n_key, resource_config.resource_label)
-        end
-
-        def translate(key, options)
-          new(options.delete(:model_name), options.delete(:model)).translate(key, options)
-        end
-        alias_method :t, :translate
-      end
-
-      def initialize(model_name, model = nil)
-        @model_name = model_name
-        @model = model || model_name.to_s.titleize
-      end
-
-      def translate(key, options = {})
-        scope = options.delete(:scope)
-        specific_key = array_to_key('resources', @model_name, scope, key)
-        defaults = [array_to_key(scope, key), key.to_s.titleize]
-        ::I18n.t specific_key, options.reverse_merge(model: @model, default: defaults, scope: 'active_admin')
-      end
-      alias_method :t, :translate
-
-      protected
-
-      def array_to_key(*arr)
-        arr.flatten.compact.join('.').to_sym
-      end
-    end
-  end
-end

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

@@ -1,102 +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
-
-      def items
-        @children.values
-      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.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/menu_collection.rb

@@ -1,91 +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.2.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/menu_item.rb

@@ -1,69 +0,0 @@
-module ActiveAdmin
-  class MenuItem
-    include Menu::MenuNode
-
-    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
-
-    attr_reader :label
-    attr_reader :url
-
-    # Don't display if the :if option passed says so
-    attr_reader :should_display
-  end
-end

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

@@ -1,266 +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
-    class << self
-      def setting(name, default)
-        Deprecation.warn "This method does not do anything and will be removed."
-      end
-    end
-
-    RegisterEvent = 'active_admin.namespace.register'.freeze
-
-    attr_reader :application, :resources, :menus
-
-    def initialize(application, name)
-      @application = application
-      @name = name.to_s.underscore
-      @resources = ResourceCollection.new
-      register_module unless root?
-      build_menu_collection
-    end
-
-    def name
-      @name.to_sym
-    end
-
-    def settings
-      @settings ||= SettingsNode.build(application.namespace_settings)
-    end
-
-    def respond_to_missing?(method, include_private = false)
-      settings.respond_to?(method) || super
-    end
-
-    def method_missing(method, *args)
-      settings.respond_to?(method) ? settings.send(method, *args) : super
-    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, &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
-      root? ? nil : @name.camelize
-    end
-
-    def route_prefix
-      root? ? nil : @name
-    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
-
-    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, false)
-
-        # 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, &block)
-      config.dsl = ResourceDSL.new(config)
-      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