glib-web 6.2.0 → 6.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52b6b62180ee0cd668652772110774bc915d8789f1fd65e9ef22fadd781977a4
-  data.tar.gz: 3d47de6a06859cce937834478bbef460e2cac999bbfbdf72cef10a781399e68f
+  metadata.gz: 8378cb302a462be1ed8ee965c9ace54b77c4eb29f7d1cc9d83a469c89d0f6d93
+  data.tar.gz: 91f29270361f13067e3bc513cd01091e82b09d7a89a40eadb4dab893b59f7a66
 SHA512:
-  metadata.gz: c6537178f38fa7703d8c3e0436f1c3d4ac1171c340bcda27d18aad936a7ff40e329488c0cbf618dd0974e4e7a7926a3b209eb3c88f29447416b1000db9fee37d
-  data.tar.gz: c532e338ce8890c52a5efc9c07c734fd99f4adba46f244f5a5c9c160b188b7630d0d18b080ad599a528ad9bb9a68fc5697c84137ec5383524308fc58b53c512b
+  metadata.gz: 62c1600d052a52e8fb020662ca4db7455518945e298c6e5ea5663e4960955d9d29129252b0780107b138bd4d585a4463f4bef253dc26460203acee362b083af8
+  data.tar.gz: 4d816f8451f71efbbb96fbcbe64fe1586211b3e328c42ec89580d711abe9f5d62033ff645f1622b855fa31e86eee5a383ed2ff6732d0a817ba6462bea6e23821

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/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,8 +160,10 @@ 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|
@@ -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/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: 6.2.0
+  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