advanced_select 0.1.0

data/app/views/advanced_select/_select.html.erb

@@ -0,0 +1,74 @@
+<div class="<%= advanced_select_class(class_map, :root) %>"
+     data-controller="advanced-select"
+     data-advanced-select-url-value="<%= options_url %>"
+     data-advanced-select-target-id-value="<%= target_id %>"
+     data-advanced-select-name-value="<%= name %>"
+     data-advanced-select-input-id-value="<%= id %>"
+     data-advanced-select-placeholder-value="<%= placeholder %>"
+     data-advanced-select-loading-text-value="<%= t("shared.advanced_select.loading") %>"
+     data-advanced-select-error-text-value="<%= t("shared.advanced_select.error") %>"
+     data-advanced-select-dependent-fields-value="<%= dependent_fields.to_json %>"
+     data-advanced-select-multiple-value="<%= multiple %>"
+     data-advanced-select-searchable-value="<%= searchable %>"
+     data-advanced-select-add-mode-value="<%= add_mode %>"
+     data-advanced-select-placeholder-class="<%= advanced_select_class(class_map, :placeholder) %>"
+     data-advanced-select-value-class="<%= advanced_select_class(class_map, :value) %>"
+     data-advanced-select-token-class="<%= advanced_select_class(class_map, :token) %>"
+     data-advanced-select-loading-class="<%= advanced_select_class(class_map, :loading) %>"
+     data-advanced-select-error-class="<%= advanced_select_class(class_map, :error) %>"
+     data-advanced-select-option-active-class="<%= advanced_select_state_class(class_map, :option_active) %>"
+     data-advanced-select-add-option-active-class="<%= advanced_select_state_class(class_map, :add_option_active) %>"
+     data-advanced-select-option-selected-class="<%= advanced_select_state_class(class_map, :option_selected) %>"
+     data-advanced-select-selected-value="<%= advanced_select_selected_value(selected_options) %>">
+  <div data-advanced-select-target="hiddenFields">
+    <% if multiple %>
+      <% selected_options.each do |option| %>
+        <%= hidden_field_tag name, option.fetch(:value, option.fetch(:id)) %>
+      <% end %>
+    <% else %>
+      <%= hidden_field_tag name, selected_options.first&.fetch(:value, selected_options.first&.fetch(:id)), id: id %>
+    <% end %>
+  </div>
+
+  <button type="button"
+          id="<%= "#{id}_trigger" %>"
+          class="<%= advanced_select_class(class_map, :trigger) %>"
+          aria-haspopup="listbox"
+          aria-expanded="false"
+          aria-controls="<%= "#{id}_dropdown" %>"
+          data-advanced-select-target="trigger"
+          data-action="advanced-select#toggle keydown->advanced-select#keydown">
+    <span id="<%= "#{id}_summary" %>" class="<%= advanced_select_class(class_map, :summary) %>" data-advanced-select-target="summary">
+      <%= render partial: "advanced_select/summary", locals: { selected_options: selected_options, multiple: multiple, placeholder: placeholder, class_map: class_map } %>
+    </span>
+    <span id="<%= "#{id}_caret" %>" class="<%= [advanced_select_class(class_map, :caret), ("hidden" if selected_options.any?)].compact.join(" ") %>" data-advanced-select-target="caret">&#8964;</span>
+    <span id="<%= "#{id}_clear" %>" class="<%= [advanced_select_class(class_map, :clear), ("hidden" if selected_options.empty?)].compact.join(" ") %>" data-advanced-select-target="clear" data-action="click->advanced-select#clear">&times;</span>
+  </button>
+
+  <div id="<%= "#{id}_dropdown" %>"
+       class="<%= [advanced_select_class(class_map, :dropdown), "hidden"].join(" ") %>"
+       data-advanced-select-target="dropdown">
+    <% if searchable %>
+      <%= tag.input type: "search",
+                    id: "#{id}_search",
+                    autocomplete: "off",
+                    placeholder: placeholder,
+                    class: advanced_select_class(class_map, :search),
+                    data: {
+                      advanced_select_target: "search",
+                      action: "input->advanced-select#search keydown->advanced-select#keydown"
+                    } %>
+    <% end %>
+
+    <%= render partial: "advanced_select/options", locals: {
+      target_id: target_id,
+      selected_options: selected_options,
+      options: advanced_select_options_for_render(options, selected_options, searchable),
+      multiple: multiple,
+      add_mode: add_mode,
+      query: nil,
+      option_content_partial: option_content_partial,
+      class_map: class_map
+    } %>
+  </div>
+</div>

data/app/views/advanced_select/_summary.html.erb

@@ -0,0 +1,14 @@
+<% if selected_options.any? %>
+  <% if multiple %>
+    <% selected_options.first(2).each do |option| %>
+      <span class="<%= advanced_select_class(class_map, :token) %>"><%= option.fetch(:display_label) %></span>
+    <% end %>
+    <% if selected_options.size > 2 %>
+      <span class="<%= advanced_select_class(class_map, :token) %>"><%= "& +#{selected_options.size - 2}" %></span>
+    <% end %>
+  <% else %>
+    <span class="<%= advanced_select_class(class_map, :value) %>"><%= selected_options.first.fetch(:display_label) %></span>
+  <% end %>
+<% else %>
+  <span class="<%= advanced_select_class(class_map, :placeholder) %>"><%= placeholder %></span>
+<% end %>

data/config/locales/en.yml

@@ -0,0 +1,7 @@
+en:
+  shared:
+    advanced_select:
+      add_option: "Add %{query}"
+      empty: "No options found"
+      error: "Options could not be loaded"
+      loading: "Loading..."

data/config/locales/tr.yml

@@ -0,0 +1,7 @@
+tr:
+  shared:
+    advanced_select:
+      add_option: "%{query} ekle"
+      empty: "Seçenek bulunamadı"
+      error: "Seçenekler yüklenemedi"
+      loading: "Yükleniyor..."

data/lib/advanced_select/class_map.rb

@@ -0,0 +1,55 @@
+module AdvancedSelect
+  class ClassMap
+    DEFAULTS = {
+      root: "ui-advanced-select",
+      trigger: "ui-advanced-select-trigger",
+      summary: "ui-advanced-select-summary",
+      placeholder: "ui-advanced-select-placeholder",
+      value: "ui-advanced-select-value",
+      token: "ui-advanced-select-token",
+      caret: "ui-advanced-select-caret",
+      clear: "ui-advanced-select-clear",
+      dropdown: "ui-advanced-select-dropdown",
+      search: "ui-advanced-select-search",
+      options: "ui-advanced-select-options",
+      option: "ui-advanced-select-option",
+      option_active: "ui-advanced-select-option-active",
+      option_selected: "",
+      option_check: "ui-advanced-select-option-check",
+      option_content: "ui-advanced-select-option-content",
+      option_description: "ui-advanced-select-option-description",
+      group_label: "ui-advanced-select-group-label",
+      add_option: "ui-advanced-select-add-option",
+      add_option_active: "",
+      empty: "ui-advanced-select-empty",
+      loading: "ui-advanced-select-loading",
+      error: "ui-advanced-select-error"
+    }.freeze
+
+    def initialize(classes = {}, append_classes = {})
+      @classes = normalize(classes)
+      @append_classes = normalize(append_classes)
+    end
+
+    def class_name(*keys)
+      keys.compact.map { |key| class_for(key.to_sym) }.compact.reject(&:empty?).join(" ")
+    end
+
+    def state_class(key)
+      class_name(key)
+    end
+
+    private
+
+    def normalize(classes)
+      classes.to_h.each_with_object({}) do |(key, value), normalized|
+        class_name = value.to_s.squish
+        normalized[key.to_sym] = class_name if class_name.present?
+      end
+    end
+
+    def class_for(key)
+      [@classes.fetch(key) { DEFAULTS[key] }, @append_classes[key]].compact.reject(&:empty?).join(" ")
+    end
+  end
+end

data/lib/advanced_select/engine.rb

@@ -0,0 +1,28 @@
+module AdvancedSelect
+  class Engine < ::Rails::Engine
+    initializer "advanced_select.helper" do
+      ActiveSupport.on_load(:action_view) do
+        include AdvancedSelect::Helper
+      end
+    end
+
+    initializer "advanced_select.assets" do |app|
+      if app.config.respond_to?(:assets)
+        javascript_path = root.join("app/javascript")
+        controller_asset = "advanced_select/advanced_select_controller.js"
+
+        unless app.config.assets.paths.map(&:to_s).include?(javascript_path.to_s)
+          app.config.assets.paths << javascript_path
+        end
+
+        unless app.config.assets.precompile.include?(controller_asset)
+          app.config.assets.precompile << controller_asset
+        end
+      end
+    end
+
+    rake_tasks do
+      load root.join("lib/tasks/advanced_select/tasks.rake")
+    end
+  end
+end

data/lib/advanced_select/helper.rb

@@ -0,0 +1,153 @@
+module AdvancedSelect
+  module Helper
+    def advanced_select_tag(name, id:, selected:, options:, placeholder:, options_url: nil, multiple: false, searchable: true, add_mode: false, dependent_fields: {}, option_content_partial: nil, classes: {}, append_classes: {})
+      selected_options = advanced_select_selected_options(selected)
+      class_map = advanced_select_class_map(classes, append_classes)
+
+      render partial: "advanced_select/select", locals: {
+        name: name,
+        id: id,
+        options_url: options_url,
+        selected_options: selected_options,
+        options: options,
+        placeholder: placeholder,
+        multiple: multiple,
+        searchable: searchable && options_url.present?,
+        add_mode: add_mode,
+        dependent_fields: dependent_fields,
+        target_id: "#{id}_options",
+        option_content_partial: option_content_partial,
+        class_map: class_map
+      }
+    end
+
+    def advanced_select_options_tag(target_id:, selected:, options:, multiple: false, add_mode: false, query: nil, option_content_partial: nil, classes: {}, append_classes: {})
+      render partial: "advanced_select/options", locals: {
+        target_id: target_id,
+        selected_options: advanced_select_selected_options(selected),
+        options: options,
+        multiple: multiple,
+        add_mode: add_mode,
+        query: query,
+        option_content_partial: option_content_partial,
+        class_map: advanced_select_class_map(classes, append_classes)
+      }
+    end
+
+    def advanced_select_class(class_map, *keys)
+      class_map.class_name(*keys)
+    end
+
+    def advanced_select_state_class(class_map, key)
+      class_map.state_class(key)
+    end
+
+    def advanced_select_selected_options(selected)
+      advanced_select_array(selected).map do |option|
+        {
+          id: option.fetch(:id).to_s,
+          value: advanced_select_option_value(option),
+          label: advanced_select_option_label(option),
+          display_label: advanced_select_option_display_label(option)
+        }
+      end
+    end
+
+    def advanced_select_selected_value(selected_options)
+      selected_options.map do |option|
+        option.merge(displayLabel: option.fetch(:display_label))
+      end.to_json
+    end
+
+    def advanced_select_options_for_render(options, selected_options, searchable)
+      searchable ? selected_options.presence || options : options
+    end
+
+    def advanced_select_add_option?(options, selected_options, add_mode, query)
+      return false unless add_mode && query.present?
+
+      query_label = advanced_select_normalized_label(query)
+      advanced_select_matched_labels(options, selected_options).none? do |label|
+        advanced_select_normalized_label(label) == query_label
+      end
+    end
+
+    def advanced_select_option_groups(options)
+      options.map do |option|
+        if option.key?(:options)
+          { label: option.fetch(:label), options: option.fetch(:options) }
+        else
+          { label: nil, options: [option] }
+        end
+      end
+    end
+
+    def advanced_select_option_selected?(option, selected_options)
+      selected_options.any? { |selected_option| selected_option.fetch(:id).to_s == option.fetch(:id).to_s }
+    end
+
+    def advanced_select_options_empty?(options)
+      advanced_select_flat_options(options).empty?
+    end
+
+    def advanced_select_option_label(option)
+      option.fetch(:label, option.fetch(:display_label, option.fetch(:value, option.fetch(:id)))).to_s
+    end
+
+    def advanced_select_option_value(option)
+      option.fetch(:value, option.fetch(:id)).to_s
+    end
+
+    def advanced_select_option_display_label(option)
+      option.fetch(:display_label, advanced_select_display_label(advanced_select_option_label(option))).to_s
+    end
+
+    def advanced_select_option_description(option)
+      option[:description].to_s
+    end
+
+    def advanced_select_display_label(label)
+      label.to_s.split(" > ").last
+    end
+
+    def advanced_select_array(value)
+      case value
+      when nil
+        []
+      when Array
+        value.compact
+      else
+        [value]
+      end
+    end
+
+    def advanced_select_matched_labels(options, selected_options)
+      option_labels = advanced_select_flat_options(options).flat_map do |option|
+        label = advanced_select_option_label(option)
+        [label, advanced_select_option_display_label(option)]
+      end
+
+      selected_labels = selected_options.flat_map do |option|
+        [advanced_select_option_label(option), advanced_select_option_display_label(option)]
+      end
+
+      option_labels + selected_labels
+    end
+
+    def advanced_select_normalized_label(label)
+      I18n.transliterate(label.to_s.squish).downcase
+    end
+
+    def advanced_select_flat_options(options)
+      options.flat_map { |option| option.key?(:options) ? option.fetch(:options) : option }
+    end
+
+    def advanced_select_class_map(classes, append_classes = {})
+      if classes.is_a?(AdvancedSelect::ClassMap)
+        classes
+      else
+        AdvancedSelect::ClassMap.new(classes, append_classes)
+      end
+    end
+  end
+end

data/lib/advanced_select/version.rb

@@ -0,0 +1,3 @@
+module AdvancedSelect
+  VERSION = "0.1.0"
+end

data/lib/advanced_select.rb

@@ -0,0 +1,8 @@
+require "advanced_select/version"
+require "advanced_select/class_map"
+require "advanced_select/engine"
+require "advanced_select/helper"
+
+module AdvancedSelect
+  # Your code goes here...
+end

data/lib/generators/advanced_select/install/install_generator.rb

@@ -0,0 +1,161 @@
+module AdvancedSelect
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      VALID_SETUPS = %w[importmap jsbundling].freeze
+
+      source_root File.expand_path("templates", __dir__)
+      class_option :setup,
+                   type: :string,
+                   default: "importmap",
+                   desc: "Host app setup: importmap or jsbundling"
+
+      def validate_options
+        return if VALID_SETUPS.include?(setup)
+
+        raise Thor::Error, "Invalid --setup=#{setup.inspect}. Expected one of: #{VALID_SETUPS.join(', ')}."
+      end
+
+      def install_stimulus_controller
+        case setup
+        when "importmap"
+          pin_importmap_controller
+        when "jsbundling"
+          copy_file "advanced_select_controller.js", "app/javascript/controllers/advanced_select_controller.js"
+        end
+      end
+
+      def install_stylesheet
+        if setup == "jsbundling"
+          copy_file "advanced_select.css", "app/assets/stylesheets/advanced_select.css"
+        end
+      end
+
+      def register_stimulus_controller
+        case setup
+        when "importmap"
+          register_importmap_controller
+        when "jsbundling"
+          register_manifest_controller
+        end
+      end
+
+      def import_stylesheet
+        case setup
+        when "importmap"
+          import_application_stylesheet
+        when "jsbundling"
+          append_postcss_import
+        end
+      end
+
+      def show_next_steps
+        say "AdvancedSelect installed.", :green
+        say "Setup: #{setup}"
+        say "Host apps still own routes, controllers, queries, and Turbo Stream option endpoints."
+      end
+
+      private
+
+      def pin_importmap_controller
+        path = "config/importmap.rb"
+        unless File.exist?(target_path(path))
+          say "Could not find #{path}; pin advanced_select/advanced_select_controller manually."
+          return
+        end
+        return if file_contains?(path, 'pin "advanced_select/advanced_select_controller"')
+
+        append_to_file path, <<~RUBY
+          pin "advanced_select/advanced_select_controller", to: "advanced_select/advanced_select_controller.js"
+        RUBY
+      end
+
+      def register_importmap_controller
+        path = "app/javascript/controllers/index.js"
+        unless File.exist?(target_path(path))
+          raise Thor::Error, "Could not find #{path} for --setup=importmap."
+        end
+        return if file_contains?(path, "advanced-select")
+
+        append_to_file path, <<~JS
+
+          import AdvancedSelectController from "advanced_select/advanced_select_controller"
+          application.register("advanced-select", AdvancedSelectController)
+        JS
+      end
+
+      def register_manifest_controller
+        unless File.exist?(target_path("app/javascript/controllers/index.js"))
+          raise Thor::Error, "Could not find app/javascript/controllers/index.js for --setup=jsbundling."
+        end
+        return if file_contains?("app/javascript/controllers/index.js", "advanced-select")
+
+        append_to_file "app/javascript/controllers/index.js", <<~JS
+
+          import AdvancedSelectController from "./advanced_select_controller"
+          application.register("advanced-select", AdvancedSelectController)
+        JS
+      end
+
+      def append_postcss_import
+        path = "app/assets/stylesheets/application.postcss.css"
+        unless File.exist?(target_path(path))
+          raise Thor::Error, "Could not find #{path} for --setup=jsbundling."
+        end
+        return if file_contains?(path, "advanced_select.css")
+
+        insert_css_import(path)
+      end
+
+      def import_application_stylesheet
+        path = "app/assets/stylesheets/application.css"
+        unless File.exist?(target_path(path))
+          say "Could not find #{path}; require advanced_select/advanced_select through your host app stylesheet entrypoint."
+          return
+        end
+
+        unless sprockets_manifest?(path) && normalize_sprockets_requires(path)
+          say "Could not safely patch #{path}; require advanced_select/advanced_select through your host app stylesheet entrypoint."
+        end
+      end
+
+      def file_contains?(path, content)
+        File.exist?(target_path(path)) && File.read(target_path(path)).include?(content)
+      end
+
+      def sprockets_manifest?(path)
+        content = File.read(target_path(path))
+        content.include?("/*") && content.include?("*/") && content.include?("*=")
+      end
+
+      def normalize_sprockets_requires(path)
+        lines = File.readlines(target_path(path))
+        lines.reject! { |line| line.match?(%r{^\s*\*=\s*require\s+advanced_select/advanced_select\s*$}) }
+
+        insert_at = lines.index { |line| line.match?(%r{^\s*\*=\s*require_tree\s+\.\s*$}) }
+        insert_at ||= lines.index { |line| line.match?(%r{^\s*\*=\s*require_self\s*$}) }
+        insert_at ||= lines.index { |line| line.strip == "*/" }
+        return false unless insert_at
+
+        lines.insert(insert_at, " *= require advanced_select/advanced_select\n")
+        File.write(target_path(path), lines.join)
+        true
+      end
+
+      def insert_css_import(path)
+        lines = File.readlines(target_path(path))
+        import_index = lines.rindex { |line| line.strip.start_with?("@import") }
+        lines.insert((import_index || -1) + 1, "@import \"advanced_select.css\";\n")
+
+        File.write(target_path(path), lines.join)
+      end
+
+      def setup
+        options[:setup].to_s
+      end
+
+      def target_path(path)
+        File.join(destination_root, path)
+      end
+    end
+  end
+end