chobble-forms 0.5.6 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38897550927a4c901cada28fbe5f63e8447bf108e6eb3bedf5d045807e45c245
-  data.tar.gz: ede19464d42338a4834967dda6a1df1048d2bef39599ddd89e079256c796ec15
+  metadata.gz: 114cd63966175b3b8f30be99441ff3da688526f9e46bc0b08c9add531c93d8eb
+  data.tar.gz: 225988209e98465f4c92d14729ad9650878519d1563cea5486f90b3342d8a28e
 SHA512:
-  metadata.gz: c24eca1ed04bf5d7cbbe7d483451368ef3b636d3d0d42018e967a5f22ddbee88e4c7c8d2c5a7f6f104828af570610d395342bb05fad838c5366f4b84edd186db
-  data.tar.gz: b486d795a2b856e0895b4736901f52fede072e35319acb7511aaef5b007919e8af5ea644365c34ef30839f0f36301a247fe0b791a5a12c98318ebdd078c11649
+  metadata.gz: 934333541f43b3fd5f8f0c24468f15a1d755b5567c0c341a856c6fedb67932f2a606d93452741ca26531a107d30cbd21363f1ec27f4acc7059a001edc3ca42ac
+  data.tar.gz: 535ab94d5f12ca207fd4c34d198e3938161465112819c0df18ea8cfa7c8f33ab29d8f44e9112aab6a011bf1889e49cf99e527223dadcdcb920f41830dbea7065

data/README.md

@@ -18,36 +18,20 @@ bundle install
 
 ## Type Safety with Sorbet
 
-ChobbleForms uses Sorbet for static type checking, providing improved type safety and better IDE support. All library files use `typed: strict` with comprehensive type signatures.
+ChobbleForms is fully typed with Sorbet (`typed: strict`) providing compile-time type safety and runtime validation. All field parameters must be symbols for a clean, consistent API.
 
 ### Type Checking
 
-Run type checking with:
-
 ```bash
 bundle exec srb tc
 ```
 
-Or use the provided Rake task:
-
-```bash
-bundle exec rake typecheck
-```
-
 ### Development Setup
 
-For contributors working on this gem:
-
 1. Install dependencies: `bundle install`
 2. Generate RBI files: `bundle exec rake sorbet_rbi`
 3. Run type checking: `bundle exec rake typecheck`
 
-All methods have full type signatures, providing:
-- Static type checking at development time
-- Runtime type validation
-- Better IDE autocomplete and documentation
-- Early detection of type mismatches
-
 ## CSS Styles
 
 ChobbleForms includes CSS for styling the form components. To use the included styles, add this to your application.css:

data/lib/chobble_forms/field_utils.rb

@@ -1,45 +1,60 @@
-# typed: false
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
 
 module ChobbleForms
   module FieldUtils
+    extend T::Sig
+
+    sig { params(field: Symbol).returns(Symbol) }
     def self.strip_field_suffix(field)
-      field.to_s.gsub(/_pass$|_comment$/, "")
+      field.to_s.gsub(/_pass$|_comment$/, "").to_sym
     end
 
+    sig { params(field: Symbol, partial: Symbol).returns(T::Array[Symbol]) }
     def self.get_composite_fields(field, partial)
-      fields = []
+      fields = T.let([], T::Array[Symbol])
       partial_str = partial.to_s
 
-      if partial_str.include?("pass_fail") && !field.to_s.end_with?("_pass")
-        fields << "#{field}_pass"
-      end
+      fields << :"#{field}_pass" if partial_str.include?("pass_fail") && !field.to_s.end_with?("_pass")
 
       if partial_str.include?("comment")
         base = field.to_s.end_with?("_pass") ? strip_field_suffix(field) : field
-        fields << "#{base}_comment"
+        fields << :"#{base}_comment"
       end
 
       fields
     end
 
+    sig { params(field: Symbol).returns(T::Boolean) }
     def self.is_pass_field?(field)
       field.to_s.end_with?("_pass")
     end
 
+    sig { params(field: Symbol).returns(T::Boolean) }
     def self.is_comment_field?(field)
       field.to_s.end_with?("_comment")
     end
 
+    sig { params(field: Symbol).returns(T::Boolean) }
     def self.is_composite_field?(field)
       is_pass_field?(field) || is_comment_field?(field)
     end
 
+    sig { params(field: Symbol).returns(Symbol) }
     def self.base_field_name(field)
       strip_field_suffix(field)
     end
 
+    sig { params(form: Symbol, field: Symbol).returns(String) }
     def self.form_field_label(form, field)
       I18n.t("forms.#{form}.fields.#{field}")
     end
+
+    sig { params(assessment_key: Symbol).returns(Symbol) }
+    def self.form_name_from_assessment(assessment_key)
+      assessment_key.to_s.gsub(/_assessment$/, "").to_sym
+    end
   end
 end

data/lib/chobble_forms/helpers.rb

@@ -7,7 +7,35 @@ module ChobbleForms
   module Helpers
     extend T::Sig
 
-    sig { params(field: T.any(Symbol, String), local_assigns: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    SelectOption = T.type_alias {
+      [String, T.any(String, Integer)]
+    }
+
+    LocalAssignValue = T.type_alias {
+      T.any(
+        String,
+        Symbol,
+        Integer,
+        Float,
+        T::Boolean,
+        T::Array[SelectOption],
+        T::Hash[Symbol, T.untyped]
+      )
+    }
+
+    FieldSetupResult = T.type_alias {
+      {
+        form_object: T.untyped,
+        i18n_base: String,
+        value: T.untyped,
+        prefilled: T::Boolean,
+        field_label: String,
+        field_hint: T.nilable(String),
+        field_placeholder: T.nilable(String)
+      }
+    }
+
+    sig { params(field: Symbol, local_assigns: T::Hash[Symbol, LocalAssignValue]).returns(FieldSetupResult) }
     def form_field_setup(field, local_assigns)
       validate_local_assigns(local_assigns)
       validate_form_context
@@ -19,17 +47,19 @@ module ChobbleForms
       build_field_setup_result(field_translations, value, prefilled)
     end
 
-    sig { params(form_object: T.untyped, field: T.any(Symbol, String)).returns([T.untyped, T::Boolean]) }
+    sig { params(form_object: T.untyped, field: Symbol).returns([T.untyped, T::Boolean]) }
     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
 
-    sig { params(form: T.untyped, comment_field: T.any(Symbol, String), base_field_label: String).returns(T::Hash[Symbol, T.untyped]) }
+    sig { params(form: T.untyped, comment_field: Symbol, base_field_label: String).returns(T::Hash[Symbol, T.untyped]) }
     def comment_field_options(form, comment_field, base_field_label)
       raise ArgumentError, "form_object required" unless form
+
       model = form.object
 
       comment_value, comment_prefilled =
@@ -81,21 +111,16 @@ module ChobbleForms
       rows
       step
       type
-    ], T::Array[Symbol])
+    ].freeze, T::Array[Symbol])
 
-    sig { params(local_assigns: T::Hash[Symbol, T.untyped]).void }
+    sig { params(local_assigns: T::Hash[Symbol, LocalAssignValue]).void }
     def validate_local_assigns(local_assigns)
-      if local_assigns[:field]&.respond_to?(:to_s) &&
-          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
+      return unless disallowed_keys.any?
+
+      raise ArgumentError, "local_assigns contains #{disallowed_keys.inspect}"
     end
 
     sig { void }
@@ -106,10 +131,12 @@ module ChobbleForms
       raise ArgumentError, "missing form_object" unless form_obj
     end
 
-    sig { params(field: T.any(Symbol, String)).returns(T::Hash[Symbol, T.nilable(String)]) }
+    sig { params(field: Symbol).returns(T::Hash[Symbol, T.nilable(String)]) }
     def build_field_translations(field)
       i18n_base = T.unsafe(instance_variable_get(:@_current_i18n_base))
-      fields_key = "#{i18n_base}.fields.#{field}"
+
+      field_without_suffix = FieldUtils.strip_field_suffix(field)
+      fields_key = "#{i18n_base}.fields.#{field_without_suffix}"
       field_label = t(fields_key, raise: true)
 
       base_parts = i18n_base.split(".")
@@ -124,42 +151,37 @@ module ChobbleForms
       }
     end
 
-    sig { params(field_translations: T::Hash[Symbol, T.nilable(String)], value: T.untyped, prefilled: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
+    sig { params(field_translations: T::Hash[Symbol, T.nilable(String)], value: T.untyped, prefilled: T::Boolean).returns(FieldSetupResult) }
     def build_field_setup_result(field_translations, value, prefilled)
       form_obj = T.unsafe(instance_variable_get(:@_current_form))
       i18n_base = T.unsafe(instance_variable_get(:@_current_i18n_base))
 
-      {
-        form_object: form_obj,
-        i18n_base: i18n_base,
-        value:,
-        prefilled:
-      }.merge(field_translations)
+      T.cast(
+        {
+          form_object: form_obj,
+          i18n_base: i18n_base,
+          value:,
+          prefilled:
+        }.merge(field_translations),
+        FieldSetupResult
+      )
     end
 
-    sig { params(model: T.untyped, field: T.any(Symbol, String)).returns(T::Hash[Symbol, T.untyped]) }
+    sig { params(model: T.untyped, field: Symbol).returns({value: T.untyped, prefilled: T::Boolean}) }
     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
+      return {value: nil, prefilled: false} if field_str.include?("password")
 
-      # 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
+      # Check if this field should not be prefilled based on excluded fields list
+      excluded_fields = T.unsafe(instance_variable_get(:@_excluded_prefill_fields))
+      return {value: current_value, prefilled: false} if excluded_fields&.include?(field)
 
-      # Extract previous value if available
       prev_inspection = T.unsafe(instance_variable_get(:@previous_inspection))
       previous_value = extract_previous_value(prev_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),
@@ -170,12 +192,11 @@ module ChobbleForms
       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
 
-    sig { params(previous_inspection: T.untyped, current_model: T.untyped, field: T.any(Symbol, String)).returns(T.untyped) }
+    sig { params(previous_inspection: T.untyped, current_model: T.untyped, field: Symbol).returns(T.untyped) }
     def extract_previous_value(previous_inspection, current_model, field)
       if !previous_inspection
         nil

data/lib/chobble_forms/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module ChobbleForms
-  VERSION = "0.5.6"
+  VERSION = "0.7.0"
 end

data/views/chobble_forms/_form_context.html.erb

@@ -8,6 +8,7 @@
   #   url: Form submission URL (defaults to model's update path)
   #   method: HTTP method (defaults to :patch for models, :post for scoped forms)
   #   local: Use standard form submission instead of Turbo (defaults to false)
+  #   excluded_prefill_fields: Array of field symbols that should not be prefilled
 
   if model
     url ||= url_for(model)
@@ -52,6 +53,11 @@ end %>
   <% @_current_form = form %>
   <% @_current_i18n_base = i18n_base %>
 
+  <% # Set excluded prefill fields if provided %>
+  <% if local_assigns[:excluded_prefill_fields] %>
+    <% @_excluded_prefill_fields = excluded_prefill_fields %>
+  <% end %>
+
   <%= yield form %>
 
   <% if model && model.respond_to?(:errors) && model.errors.any? %>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chobble-forms
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.7.0
 platform: ruby
 authors:
 - Chobble.com
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-12 00:00:00.000000000 Z
+date: 2025-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails