chobble-forms 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a667bfdadedd91552428ae7b8de49675340618beabd0a6784941861805a4655e
+  data.tar.gz: 6461e968376cf809af015f83dc89fd8cde783a79819c68faca28d3a938a945bb
+SHA512:
+  metadata.gz: ac860f4f3d10aa3ab790b19a49871d8802a099ea4868f626888d2bd7dd29de2901ec604bd4f4fe31e7e47b327ac870d7565007c6ea18c0f6ac9c097e5d6429a3
+  data.tar.gz: 7c32149a54105636daffb3b88dc74327293cd3c0bd60abc4396ce256cac2562fa732fc1a17e66426c52947deb7251c8205bb60f1b2b6bad47f95021ec305149b

data/README.md

@@ -0,0 +1,3 @@
+# Chobble Forms
+
+Semantic Rails forms with strict i18n enforcement.

data/lib/chobble-forms.rb

@@ -0,0 +1,6 @@
+require_relative "version"
+require_relative "engine"
+require_relative "helpers"
+
+module ChobbleForms
+end

data/lib/engine.rb

@@ -0,0 +1,21 @@
+module ChobbleForms
+  class Engine < ::Rails::Engine
+    isolate_namespace ChobbleForms
+
+    initializer "chobble_forms.add_view_paths" do |app|
+      ActiveSupport.on_load(:action_controller) do
+        prepend_view_path ChobbleForms::Engine.root.join("views")
+      end
+    end
+
+    config.to_prepare do
+      ApplicationController.helper(ChobbleForms::Helpers)
+    end
+
+    initializer "chobble_forms.view_helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include ChobbleForms::Helpers
+      end
+    end
+  end
+end

data/lib/helpers.rb

@@ -0,0 +1,206 @@
+require "action_view"
+
+module ChobbleForms
+  module Helpers
+    include ActionView::Helpers::NumberHelper
+    def form_field_setup(field, local_assigns)
+      validate_local_assigns(local_assigns)
+      validate_form_context
+
+      field_translations = build_field_translations(field)
+      value, prefilled = get_field_value_and_prefilled_status(@_current_form,
+        field)
+
+      build_field_setup_result(field_translations, value, prefilled)
+    end
+
+    def get_field_value_and_prefilled_status(form_object, field)
+      return [nil, false] unless form_object&.object
+      model = form_object.object
+      resolved = resolve_field_value(model, field)
+      [resolved[:value], resolved[:prefilled]]
+    end
+
+    def comment_field_options(form, comment_field, base_field_label)
+      raise ArgumentError, "form_object required" unless form
+      model = form.object
+
+      comment_value, comment_prefilled =
+        get_field_value_and_prefilled_status(
+          form,
+          comment_field
+        )
+
+      has_comment = comment_value.present?
+
+      base_field = comment_field.to_s.chomp("_comment")
+
+      placeholder_text = t("shared.field_comment_placeholder", field: base_field_label)
+      textarea_id = "#{base_field}_comment_textarea_#{model.object_id}"
+      checkbox_id = "#{base_field}_has_comment_#{model.object_id}"
+      display_style = has_comment ? "block" : "none"
+
+      {
+        options: {
+          rows: 2,
+          placeholder: placeholder_text,
+          id: textarea_id,
+          style: "display: #{display_style};",
+          value: comment_value
+        },
+        prefilled: comment_prefilled,
+        has_comment: has_comment,
+        checkbox_id: checkbox_id
+      }
+    end
+
+    def radio_button_options(prefilled, checked_value, expected_value)
+      (prefilled && checked_value == expected_value) ? {checked: true} : {}
+    end
+
+    private
+
+    ALLOWED_LOCAL_ASSIGNS = %i[
+      accept
+      field
+      max
+      min
+      number_options
+      options
+      preview_size
+      required
+      rows
+      step
+      type
+    ]
+
+    def validate_local_assigns(local_assigns)
+      if local_assigns[:field].present? &&
+          local_assigns[:field].to_s.match?(/^[A-Z]/)
+        raise ArgumentError, "Field names must be snake_case symbols, not class names. Use :field, not Field."
+      end
+
+      locally_assigned_keys = (local_assigns || {}).keys
+      disallowed_keys = locally_assigned_keys - ALLOWED_LOCAL_ASSIGNS
+
+      if disallowed_keys.any?
+        raise ArgumentError, "local_assigns contains #{disallowed_keys.inspect}"
+      end
+    end
+
+    def validate_form_context
+      raise ArgumentError, "missing i18n_base" unless @_current_i18n_base
+      raise ArgumentError, "missing form_object" unless @_current_form
+    end
+
+    def build_field_translations(field)
+      fields_key = "#{@_current_i18n_base}.fields.#{field}"
+      field_label = t(fields_key, raise: true)
+
+      base_parts = @_current_i18n_base.split(".")
+      root = base_parts[0..-2]
+      hint_key = (root + ["hints", field]).join(".")
+      placeholder_key = (root + ["placeholders", field]).join(".")
+
+      {
+        field_label:,
+        field_hint: t(hint_key, default: nil),
+        field_placeholder: t(placeholder_key, default: nil)
+      }
+    end
+
+    def build_field_setup_result(field_translations, value, prefilled)
+      {
+        form_object: @_current_form,
+        i18n_base: @_current_i18n_base,
+        value:,
+        prefilled:
+      }.merge(field_translations)
+    end
+
+    def resolve_field_value(model, field)
+      field_str = field.to_s
+
+      # Never return values for password fields
+      if field_str.include?("password")
+        return {value: nil, prefilled: false}
+      end
+
+      # Check current model value
+      current_value = model.send(field) if model.respond_to?(field)
+
+      # Check if this field should be excluded from prefilling
+      if defined?(InspectionsController::NOT_COPIED_FIELDS) &&
+          InspectionsController::NOT_COPIED_FIELDS.include?(field_str)
+        return {value: current_value, prefilled: false}
+      end
+
+      # Extract previous value if available
+      previous_value = extract_previous_value(@previous_inspection, model, field)
+
+      # Return previous value if current is nil and previous exists
+      if current_value.nil? && !previous_value.nil?
+        return {
+          value: format_numeric_value(previous_value),
+          prefilled: true
+        }
+      end
+
+      if field_str.end_with?("_id") && field_str != "id"
+        resolve_association_value(model, field_str)
+      else
+        # Always return current value, even if nil
+        {value: current_value, prefilled: false}
+      end
+    end
+
+    def extract_previous_value(previous_inspection, current_model, field)
+      if !previous_inspection
+        nil
+      elsif current_model.class.name.include?("Assessment")
+        assessment_type = current_model.class.name.demodulize.underscore
+        previous_model = previous_inspection.send(assessment_type)
+        previous_model&.send(field)
+      else
+        previous_inspection.send(field)
+      end
+    end
+
+    def format_numeric_value(value)
+      if value.is_a?(String) &&
+          value.match?(/\A-?\d*\.?\d+\z/) &&
+          (float_value = Float(value, exception: false))
+        value = float_value
+      end
+
+      return value unless value.is_a?(Numeric)
+
+      number_with_precision(
+        value,
+        precision: 4,
+        strip_insignificant_zeros: true
+      )
+    end
+
+    def resolve_association_value(model, field_str)
+      base_name = field_str.chomp("_id")
+      association_name = base_name.to_sym
+
+      if model.respond_to?(association_name)
+        {value: model.send(association_name), prefilled: true}
+      elsif model.respond_to?(field_str)
+        value = model.send(field_str)
+        if value && model.class.reflect_on_association(association_name)
+          associated = model.class
+            .reflect_on_association(association_name)
+            .klass.find_by(id: value)
+          {value: associated, prefilled: true}
+        else
+          {value: value, prefilled: true}
+        end
+      else
+        {value: nil, prefilled: false}
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module ChobbleForms
+  VERSION = "0.3.0"
+end

data/views/chobble_forms/_auto_submit_select.html.erb

@@ -0,0 +1,55 @@
+<%
+  # Auto-submit select field options
+  field = local_assigns[:field] or raise ArgumentError, "field is required for auto submit select"
+  options = local_assigns[:options] or raise ArgumentError, "options is required for auto submit select"
+  
+  # Check if we're in a form context with form object or need standalone
+  if local_assigns[:form]
+    form_object = local_assigns[:form]
+    selected_value = params[field] || form_object.object.send(field) rescue nil
+  else
+    # Standalone usage - must provide url
+    url = local_assigns[:url] or raise ArgumentError, "url is required for standalone auto submit select"
+    selected_value = params[field]
+  end
+  
+  # Optional parameters
+  label = local_assigns[:label]
+  include_blank = local_assigns[:include_blank]
+  blank_text = local_assigns[:blank_text] || "All"
+  turbo_disabled = local_assigns.has_key?(:turbo_disabled) ? local_assigns[:turbo_disabled] : true
+  preserve_params = local_assigns[:preserve_params] || []
+%>
+
+<% if local_assigns[:form] %>
+  <% if label %>
+    <%= form_object.label field, label %>
+  <% end %>
+  
+  <%= form_object.select field,
+      options_for_select(options, selected_value),
+      include_blank ? { include_blank: blank_text } : {},
+      { onchange: "this.form.submit();" } %>
+      
+<% else %>
+  <!-- Standalone auto-submit select form -->
+  <%= form_with url: url, method: :get, data: (turbo_disabled ? { turbo: false } : {}) do |form| %>
+    
+    <!-- Preserve other parameters -->
+    <% preserve_params.each do |param| %>
+      <% if params[param].present? %>
+        <%= form.hidden_field param, value: params[param] %>
+      <% end %>
+    <% end %>
+    
+    <% if label %>
+      <%= form.label field, label %>
+    <% end %>
+    
+    <%= form.select field,
+        options_for_select(options, selected_value),
+        include_blank ? { include_blank: blank_text } : {},
+        { onchange: "this.form.submit();" } %>
+        
+  <% end %>
+<% end %>

data/views/chobble_forms/_autocomplete_field.html.erb

@@ -0,0 +1,17 @@
+<%
+  setup = form_field_setup(field, local_assigns)
+
+  field_options = {
+    required: local_assigns[:required] || false,
+    list: "#{field}_autocomplete_#{setup[:form_object].object.object_id}",
+    value: setup[:value]
+  }
+%>
+
+<%= setup[:form_object].label field, setup[:field_label] %>
+<%= setup[:form_object].text_field field, field_options %>
+<datalist id="<%= field_options[:list] %>">
+  <% options&.each do |option| %>
+    <option value="<%= option %>"></option>
+  <% end %>
+</datalist>

data/views/chobble_forms/_checkbox.html.erb

@@ -0,0 +1,12 @@
+<%
+  # Get i18n_base from section (already validated there)
+  setup = form_field_setup(field, local_assigns)
+%>
+
+<%= setup[:form_object].label field do %>
+  <%= setup[:form_object].check_box field %>
+  <%= setup[:field_label] %>
+  <% if setup[:field_hint].present? %>
+    <small><%= setup[:field_hint] %></small>
+  <% end %>
+<% end %>

data/views/chobble_forms/_comment.html.erb

@@ -0,0 +1,40 @@
+<%
+  # Form partial for comment fields with toggle visibility
+  # Required parameters:
+  #   field: Symbol representing the field name
+  # Optional parameters:
+  #   maxlength: Maximum character length (default: 1000)
+  #   placeholder: Placeholder text
+
+  maxlength ||= 1000
+  placeholder ||= nil
+
+  form = @_current_form
+  checkbox_id = "toggle_#{field}_#{form.object.object_id}"
+  textarea_id = "#{form.object_name}_#{field}"
+
+  # Check if there's existing content
+  has_content = form.object.send(field).present?
+%>
+
+<div class="comment-field-container">
+  <label for="<%= checkbox_id %>">
+    <input type="checkbox" id="<%= checkbox_id %>"
+      <%= 'checked' if has_content %>
+      data-comment-toggle="<%= textarea_id %>"
+      data-comment-container="<%= textarea_id %>_container"
+    >
+    <%= t("shared.comment") %>
+  </label>
+
+  <div id="<%= textarea_id %>_container"
+    style="display: <%= has_content ? 'block' : 'none' %>"
+  >
+    <%= form.text_field field,
+        maxlength: maxlength,
+        placeholder: placeholder,
+        id: textarea_id,
+        title: "Max #{maxlength} characters"
+    %>
+  </div>
+</div>

data/views/chobble_forms/_comment_checkbox.html.erb

@@ -0,0 +1,18 @@
+<%
+  # Partial for comment checkbox
+  # Required parameters:
+  #   comment_field: The comment field name (e.g., :width_comment)
+  #   checkbox_id: Unique ID for the checkbox
+  #   textarea_id: ID of the textarea to show/hide
+  #   has_comment: Whether comment exists
+%>
+
+<label for="<%= checkbox_id %>" class="comment-checkbox">
+  <input type="checkbox"
+    id="<%= checkbox_id %>"
+    <%= 'checked' if has_comment %>
+    data-comment-toggle="<%= textarea_id %>"
+    data-comment-container="<%= textarea_id %>"
+  >
+  <%= t('shared.comment') %>
+</label>

data/views/chobble_forms/_date_field.html.erb

@@ -0,0 +1,15 @@
+<%
+  setup = form_field_setup(field, local_assigns)
+  required ||= false
+  field_options = {
+    placeholder: setup[:field_placeholder],
+    required: required
+  }.compact
+  field_options[:value] = local_assigns[:value] if local_assigns[:value]
+%>
+
+<%= setup[:form_object].label field, setup[:field_label] %>
+<%= setup[:form_object].send(:date_field, field, field_options) %>
+<% if setup[:field_hint].present? %>
+  <small><%= setup[:field_hint] %></small>
+<% end %>

data/views/chobble_forms/_decimal_comment.html.erb

@@ -0,0 +1,58 @@
+<%
+  # Composite partial for decimal + comment fields with grid layout
+  # Required parameters:
+  #   field: Base field name (e.g., 'platform_height')
+  # Optional parameters:
+  #   min: Minimum value
+  #   max: Maximum value
+  #   required: Whether the decimal field is required
+  #   placeholder: Placeholder text
+  #
+  # This will render:
+  #   - Decimal field: field (e.g., 'platform_height')
+  #   - Comment field: field + '_comment' (e.g., 'platform_height_comment')
+
+  decimal_field = field
+  comment_field = "#{field}_comment".to_sym
+
+  form = @_current_form
+  model = form.object
+
+  field_data = form_field_setup(field, local_assigns)
+
+  decimal_options = {
+    inputmode: "decimal",
+    pattern: "[0-9]*[.]?[0-9]*",
+    placeholder: field_data[:field_placeholder] || local_assigns[:placeholder],
+    required: local_assigns[:required] || false,
+    class: "number"
+  }
+
+  if field_data[:prefilled]
+    decimal_options[:value] = field_data[:value]
+  end
+
+  decimal_options[:data] = {}
+  decimal_options[:data][:min] = local_assigns[:min] if local_assigns[:min]
+  decimal_options[:data][:max] = local_assigns[:max] if local_assigns[:max]
+
+  comment_info = comment_field_options(
+    form,
+    comment_field,
+    field_data[:field_label]
+  )
+%>
+
+<div class="form-grid number-comment" id="<%= decimal_field %>">
+  <%= form.label decimal_field, field_data[:field_label], class: "label" %>
+  <%= form.text_field decimal_field, decimal_options %>
+
+  <%= render 'chobble_forms/comment_checkbox',
+      comment_field: comment_field,
+      checkbox_id: comment_info[:checkbox_id],
+      textarea_id: comment_info[:options][:id],
+      has_comment: comment_info[:has_comment],
+      prefilled: comment_info[:prefilled] %>
+
+  <%= form.text_area comment_field, comment_info[:options] %>
+</div>

data/views/chobble_forms/_display_field.html.erb

@@ -0,0 +1,11 @@
+<%
+  # Get i18n_base from section (already validated there)
+  setup = form_field_setup(field, local_assigns)
+
+  # Get value from model object automatically
+  model_object = setup[:form_object].object
+  value = model_object.send(field) if model_object.respond_to?(field)
+%>
+
+<%= setup[:form_object].label field, setup[:field_label] %>
+<p><%= value %></p>

data/views/chobble_forms/_errors.html.erb

@@ -0,0 +1,26 @@
+<%
+  # Form errors component - displays validation errors for any model object
+  model_object = local_assigns[:model] || local_assigns[:object]
+  raise ArgumentError, "model object is required for form errors" if model_object.nil?
+  
+  # Use inherited i18n_base from form context
+  i18n_base = @_current_i18n_base
+  raise ArgumentError, "i18n_base is required for form errors" if i18n_base.nil?
+  
+  # Custom header text or use i18n lookup - no fallbacks
+  header_text = local_assigns[:header] || 
+                t("#{i18n_base}.errors.header", 
+                  count: model_object.errors.count, 
+                  raise: true)
+%>
+
+<% if model_object.errors.any? %>
+  <aside class="form-errors" role="alert">
+    <h3><%= header_text %></h3>
+    <ul>
+      <% model_object.errors.each do |error| %>
+        <li><%= error.full_message %></li>
+      <% end %>
+    </ul>
+  </aside>
+<% end %>

data/views/chobble_forms/_field_with_link.html.erb

@@ -0,0 +1,33 @@
+<%
+  # Field with optional link to the right
+  # Required locals:
+  #   - field_type: :text_field or :autocomplete_field
+  #   - field: field name
+  #   - required: boolean
+  # Optional locals:
+  #   - link_url: URL for the link
+  #   - link_text: Text for the link
+  #   - options: options for autocomplete_field
+  
+  field_type = local_assigns[:field_type] || :text_field
+  field = local_assigns[:field]
+  required = local_assigns[:required] || false
+  link_url = local_assigns[:link_url]
+  link_text = local_assigns[:link_text]
+  options = local_assigns[:options] || []
+  
+  has_link = link_url.present? && link_text.present?
+  css_classes = has_link ? "field field-with-link" : "field"
+%>
+
+<div class="<%= css_classes %>">
+  <% if field_type == :autocomplete_field %>
+    <%= render 'chobble_forms/autocomplete_field', field: field, required: required, options: options %>
+  <% else %>
+    <%= render 'chobble_forms/text_field', field: field, required: required %>
+  <% end %>
+  
+  <% if has_link %>
+    <%= link_to link_text, link_url %>
+  <% end %>
+</div>

data/views/chobble_forms/_fields.html.erb

@@ -0,0 +1,9 @@
+<% model.class.form_fields(user: current_user).each do |fieldset| %>
+  <%= render 'chobble_forms/fieldset', legend_key: fieldset[:legend_i18n_key] do %>
+    <% fieldset[:fields].each do |field_config| %>
+      <% render_options = { field: field_config[:field] } %>
+      <% render_options.merge!(field_config[:attributes]) if field_config[:attributes] %>
+      <%= render "chobble_forms/#{field_config[:partial]}", render_options %>
+    <% end %>
+  <% end %>
+<% end %>

data/views/chobble_forms/_fieldset.html.erb

@@ -0,0 +1,29 @@
+<%
+  # Set form and i18n context for child form controls
+  @_current_form = local_assigns[:form] || @_current_form
+  i18n_base = @_current_i18n_base || local_assigns[:i18n_base]
+  raise ArgumentError, "i18n_base is required for form fieldsets" if i18n_base.nil?
+  @_current_i18n_base = i18n_base
+  
+  # Determine legend text
+  if local_assigns[:legend]
+    legend_text = local_assigns[:legend]
+  elsif local_assigns[:legend_key] && i18n_base
+    # Remove .fields suffix if present to get to sections level
+    sections_base = i18n_base.sub(/\.fields$/, '')
+    legend_text = t("#{sections_base}.sections.#{local_assigns[:legend_key]}")
+    # Fail loudly if translation is missing
+    if legend_text.start_with?("translation missing:")
+      raise "Missing i18n key: #{sections_base}.sections.#{local_assigns[:legend_key]}"
+    end
+  else
+    legend_text = local_assigns[:legend_key]&.to_s&.humanize || "Section"
+  end
+%>
+
+<fieldset>
+  <% if legend_text.present? %>
+    <legend><%= legend_text %></legend>
+  <% end %>
+  <%= yield %>
+</fieldset>

data/views/chobble_forms/_file_field.html.erb

@@ -0,0 +1,29 @@
+<%
+  # Get i18n_base from section (already validated there)
+  setup = form_field_setup(field, local_assigns)
+
+  # Form field options
+  accept = local_assigns[:accept] || "image/*"
+  preview_size = local_assigns[:preview_size] || 200
+  model = setup[:form_object].object
+  current_file = model.send(field) if model.respond_to?(field)
+%>
+
+<%= setup[:form_object].label field, setup[:field_label] %>
+<%= setup[:form_object].file_field field, accept: accept %>
+
+<% if current_file&.attached? %>
+  <div class="file-preview" style="margin-top: 10px;">
+    <% if current_file.image? %>
+      <%= image_tag current_file.variant(resize_to_limit: [preview_size, preview_size]),
+          alt: "Current #{setup[:field_label].downcase}" %>
+      <p><small>Current <%= setup[:field_label].downcase %>: <strong><%= current_file.filename %></strong></small></p>
+    <% else %>
+      <p>Current <%= setup[:field_label].downcase %>: <strong><%= current_file.filename %></strong></p>
+    <% end %>
+  </div>
+<% end %>
+
+<% if setup[:field_hint].present? %>
+  <small class="form-text"><%= setup[:field_hint] %></small>
+<% end %>