glib-web 5.1.5 → 6.3.1

data/app/views/json_ui/garage/test_page/run_multiple.json.jbuilder

@@ -0,0 +1,31 @@
+json.title 'Test Page (Run Multiple)'
+
+page = json_ui_page json
+
+render 'json_ui/garage/test_page/header', json: json, page: page
+
+page.body childViews: ->(body) do
+  body.panels_responsive padding: glib_json_padding_body, childViews: ->(res) do
+    res.h2 text: 'runMultiple ordering'
+    res.spacer height: 8
+    res.button \
+      text: 'Run sequence',
+      onClick: ->(action) do
+        action.runMultiple childActions: ->(multiple) do
+          # Two writes to the SAME target: the final text proves in-order,
+          # sequential execution (last write wins).
+          multiple.logics_set targetId: 'sequence_status', data: { text: 'STEP 1' }
+          multiple.logics_set targetId: 'sequence_status', data: { text: 'STEP 2' }
+          # Nested runMultiple must execute within the outer sequence.
+          multiple.runMultiple childActions: ->(nested) do
+            nested.logics_set targetId: 'nested_status', data: { text: 'NESTED DONE' }
+          end
+          multiple.logics_set targetId: 'sequence_status', data: { text: 'STEP 3' }
+          multiple.snackbars_alert message: 'Sequence finished'
+        end
+      end
+    res.spacer height: 8
+    res.label id: 'sequence_status', text: 'PENDING'
+    res.label id: 'nested_status', text: 'PENDING'
+  end
+end

data/app/views/json_ui/garage/test_page/windows_reload.json.jbuilder

@@ -0,0 +1,57 @@
+json.title 'Test Page (Windows Reload)'
+
+page = json_ui_page json
+
+render 'json_ui/garage/test_page/header', json: json, page: page
+
+# Contract page for `windows_reload` (see the npm package's
+# actions/windows/reload.js): reload re-renders the CURRENT page from the
+# server in place -- user input is discarded (guarded by the dirty prompt),
+# scroll position is preserved, and the history entry is REPLACED, so Back
+# skips the pre-reload state.
+page.body childViews: ->(body) do
+  body.panels_responsive padding: glib_json_padding_body, childViews: ->(res) do
+    res.h2 text: 'Windows reload contract'
+
+    # Changes on every render so specs can detect that a reload completed
+    # (a bare reload keeps the same URL, so the URL proves nothing).
+    res.label text: "Render stamp: #{SecureRandom.hex(8)}"
+    res.label text: "Step: #{params[:step] || 'initial'}"
+    res.spacer height: 8
+
+    res.panels_form \
+      url: json_ui_garage_url(path: 'forms/generic_post'),
+      method: 'post',
+      childViews: ->(form) do
+        form.fields_text width: 'matchParent', name: 'user[nickname]', label: 'Nickname'
+      end
+
+    res.spacer height: 8
+    res.button \
+      text: 'windows/reload',
+      onClick: ->(action) do
+        action.windows_reload
+      end
+    res.spacer height: 8
+    res.button \
+      text: 'windows/open (step two)',
+      onClick: ->(action) do
+        action.windows_open url: json_ui_garage_url(path: 'test_page/windows_reload', step: 'two')
+      end
+    res.spacer height: 8
+    res.button \
+      text: 'windows/reload (step three)',
+      onClick: ->(action) do
+        action.windows_reload url: json_ui_garage_url(path: 'test_page/windows_reload', step: 'three')
+      end
+
+    # Tall filler so the page scrolls; the bottom button lets specs trigger a
+    # reload without Cypress scrolling back up to reach a button.
+    res.spacer height: 2000
+    res.button \
+      text: 'windows/reload (from bottom)',
+      onClick: ->(action) do
+        action.windows_reload
+      end
+  end
+end

data/lib/glib/engine.rb

@@ -1,7 +1,139 @@
+require 'active_snapshot/models/snapshot'
+
 module Glib
   module Web
     class Engine < ::Rails::Engine
       # isolate_namespace Glib::Web
+
+      # Extends ActiveSnapshot::Snapshot (the snapshot record class) with a structured-diff
+      # reader so consumers don't have to re-parse raw Hashdiff tuples from the `diff` column.
+      # Runs as an engine initializer (not at file-load time) because `scope` and other AR
+      # class methods aren't available until ActiveRecord is fully loaded.
+      initializer 'glib.active_snapshot_ext' do
+        ActiveSnapshot::Snapshot.class_eval do
+          unless const_defined?(:Change)
+            const_set(:Change, Struct.new(:index, :action, :from, :to))
+          end
+
+          # Mirror `Glib::ApplicationRecord.created_desc` so call sites can use the codebase-wide
+          # convention instead of `order(created_at: :desc)`.
+          unless respond_to?(:created_desc)
+            scope :created_desc, -> { order(created_at: :desc) }
+          end
+
+          # Parses the stored diff into a flat hash of Change structs:
+          #   { 'item' => [Change, ...], 'association_name' => [Change, ...], ... }
+          # Returns an empty structure if no diff exists (e.g. the first snapshot).
+          # Reads from a dedicated `diff` column if the table has one (app override),
+          # otherwise falls back to `metadata['diff']` (glib-web's default storage).
+          #
+          # JSONB round-trips every value as a string, so datetime/date column values arrive as
+          # ISO8601 strings instead of Time/Date objects. The cast_* methods resolve the column
+          # type from the live model schema and cast the value back so consumers (e.g. timeline
+          # helpers) receive typed values. Casts are guarded:
+          #   - Deleted column → type_for_attribute returns a default Value type (type=nil) → skipped
+          #   - Deleted model → safe_constantize returns nil → skipped
+          #   - Deleted association → reflect_on_association returns nil → skipped
+          #   - Changed column type → type.cast returns nil for unparseable values (no crash)
+          #   - Exotic type failure → rescue returns the raw value (defense-in-depth)
+          def changes_from_prev_version
+            diff = self[:diff] || metadata&.dig('diff')
+            return { 'item' => [] } if diff.nil?
+
+            root = item_type.to_s.safe_constantize
+
+            result = {
+              'item' => (diff['item'] || []).map { |data| cast_item_change(build_change(data), root) }
+            }
+
+            (diff['associations'] || {}).each do |association, tuples|
+              assoc_model = root&.reflect_on_association(association.to_s)&.klass
+              result[association.to_s] = tuples.map { |data| cast_association_change(build_change(data), assoc_model) }
+            end
+
+            result
+          end
+
+          # Converts a single raw Hashdiff tuple (e.g. ["~", "field", old, new]) into a Change struct.
+          # For item-level tuples, `data[1]` is the column name (e.g. "title").
+          # For association tuples, `data[1]` is a numeric path like "[0]" (position in the collection).
+          # Both are captured as `index` so consumers can label rows via humanize.
+          def build_change(data)
+            actions = {
+              '+' => 'create',
+              '-' => 'destroy',
+              '~' => 'update'
+            }.freeze
+
+            change = ActiveSnapshot::Snapshot.const_get(:Change).new
+            change.action = actions[data[0].to_s]
+
+            path = data[1].to_s
+            bracket_match = path.match(/\[(?<index>[^\]]+)\]/)
+            change.index = bracket_match ? bracket_match[:index] : path
+
+            payload = data[2]
+            case change.action
+            when 'create'
+              change.from = nil
+              change.to = payload
+            when 'destroy'
+              change.from = payload
+              change.to = nil
+            when 'update'
+              change.from = payload
+              change.to = data[3]
+            else
+              raise "Unexpected Hashdiff op: #{data[0].inspect}"
+            end
+
+            change
+          end
+
+          private
+            # Item-level change: from/to are scalar column values. Cast each to the column's real type.
+            def cast_item_change(change, root)
+              change.from = cast_column_value(root, change.index, change.from)
+              change.to   = cast_column_value(root, change.index, change.to)
+              change
+            end
+
+            # Association-level change: from/to are attribute hashes. Cast each attribute by the
+            # association model's column types.
+            def cast_association_change(change, assoc_model)
+              change.from = cast_attributes(assoc_model, change.from)
+              change.to   = cast_attributes(assoc_model, change.to)
+              change
+            end
+
+            # Cast a single value when `column` is a date/time column on `model`; otherwise return it
+            # unchanged. Safeguards for schema drift after the snapshot was taken:
+            #   - Deleted column → type_for_attribute returns a default type (type=nil) → skipped
+            #   - Changed column type → type.cast may return nil for the old value → return raw value
+            #   - Exotic failure → rescue returns raw value
+            # In all fallback cases the raw value is returned so the timeline never loses data.
+            def cast_column_value(model, column, value)
+              return value if value.nil? || model.nil?
+
+              type = model.type_for_attribute(column.to_s)
+              return value unless %i[datetime date time].include?(type.type)
+
+              casted = type.cast(value)
+              # If the column type changed after the snapshot was taken, the old value may not
+              # be parseable as the new type — type.cast returns nil silently. Return the raw
+              # value so the timeline still shows the original data instead of "<not set>".
+              casted.nil? ? value : casted
+            rescue StandardError
+              value
+            end
+
+            def cast_attributes(model, attrs)
+              return attrs unless model && attrs.is_a?(Hash)
+
+              attrs.to_h { |column, value| [column, cast_column_value(model, column, value)] }
+            end
+        end
+      end
     end
   end
 end

data/lib/glib/rubocop.rb

@@ -1,5 +1,4 @@
 require_relative 'rubocop/cops/localize'
-require_relative 'rubocop/cops/multiline_method_call_style'
 require_relative 'rubocop/cops/json_ui/base_nested_parameter'
 require_relative 'rubocop/cops/json_ui/nested_block_parameter'
 require_relative 'rubocop/cops/json_ui/nested_action_parameter'

data/lib/glib/snapshot.rb

@@ -95,8 +95,20 @@ module Glib
 
       raise 'unknown action' if !known_actions.include?(action.to_s)
 
+      # Cheap pre-check WITHOUT a lock — the overwhelmingly common case is "nothing
+      # changed". same_as_before? is a pure read (it re-queries snapshot_prev and
+      # associations each call) and cannot produce a false "same", so returning nil
+      # here is always safe and skips the row lock entirely.
+      return nil if same_as_before?
+
       result = nil
       with_lock do
+        # Re-check under the lock: another writer may have snapshotted this exact
+        # change between the unlocked pre-check and here. NOT optional — without it,
+        # every concurrent writer that passed the pre-check would compute
+        # last_version + 1 and insert a duplicate snapshot of the same change.
+        next if same_as_before?
+
         version = last_version + 1
         metadata = {
           action: action,
@@ -114,11 +126,8 @@ module Glib
           snapshot_obj.delete(:user)
         end
 
-        # dont create version if same as before
-        if !same_as_before?
-          result = create_snapshot!(**snapshot_obj)
-          remove_old_snapshot if result.present?
-        end
+        result = create_snapshot!(**snapshot_obj)
+        remove_old_snapshot if result.present?
       end
       result
     end
@@ -151,11 +160,13 @@ module Glib
         associations = {}
       end
 
+      item_attrs = normalize_attributes(item.attributes.except(*ignore_keys))
+      current_attrs = normalize_attributes(attributes.except(*ignore_keys))
       obj = {
-        'item' => ::Hashdiff.diff(item.attributes.except(*ignore_keys), attributes.except(*ignore_keys))
+        'item' => ::Hashdiff.diff(item_attrs, current_attrs)
       }
 
-      obj['associations'] = associations_for_snapshot.reduce({}) do |prev, curr| # rubocop:disable Glib/MultilineMethodCallStyle
+      obj['associations'] = associations_for_snapshot.reduce({}) do |prev, curr|
         association_records = records_for_snapshot(curr)
         first_record_off_same_collection = association_records.first
 
@@ -183,22 +194,29 @@ module Glib
         now = association_records
 
         if before.blank?
-          prev.merge(curr.to_s => ::Hashdiff.diff([], now.map { |record| record.attributes.except(*association_ignored_keys) }))
+          prev.merge(
+            curr.to_s => ::Hashdiff.diff(
+              [],
+              now.map { |record| normalize_attributes(record.attributes.except(*association_ignored_keys)) }
+            )
+          )
         else
           diff = before.map.with_index do |record_before, index|
             record_now = now.find_by(id: record_before.id)
             if record_now.blank?
-              ['-', "[#{index}]", record_before.attributes.except(*association_ignored_keys)]
+              ['-', "[#{index}]", normalize_attributes(record_before.attributes.except(*association_ignored_keys))]
             elsif record_now.present?
-              next if Hashdiff.diff(record_before.attributes.except(*association_ignored_keys), record_now.attributes.except(*association_ignored_keys)).blank?
-              ['~', "[#{index}]", record_before.attributes.except(*association_ignored_keys), record_now.attributes.except(*association_ignored_keys)]
+              before_attrs = normalize_attributes(record_before.attributes.except(*association_ignored_keys))
+              now_attrs = normalize_attributes(record_now.attributes.except(*association_ignored_keys))
+              next if Hashdiff.diff(before_attrs, now_attrs).blank?
+              ['~', "[#{index}]", before_attrs, now_attrs]
             end
           end.compact_blank
 
           diff2 = now.map.with_index do |record_now, index|
             record_before = before.detect { |record| record.id == record_now.id }
             if record_before.blank?
-              ['+', "[#{index}]", record_now.attributes.except(*association_ignored_keys)]
+              ['+', "[#{index}]", normalize_attributes(record_now.attributes.except(*association_ignored_keys))]
             end
           end.compact_blank
 
@@ -296,5 +314,32 @@ module Glib
           Array(records)
         end
       end
+
+      # Datetimes lose sub-millisecond precision on the snapshot store→reify round-trip:
+      # the JSON column encodes Time via ActiveSupport::JSON::Encoding.time_precision
+      # (default 3 = milliseconds, truncated not rounded), and reify casts that string
+      # back to a Time whose usec is a multiple of 1000. The live DB value keeps full
+      # microsecond precision, so Hashdiff (which compares Time values with ==) reports a
+      # phantom change on every re-snapshot of any watched sub-second datetime. Floor both
+      # sides to the same precision before the compare. The divisor is derived from
+      # time_precision so a consumer who raises it to 6 (microseconds) is not truncated.
+      # Because Hashdiff emits these floored values, the stored `metadata['diff']` also
+      # carries ms-precision datetimes (not just the in-memory comparison) — readers that
+      # introspect the raw diff see `.123000` even when the column holds `.123456`.
+      def normalize_attributes(hash)
+        divisor = snapshot_time_divisor
+        hash.transform_values { |value| normalize_datetime(value, divisor) }
+      end
+
+      def normalize_datetime(value, divisor = snapshot_time_divisor)
+        return value unless value.respond_to?(:usec)
+        return value if divisor <= 1
+
+        value.change(usec: value.usec - value.usec % divisor)
+      end
+
+      def snapshot_time_divisor
+        10 ** (6 - ActiveSupport::JSON::Encoding.time_precision)
+      end
   end
 end

data/lib/glib/test/parallel_coverage.rb

@@ -14,6 +14,7 @@ module Glib
     #   end
     #
     # This will:
+    # - Build Vite assets (if the app uses Vite) once, before workers fork
     # - Enable parallel test execution using all available processors
     # - Configure SimpleCov to track each worker separately
     # - Automatically merge coverage results from all workers
@@ -21,6 +22,21 @@ module Glib
       extend ActiveSupport::Concern
 
       included do
+        # Vite's lazy autoBuild is not fork-safe: its build mutex is a thread
+        # Mutex, so when the test manifest is stale, every parallel worker's
+        # first asset lookup spawns its own full `vite build` (a node process
+        # using several hundred MB). With :number_of_processors workers that
+        # is enough concurrent builds to exhaust RAM and swap and OOM the
+        # machine. Build once here, in the parent process before forking, so
+        # the workers' freshness checks all pass without building. The guard
+        # mirrors the lazy path's own `should_build?` so this stays a no-op
+        # wherever the workers would never have built either (autoBuild off,
+        # or a dev server serving the test mode).
+        if defined?(ViteRuby) && ViteRuby.config.auto_build && !ViteRuby.instance.dev_server_running?
+          ViteRuby.commands.build ||
+            raise('vite build failed (a cached failed build also lands here; see log or run bin/vite build)')
+        end
+
         # Set threshold for force parallelization.
         parallelize(workers: :number_of_processors, threshold: 1)
 

data/lib/tasks/db.rake

@@ -81,6 +81,12 @@ namespace :db do
                 attrs[key] = value.to_json
               elsif value.is_a? BigDecimal
                 attrs[key] = value.to_f
+              elsif value.is_a?(IPAddr)
+                # inet/cidr columns deserialize to IPAddr. Dump as a plain string so
+                # fixtures stay portable: IPAddr's internal `family` constant differs
+                # between Linux/WSL and macOS, so a YAML-dumped IPAddr object raises
+                # when loaded on the other OS. Strings re-parse via cast_value on any platform.
+                attrs[key] = value.to_s
               end
             end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glib-web
 version: !ruby/object:Gem::Version
-  version: 5.1.5
+  version: 6.3.1
 platform: ruby
 authors:
 - ''
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-04 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activestorage
@@ -206,6 +206,7 @@ files:
 - app/helpers/glib/json_ui/default.rb
 - app/helpers/glib/json_ui/dynamic_field_builders.rb
 - app/helpers/glib/json_ui/generic_builders.rb
+- app/helpers/glib/json_ui/json_logic_lint.rb
 - app/helpers/glib/json_ui/list_builders.rb
 - app/helpers/glib/json_ui/menu_builder.rb
 - app/helpers/glib/json_ui/page_helper.rb
@@ -420,7 +421,12 @@ files:
 - app/views/json_ui/garage/test_page/fields_url_fragment.json.jbuilder
 - app/views/json_ui/garage/test_page/flow.json.jbuilder
 - app/views/json_ui/garage/test_page/form.json.jbuilder
+- app/views/json_ui/garage/test_page/form_dirty_hooks.json.jbuilder
 - app/views/json_ui/garage/test_page/form_dynamic.json.jbuilder
+- app/views/json_ui/garage/test_page/form_dynamic_dirty.json.jbuilder
+- app/views/json_ui/garage/test_page/form_removed_field.json.jbuilder
+- app/views/json_ui/garage/test_page/form_removed_field_onload.json.jbuilder
+- app/views/json_ui/garage/test_page/form_touched_validation.json.jbuilder
 - app/views/json_ui/garage/test_page/forms.json.jbuilder
 - app/views/json_ui/garage/test_page/grid.json.jbuilder
 - app/views/json_ui/garage/test_page/horizontal.json.jbuilder
@@ -429,6 +435,8 @@ files:
 - app/views/json_ui/garage/test_page/lifecycle.json.jbuilder
 - app/views/json_ui/garage/test_page/list.json.jbuilder
 - app/views/json_ui/garage/test_page/list_editable.json.jbuilder
+- app/views/json_ui/garage/test_page/logics_run.json.jbuilder
+- app/views/json_ui/garage/test_page/logics_run_multi_form.json.jbuilder
 - app/views/json_ui/garage/test_page/logics_set.json.jbuilder
 - app/views/json_ui/garage/test_page/multimedia_video.json.jbuilder
 - app/views/json_ui/garage/test_page/pagination.json.jbuilder
@@ -437,6 +445,7 @@ files:
 - app/views/json_ui/garage/test_page/popovers.json.jbuilder
 - app/views/json_ui/garage/test_page/progressCircle.json.jbuilder
 - app/views/json_ui/garage/test_page/responsive.json.jbuilder
+- app/views/json_ui/garage/test_page/run_multiple.json.jbuilder
 - app/views/json_ui/garage/test_page/scroll.json.jbuilder
 - app/views/json_ui/garage/test_page/selectable.json.jbuilder
 - app/views/json_ui/garage/test_page/sheets.json.jbuilder
@@ -453,6 +462,7 @@ files:
 - app/views/json_ui/garage/test_page/web.json.jbuilder
 - app/views/json_ui/garage/test_page/window.json.jbuilder
 - app/views/json_ui/garage/test_page/windows.json.jbuilder
+- app/views/json_ui/garage/test_page/windows_reload.json.jbuilder
 - app/views/json_ui/garage/views/_chart_data.json.jbuilder
 - app/views/json_ui/garage/views/_checkbox_expand.json.jbuilder
 - app/views/json_ui/garage/views/_expand_shrink_ex.json.jbuilder
@@ -522,7 +532,6 @@ files:
 - lib/glib/rubocop/cops/json_ui/nested_action_parameter.rb
 - lib/glib/rubocop/cops/json_ui/nested_block_parameter.rb
 - lib/glib/rubocop/cops/localize.rb
-- lib/glib/rubocop/cops/multiline_method_call_style.rb
 - lib/glib/rubocop/cops/test_name_parentheses.rb
 - lib/glib/snapshot.rb
 - lib/glib/test/changed_files_rubocop.rb