easy-admin-rails 0.1.0

data/app/components/easy_admin/fields/form/has_many_component.rb

@@ -0,0 +1,416 @@
+module EasyAdmin
+  module Fields
+    module Form
+      class HasManyComponent < EasyAdmin::Fields::BaseComponent
+        def view_template
+          div(class: "mb-4") do
+            label(for: field_id, class: label_classes) do
+              plain field_label
+              if required?
+                span(class: "text-red-500 ml-1") { "*" }
+              end
+            end
+
+            div(
+              class: select_container_classes,
+              data: {
+                controller: "select-field",
+                select_field_multiple_value: multiple?.to_s,
+                select_field_placeholder_value: placeholder,
+                select_field_suggest_value: suggest_mode?.to_s,
+                select_field_suggest_url_value: suggest_mode? ? suggest_url : "",
+                field_name: "#{field_name.to_s.singularize}_ids"
+              }
+            ) do
+              render_multiple_select_container
+              render_select_dropdown
+              render_clear_button
+              render_hidden_inputs
+            end
+
+            if field[:help_text]
+              p(class: "mt-1 text-sm text-gray-500") { field[:help_text] }
+            end
+          end
+        end
+
+        private
+
+        def multiple?
+          true
+        end
+
+        def suggest_mode?
+          result = field[:suggest].present?
+          Rails.logger.debug "HasMany suggest_mode? #{field_name}: #{result}, suggest config: #{field[:suggest]}"
+          result
+        end
+
+        def suggest_url
+          return "" unless suggest_mode?
+
+          # Extract resource name from form object
+          resource_name = form.object.class.name.underscore.pluralize
+
+          # For has_many fields, use the association name
+          search_field_name = field_name
+
+          easy_admin_url_helpers.suggest_resource_path(resource_name, field: search_field_name)
+        end
+
+        def placeholder
+          field[:placeholder] || "Search #{field_label.downcase}..."
+        end
+
+        def label_classes
+          "block text-sm font-medium text-gray-700 mb-1"
+        end
+
+        def select_container_classes
+          base_classes = "relative"
+          classes = [base_classes]
+          classes << "select-multiple"
+          classes.join(" ")
+        end
+
+        def render_multiple_select_container
+          div(class: "relative border border-gray-300 rounded-md bg-white min-h-10 focus-within:ring-1 focus-within:ring-blue-500 focus-within:border-blue-500 transition-colors duration-200") do
+            div(class: "flex flex-wrap items-center gap-1 p-2 pr-8") do
+              # Selected items container - will be populated by Stimulus controller
+              div(class: "flex flex-wrap items-center gap-1", data: { select_field_target: "selectedItems" }) do
+                current_selected_values.each do |selected_value|
+                  render_selected_item(selected_value)
+                end
+              end
+
+              # Search input
+              input(
+                type: "text",
+                class: "flex-1 min-w-20 border-none outline-none text-sm placeholder-gray-400 bg-transparent",
+                placeholder: current_selected_values.empty? ? placeholder : "",
+                data: {
+                  select_field_target: "search",
+                  action: "input->select-field#filter keydown->select-field#handleKeydown focus->select-field#openDropdown"
+                }
+              )
+            end
+          end
+        end
+
+        def render_selected_item(selected_value)
+          span(
+            class: "selected-item inline-flex items-center px-2 py-1 text-xs bg-blue-100 text-blue-800 rounded cursor-pointer hover:bg-blue-200 transition-colors duration-150",
+            data: {
+              value: selected_value,
+              action: "click->select-field#removeItem"
+            }
+          ) do
+            plain display_text_for_value(selected_value)
+            span(class: "remove-item ml-1 text-blue-600 hover:text-blue-800 font-medium") { plain "×" }
+          end
+        end
+
+        def render_select_dropdown
+          div(
+            class: "select-dropdown absolute z-50 w-full mt-1 bg-white border border-gray-300 rounded-md shadow-lg max-h-60 overflow-auto opacity-0 invisible transform scale-95 transition-all duration-200 ease-out",
+            data: { select_field_target: "dropdown" }
+          ) do
+            if suggest_mode?
+              # For suggest mode, options will be loaded dynamically
+              render_no_results_message
+              render_loading_message
+            else
+              # For static mode, render all options
+              options.each do |option|
+                render_option(option)
+              end
+              render_no_results_message
+            end
+          end
+        end
+
+        def render_option(option)
+          option_value, option_text = extract_option_value_and_text(option)
+
+          div(
+            class: "select-option px-3 py-2 text-sm text-gray-900 cursor-pointer hover:bg-blue-50 hover:text-blue-900 transition-colors duration-150",
+            data: {
+              value: option_value,
+              action: "click->select-field#selectOption",
+              select_field_target: "option"
+            }
+          ) do
+            plain option_text.to_s
+          end
+        end
+
+        def render_no_results_message
+          div(
+            class: "select-no-results px-3 py-2 text-sm text-gray-500 text-center",
+            data: { select_field_target: "noResults" },
+            style: "display: none;"
+          ) do
+            plain "No options found"
+          end
+        end
+
+        def render_loading_message
+          div(
+            class: "select-loading px-3 py-2 text-sm text-gray-500 text-center",
+            data: { select_field_target: "loading" },
+            style: "display: none;"
+          ) do
+            plain "Loading..."
+          end
+        end
+
+        def render_clear_button
+          button(
+            type: "button",
+            class: "select-clear absolute top-2 right-8 p-1 text-gray-400 hover:text-gray-600 bg-white rounded transition-colors duration-150",
+            data: { action: "click->select-field#clearAll" },
+            title: "Clear all selections"
+          ) do
+            unsafe_raw('<svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/></svg>')
+          end
+        end
+
+        def extract_option_value_and_text(option)
+          if option.is_a?(Array)
+            [option[1], option[0]]
+          elsif option.is_a?(Hash)
+            [option[:value] || option["value"], option[:text] || option["text"] || option[:label] || option["label"]]
+          else
+            [option, option]
+          end
+        end
+
+        def display_text_for_value(value)
+          # Find the display text for the given value
+          options.each do |option|
+            option_value, option_text = extract_option_value_and_text(option)
+            return option_text if option_value.to_s == value.to_s
+          end
+
+          # If not found in options and we have a current association, try to get it from there
+          if form.object&.respond_to?(field_name)
+            association_records = form.object.public_send(field_name)
+            found_record = nil
+
+            if association_records.respond_to?(:find)
+              found_record = association_records.find { |r| r.id.to_s == value.to_s }
+            elsif association_records.respond_to?(:detect)
+              found_record = association_records.detect { |r| r.id.to_s == value.to_s }
+            end
+
+            if found_record
+              return display_text_for(found_record)
+            end
+          end
+
+          value.to_s
+        end
+
+        def options
+          @options ||= build_options
+        end
+
+        def form_field_name
+          model_name = form.object.class.name.underscore
+          "#{model_name}[#{field_name.to_s.singularize}_ids]"
+        end
+
+        def current_selected_values
+          if form.object&.respond_to?(field_name)
+            association_records = form.object.public_send(field_name)
+            if association_records.respond_to?(:pluck)
+              association_records.pluck(:id).map(&:to_s)
+            elsif association_records.respond_to?(:map)
+              association_records.map { |r| r.id.to_s }
+            else
+              []
+            end
+          else
+            []
+          end
+        end
+
+        # Override to render hidden inputs properly for has_many associations
+        # def view_template
+        #   div(class: "mb-4") do
+        #     label(for: field_id, class: label_classes) do
+        #       plain field_label
+        #       if required?
+        #         span(class: "text-red-500 ml-1") { "*" }
+        #       end
+        #     end
+        #
+        #     div(
+        #       class: select_container_classes,
+        #       data: {
+        #         controller: "select-field",
+        #         select_field_multiple_value: multiple?.to_s,
+        #         select_field_placeholder_value: placeholder,
+        #         field_name: field_name
+        #       }
+        #     ) do
+        #       if multiple?
+        #         render_multiple_select_container
+        #       else
+        #         render_single_select_input
+        #       end
+        #       render_select_dropdown
+        #       render_clear_button if multiple?
+        #
+        #       # Render hidden inputs INSIDE the controller scope
+        #       render_hidden_inputs
+        #     end
+        #
+        #     if field[:help_text]
+        #       p(class: "mt-1 text-sm text-gray-500") { field[:help_text] }
+        #     end
+        #   end
+        # end
+
+        def render_hidden_inputs
+          current_selected_values.each do |selected_value|
+            input(
+              type: "hidden",
+              name: "#{form_field_name}[]",
+              value: selected_value,
+              data: { select_field_target: "hiddenInput" }
+            )
+          end
+        end
+
+        def build_options
+          available_options.map do |item|
+            [display_text_for(item), item.id]
+          end
+        end
+
+        def available_options
+          @available_options ||= load_available_options
+        end
+
+        def load_available_options
+          # Get the association class
+          association_class = get_association_class
+          return [] unless association_class
+
+          # Load all available options (limit for performance if needed)
+          association_class.limit(field[:limit] || 1000)
+        end
+
+        def selected_ids
+          @selected_ids ||= load_selected_ids
+        end
+
+        def load_selected_ids
+          if form.object&.respond_to?(field_name)
+            association_records = form.object.public_send(field_name)
+            if association_records.respond_to?(:pluck)
+              association_records.pluck(:id).map(&:to_s)
+            elsif association_records.respond_to?(:map)
+              association_records.map { |r| r.id.to_s }
+            else
+              []
+            end
+          else
+            []
+          end
+        end
+
+        def get_association_class
+          # Try to get the association class from the model
+          if form.object.class.respond_to?(:reflect_on_association)
+            association = form.object.class.reflect_on_association(field_name.to_sym)
+            return association&.klass
+          end
+
+          # Fallback: try to constantize the association name
+          begin
+            association_name.singularize.camelize.constantize
+          rescue NameError
+            nil
+          end
+        end
+
+        def association_name
+          @association_name ||= determine_association_name
+        end
+
+        def determine_association_name
+          return field[:association_name] if field[:association_name]
+          field_name.to_s
+        end
+
+        def search_url
+          # TODO: Create proper route helper for associations search
+          field[:search_url] || "#{EasyAdmin::Engine.routes.url_helpers.resources_path(resource_name: 'associations').chomp('/')}/search"
+        end
+
+        def hidden_field_name_base
+          return field[:form_field_name] if field[:form_field_name]
+          model_name = form.object.class.name.underscore
+          "#{model_name}[#{field_name.to_s.singularize}_ids]"
+        end
+
+        def display_text_for(item)
+          display_method = field[:display_method] || :name
+
+          if display_method.respond_to?(:call)
+            display_method.call(item)
+          elsif item.respond_to?(display_method)
+            item.send(display_method)
+          elsif item.respond_to?(:name)
+            item.name
+          elsif item.respond_to?(:title)
+            item.title
+          elsif item.respond_to?(:to_label)
+            item.to_label
+          else
+            "##{item.id}"
+          end
+        end
+
+        def details_for(item)
+          if field[:details_method]
+            item.send(field[:details_method])
+          elsif item.respond_to?(:created_at)
+            "Created #{item.created_at.strftime('%b %d, %Y')}"
+          else
+            "ID: #{item.id}"
+          end
+        end
+
+        def view_path_for(item)
+          field[:view_path_proc]&.call(item) ||
+            EasyAdmin::Engine.routes.url_helpers.resource_path(
+              resource_name: item.class.name.underscore.pluralize,
+              id: item.id
+            )
+        end
+
+        def edit_path_for(item)
+          field[:edit_path_proc]&.call(item) ||
+            EasyAdmin::Engine.routes.url_helpers.edit_resource_path(
+              resource_name: item.class.name.underscore.pluralize,
+              id: item.id
+            )
+        end
+
+        def new_path
+          field[:new_path_proc]&.call ||
+            EasyAdmin::Engine.routes.url_helpers.new_resource_path(
+              resource_name: association_name.singularize.pluralize
+            )
+        end
+
+        def hidden_field_name
+          "#{hidden_field_name_base}[]"
+        end
+      end
+    end
+  end
+end

data/app/components/easy_admin/fields/form/json_component.rb

@@ -0,0 +1,81 @@
+module EasyAdmin
+  module Fields
+    module Form
+      class JsonComponent < Fields::BaseComponent
+        def view_template
+          div(class: "space-y-2") do
+            label(
+              for: field_id,
+              class: "block text-sm font-medium text-gray-700"
+            ) { field_label }
+            
+            div(
+              class: "relative",
+              data: {
+                controller: "jsoneditor",
+                jsoneditor_mode_value: "code",
+                jsoneditor_data_value: current_json_value.to_json
+              }
+            ) do
+              # Hidden field to store the JSON value
+              input(
+                type: "hidden",
+                name: form_field_name,
+                id: "#{field_id}_hidden",
+                value: current_json_value_string,
+                data: { jsoneditor_target: "hiddenField" }
+              )
+              
+              # JSONEditor container
+              div(
+                id: field_id,
+                data: { jsoneditor_target: "editor" },
+                style: "height: 400px; border: 1px solid #d1d5db; border-radius: 0.375rem;"
+              )
+            end
+            
+            if field[:help_text].present?
+              p(class: "text-sm text-gray-500") { field[:help_text] }
+            end
+          end
+        end
+
+        private
+
+        def form_field_name
+          model_name = form.object.class.name.underscore
+          "#{model_name}[#{field_name}]"
+        end
+
+        def current_json_value_string
+          current_value = form.object.public_send(field_name) || value
+          return "" unless current_value.present?
+          
+          if current_value.is_a?(String)
+            current_value
+          else
+            JSON.pretty_generate(current_value)
+          end
+        end
+
+        def current_json_value
+          current_value = form.object.public_send(field_name) || value
+
+          if current_value.present?
+            if current_value.is_a?(String)
+              begin
+                JSON.parse(current_value)
+              rescue JSON::ParserError
+                { error: "Invalid JSON", raw_value: current_value }
+              end
+            else
+              current_value
+            end
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/easy_admin/fields/form/number_component.rb

@@ -0,0 +1,55 @@
+module EasyAdmin
+  module Fields
+    module Form
+      class NumberComponent < BaseComponent
+        def view_template
+          div(class: "mb-4") do
+            label(for: field_id, class: label_classes) do
+              plain field_label
+              if required?
+                span(class: "text-red-500 ml-1") { "*" }
+              end
+            end
+            input(
+              type: "number",
+              name: form_field_name,
+              id: field_id,
+              value: current_value,
+              class: input_classes,
+              required: required?,
+              placeholder: field[:placeholder] || "Enter #{field_label.downcase}"
+            )
+            if field[:help_text]
+              p(class: "mt-1 text-sm text-gray-500") { field[:help_text] }
+            end
+          end
+        end
+
+        private
+
+        def label_classes
+          "block text-sm font-medium text-gray-700 mb-1"
+        end
+
+        def input_classes
+          base_classes = "block w-full px-3 py-2 border rounded-md shadow-sm text-sm"
+          state_classes = "border-gray-300 placeholder-gray-400"
+          focus_classes = "focus:outline-none focus:ring-1 focus:ring-blue-500 focus:border-blue-500"
+          hover_classes = "hover:border-gray-400"
+          transition_classes = "transition-colors duration-200"
+          
+          "#{base_classes} #{state_classes} #{focus_classes} #{hover_classes} #{transition_classes}"
+        end
+
+        def form_field_name
+          model_name = form.object.class.name.underscore
+          "#{model_name}[#{field_name}]"
+        end
+
+        def current_value
+          form.object.public_send(field_name) if form.object.respond_to?(field_name)
+        end
+      end
+    end
+  end
+end