glib-web 6.2.0 → 6.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52b6b62180ee0cd668652772110774bc915d8789f1fd65e9ef22fadd781977a4
-  data.tar.gz: 3d47de6a06859cce937834478bbef460e2cac999bbfbdf72cef10a781399e68f
+  metadata.gz: 4f55e891cbc4a9325dbf8fe235dcb593982686ec8e36f62d86b6aea853e83f22
+  data.tar.gz: 6299bcaf264a60d4a604dc6dc7f44f45f2671f2827b8a6fe26f266979d82dbf5
 SHA512:
-  metadata.gz: c6537178f38fa7703d8c3e0436f1c3d4ac1171c340bcda27d18aad936a7ff40e329488c0cbf618dd0974e4e7a7926a3b209eb3c88f29447416b1000db9fee37d
-  data.tar.gz: c532e338ce8890c52a5efc9c07c734fd99f4adba46f244f5a5c9c160b188b7630d0d18b080ad599a528ad9bb9a68fc5697c84137ec5383524308fc58b53c512b
+  metadata.gz: 368a1c82a9ee9f539b38d4e3396b0fa14cf449fef03d50862239b549d3d9593a19b8961f41e521d8a627bf58530b63b5ac6f1a89310bebe1d0b5a5e61d811361
+  data.tar.gz: b8fe1cd9c3256ad9d3d7ea1cafb5adef1ec80e984ec7678edfd5e6aaec585babdc96aaddcef189003269ab9a33b89b00aae5fe5ac1c4988458de0ec3fa33fec4

data/app/controllers/concerns/glib/form_stepper/controller.rb

@@ -0,0 +1,73 @@
+module Glib
+  module FormStepper
+    # A session-backed multi-step wizard: per-step answers accumulate in the
+    # session and nothing is persisted until the final step commits. Fits
+    # pre-account flows and any wizard where an abandoned run should simply
+    # disappear.
+    #
+    # The including controller declares the flow and its session bucket:
+    #
+    #   class ApplyController < ApplicationController
+    #     include Glib::FormStepper::Controller
+    #
+    #     STEPS = [
+    #       Glib::FormStepper::Step.new(key: :program, title: "Program", position: 1),
+    #       Glib::FormStepper::Step.new(key: :auditor, title: "Auditor", position: 2)
+    #     ].freeze
+    #     SESSION_KEY = "apply_application".freeze
+    #   end
+    #
+    # The current step is resolved from `params[:id]`, defaulting to the first step.
+    module Controller
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :current_step, :next_step, :prev_step, :step_data, :steps
+      end
+
+      def steps
+        self.class::STEPS
+      end
+
+      def current_step
+        @current_step ||= find_step(params[:id] || steps.first.key)
+      end
+
+      def next_step
+        idx = steps.index(current_step)
+        idx && steps[idx + 1]
+      end
+
+      def prev_step
+        idx = steps.index(current_step)
+        idx&.positive? ? steps[idx - 1] : nil
+      end
+
+      # Every answer gathered so far, one hash per step key.
+      def session_data
+        session[self.class::SESSION_KEY] ||= {}
+      end
+
+      # The current step's answers — what its form reads to prefill itself.
+      def step_data
+        session_data[current_step.key.to_s] || {}
+      end
+
+      # Merge (not replace) so re-submitting a step updates rather than clobbers.
+      def save_step_data(data)
+        key = current_step.key.to_s
+        session_data[key] = (session_data[key] || {}).merge(data)
+      end
+
+      def clear_session_data
+        session.delete(self.class::SESSION_KEY)
+      end
+
+      private
+        def find_step(key)
+          steps.find { |step| step.key == key.to_sym } ||
+            raise(ArgumentError, "Unknown step: #{key}")
+        end
+    end
+  end
+end

data/app/controllers/concerns/glib/form_stepper/step.rb

@@ -0,0 +1,12 @@
+module Glib
+  module FormStepper
+    # One step in a session-backed wizard: just its identity and label. `key` is
+    # coerced to a symbol so a step declared with either a symbol or string, and a
+    # `params[:id]` that always arrives as a string, resolve to the same step.
+    Step = Data.define(:key, :title, :position) do
+      def initialize(key:, title:, position:)
+        super(key: key.to_sym, title: title, position: position)
+      end
+    end
+  end
+end

data/app/models/glib/country_list.rb

@@ -0,0 +1,33 @@
+require 'countries' # ISO 3166 data (ISO3166::Country)
+
+module Glib
+  # ISO 3166 country data for country dropdowns.
+  #
+  # Backed entirely by the `countries` gem, so there is no table to migrate or
+  # seed, and renames (Türkiye, Czechia) arrive with a `bundle update`. Store
+  # the alpha-2 code rather than the name, so a rename never invalidates
+  # existing data.
+  module CountryList
+    class << self
+      # `common_name` is what people actually call the place ("South Korea",
+      # "United Kingdom") rather than the formal ISO name ("Korea (Republic of)").
+      def options
+        @options ||= ISO3166::Country.all
+          .map { |country| { value: country.alpha2, text: country.common_name || country.iso_short_name } }
+          .sort_by { |option| option[:text] }
+          .freeze
+      end
+
+      def codes
+        @codes ||= options.pluck(:value).freeze
+      end
+
+      def name_for(code)
+        return if code.blank?
+
+        country = ISO3166::Country[code]
+        country && (country.common_name || country.iso_short_name)
+      end
+    end
+  end
+end

data/app/models/glib/state_list.rb

@@ -0,0 +1,49 @@
+require 'countries' # ISO 3166-2 subdivision data (ISO3166::Country)
+
+module Glib
+  # ISO 3166-2 subdivision (state/province/territory) data for state dropdowns.
+  #
+  # The companion to Glib::CountryList: backed entirely by the `countries` gem,
+  # so there is no table to migrate or seed, and renames arrive with a
+  # `bundle update`. Store the subdivision code (e.g. "NSW") rather than the
+  # name, so a rename never invalidates existing data. The code is only unique
+  # within a country, so always store it alongside the country code.
+  #
+  # Not every country has subdivisions in the ISO data (e.g. Vatican City); for
+  # those `options_for` returns `[]` and the UI should fall back to a plain text
+  # field or omit the state input entirely.
+  module StateList
+    class << self
+      # Options for a single country's state dropdown, sorted by display name.
+      # `country_code` is an alpha-2 code, matching what Glib::CountryList stores.
+      def options_for(country_code)
+        return [] if country_code.blank?
+
+        (@options_by_country ||= {})[country_code.to_s.upcase] ||= build_options(country_code)
+      end
+
+      def codes_for(country_code)
+        options_for(country_code).pluck(:value)
+      end
+
+      def name_for(country_code, state_code)
+        return if country_code.blank? || state_code.blank?
+
+        country = ISO3166::Country[country_code]
+        subdivision = country&.subdivisions&.dig(state_code.to_s.upcase)
+        subdivision&.name
+      end
+
+      private
+        def build_options(country_code)
+          country = ISO3166::Country[country_code]
+          return [] if country.nil?
+
+          country.subdivisions
+            .map { |code, subdivision| { value: code, text: subdivision.name } }
+            .sort_by { |option| option[:text] }
+            .freeze
+        end
+    end
+  end
+end

data/app/views/json_ui/garage/actions/_dialogs_show.json.jbuilder

@@ -24,7 +24,11 @@ markdown = '## Emphasis' + "\n" +
   It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged.
   It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages,
   and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
-  "
+  ".gsub("\n", "  \n")
+# The gsub turns each bare newline into a markdown hard break: the renderer
+# uses standard (breaks: false) semantics, under which these hand-wrapped
+# lines would otherwise reflow into one block — and this dialog exists to
+# demonstrate scrolling, so it needs its ~20 visible lines.
 
 
 options = {}

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

@@ -367,5 +367,8 @@ page.body childViews: ->(body) do
     #     end
     #   )
     # end
+    #
+
+    res.button text: 'windows/reload', onClick: ->(action) { action.windows_reload }
   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/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/glib-web.rb

@@ -1,3 +1,5 @@
+require 'ostruct'
+
 if defined?(::Rails)
   require 'glib/engine'
   require 'glib/snapshot'

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,13 @@
 --- !ruby/object:Gem::Specification
 name: glib-web
 version: !ruby/object:Gem::Version
-  version: 6.2.0
+  version: 6.3.2
 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
@@ -122,6 +121,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: countries
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -150,7 +177,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email: ''
 executables: []
 extensions: []
@@ -163,6 +189,8 @@ files:
 - app/controllers/concerns/glib/analytics/funnel.rb
 - app/controllers/concerns/glib/auth/policy.rb
 - app/controllers/concerns/glib/auth/response.rb
+- app/controllers/concerns/glib/form_stepper/controller.rb
+- app/controllers/concerns/glib/form_stepper/step.rb
 - app/controllers/concerns/glib/json/dynamic_text.rb
 - app/controllers/concerns/glib/json/libs.rb
 - app/controllers/concerns/glib/json/new_dynamic_text.rb
@@ -228,8 +256,10 @@ files:
 - app/models/glib/active_storage/attachment.rb
 - app/models/glib/active_storage/blob.rb
 - app/models/glib/application_record.rb
+- app/models/glib/country_list.rb
 - app/models/glib/dummy_job_application.rb
 - app/models/glib/dynamic_text_record.rb
+- app/models/glib/state_list.rb
 - app/models/glib/text.rb
 - app/policies/glib/application_policy.rb
 - app/validators/email_typo_validator.rb
@@ -541,10 +571,8 @@ files:
 - lib/glib/time_returning_mailer.rb
 - lib/glib/value.rb
 - lib/tasks/db.rake
-homepage:
 licenses: []
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -559,8 +587,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: ''
 test_files: []