demo_mode 3.4.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0cf4bfb4f300ba2c592c20287bfbb36eba0670f4e36f41da729712366637917
-  data.tar.gz: fc4ce80f27450f77d04b5f12668b32a2bb2d8b246919884a193810cbbd6776c1
+  metadata.gz: 5b2e916a3b2b58e6f3cbd027fad72a91b8cb550443a50e64988caa0dbd1ff6fa
+  data.tar.gz: ff00e7655ecf6d9e5ae118b84542bf97ec6e568143e4c2961ef42b1c28e0894c
 SHA512:
-  metadata.gz: 59d84c5fec1c5971a5661cb19383b4a831e59378ddaa9958f17f0577453706f2fb58eee90d71b2fa1870b22287a519f59f910fa828e72600b75b1c98435a2e0f
-  data.tar.gz: 857e22d08f59ed49830170b8b7aa5446c276dd13d44a86a1ae1e6fbeebf991cf53a15cc833059eaa8a243481d38a8644845b1476769a8475c21044ac2117cbca
+  metadata.gz: b240952b7f353fff7cb723a409cc07806ffc477d83640968d486d4050f69d37d51777fa93e603f3e41b869226314cffba020fc7df96f640220dd5389591c0895
+  data.tar.gz: ee5ebfd9364b612abaa6dbff7b0f6d6f0e3624dbd7383486282c9504e85d4d96ee54c39c76b143f4d4f10cb06f557ee0355595b57ca35faf5384ca951f6d883f

data/README.md

@@ -1,5 +1,5 @@
-Demo Mode
-=========
+# Demo Mode
+
 [![Gem Version](https://badge.fury.io/rb/demo_mode.svg)](https://rubygems.org/gems/demo_mode)
 [![Tests](https://github.com/Betterment/demo_mode/actions/workflows/tests.yml/badge.svg)](https://github.com/Betterment/demo_mode/actions/workflows/tests.yml)
 
@@ -35,22 +35,23 @@ To learn more about how we use `demo_mode` at **Betterment**, check out :sparkle
 
 ## Table of Contents
 
-* [Getting Started](#getting-started)
-  * [Installation](#installation)
-  * [App-Specific Setup](#app-specific-setup)
-* [Defining Personas](#defining-personas)
-* [Customizing the Design](#customizing-the-design)
-* [Optional Features](#optional-features)
-  * [The "Sign Up" Link](#the-sign-up-link)
-  * [The "Display Credentials" feature](#the-display-credentials-feature)
-  * [Developer CLI](#developer-cli)
-  * [Callbacks](#callbacks)
-  * [Non-User Personas](#non-user-personas)
-  * [FactoryBot `sequence` extension](#factorybot-sequence-extension)
-* [Deploying a demo environment to the cloud](#deploying-a-demo-environment-to-the-cloud)
-  * [How to avoid breaking your new "demo" env](#how-to-avoid-breaking-your-new-demo-env)
-* [How to Contribute](#how-to-contribute)
-  * [Suggested Workflow](#suggested-workflow)
+- [Getting Started](#getting-started)
+  - [Installation](#installation)
+  - [App-Specific Setup](#app-specific-setup)
+- [Defining Personas](#defining-personas)
+- [Customizing the Design](#customizing-the-design)
+- [Optional Features](#optional-features)
+  - [The "Sign Up" Link](#the-sign-up-link)
+  - [The "Display Credentials" feature](#the-display-credentials-feature)
+  - [Developer CLI](#developer-cli)
+  - [Callbacks](#callbacks)
+  - [Non-User Personas](#non-user-personas)
+  - [FactoryBot `sequence` extension](#factorybot-sequence-extension)
+  - [Database-backed sequences](#database-backed-sequences)
+- [Deploying a demo environment to the cloud](#deploying-a-demo-environment-to-the-cloud)
+  - [How to avoid breaking your new "demo" env](#how-to-avoid-breaking-your-new-demo-env)
+- [How to Contribute](#how-to-contribute)
+  - [Suggested Workflow](#suggested-workflow)
 
 ## Getting Started
 
@@ -538,6 +539,38 @@ end
   conditionally disable any uniqueness validations (e.g.
   `validates ... unless DemoMode.enabled?`).
 
+### Database-backed sequences
+
+By default, `CleverSequence` (used by the FactoryBot `sequence` extension) uses an in-memory Ruby counter. For production demo environments running multiple processes or requiring persistence across restarts, you can enable PostgreSQL-backed sequences:
+
+```ruby
+DemoMode.configure do
+  CleverSequence.use_database_sequences = true
+end
+```
+
+This feature flag controls whether `CleverSequence` uses PostgreSQL native sequences or the existing Ruby-based counter, allowing for gradual rollout and easy rollback. By default, `use_database_sequences` is `false`.
+
+You can check the current setting with:
+
+```ruby
+CleverSequence.use_database_sequences? # => false (default)
+```
+
+You can also enforce that database sequences exist before they are used. When enabled, `CleverSequence` will raise an error if a sequence is requested but the corresponding PostgreSQL SEQUENCE does not exist yet (prompting the engineer to run a migration that creates the SEQUENCE). When disabled (the default), `CleverSequence` will fall back to calculating the next sequence value based on existing database data:
+
+```ruby
+DemoMode.configure do
+  CleverSequence.enforce_sequences_exist = true
+end
+```
+
+You can check this setting with:
+
+```ruby
+CleverSequence.enforce_sequences_exist? # => false (default)
+```
+
 ## Deploying a demo environment to the cloud
 
 This gem truly shines when used to deploy a "demo" version of
@@ -652,6 +685,13 @@ you operate an "on call" process, engineers should be made aware
 that this demo environment _is_ a "production-like" environment
 and should expect "production-like" uptime guarantees.
 
+We also emit an `ActiveSupport::Notifications` event
+(`demo_mode.persona_generated`) every time a persona is generated, which can be
+useful for tracking usage over time and alerting to any unexpected spikes,
+drops in usage, and changes to performance. The custom event payload includes the
+persona name and variant, in addition to standard attributes like execution
+duration and exception details (if an error occurred during generation).
+
 Again, to learn more about how we use and operate our "demo"
 environments at **Betterment**, check out our ✨ [RailsConf 2022 talk entitled
 "RAILS_ENV=demo"](https://youtu.be/VibJu9IMohc)
@@ -669,7 +709,7 @@ creating a new issue to get early feedback on your proposed change.
 
 ### Suggested Workflow
 
-* Fork the project and create a new branch for your contribution.
-* Write your contribution (and any applicable test coverage).
-* Make sure all tests pass (`bundle exec rake`).
-* Submit a pull request.
+- Fork the project and create a new branch for your contribution.
+- Write your contribution (and any applicable test coverage).
+- Make sure all tests pass (`bundle exec rake`).
+- Submit a pull request.

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class CleverSequence
+  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)
+        # 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)
+      else # current should == lower + 1
+        lower
+      end
+    end
+
+    def next_between(lower, upper)
+      [((lower + 1) / 2) + (upper / 2), lower * 2].min
+    end
+
+    def exists?(value)
+      klass.public_send(finder_method, block.call(value))
+    end
+
+    # TODO: Move onto modern finder methods.
+    def finder_method
+      :"find_by_#{column_name.to_s.underscore.sub('_crypt', '')}"
+    end
+  end
+end

data/lib/demo_mode/clever_sequence/postgres_backend.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+class CleverSequence
+  module PostgresBackend
+    SEQUENCE_PREFIX = 'cs_'
+
+    class SequenceNotFoundError < StandardError
+      attr_reader :sequence_name, :klass, :attribute
+
+      def initialize(sequence_name:, klass:, attribute:)
+        @sequence_name = sequence_name
+        @klass = klass
+        @attribute = attribute
+
+        super(
+          "Sequence '#{sequence_name}' not found for #{klass.name}##{attribute}. "
+        )
+      end
+    end
+
+    module SequenceResult
+      Exists = Data.define(:sequence_name)
+      Missing = Data.define(:sequence_name, :klass, :attribute, :calculated_start_value)
+    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)
+          nextval_from_sequence(name, klass, attribute, block)
+        else
+          nextval_without_sequence(name, klass, attribute, block)
+        end
+      end
+
+      def sequence_name(klass, attribute)
+        table = klass.table_name.gsub(/[^a-z0-9_]/i, '_')
+        attr = attribute.to_s.gsub(/[^a-z0-9_]/i, '_')
+        # Handle PostgreSQL identifier limit:
+        limit = (63 - SEQUENCE_PREFIX.length) / 2
+        # Lowercase to avoid PostgreSQL case-sensitivity issues with unquoted identifiers
+        "#{SEQUENCE_PREFIX}#{table[0, limit]}_#{attr[0, limit]}".downcase
+      end
+
+      def 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)
+          exists = sequence_cache[sequence_name].is_a?(SequenceResult::Exists)
+          log "[DemoMode] Sequence #{sequence_name} #{exists ? 'exists' : 'missing'} (cached)"
+          return exists
+        end
+
+        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, hint: nil)
+        column_name = klass.attribute_aliases.fetch(attribute.to_s, attribute.to_s)
+        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
+
+          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
+  end
+end

data/lib/demo_mode/clever_sequence.rb

@@ -1,13 +1,41 @@
 # 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
   DEFAULT_BLOCK = ->(i) { i }
 
+  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
@@ -23,7 +51,6 @@ class CleverSequence
     end
   end
 
-  cattr_accessor(:sequences) { {} }
   attr_reader :klass, :attribute, :block
 
   def initialize(attribute, &block)
@@ -38,64 +65,48 @@ class CleverSequence
   end
 
   def next
-    @last_value = last_value + 1
+    value = if klass
+      self.class.backend.nextval(klass, attribute, block)
+    else
+      (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
-  end
-
-  def column_exists?
-    klass && klass.column_names.include?(column_name)
-  end
-
-  LowerBoundFinder = Struct.new(:klass, :column_name, :block) do
-    def lower_bound(current = 1, lower = 0, upper = Float::INFINITY)
-      if exists?(current)
-        lower_bound(next_between(current, upper), [current, lower].max, upper)
-      elsif current - lower > 1
-        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
-
-    def exists?(value)
-      klass.public_send(finder_method, block.call(value))
+  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
 
-    # TODO: Move onto modern finder methods.
-    def finder_method
-      :"find_by_#{column_name.to_s.underscore.sub('_crypt', '')}"
+  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,12 +63,30 @@ module DemoMode
     end
 
     def generate!(variant: :default, password: nil, options: {})
-      variant = variants[variant]
-      CleverSequence.reset! if defined?(CleverSequence)
-      DemoMode.current_password = password if password
-      DemoMode.around_persona_generation.call(variant.signinable_generator, **options)
-    ensure
-      DemoMode.current_password = nil
+      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

data/lib/demo_mode/version.rb

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

data/lib/generators/templates/initializer.rb

@@ -34,6 +34,14 @@ DemoMode.configure do
   # ====================================
   # personas_path 'config/personas'
 
+  # CleverSequence configuration (for FactoryBot sequence extension):
+  # ==================================================================
+  # Enable PostgreSQL-backed sequences (defaults to false):
+  # CleverSequence.use_database_sequences = true
+  #
+  # Raise an error if a database sequence doesn't exist (defaults to false):
+  # CleverSequence.enforce_sequences_exist = true
+
   # A callback that wraps persona-based account generation.
   # You must run `generator.call` and return the "signinable" object:
   # ==================================================

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: demo_mode
 version: !ruby/object:Gem::Version
-  version: 3.4.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
@@ -227,6 +228,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -324,6 +339,9 @@ 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
 - lib/demo_mode/clis/multi_word_search_patch.rb
 - lib/demo_mode/concerns/configurable.rb
@@ -350,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
@@ -364,7 +383,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: A configurable demo mode for your Rails app.
 test_files: []