activeadmin-searchable_select 1.0.0

data/bin/rspec

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/gemfiles/rails_4.2_active_admin_1.0.0.pre4.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.2"
+gem "activeadmin", "1.0.0.pre4"
+gem "jquery-ui-rails", "~> 5.0"
+
+gemspec path: "../"

data/gemfiles/rails_5.1_active_admin_1.0.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 5.1"
+gem "activeadmin", "~> 1.0"
+
+gemspec path: "../"

data/gemfiles/rails_5.1_active_admin_1.1.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 5.1"
+gem "activeadmin", "~> 1.1"
+
+gemspec path: "../"

data/lib/activeadmin-searchable_select.rb

@@ -0,0 +1,6 @@
+# rubocop:disable Style/FileName
+
+require 'activeadmin/searchable_select'
+
+require 'activeadmin/inputs/filters/searchable_select_input'
+require 'activeadmin/inputs/searchable_select_input'

data/lib/activeadmin/inputs/filters/searchable_select_input.rb

@@ -0,0 +1,13 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      # Searchable select input type for ActiveAdmin filters.
+      #
+      # @see ActiveAdmin::SearchableSelect::SelectInputExtension
+      #   SelectInputExtension for list of available options.
+      class SearchableSelectInput < SelectInput
+        include SearchableSelect::SelectInputExtension
+      end
+    end
+  end
+end

data/lib/activeadmin/inputs/searchable_select_input.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module Inputs
+    # Searchable select input type for ActiveAdmin filters.
+    #
+    # @see ActiveAdmin::SearchableSelect::SelectInputExtension
+    #   SelectInputExtension for list of available options.
+    class SearchableSelectInput < Formtastic::Inputs::SelectInput
+      include SearchableSelect::SelectInputExtension
+    end
+  end
+end

data/lib/activeadmin/searchable_select.rb

@@ -0,0 +1,20 @@
+require 'activeadmin/searchable_select/engine'
+require 'activeadmin/searchable_select/option_collection'
+require 'activeadmin/searchable_select/resource_extension'
+require 'activeadmin/searchable_select/resource_dsl_extension'
+require 'activeadmin/searchable_select/select_input_extension'
+require 'activeadmin/searchable_select/version'
+
+ActiveAdmin::Resource.send :include, ActiveAdmin::SearchableSelect::ResourceExtension
+ActiveAdmin::ResourceDSL.send :include, ActiveAdmin::SearchableSelect::ResourceDSLExtension
+
+module ActiveAdmin
+  # Global settings for searchable selects
+  module SearchableSelect
+    # Statically render all options into searchable selects with
+    # `ajax` option set to true. This can be used to ease ui driven
+    # integration testing.
+    mattr_accessor :inline_ajax_options
+    self.inline_ajax_options = false
+  end
+end

data/lib/activeadmin/searchable_select/engine.rb

@@ -0,0 +1,11 @@
+require 'active_admin'
+require 'select2-rails'
+
+module ActiveAdmin
+  module SearchableSelect
+    # @api private
+    class Engine < ::Rails::Engine
+      engine_name 'activeadmin_searchable_select'
+    end
+  end
+end

data/lib/activeadmin/searchable_select/option_collection.rb

@@ -0,0 +1,103 @@
+module ActiveAdmin
+  module SearchableSelect
+    # @api private
+    class OptionCollection
+      def initialize(name, options)
+        @name = name
+        @scope = extract_scope_option(options)
+        @display_text = extract_display_text_option(options)
+        @filter = extract_filter_option(options)
+        @per_page = options.fetch(:per_page, 10)
+      end
+
+      def scope(template, params)
+        case @scope
+        when Proc
+          if @scope.arity.zero?
+            template.instance_exec(&@scope)
+          else
+            template.instance_exec(params, &@scope)
+          end
+        else
+          @scope
+        end
+      end
+
+      def display_text(record)
+        @display_text.call(record)
+      end
+
+      def collection_action_name
+        "#{@name}_options"
+      end
+
+      def as_json(template, params)
+        records, more = fetch_records(template, params)
+
+        results = records.map do |record|
+          {
+            id: record.id,
+            text: display_text(record)
+          }
+        end
+
+        { results: results, pagination: { more: more } }
+      end
+
+      private
+
+      attr_reader :per_page
+
+      def fetch_records(template, params)
+        paginate(filter(scope(template, params), params[:term]),
+                 params[:page])
+      end
+
+      def filter(scope, term)
+        term ? @filter.call(term, scope) : scope
+      end
+
+      def paginate(scope, page_index)
+        page_index = page_index.to_i
+
+        records = scope.limit(per_page + 1).offset(page_index * per_page).to_a
+
+        [
+          records.slice(0, per_page),
+          records.size > per_page
+        ]
+      end
+
+      def extract_scope_option(options)
+        options.fetch(:scope) do
+          raise('Missing option: scope. ' \
+                'Pass the collection of items to render options for.')
+        end
+      end
+
+      def extract_display_text_option(options)
+        options.fetch(:display_text) do
+          text_attribute = options.fetch(:text_attribute) do
+            raise('Missing option: display_text or text_attribute. ' \
+                  'Either pass a proc to determine the display text for a record ' \
+                  'or set the text_attribute option.')
+          end
+
+          ->(record) { record.send(text_attribute) }
+        end
+      end
+
+      def extract_filter_option(options)
+        options.fetch(:filter) do
+          text_attribute = options.fetch(:text_attribute) do
+            raise('Missing option: filter or text_attribute. ' \
+                  'Either pass a proc which filters the scope according to a given ' \
+                  'or set the text_attribute option to apply a default Ransack filter.')
+          end
+
+          ->(term, scope) { scope.ransack("#{text_attribute}_cont" => term).result }
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/searchable_select/resource_dsl_extension.rb

@@ -0,0 +1,39 @@
+module ActiveAdmin
+  module SearchableSelect
+    # Mixin for ActiveAdmin resource DSL
+    module ResourceDSLExtension
+      # Define a collection action to serve options JSON data for
+      # searchable selects.
+      #
+      # @param scope [ActiveRecord::Relation, Proc] Either a
+      #   collection of records to create options for or a proc
+      #   returning such a collection. Procs are evaluated in the
+      #   context of the collection action defined by this
+      #   method. Procs can optionally take a single `params` argument
+      #   containing data defined under the `params` key of the
+      #   input's `ajax` option. Required.
+      #
+      # @param text_attribute [Symbol] Name of attribute to use as
+      #   display name and to filter by search term.
+      #
+      # @param display_text [Proc] Takes the record as
+      #   parameter. Required if `text_attribute` is not present.
+      #
+      # @param filter [Proc] Takes the search term and an Active
+      #   Record scope as parameters and needs to return a scope of
+      #   filtered records. Required if `text_attribute` is not
+      #   present.
+      #
+      # @param name [Symbol] Optional collection name if helper is
+      #   used multiple times within one resource.
+      def searchable_select_options(name: :all, **options)
+        option_collection = OptionCollection.new(name, options)
+        config.searchable_select_option_collections[name] = option_collection
+
+        collection_action(option_collection.collection_action_name) do
+          render(json: option_collection.as_json(self, params))
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/searchable_select/resource_extension.rb

@@ -0,0 +1,10 @@
+module ActiveAdmin
+  module SearchableSelect
+    # @api private
+    module ResourceExtension
+      def searchable_select_option_collections
+        @searchable_select_option_collections ||= {}
+      end
+    end
+  end
+end

data/lib/activeadmin/searchable_select/select_input_extension.rb

@@ -0,0 +1,130 @@
+module ActiveAdmin
+  module SearchableSelect
+    # Mixin for searchable select inputs.
+    #
+    # Supports the same options as inputs of type `:select`.
+    #
+    # Adds support for an `ajax` option to fetch options data from a
+    # JSON endpoint. Pass either `true` to use defaults or a hash
+    # containing some of the following options:
+    #
+    # - `resource`: ActiveRecord model class of ActiveAdmin resource
+    #    which provides the collection action to fetch options
+    #    from. By default the resource is auto detected via the name
+    #    of the input attribute.
+    #
+    # - `collection_name`: Name passed to the
+    #   `searchable_select_options` method that defines the collection
+    #   action to fetch options from.
+    #
+    # - `params`: Hash of query parameters that shall be passed to the
+    #   options endpoint.
+    #
+    # If the `ajax` option is present, the `collection` option is
+    # ignored.
+    module SelectInputExtension
+      # @api private
+      def input_html_options
+        options = super
+        options[:class] = [options[:class], 'searchable-select-input'].compact.join(' ')
+        options.merge('data-ajax-url' => ajax_url)
+      end
+
+      # @api private
+      def collection_from_options
+        return super unless options[:ajax]
+
+        if SearchableSelect.inline_ajax_options
+          all_options_collection
+        else
+          selected_value_collection
+        end
+      end
+
+      private
+
+      def ajax_url
+        return unless options[:ajax]
+        template.polymorphic_path([:admin, ajax_resource_class],
+                                  action: option_collection.collection_action_name,
+                                  **ajax_params)
+      end
+
+      def all_options_collection
+        option_collection_scope.all.map do |record|
+          option_for_record(record)
+        end
+      end
+
+      def selected_value_collection
+        [selected_value_option].compact
+      end
+
+      def selected_value_option
+        option_for_record(selected_record) if selected_record
+      end
+
+      def option_for_record(record)
+        [option_collection.display_text(record), record.id]
+      end
+
+      def selected_record
+        @selected_record ||=
+          selected_value && option_collection_scope.find_by_id(selected_value)
+      end
+
+      def selected_value
+        @object.send(input_name) if @object
+      end
+
+      def option_collection_scope
+        option_collection.scope(template, ajax_params)
+      end
+
+      def option_collection
+        ajax_resource
+          .searchable_select_option_collections
+          .fetch(ajax_option_collection_name) do
+          raise("No option collection named '#{ajax_option_collection_name}' " \
+                "defined in '#{ajax_resource_class.name}' admin.")
+        end
+      end
+
+      def ajax_resource
+        @ajax_resource ||=
+          template.active_admin_namespace.resource_for(ajax_resource_class) ||
+          raise("No admin found for '#{ajax_resource_class.name}' to fetch " \
+                'options for searchable select input from.')
+      end
+
+      def ajax_resource_class
+        ajax_options.fetch(:resource) do
+          raise_cannot_auto_detect_resource unless reflection
+          reflection.klass
+        end
+      end
+
+      def raise_cannot_auto_detect_resource
+        raise('Cannot auto detect resource to fetch options for searchable select input from. ' \
+              "Explicitly pass class of an ActiveAdmin resource:\n\n" \
+              "  f.input(:custom_category,\n" \
+              "          type: :searchable_select,\n" \
+              "          ajax: {\n" \
+              "            resource: Category\n" \
+              "          })\n")
+      end
+
+      def ajax_option_collection_name
+        ajax_options.fetch(:collection_name, :all)
+      end
+
+      def ajax_params
+        ajax_options.fetch(:params, {})
+      end
+
+      def ajax_options
+        options[:ajax] == true ? {} : options[:ajax]
+      end
+    end
+  end
+end

data/lib/activeadmin/searchable_select/version.rb

@@ -0,0 +1,5 @@
+module ActiveAdmin
+  module SearchableSelect
+    VERSION = '1.0.0'.freeze
+  end
+end

data/spec/features/ajax_params_spec.rb

@@ -0,0 +1,53 @@
+require 'rails_helper'
+
+require 'support/models'
+require 'support/capybara'
+require 'support/active_admin_helpers'
+
+RSpec.describe 'ajax params', type: :request do
+  before(:each) do
+    ActiveAdminHelpers.setup do
+      ActiveAdmin.register(Category) do
+        searchable_select_options(scope: lambda do |params|
+                                           Category.where(created_by_id: params[:created_by])
+                                         end,
+                                  text_attribute: :name)
+      end
+
+      ActiveAdmin.register(Post) do
+        form do |f|
+          f.input(:category,
+                  as: :searchable_select,
+                  ajax: {
+                    params: {
+                      created_by: current_user.id
+                    }
+                  })
+        end
+      end
+    end
+  end
+
+  it 'passes parameters when rendering selected item' do
+    user = User.create
+    category = Category.create(name: 'Travel', created_by: user)
+    post = Post.create(category: category)
+
+    ApplicationController.current_user = user
+    get "/admin/posts/#{post.id}/edit"
+
+    expect(response.body).to have_selector('.searchable-select-input option[selected]',
+                                           text: 'Travel')
+  end
+
+  it 'includes parameters in ajax url' do
+    user = User.create
+
+    ApplicationController.current_user = user
+    get '/admin/posts/new'
+
+    url_matcher = "?created_by=#{user.id}"
+    expect(response.body).to have_selector('.searchable-select-input' \
+                                           "[data-ajax-url*='#{url_matcher}']")
+  end
+end