demo_mode 3.5.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a112b6f295027661f77ad3e708d373f6e24483ee562aa23307787c29f5cb45a9
-  data.tar.gz: 61c4948ea423a70295d48ed8b62a2d7de6359efa30560a8b40faa6831e2ada3a
+  metadata.gz: 5b2e916a3b2b58e6f3cbd027fad72a91b8cb550443a50e64988caa0dbd1ff6fa
+  data.tar.gz: ff00e7655ecf6d9e5ae118b84542bf97ec6e568143e4c2961ef42b1c28e0894c
 SHA512:
-  metadata.gz: 85fc9433912c6d7b9272cb9e7c526b9fdb7f3326784d6b65ba0b42dd9b9b022f643b79c7f7f5a299af5ee9bddf6c3594414a010fb1dc2bf670642a25b4c363c2
-  data.tar.gz: e05fed5948d72ef9cdd31bf01be8a9589648cdee0da4c6e24c080e1f82fab3cf2c669b6eb47dab470e730b8adbce943cd85c76c3c160f3bc1ed6bc458aaffad3
+  metadata.gz: b240952b7f353fff7cb723a409cc07806ffc477d83640968d486d4050f69d37d51777fa93e603f3e41b869226314cffba020fc7df96f640220dd5389591c0895
+  data.tar.gz: ee5ebfd9364b612abaa6dbff7b0f6d6f0e3624dbd7383486282c9504e85d4d96ee54c39c76b143f4d4f10cb06f557ee0355595b57ca35faf5384ca951f6d883f

data/lib/demo_mode/clever_sequence/in_memory_backend.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class CleverSequence
+  module InMemoryBackend
+    class << self
+      def nextval(klass, attribute, block)
+        key = [klass.name, attribute.to_s]
+        sequence_state[key] = current_value(klass, attribute, block, key) + 1
+      end
+
+      def reset!
+        @sequence_state = {}
+      end
+
+      def starting_value(klass, attribute, block)
+        column_name = resolve_column_name(klass, attribute)
+
+        if column_exists?(klass, column_name)
+          LowerBoundFinder.new(klass, column_name, block).lower_bound
+        else
+          0
+        end
+      end
+
+      def with_sequence_adjustment(**)
+        # No-op for InMemoryBackend. After reset!, nextval already
+        # recalculates from the database via starting_value/LowerBoundFinder,
+        # which finds the correct lower bound past existing data.
+        yield
+      end
+
+      def sequence_state
+        @sequence_state ||= {}
+      end
+
+      private
+
+      def current_value(klass, attribute, block, key)
+        sequence_state[key] || starting_value(klass, attribute, block)
+      end
+
+      def resolve_column_name(klass, attribute)
+        klass.attribute_aliases[attribute.to_s] || attribute.to_s
+      end
+
+      def column_exists?(klass, column_name)
+        klass && klass.column_names.include?(column_name)
+      end
+    end
+  end
+end

data/lib/demo_mode/clever_sequence/lower_bound_finder.rb

@@ -1,19 +1,55 @@
 # frozen_string_literal: true
 
 class CleverSequence
-  LowerBoundFinder = Struct.new(:klass, :column_name, :block) do
-    def lower_bound(current = 1, lower = 0, upper = Float::INFINITY)
+  class LowerBoundFinder
+    attr_reader :klass, :column_name, :block
+
+    def initialize(klass, column_name, block)
+      @klass = klass
+      @column_name = column_name
+      @block = block
+    end
+
+    def lower_bound(hint: nil)
+      with_lock do
+        start = hint && hint >= 1 ? hint : 1
+        # If the hint overshoots the actual data, return it directly.
+        # The hint is a previously-known high-water mark, so it's a valid
+        # lower bound. Callers pass the result through GREATEST against the
+        # PG sequence, so a higher value is always safe and avoids a costly
+        # binary search back down to data that won't be used anyway.
+        next hint if start > 1 && !exists?(start)
+
+        _lower_bound(start, 0, Float::INFINITY)
+      end
+    end
+
+    private
+
+    def with_lock(&)
+      if ActiveRecord::Base.connection.adapter_name.casecmp?('postgresql')
+        ActiveRecord::Base.with_transactional_lock("lower-bound-#{klass}-#{column_name}", &)
+      else
+        yield
+      end
+    end
+
+    def _lower_bound(current, lower, upper)
       if exists?(current)
-        lower_bound(next_between(current, upper), [current, lower].max, upper)
+        # When upper is at most current + 1, we know current is the highest
+        # existing value (upper is always a known-false or Infinity bound).
+        # next_between would return current due to integer division, causing
+        # infinite recursion, so return early.
+        return current if upper <= current + 1
+
+        _lower_bound(next_between(current, upper), [current, lower].max, upper)
       elsif current - lower > 1
-        lower_bound(next_between(lower, current), lower, [current, upper].min)
+        _lower_bound(next_between(lower, current), lower, [current, upper].min)
       else # current should == lower + 1
         lower
       end
     end
 
-    private
-
     def next_between(lower, upper)
       [((lower + 1) / 2) + (upper / 2), lower * 2].min
     end

data/lib/demo_mode/clever_sequence/postgres_backend.rb

@@ -24,35 +24,35 @@ class CleverSequence
     end
 
     class << self
+      def reset!
+        Thread.current[:clever_sequence_cache] = {}
+      end
+
+      def starting_value(klass, attribute, block)
+        calculate_sequence_value(klass, attribute, block)
+      end
+
+      def with_sequence_adjustment(last_values: {})
+        previous = Thread.current[:clever_sequence_adjustment_enabled]
+        previous_last_values = Thread.current[:clever_sequence_last_values]
+        log "[DemoMode] Enabling sequence adjustment for retry"
+        Thread.current[:clever_sequence_adjustment_enabled] = true
+        Thread.current[:clever_sequence_last_values] = last_values
+        yield
+      ensure
+        Thread.current[:clever_sequence_adjustment_enabled] = previous
+        Thread.current[:clever_sequence_last_values] = previous_last_values
+        log "[DemoMode] Disabled sequence adjustment"
+      end
+
       def nextval(klass, attribute, block)
         name = sequence_name(klass, attribute)
+        log "[DemoMode] nextval called for #{klass.name}##{attribute} (sequence: #{name})"
 
         if sequence_exists?(name)
-          sequence_cache[name] = SequenceResult::Exists.new(name)
-
-          result = ActiveRecord::Base.connection.execute(
-            "SELECT nextval('#{name}')",
-          )
-          result.first['nextval'].to_i
+          nextval_from_sequence(name, klass, attribute, block)
         else
-          start_value = calculate_sequence_value(klass, attribute, block)
-
-          sequence_cache[name] = SequenceResult::Missing.new(
-            sequence_name: name,
-            klass: klass,
-            attribute: attribute,
-            calculated_start_value: start_value + 1,
-          )
-
-          if CleverSequence.enforce_sequences_exist
-            raise SequenceNotFoundError.new(
-              sequence_name: name,
-              klass: klass,
-              attribute: attribute,
-            )
-          else
-            start_value + 1
-          end
+          nextval_without_sequence(name, klass, attribute, block)
         end
       end
 
@@ -61,36 +61,122 @@ class CleverSequence
         attr = attribute.to_s.gsub(/[^a-z0-9_]/i, '_')
         # Handle PostgreSQL identifier limit:
         limit = (63 - SEQUENCE_PREFIX.length) / 2
-        "#{SEQUENCE_PREFIX}#{table[0, limit]}_#{attr[0, limit]}"
+        # Lowercase to avoid PostgreSQL case-sensitivity issues with unquoted identifiers
+        "#{SEQUENCE_PREFIX}#{table[0, limit]}_#{attr[0, limit]}".downcase
       end
 
       def sequence_cache
-        @sequence_cache ||= {}
+        Thread.current[:clever_sequence_cache] ||= {}
       end
 
       private
 
+      def log(message, level: DemoMode.log_level)
+        Rails.logger.public_send(level, message)
+      end
+
+      def nextval_from_sequence(name, klass, attribute, block)
+        # On first use with adjustment enabled, ensure sequence is past existing data
+        if adjust_sequences_enabled? && !sequence_cache[name].is_a?(SequenceResult::Exists)
+          log "[DemoMode] Sequence adjustment enabled, adjusting #{name}"
+          adjust_sequence_if_needed(name, klass, attribute, block)
+        end
+        sequence_cache[name] = SequenceResult::Exists.new(name)
+
+        result = ActiveRecord::Base.connection.execute(
+          "SELECT nextval('#{name}')",
+        )
+        value = result.first['nextval'].to_i
+        log "[DemoMode] nextval for #{klass.name}##{attribute} returned #{value}"
+        value
+      end
+
+      def nextval_without_sequence(name, klass, attribute, block)
+        next_value = calculate_next_missing_value(name, klass, attribute, block)
+
+        if CleverSequence.enforce_sequences_exist
+          log "[DemoMode] Raising SequenceNotFoundError for #{name}", level: :warn
+          raise SequenceNotFoundError.new(
+            sequence_name: name, klass: klass, attribute: attribute,
+          )
+        else
+          log "[DemoMode] nextval returning #{next_value} (fallback, #{name} missing)"
+          next_value
+        end
+      end
+
+      def calculate_next_missing_value(name, klass, attribute, block)
+        cached = sequence_cache[name]
+
+        next_value = if cached.is_a?(SequenceResult::Missing)
+          cached.calculated_start_value + 1
+        else
+          calculate_sequence_value(klass, attribute, block) + 1
+        end
+
+        sequence_cache[name] = SequenceResult::Missing.new(
+          sequence_name: name, klass: klass,
+          attribute: attribute, calculated_start_value: next_value
+        )
+
+        next_value
+      end
+
+      def adjust_sequences_enabled?
+        Thread.current[:clever_sequence_adjustment_enabled]
+      end
+
       def sequence_exists?(sequence_name)
         if sequence_cache.key?(sequence_name)
-          case sequence_cache[sequence_name]
-          when SequenceResult::Exists
-            return true
-          else
-            return false
-          end
+          exists = sequence_cache[sequence_name].is_a?(SequenceResult::Exists)
+          log "[DemoMode] Sequence #{sequence_name} #{exists ? 'exists' : 'missing'} (cached)"
+          return exists
         end
 
-        ActiveRecord::Base.connection.execute(
-          "SELECT 1 FROM information_schema.sequences WHERE sequence_name = '#{sequence_name}' LIMIT 1",
+        exists = ActiveRecord::Base.connection.execute(
+          "SELECT 1 FROM information_schema.sequences " \
+          "WHERE sequence_name = '#{sequence_name}' LIMIT 1",
         ).any?
+        log "[DemoMode] Sequence #{sequence_name} #{exists ? 'found' : 'not found'}"
+        exists
       end
 
-      def calculate_sequence_value(klass, attribute, block)
+      def calculate_sequence_value(klass, attribute, block, hint: nil)
         column_name = klass.attribute_aliases.fetch(attribute.to_s, attribute.to_s)
-        return 0 unless klass.column_names.include?(column_name)
+        unless klass.column_names.include?(column_name)
+          log "[DemoMode] Column #{column_name} not found on #{klass.name}", level: :warn
+          return 0
+        end
+
+        value = LowerBoundFinder.new(klass, column_name, block).lower_bound(hint:)
+        log "[DemoMode] Calculated sequence value for #{klass.name}##{attribute}: #{value} (hint: #{hint || 'none'})"
+        value
+      end
+
+      def hint_for(klass, attribute)
+        last_values = Thread.current[:clever_sequence_last_values]
+        last_values && last_values[[klass.name, attribute.to_s]]
+      end
+
+      def adjust_sequence_if_needed(sequence_name, klass, attribute, block)
+        ActiveRecord::Base.with_transactional_lock("adjust-sequence-#{sequence_name}") do
+          hint = hint_for(klass, attribute)
+          max_value = calculate_sequence_value(klass, attribute, block, hint:)
+          if max_value < 1
+            log "[DemoMode] No adjustment needed for #{sequence_name}"
+            return
+          end
 
-        ActiveRecord::Base.with_transactional_lock("lower-bound-#{klass}-#{column_name}") do
-          LowerBoundFinder.new(klass, column_name, block).lower_bound
+          log "[DemoMode] Adjusting #{sequence_name} to at least #{max_value}"
+          # setval sets the sequence's last_value. With the default 3rd argument (true),
+          # the next nextval() will return last_value + 1.
+          # We only want to advance (never go backwards), so we use GREATEST.
+          result = ActiveRecord::Base.connection.execute(<<~SQL.squish)
+            SELECT setval('#{sequence_name}',
+              GREATEST(#{max_value}, (SELECT last_value FROM #{sequence_name})))
+          SQL
+          new_last_value = result.first['setval'].to_i
+          log "[DemoMode] #{sequence_name} adjusted to #{new_last_value}"
         end
       end
     end

data/lib/demo_mode/clever_sequence.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'clever_sequence/lower_bound_finder'
+require_relative 'clever_sequence/in_memory_backend'
 require_relative 'clever_sequence/postgres_backend'
 
 class CleverSequence
@@ -9,15 +10,32 @@ class CleverSequence
   cattr_accessor(:sequences) { {} }
   cattr_accessor(:use_database_sequences) { false }
   cattr_accessor(:enforce_sequences_exist) { false }
+  cattr_accessor(:retry_on_uniqueness_violation) { true }
 
   class << self
     alias use_database_sequences? use_database_sequences
     alias enforce_sequences_exist? enforce_sequences_exist
+    alias retry_on_uniqueness_violation? retry_on_uniqueness_violation
+
+    def backend
+      use_database_sequences? ? PostgresBackend : InMemoryBackend
+    end
 
     def reset!
+      backend.reset!
       sequences.each_value(&:reset!)
     end
 
+    def with_sequence_adjustment(&)
+      last_values = snapshot_last_values
+      reset!
+      backend.with_sequence_adjustment(last_values:, &)
+    end
+
+    def snapshot_last_values
+      sequences.transform_values { |seq| seq.send(:last_value) }.compact
+    end
+
     def next(klass, name)
       lookup(klass, name)&.next
     end
@@ -47,41 +65,48 @@ class CleverSequence
   end
 
   def next
-    @last_value = if CleverSequence.use_database_sequences?
-      PostgresBackend.nextval(klass, attribute, block)
+    value = if klass
+      self.class.backend.nextval(klass, attribute, block)
     else
-      last_value + 1
+      (last_value || 0) + 1
     end
+    self.last_value = value
     last
   end
 
   def last
-    block.call(last_value)
+    block.call(last_value || (klass ? self.class.backend.starting_value(klass, attribute, block) : 0))
   end
 
   def reset!
-    remove_instance_variable(:@last_value) if instance_variable_defined?(:@last_value)
+    clear_last_value
   end
 
   private
 
   def last_value
-    @last_value ||= starting_value
-  end
-
-  def starting_value
-    if column_exists?
-      LowerBoundFinder.new(klass, column_name, block).lower_bound
+    if klass
+      Thread.current[:clever_sequence_last_value]&.dig(klass.name, attribute)
     else
-      0
+      @last_value
     end
   end
 
-  def column_name
-    klass.attribute_aliases[attribute] || attribute
+  def last_value=(value)
+    if klass
+      Thread.current[:clever_sequence_last_value] ||= {}
+      Thread.current[:clever_sequence_last_value][klass.name] ||= {}
+      Thread.current[:clever_sequence_last_value][klass.name][attribute] = value
+    else
+      @last_value = value
+    end
   end
 
-  def column_exists?
-    klass && klass.column_names.include?(column_name)
+  def clear_last_value
+    if klass
+      Thread.current[:clever_sequence_last_value]&.[](klass.name)&.delete(attribute)
+    else
+      @last_value = nil
+    end
   end
 end

data/lib/demo_mode/config.rb

@@ -13,6 +13,7 @@ module DemoMode
     configurable_value(:signinable_username_method) { :email }
     configurable_value(:personas_path) { 'config/personas' }
     configurable_value(:session_timeout) { 30.minutes }
+    configurable_value(:log_level) { :debug }
     configurable_boolean(:display_credentials)
     configurations << :stylesheets
     configurations << :logo

data/lib/demo_mode/persona.rb

@@ -63,16 +63,32 @@ module DemoMode
     end
 
     def generate!(variant: :default, password: nil, options: {})
+      retried = false
       ActiveSupport::Notifications.instrument('demo_mode.persona.generate', name: name, variant: variant) do
         variant = variants[variant]
         CleverSequence.reset! if defined?(CleverSequence)
         DemoMode.current_password = password if password
         DemoMode.around_persona_generation.call(variant.signinable_generator, **options)
+      rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
+        raise if retried || !should_retry_with_sequence_adjustment?(e)
+
+        retried = true
+        CleverSequence.with_sequence_adjustment do
+          DemoMode.around_persona_generation.call(variant.signinable_generator, **options)
+        end
       ensure
         DemoMode.current_password = nil
       end
     end
 
+    def should_retry_with_sequence_adjustment?(error)
+      return false unless defined?(CleverSequence)
+      return false unless CleverSequence.retry_on_uniqueness_violation?
+
+      Rails.logger.warn("[DemoMode] Uniqueness violation during persona generation, retrying with sequence adjustment: #{error.message}")
+      true
+    end
+
     def callout(callout = true) # rubocop:disable Style/OptionalBooleanParameter
       @callout = callout
     end

data/lib/demo_mode/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DemoMode
-  VERSION = '3.5.0'
+  VERSION = '3.6.0'
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: demo_mode
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Nathan Griffith
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -338,6 +339,7 @@ files:
 - db/migrate/20250210222933_add_demo_mode_sessions_status.rb
 - lib/demo_mode.rb
 - lib/demo_mode/clever_sequence.rb
+- lib/demo_mode/clever_sequence/in_memory_backend.rb
 - lib/demo_mode/clever_sequence/lower_bound_finder.rb
 - lib/demo_mode/clever_sequence/postgres_backend.rb
 - lib/demo_mode/cli.rb
@@ -366,6 +368,7 @@ licenses:
 metadata:
   rubygems_mfa_required: 'true'
   changelog_uri: https://github.com/Betterment/demo_mode/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -380,7 +383,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: A configurable demo mode for your Rails app.
 test_files: []