inline_forms 8.1.8 → 8.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6faae45fc3c25f20b57cc614e61e77a5264c1d866a5fde22a6e634c639fb54b9
-  data.tar.gz: a30324d9cc1f598b4a9c5531f0b4fa45fe47186d2a07b8fc956e38c988a52872
+  metadata.gz: 03b05e4fb178ef02526d7fc573fa698dac22cb9061314ad84a03c70967b872f7
+  data.tar.gz: 8853ac3bfe3815ce88d9b1448e75176a500ff36c046b4d3fda974d2fe56fb194
 SHA512:
-  metadata.gz: 9777058054bb9d8e1ff3213e0fd7bf420fd060f69a43005aef71e2fc9088aa58ccfb0e60aaa5ac4d57739aaa555bb01820bb1cc328d31543295ca8377c476eff
-  data.tar.gz: 3f938ebcb879f72cecd60bd0c2e8eab47c1d01c410c7e32c137953e8f925cda614ce1b32e418bd887d0c833aaeecb0909fb9ba73c75911742473b22cfc9e186c
+  metadata.gz: 48459f5b60427af52f97574d7d1d8c774cf179f10dd7d0849e5c07a2a3e32243e46f0ccb9e09f4d7295513138e85105e929d22d68da1b14e4fd8771b9dce85d8
+  data.tar.gz: 7196bf92ee6c2357e6c11511a85254fdca7675cc715653f12f30d63dd212df8a1e409c69848428d4ac86fcfa088e019dce8f82678ecc8228994f94ddf5455d9a

data/CHANGELOG.md

@@ -4,6 +4,45 @@ All notable changes to this project are documented in this file.
 
 ## [Unreleased]
 
+## [8.1.10] - 2026-05-27
+
+### Changed
+
+- **`:decimal_field` is now a real `decimal(p, s)` column instead of a `varchar`.** The FormElementRegistry mapping moves from `:decimal_field => :string` to `:decimal_field => :decimal`, so `rails g inline_forms Foo price:decimal_field` now emits `t.decimal :price, precision: 10, scale: 2` (the sensible default — invoice/balance up to 99,999,999.99). This closes a long-standing inconsistency: `decimal_field` was the only "numeric" Tier 1 helper that stored its value as text, so `"ace"` would happily round-trip and `Foo.sum(:price)` was a runtime cast error. Existing apps generated before 8.1.10 keep their varchar columns until they migrate; only newly-generated tables get `:decimal`.
+- **New CLI syntax: `name:decimal_field{p,s}` overrides precision/scale.** Mirrors Rails' built-in `name:decimal{p,s}` grammar. Examples: `latitude:decimal_field{9,6}` -> `decimal(9, 6)` (~11 cm GPS accuracy), `longitude:decimal_field{10,6}` -> `decimal(10, 6)`, `dose:decimal_field{6,3}` -> `decimal(6, 3)`. Rails' own `Rails::Generators::GeneratedAttribute.parse` only honors `{…}` on a hardcoded list of built-in types and glues the braces onto custom types as part of the type symbol; `inline_forms_attribute_overrides.rb` now pre-processes the suffix off `:decimal_field` and stores precision/scale in `attr_options` for the migration emitter to read.
+- **`decimal_field_show` / `_edit` render `BigDecimal` as fixed-point.** Once the column became a real `:decimal`, `object[attribute]` started returning `BigDecimal`, whose `to_s` defaults to scientific notation (`"0.1234e2"`). Both helpers now call `value.to_s("F")` for BigDecimal and fall through to the generic `to_s` for legacy varchar values, so existing apps display correctly with either column shape.
+
+### Added
+
+- **`FormElementShowcase` demos the new `{p,s}` syntax.** Two new attributes (`latitude:decimal_field{9,6}`, `longitude:decimal_field{10,6}`) sit alongside `price:decimal_field` in the "Numbers" header, exercising both the default `(10, 2)` and explicit overrides. Seed values are Curaçao's Willemstad coordinates (`12.123456 / -68.987654`) — exactly representable in the chosen scale so the round-trip test is bit-identical rather than float-fuzzy.
+- **`validates :price, latitude, longitude, numericality: …` in the showcase model.** Without an explicit validation, ActiveRecord silently casts `"ace"` to `BigDecimal("0")` on a `:decimal` column. The validation keeps the round-trip honest (the new integration test asserts a 422 on `"ace"`), and the `:latitude` / `:longitude` validations also pin the lat/lon ranges (±90, ±180).
+- **Model + integration tests** cover the precision/scale schema (`columns_hash["latitude"].precision == 9`), the BigDecimal round-trip at full scale, the rejection of out-of-range GPS values, and the rejection of non-numeric input.
+
+### Lockstep
+
+- `inline_forms`, `inline_forms_installer`, and `validation_hints` bumped from 8.1.9 to 8.1.10 in lockstep, even though `validation_hints` has no behavior change in this release.
+
+## [8.1.9] - 2026-05-27
+
+### Fixed
+
+- **`dropdown_with_values_show` and `dropdown_with_values_info` double-translated their labels.** `attribute_values` already runs each label through `t()` (it has to, so the values hash can use translation keys). The two show/info helpers then ran `t()` again on the *already-translated* string, so a missing translation rendered a bizarre `<span class="translation_missing" title="Low&quot;&gt;Low&lt;/Span&gt;">Low"&gt;Low&lt;/Span&gt;</span>` blob inside the inline-edit link (visible on `priority` / `priority2` in the showcase). The second `t()` call has been removed and the helpers now nil-guard the lookup, matching the 8.1.7 fixes to `dropdown_with_integers_show` and the two scale helpers.
+- **`money_field_show` dropped cents on whole-dollar amounts.** money-rails defaults `humanized_money_with_symbol` to `no_cents_if_whole: true`, so `Money.from_amount(124.00, "USD")` rendered as `$124` while `Money.from_amount(12.34, "USD")` rendered as `$12.34` — inconsistent, and indistinguishable from a precision bug on values that *rounded* to a whole dollar (e.g. `Money.from_amount(123.999, "USD")` rounds up to 12400 cents because cents are the smallest Money unit; the helper now shows that as `$124.00`). The helper now passes `no_cents_if_whole: false` so the displayed amount always has two decimals.
+
+### Changed
+
+- **`FormElementShowcase` now demos `[:locales, :check_list]` + `[:locales_display, :info_list]` instead of `[:roles, :info_list]`.** Role is reserved for the auth Member/User model — reusing it on the showcase coincidentally shared rows with `roles_users` and obscured how the demo associations were coupled. The example app now seeds four locales (`en`/`nl`/`de`/`fr`, English is the default attached to the full demo) and a `has_and_belongs_to_many :locales` join, so the showcase exercises the editable HABTM editor (`check_list`) and the read-only mirror (`info_list`) side-by-side. The read-only row uses `alias_method :locales_display, :locales` because inline_forms keys turbo frames by attribute name, so two rows for the same association need two distinct names.
+- **`start_month` label renamed to "Start month and year".** The widget is a month_year_picker; the old label hid the year half.
+- **Full-demo seed now populates `attachment` / `jingle` / `cover`.** The installer ships `sample.txt`, `sample.wav` (440Hz / 0.5s mono PCM, generated with ffmpeg), and `sample_cover.png` under `lib/installer_templates/example_app_assets`, copies them into the generated app's `db/seed_uploads/`, and the seed migration hands File handles to CarrierWave so the three file-upload rows in the full demo render thumbnails / links instead of placeholders.
+
+### Added
+
+- **`ExampleAppShowcaseLocalesAssociationsTest` integration test.** Covers `check_list` toggling the HABTM (`locale_ids` add + remove via two PUTs), `info_list` rendering the `_presentation` for attached records, and the `--` empty-state placeholder. Replaces the dropped `roles`-based assertions in `ExampleAppShowcasePageRenderTest`.
+
+### Lockstep
+
+- `inline_forms`, `inline_forms_installer`, and `validation_hints` bumped from 8.1.8 to 8.1.9 in lockstep, even though `validation_hints` has no behavior change in this release.
+
 ## [8.1.8] - 2026-05-27
 
 ### Added

data/lib/generators/inline_forms_attribute_overrides.rb

@@ -22,6 +22,37 @@ Rails::Generators::GeneratedAttribute.class_eval do
     true
   end
 
+  # Recognize `name:decimal_field{p,s}` on the command line and hoist the
+  # precision/scale into `attr_options`. Rails' own
+  # `Rails::Generators::GeneratedAttribute.parse` only honors the `{…}`
+  # suffix for a hardcoded list of built-in types (`:string`, `:integer`,
+  # `:primary_key`, `:decimal`, ...); for our custom `:decimal_field` it
+  # just glues the braces onto the type symbol (`:"decimal_field{10,2}"`)
+  # and `column_type` falls through to `:unknown`. Strip the braces here,
+  # delegate to the original parse with a clean `name:decimal_field`, and
+  # then attach the parsed numbers to attr_options so the migration
+  # emitter can render `t.decimal :name, precision: P, scale: S`.
+  #
+  # Bare `name:decimal_field` (no braces) parses unchanged — the
+  # migration emitter applies precision: 10, scale: 2 as the default.
+  class << self
+    unless method_defined?(:parse_with_inline_forms_decimal) || private_method_defined?(:parse_with_inline_forms_decimal)
+      alias_method :parse_without_inline_forms_decimal, :parse
+    end
+
+    def parse(column_definition)
+      if column_definition.is_a?(String) &&
+         (m = column_definition.match(/\A(\w+):decimal_field\{(\d+),(\d+)\}\z/))
+        attr = parse_without_inline_forms_decimal("#{m[1]}:decimal_field")
+        attr.attr_options[:precision] = m[2].to_i
+        attr.attr_options[:scale]     = m[3].to_i
+        attr
+      else
+        parse_without_inline_forms_decimal(column_definition)
+      end
+    end
+  end
+
   # Deducts the column_type for migrations from the type.
   #
   # We first merge the Special Column Types with the Default Column Types,

data/lib/generators/inline_forms_generator.rb

@@ -164,11 +164,29 @@ module InlineForms
           else
             if attribute.migration?
               attribute.attribute_type == :unknown ? commenter = '#' : commenter = ' '
+              # Render precision/scale for real :decimal columns. The override
+              # in lib/generators/inline_forms_attribute_overrides.rb teaches
+              # `Rails::Generators::GeneratedAttribute.parse` to extract
+              # `{p,s}` off the type for :decimal_field (Rails' own parser
+              # only honors `{…}` for a hardcoded list of built-in types
+              # and otherwise glues the braces onto the type symbol).
+              # Apply sensible defaults — precision: 10, scale: 2 — so a
+              # bare `name:decimal_field` becomes a real decimal column
+              # instead of the legacy varchar that 8.1.9 and earlier
+              # emitted. Existing apps keep their varchar columns until
+              # they migrate; only newly-generated tables get :decimal.
+              column_opts = ""
+              if attribute.column_type == :decimal
+                precision = attribute.attr_options[:precision] || 10
+                scale     = attribute.attr_options[:scale]     || 2
+                column_opts = ", precision: #{precision}, scale: #{scale}"
+              end
               @columns << commenter +
                 '     t.' +
                 attribute.column_type.to_s +
                 " :" +
                 attribute.name +
+                column_opts +
                 " \n"
             end
           end

data/lib/inline_forms/form_element_registry.rb

@@ -8,7 +8,7 @@ module InlineForms
       :check_list => :no_migration,
       :ckeditor => :text,
       :date_select => :date,
-      :decimal_field => :string,
+      :decimal_field => :decimal,
       :devise_password_field => :string,
       :dropdown => :belongs_to,
       :dropdown_with_integers => :integer,

data/lib/inline_forms/form_elements/decimal_field_helper.rb

@@ -6,13 +6,33 @@ module InlineForms
     # -*- encoding : utf-8 -*-
     
     def decimal_field_show(object, attribute)
-      link_to_inline_edit object, attribute, object[attribute].nil? ? "<i class='fi-plus'></i>".html_safe : object[attribute], from_callee: __callee__
+      # `:decimal_field` columns are real `:decimal(p, s)` since 8.1.10,
+      # which means `object[attribute]` returns a `BigDecimal`. Calling
+      # `to_s` on a BigDecimal without arguments returns scientific
+      # notation (`"0.1234e2"`), not the `"12.34"` users expect — render
+      # fixed-point. Strings (legacy varchar columns on apps generated
+      # before 8.1.10) and integers/floats also work with `to_s("F")` via
+      # their generic `to_s` fallback.
+      value = object[attribute]
+      label = if value.nil?
+                "<i class='fi-plus'></i>".html_safe
+              elsif value.is_a?(BigDecimal)
+                value.to_s("F")
+              else
+                value.to_s
+              end
+      link_to_inline_edit object, attribute, label, from_callee: __callee__
     end
-    
+
     def decimal_field_edit(object, attribute)
-      text_field_tag attribute, (object.send attribute.to_sym), :class => 'input_decimal_field'  # for abide: , :required => true
+      # Render with fixed-point in the edit textbox for the same reason
+      # decimal_field_show does — otherwise the user sees "0.1234e2" in
+      # the edit field on an existing value, and round-trips it back.
+      value = object.send(attribute.to_sym)
+      value = value.to_s("F") if value.is_a?(BigDecimal)
+      text_field_tag attribute, value, :class => 'input_decimal_field'  # for abide: , :required => true
     end
-    
+
     def decimal_field_update(object, attribute)
       object.send :write_attribute, attribute.to_sym, params[attribute.to_sym]
     end

data/lib/inline_forms/form_elements/dropdown_with_values_helper.rb

@@ -7,8 +7,19 @@ module InlineForms
     
     # dropdown_with_values
     def dropdown_with_values_show(object, attribute)
+      # `attribute_values` already runs every label through `t()` (see
+      # InlineForms::Helpers#attribute_values). Calling `t()` again here on
+      # an already-translated (and possibly already-rendered as
+      # `<span class="translation_missing">...</span>`) string used the
+      # whole string as an I18n key, so a missing translation rendered the
+      # bizarre `<span class="translation_missing" title="Low&quot;&gt;Low&lt;/Span&gt;">…</span>`
+      # blob the user spotted on `priority`/`priority2`. Use the already-
+      # translated value as-is and fall back to the empty-state placeholder
+      # for nil (mirrors radio_button_show and the 8.1.7 scale fixes).
       values = attribute_values(object, attribute)
-      link_to_inline_edit object, attribute, object.send(attribute) ? t(values.assoc(object.send(attribute))[1]) : "<i class='fi-plus'></i>".html_safe, from_callee: __callee__
+      pair = object.send(attribute) ? values.assoc(object.send(attribute)) : nil
+      label = pair ? pair[1] : "<i class='fi-plus'></i>".html_safe
+      link_to_inline_edit object, attribute, label, from_callee: __callee__
     end
     
     def dropdown_with_values_edit(object, attribute)
@@ -31,8 +42,11 @@ module InlineForms
     end
     
     def dropdown_with_values_info(object, attribute)
+      # `attribute_values` already translates; do not double-translate here
+      # (was the same double-`t()` bug as dropdown_with_values_show).
       values = attribute_values(object, attribute)
-      t(values.assoc(object.send(attribute))[1]) rescue '-'
+      pair = values.assoc(object.send(attribute))
+      pair ? pair[1] : '-'
     end
       INLINE_FORMS_FORM_ELEMENT
     end

data/lib/inline_forms/form_elements/money_field_helper.rb

@@ -6,16 +6,22 @@ module InlineForms
     # -*- encoding : utf-8 -*-
     
     def money_field_show(object, attribute)
-      # `humanized_money_with_symbol` (money-rails) returns "" for nil/blank
-      # which renders as an empty anchor — show the empty-state placeholder
-      # instead, matching the nil branch on dropdown/radio show helpers.
+      # Two money-rails-specific quirks the bare helper used to leak:
+      #   1. `humanized_money_with_symbol(nil)` returns "", which renders
+      #      as an empty `<a>` tag. Fall back to the empty-state
+      #      placeholder used by the other choice helpers instead.
+      #   2. `humanized_money_with_symbol` defaults `no_cents_if_whole: true`,
+      #      so whole-dollar amounts show without cents ("$124" instead of
+      #      "$124.00"). That's inconsistent with non-whole amounts ("$12.34")
+      #      and looks like a precision bug on values that rounded up to a
+      #      whole dollar (e.g. `Money.from_amount(123.999, "USD")` rounds
+      #      to 12400 cents → "$124" by default; "$124.00" with the override).
+      #      Always show cents.
       value = object.send(attribute)
-      label = if defined?(humanized_money_with_symbol) && value.respond_to?(:zero?) && !value.zero?
-                humanized_money_with_symbol(value)
-              elsif value.blank?
+      label = if value.blank?
                 "<i class='fi-plus'></i>".html_safe
               else
-                humanized_money_with_symbol(value)
+                humanized_money_with_symbol(value, no_cents_if_whole: false)
               end
       link_to_inline_edit object, attribute, label, from_callee: __callee__
     end

data/lib/inline_forms/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module InlineForms
-  VERSION = "8.1.8"
+  VERSION = "8.1.10"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inline_forms
 version: !ruby/object:Gem::Version
-  version: 8.1.8
+  version: 8.1.10
 platform: ruby
 authors:
 - Ace Suares