rs-activeadmin-searchable_select 4.0.5

data/spec/internal/db/schema.rb

@@ -0,0 +1,63 @@
+ActiveRecord::Schema.define do
+  create_table(:active_admin_comments, force: true) do |t|
+    t.string :namespace
+    t.text   :body
+    t.string :resource_id,   null: false
+    t.string :resource_type, null: false
+    t.references :author, polymorphic: true
+    t.timestamps null: false
+  end
+
+  create_table(:categories, force: true) do |t|
+    t.string :name
+    t.text :description
+    t.belongs_to :created_by
+    t.timestamps
+  end
+
+  create_table(:posts, force: true) do |t|
+    t.string :title
+    t.text :body
+    t.belongs_to :category
+    t.belongs_to :user
+    t.boolean :published
+    t.timestamps
+  end
+
+  create_table(:rgb_colors, force: true) do |t|
+    t.string :code
+    t.text :description
+  end
+
+  create_table(:internal_tag_names, force: true) do |t|
+    t.string :name
+    t.text :description
+    t.integer :color_id
+  end
+
+  create_table(:option_types, force: true) do |t|
+    t.string :name
+  end
+
+  create_table(:option_values, force: true) do |t|
+    t.string :value
+    t.belongs_to :option_type
+  end
+
+  create_table(:products, force: true) do |t|
+    t.string :name
+    t.belongs_to :option_type
+  end
+
+  create_table(:variants, force: true) do |t|
+    t.integer :price
+    t.belongs_to :product
+    t.belongs_to :option_value
+  end
+
+  create_table(:users, force: true) do |t|
+    t.string :name
+    t.string :email
+    t.timestamps
+  end
+end

data/spec/internal/db/seeds.rb

@@ -0,0 +1,88 @@
+# Create sample users
+users = []
+10.times do |i|
+  users << User.create!(name: "User #{i + 1}")
+end
+
+# Create sample categories
+categories = []
+5.times do |i|
+  categories << Category.create!(
+    name: "Category #{i + 1}",
+    created_by: users.sample
+  )
+end
+
+# Create sample posts
+20.times do |i|
+  Post.create!(
+    title: "Post #{i + 1}",
+    category: categories.sample,
+    user: users.sample,
+    published: [true, false].sample
+  )
+end
+
+# Create RGB colors
+colors = [
+  { code: '#FF0000', description: 'Red' },
+  { code: '#00FF00', description: 'Green' },
+  { code: '#0000FF', description: 'Blue' },
+  { code: '#FFFF00', description: 'Yellow' },
+  { code: '#FF00FF', description: 'Magenta' },
+  { code: '#00FFFF', description: 'Cyan' },
+  { code: '#000000', description: 'Black' },
+  { code: '#FFFFFF', description: 'White' }
+]
+
+rgb_colors = colors.map { |color| RgbColor.create!(color) }
+
+# Create internal tag names
+10.times do |i|
+  InternalTagName.create!(
+    name: "Tag #{i + 1}",
+    description: "Description for tag #{i + 1}",
+    color: rgb_colors.sample
+  )
+end
+
+# Create option types and values
+option_types = []
+3.times do |i|
+  option_type = OptionType.create!(name: "Option Type #{i + 1}")
+  option_types << option_type
+
+  5.times do |j|
+    OptionValue.create!(
+      value: "Value #{j + 1} for #{option_type.name}",
+      option_type: option_type
+    )
+  end
+end
+
+# Create products and variants
+10.times do |i|
+  product = Product.create!(
+    name: "Product #{i + 1}",
+    option_type: option_types.sample
+  )
+
+  3.times do |j|
+    Variant.create!(
+      price: (10 + j) * 100,
+      product: product,
+      option_value: product.option_type&.option_values&.sample
+    )
+  end
+end
+
+puts 'Seed data created successfully!'
+puts "Created #{User.count} users"
+puts "Created #{Category.count} categories"
+puts "Created #{Post.count} posts"
+puts "Created #{RgbColor.count} RGB colors"
+puts "Created #{InternalTagName.count} internal tag names"
+puts "Created #{OptionType.count} option types"
+puts "Created #{OptionValue.count} option values"
+puts "Created #{Product.count} products"
+puts "Created #{Variant.count} variants"

data/spec/internal/esbuild.config.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+const esbuild = require('esbuild');
+const path = require('path');
+
+// Configuration for esbuild with proper module resolution
+const config = {
+  entryPoints: ['app/js/active_admin.js'],
+  bundle: true,
+  sourcemap: true,
+  format: 'iife',
+  outdir: 'app/assets/builds',
+  publicPath: '/assets',
+  inject: ['./inject-jquery.js']
+};
+
+// Check if we're in watch mode
+const watchMode = process.argv.includes('--watch');
+
+if (watchMode) {
+  // Start the build with watch mode
+  esbuild.context(config).then(ctx => {
+    ctx.watch();
+    console.log('Watching for changes...');
+  });
+} else {
+  // Single build
+  esbuild.build(config).then(() => {
+    console.log('Build completed');
+  }).catch(() => process.exit(1));
+}

data/spec/internal/inject-jquery.js

@@ -0,0 +1,4 @@
+// https://github.com/evanw/esbuild/issues/1681
+// This file injects jQuery as a global for all modules
+export { default as $ } from 'jquery/dist/jquery.js'
+export { default as jQuery } from 'jquery/dist/jquery.js'

data/spec/internal/log/.gitignore

@@ -0,0 +1 @@
+*.log

data/spec/internal/package/LICENSE.txt

@@ -0,0 +1,25 @@
+
+Copyright for portions of `codevise/activeadmin-searchable_select`
+held by Mark Fariburn, Praxitar Ltd, 2014 as part of
+`mfairburn/activeadmin-select2` which this project is based on. All
+other copyright for `codevise/activeadmin-searchable_select` held by
+Codevise Solutions Ltd, 2017.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/internal/package/README.md

@@ -0,0 +1,439 @@
+# ActiveAdmin Searchable Select
+
+[![Gem Version](https://badge.fury.io/rb/activeadmin-searchable_select.svg)](http://badge.fury.io/rb/activeadmin-searchable_select)
+[![NPM Version](https://badge.fury.io/js/@codevise%2Factiveadmin-searchable_select.svg)](https://badge.fury.io/js/@codevise%2Factiveadmin-searchable_select)
+[![npm](https://img.shields.io/npm/dm/@codevise/activeadmin-searchable_select)](https://www.npmjs.com/package/@codevise/activeadmin-searchable_select)
+[![Build Status](https://github.com/codevise/activeadmin-searchable_select/actions/workflows/tests.yml/badge.svg)](https://github.com/codevise/activeadmin-searchable_select/actions)
+
+Searchable select boxes (via [Select2](https://select2.org/)) for
+ActiveAdmin forms and filters. Extends the ActiveAdmin resource DSL to
+allow defining JSON endpoints to fetch options from asynchronously.
+
+## Installation
+
+Add `activeadmin-searchable_select` to your Gemfile:
+
+```ruby
+   gem 'activeadmin-searchable_select'
+```
+
+### ActiveAdmin 4.x (esbuild/importmap)
+
+ActiveAdmin 4 uses modern JavaScript bundlers. If you encounter "select2 is not a function" errors in production, see the [complete setup guide](docs/setup-active-admin.md).
+
+#### Quick Install with Generator
+
+```bash
+# For esbuild (recommended)
+rails generate active_admin:searchable_select:install
+
+# For importmap
+rails generate active_admin:searchable_select:install --bundler=importmap
+```
+
+#### Manual Setup for esbuild
+
+1. Install npm packages:
+```bash
+npm install @codevise/activeadmin-searchable_select jquery select2
+```
+
+2. In `app/javascript/active_admin.js`:
+```javascript
+import "@activeadmin/activeadmin";
+import $ from 'jquery';
+import select2 from 'select2';
+
+// Critical: Initialize select2 on jQuery (fixes production builds)
+select2($);
+window.$ = window.jQuery = $;
+
+import '@codevise/activeadmin-searchable_select';
+```
+
+3. Add Select2 CSS to your ActiveAdmin stylesheet:
+```css
+@import url('https://cdn.jsdelivr.net/npm/select2@4.1.0-rc.0/dist/css/select2.min.css');
+```
+
+### ActiveAdmin 3.x and older
+
+##### Using assets via Sprockets
+Import stylesheets and require javascripts:
+
+```scss
+// active_admin.css.scss
+@import "active_admin/searchable_select";
+```
+
+```coffee
+// active_admin.js
+//= require active_admin/searchable_select
+```
+
+##### Using assets via Webpacker
+
+Add to `package.json`:
+```json
+"dependencies": {
+  "@codevise/activeadmin-searchable_select": "^1.8.0"
+}
+```
+
+In `app/javascript/packs/active_admin.js`:
+```javascript
+import '@codevise/activeadmin-searchable_select';
+```
+
+In `app/javascript/stylesheets/active_admin.scss`:
+```css
+@import '@codevise/activeadmin-searchable_select';
+```
+
+## Usage
+
+### Making Select Boxes Searchable
+
+To add search functionality to a select box, use the
+`:searchable_select` input type:
+
+```ruby
+   ActiveAdmin.register Product do
+     form do |f|
+       f.input(:category, as: :searchable_select)
+     end
+   end
+```
+
+This also works for filters:
+
+```ruby
+   ActiveAdmin.register Product do
+     filter(:category, as: :searchable_select)
+   end
+```
+
+By default, you can only select one at a time for a filter. You can
+specify a multi-select with:
+
+```ruby
+   ActiveAdmin.register Product do
+     filter(:category, as: :searchable_select, multiple: true)
+   end
+```
+
+### Fetching Options via Ajax
+
+For large collections, rendering the whole set of options can be to
+expensive. Use the `ajax` option to fetch a set of matching options
+once the user begins to type:
+
+```ruby
+
+   ActiveAdmin.register Product do
+     filter(:category,
+            as: :searchable_select,
+            ajax: true)
+   end
+```
+
+If the input attribute corresponds to an ActiveAdmin resource, it is
+expected to provide the JSON endpoint that provides the options. Use
+the `searchable_select_options` method to define the required
+collection action:
+
+```ruby
+   ActiveAdmin.register Category do
+     searchable_select_options(scope: Category.all,
+                               text_attribute: :name)
+   end
+```
+
+By default, `scope` needs to be a Ransack enabled ActiveRecord
+collection proxy determining which options are available. The
+attribute given by `text_attribute` will be used to get a display name
+for each record. Via Ransack, it is also used to filter by search
+term. Limiting result set size is handled automatically.
+
+You can customize the display text:
+
+```ruby
+   ActiveAdmin.register Category do
+     searchable_select_options(scope: Category.all,
+                               text_attribute: :name,
+                               display_text: ->(record) { "Category: #{record.name}" } )
+   end
+```
+
+Note that `text_attribute` is still required to perform filtering via
+Ransack. You can pass the `filter` option, to specify your own
+filtering strategy:
+
+```ruby
+   ActiveAdmin.register Category do
+     searchable_select_options(scope: Category.all,
+                               text_attribute: :name,
+                               filter: lambda |term, scope|
+                                 scope.ransack(name_cont_all: term.split(' ')).result
+                               end)
+   end
+```
+
+`scope` can also be a lambda which is evaluated in the context of the
+collection action defined by the helper:
+
+```ruby
+   ActiveAdmin.register Category do
+     searchable_select_options(scope: -> { Category.allowed_for(current_user) },
+                               text_attribute: :name)
+   end
+```
+
+If the input attribute is set on the form's object, ajax based
+searchable selects will automatically render a single option to ensure
+the selected item is displayed correctly even before options have been
+loaded asynchronously.
+
+#### Specifying the Options Endpoint Resource
+
+If the resource that provides the options endpoint cannot be guessed
+based on the input attribute name, you can pass an object with a
+`resource` key as `ajax` option:
+
+```ruby
+   ActiveAdmin.register Product do
+     form do |f|
+       f.input(:additional_category,
+               as: :searchable_select,
+               ajax: { resource: Category })
+     end
+   end
+```
+
+#### Multiple Options Endpoints per Resource
+
+A single ActiveAdmin resource can define multiple options endpoints:
+
+```ruby
+   ActiveAdmin.register Category do
+     searchable_select_options(name: :favorites,
+                               scope: Category.favorites,
+                               text_attribute: :name)
+
+     searchable_select_options(name: :recent,
+                               scope: Category.recent,
+                               text_attribute: :name)
+   end
+```
+
+To specify which collection to use, pass an object with a
+`collection_name` key as `ajax` option:
+
+```ruby
+   ActiveAdmin.register Product do
+     form do |f|
+        f.input(:category,
+                as: :searchable_select,
+                ajax: { collection_name: :favorites })
+     end
+   end
+```
+
+#### Querying Multiple Attributes
+
+ActiveAdmin Searchable Select querying is performed by Ransack. As such, you can
+build your query in a way that it can query multiple attributes at once.
+
+```ruby
+   ActiveAdmin.register User do
+     searchable_select_options(scope: User.all,
+                               text_attribute: :username,
+                               filter: lambda do |term, scope|
+                                 scope.ransack(email_or_username_cont: term).result
+                               end)
+   end
+```
+
+In this example, the `all` scope will query `email OR username`.
+
+You can add the additional payload as dsl option:
+
+```ruby
+   ActiveAdmin.register Category do
+     searchable_select_options(scope: Category.all,
+                               text_attribute: :name,
+                               additional_payload: ->(record) { { foo: record.bar } } )
+   end
+```
+
+response example which uses additional_payload:
+
+```json
+{
+  "results": [{ "id": "1", "text": "Bicycles", "foo": "Bar" }],
+  "pagination": { "more": "false" }
+}
+```
+
+#### Passing Parameters
+
+You can pass additional parameters to the options endpoint:
+
+```ruby
+   ActiveAdmin.register Product do
+     form do |f|
+        f.input(:category,
+                as: :searchable_select,
+                ajax: {
+                  params: {
+                    some: 'value'
+                  }
+                })
+     end
+   end
+```
+
+The lambda passed as `scope` can receive those parameters as first
+argument:
+
+```ruby
+   ActiveAdmin.register Category do
+     searchable_select_options(scope: lambda do |params|
+                                 Category.find_all_by_some(params[:some])
+                               end,
+                               text_attribute: :name)
+   end
+```
+
+#### Path options for nested resources
+
+Example for the following setup:
+
+```ruby
+# Models
+class OptionType < ActiveRecord::Base; end
+
+class OptionValue < ActiveRecord::Base
+  belongs_to :option_type
+end
+
+class Product < ActiveRecord::Base
+  belongs_to :option_type
+  has_many :variants
+end
+
+class Variant < ActiveRecord::Base
+  belongs_to :product
+  belongs_to :option_value
+end
+
+# ActiveAdmin
+ActiveAdmin.register(OptionType)
+
+ActiveAdmin.register(Product)
+
+ActiveAdmin.register(OptionValue) do
+  belongs_to :option_type
+  searchable_select_options(scope: lambda do |params|
+                                     OptionValue.where(
+                                       option_type_id: params[:option_type_id]
+                                     )
+                                   end,
+                            text_attribute: :value)
+end
+```
+
+It is possible to pass path parameters for correctly generating URLs for nested resources fetching via `path_params`
+
+```ruby
+ActiveAdmin.register(Variant) do
+  belongs_to :product
+
+  form do |f|
+    ...
+    f.input(:option_value,
+            as: :searchable_select,
+            ajax: {
+              resource: OptionValue,
+              path_params: {
+                option_type_id: f.object.product.option_type_id
+              }
+            })
+    ...
+  end
+end
+```
+
+This will generate the path for fetching as `all_options_admin_option_type_option_values(option_type_id: f.object.product.option_type_id)` (e.g. `/admin/option_types/2/option_values/all_options`)
+
+#### Inlining Ajax Options in Feature Tests
+
+When writing UI driven feature specs (i.e. with Capybara),
+asynchronous loading of select options can increase test
+complexity. `activeadmin-searchable_select` provides an option to
+render all available options just like a normal select input while
+still exercsing the same code paths including `scope` and
+`text_attribute` handling.
+
+For example with RSpec/Capybara, simply set `inline_ajax_options` true
+for feature specs:
+
+```ruby
+  RSpec.configure do |config|
+    config.before(:each) do |example|
+      ActiveAdmin::SearchableSelect.inline_ajax_options = (example.metadata[:type] == :feature)
+    end
+  end
+
+```
+
+### Passing options to Select2
+
+It is possible to pass and define configuration options to Select2
+via `data-attributes` using nested (subkey) options.
+
+Attributes need to be added to the `input_html` option in the form input.
+For example you can tell Select2 how long to wait after a user
+has stopped typing before sending the request:
+
+```ruby
+   ...
+   f.input(:category,
+           as: :searchable_select,
+           ajax: true,
+           input_html: {
+             data: {
+               'ajax--delay' => 500
+             }
+           })
+   ...
+```
+
+
+## Development
+
+To run the tests install bundled gems and invoke RSpec:
+
+```
+$ bundle
+$ bundle exec rspec
+```
+
+The test suite can be run against different versions of Rails and
+Active Admin (see `Appraisals` file):
+
+```
+$ appraisal install
+$ appraisal rspec
+```
+
+Please make sure changes conform with the styleguide:
+
+```
+$ bundle exec rubocop
+```
+
+## Acknowledgements
+
+Based on
+[mfairburn/activeadmin-select2](https://github.com/mfairburn/activeadmin-select2).

data/spec/internal/package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@rocket-sensei/activeadmin-searchable_select",
+  "version": "4.0.2",
+  "description": "Use searchable selects based on Select2 in Active Admin forms and filters.",
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "style": "src/searchable_select.scss",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./css": "./src/searchable_select.css",
+    "./style": "./src/searchable_select.css",
+    "./scss": "./src/searchable_select.scss"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/glebtv/activeadmin-searchable_select.git"
+  },
+  "author": "Codevise Solutions Ltd <info@codevise.de>",
+  "license": "MIT",
+  "private": false,
+  "bugs": {
+    "url": "https://github.com/glebtv/activeadmin-searchable_select/issues"
+  },
+  "homepage": "https://github.com/glebtv/activeadmin-searchable_select#readme",
+  "keywords": [
+    "select2",
+    "active",
+    "admin",
+    "searchable",
+    "select",
+    "activeadmin",
+    "rails"
+  ],
+  "peerDependencies": {
+    "jquery": ">= 3.0, < 5",
+    "select2": "^4.0.0 || ^4.1.0-rc.0"
+  },
+  "files": [
+    "src/**/*"
+  ]
+}

data/spec/internal/package/src/index.js

@@ -0,0 +1 @@
+../../../../src/index.js

data/spec/internal/package/src/searchable_select/init.js

@@ -0,0 +1 @@
+../../../../../src/searchable_select/init.js