super_settings 0.0.1.rc3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9562c88fa68bb2d609f007ed31371870706ab0e12a772857caefc7d4f84fb89
-  data.tar.gz: f434c13622fe523791b543d9c04f5023cbdcee3d265dcbd2b2d9da0947780c64
+  metadata.gz: 3b4e4df83235545b59d31ec20206e265ab19bbe0d4a21de81405bdc7fab892c6
+  data.tar.gz: 8de1f0d4f30714f93f11e1c5b7f004232793676877f2f0396d3fe757cbd2629e
 SHA512:
-  metadata.gz: b13fa738e17df5bd4693939e4c182b4b81b668e0b113a6067e63d436f118e9362438f2503b40c7f6de05f5675653f00fae571c96195d55b3c56b6f557243a29e
-  data.tar.gz: 2bbc6ee2b3059a136e134f4204c94cc4ca0437380ca132de5275be7b3a8c7623c9ae4e2b42f8aa268ea814c74b3ecf12b9fc6a370252eaa65501599b8a3da5f5
+  metadata.gz: e7d3fa4f5025a6c541fab3f61d906bf1be43e1378c3c88c27d33e726ff18fd3f5d3d3a73c43b11f43945fcc5677eb23ac34fc8f52d66582d755c4a44247454df
+  data.tar.gz: 7b0915ea64422d358d5d93a299c75ee63c620b1d2a476dd15f379c0129ccf67d3760536aaf16798094c1f8c8afa99594b5ace27126d18eaafde004fb30556e44

data/README.md

@@ -19,6 +19,10 @@ SuperSettings provides a simple interface for accessing settings backed by a thr
 
 There is also an out of the box Web UI and REST API for managing settings. You can specify data types for your settings (string, integer, float, boolean, datetime, or array) to ensure that values will be valid. You can also supply documentation for each setting so that it's clear what each one does and how it is used.
 
+Changes to settings are stored whenever a setting is changed to give you an audit trail if you need it for compliance reasons. In addition, you can provide your own callbacks to execute whenever a setting is changed.
+
+There is a companion gem [ultra_settings](https://github.com/bdurand/ultra_settings) that can be used to integrate SuperSettings into a combined configuration system alongside YAML files and environment variables.
+
 ## Usage
 
 - [Getting Value](#getting-values)
@@ -51,65 +55,6 @@ SuperSettings.datetime("key") # -> returns a `Time` object
 SuperSettings.array("key") # -> returns an array of strings
 ```
 
-#### Hashes
-There is also a method to get multiple settings at once structured as a hash.
-
-```ruby
-SuperSettings.structured("parent") # -> returns an hash
-```
-
-The key provided to the `SuperSettings.structured` method indicates the key prefix and constructs the hash from settings that have keys beginning with that prefix. Keys are also broken down by a delimiter so you can create nested hashes. The delimiter defaults to `"."`, but you can specify a different one with the `delimiter` keyword argument.
-
-You can also set a maximum depth to the returned hash with the `max_depth` keyword argument.
-
-So, if you have the following settings:
-
-```
-vendors.company_1.path = "/co1"
-vendors.company_1.timeout = 5
-vendors.company_2.path = "/co2"
-page_size = 20
-```
-
-You would get these results:
-
-```ruby
-SuperSettings.structured("vendors")
-# {
-#   "company_1" => {
-#     "path" => "/co1",
-#     "timeout" => 5
-#   },
-#   "company_2" => {
-#     "path" => "/co2"
-#    }
-# }
-
-SuperSettings.structured("vendors.company_1")
-# {"path" => "/co1", "timeout" => 5}
-
-SuperSettings.structured("vendors.company_2")
-# {"path" => "/co2"}
-
-# Get all the settings by omitting the key
-SuperSettings.structured
-# {
-#   "vendors" => {
-#     "company_1" => {"path" => "/co1", "timeout" => 5},
-#     "company_2" => {"path" => "/co2"}
-#   },
-#   "page_size" => 20
-# }
-
-# Limit the nesting depth of the returned hash to one level
-SuperSettings.structured(max_depth: 1)
-# {
-#   "vendors.company_1.path => "/co1",
-#   "vendors.company_1.timeout" => 5,
-#   "vendors.company_2.path" => "/co2",
-#   "page_size" => 20
-# }
-```
 
 #### Defaults
 
@@ -132,13 +77,38 @@ SuperSettings.enabled?("enabled_users.#{id}")
 
 # GOOD: use an array if there are a limited number of values
 SuperSettings.array("enabled_users", []).include?(id)
-
-# GOOD: use a hash if you need to scale to any number of values
-SuperSettings.structured("enabled_users", {})["id"]
 ```
 
 The cache will scale without issue to handle hundreds of settings. However, you should avoid creating thousands of settings. Because all settings are read into memory, having too many settings records can lead to performance or memory issues.
 
+#### Request Context
+
+You can ensure that settings won't change in a block of code by surrounding it with a `SuperSettings.context` block. Inside a `context` block, a setting will always return the same value. This can prevent race conditions where you code may branch based on a setting value.
+
+```ruby
+# This code could be unsafe since the value of the "threshold" setting could
+# change after the if statement is checked.
+if SuperSettings.integer("threshold") > 0
+  do_something(SuperSettings.integer("threshold"))
+end
+
+# With a context block, the value for the "threshold setting will always
+# return the same value
+SuperSettings.context do
+  if SuperSettings.integer("threshold") > 0
+    do_something(SuperSettings.integer("threshold"))
+  end
+end
+```
+
+It's a good idea to add a `context` block around your main unit of work:
+
+- Rack application: add `SuperSettings::Context::RackMiddleware` to your middleware stack
+- Sidekiq: add `SuperSettings::Context::SidekiqMiddleware` to your server middleware
+- ActiveJob: add an `around_perform` callback that calls `SuperSettings.context`
+
+In a Rails application all of these will be done automatically.
+
 ### Data Model
 
 Each setting has a key, value, value type, and optional description. The key must be unique. The value type can be one of "string", "integer", "float", "boolean", "datetime", or "array". The array value type will always return an array of strings.
@@ -149,6 +119,16 @@ It is not possible to store an empty string in a setting; empty strings will be
 
 A history of all settings changes is updated every time the value is changed in the `histories` association. You can also record who made the changes.
 
+#### Callbacks
+
+You can define custom callbacks on the `SuperSettings::Setting` model that will be called whenever a setting is changed. For example, if you needed to log all changes to you settings in your application logs, you could do something like this:
+
+```ruby
+SuperSettings::Setting.after_save do |setting|
+  Application.logger.info("Setting #{setting.key} changed: #{setting.changes.inspect})
+end
+```
+
 #### Storage Engines
 
 This gem abstracts out the storage engine and can support multiple storage mechanisms. It has built in support for ActiveRecord, Redis, and HTTP storage.
@@ -220,7 +200,7 @@ The gem ships with a Rails engine that provides easy integration with a Rails ap
 The default storage engine for a Rails application will be the ActiveRecord storage. You need to install the database migrations first with:
 
 ```bash
-rails app:super_settings:install:migrations
+rails super_settings:install:migrations
 ```
 
 You also need to mount the engine routes in your application's `config/routes.rb` file. The routes can be mounted under any prefix you'd like.
@@ -270,10 +250,15 @@ SuperSettings.configure do |config|
     end
   end
 
-  # Define a method that returns the value that will be stored in the settings history in
+  # Define a block that returns the value that will be stored in the settings history in
   # the `changed_by` column.
   config.controller.define_changed_by do
-    current_user.name
+    current_user.id
+  end
+
+  # Define a block that determines how to display the `changed_by`` value in the setting history.
+  config.model.define_changed_by_display do |changed_by_id|
+    User.find_by(id: changed_by_id)&.name
   end
 
   # You can define the storage engine for the model. This can be either done either with a Class
@@ -284,6 +269,11 @@ SuperSettings.configure do |config|
   # You can also specify a cache implementation to use to cache the last updated timestamp
   # for model changes. By default this will use `Rails.cache`.
   # config.model.cache = Rails.cache
+
+  # You can define after_save callbacks for the model.
+  # config.model.after_save do |setting|
+  #   Rail.logger.info("Setting #{setting.key} changed to #{setting.value.inspect}")
+  # end
 end
 ```
 

data/VERSION

@@ -1 +1 @@
-0.0.1.rc3
+1.0.0

data/app/helpers/super_settings/settings_helper.rb

@@ -19,7 +19,7 @@ module SuperSettings
     def super_settings_application_header
       config = Configuration.instance.controller
       content = "#{super_settings_application_name} Settings"
-      if config.application_logo.present?
+      if Coerce.present?(config.application_logo)
         content = image_tag(config.application_logo, alt: "").concat(content)
       end
       if config.application_link

data/lib/super_settings/application/api.js

@@ -35,13 +35,19 @@
 
     params = options.params
     let queryParams = null;
-    const fetchOptions = {credentials: "same-origin"};
+    const headers = new Headers();
+    const fetchOptions = {credentials: "same-origin", headers: headers};
     const accessToken = window.sessionStorage.getItem("super_settings_access_token");
-    const headers = {"Accept": "application/json"};
+
+    headers.set("Accept", "application/json");
     if (accessToken) {
-      headers["Authorization"] = "Bearer " + accessToken;
+      headers.set("Authorization", "Bearer " + accessToken);
     }
-    Object.assign(headers, SuperSettingsAPI.headers);
+    Object.entries(SuperSettingsAPI.headers).forEach(function(entry) {
+      const [key, value] = entry;
+      headers.set(key, value);
+    });
+
     if (method === "POST") {
       queryParams = Object.assign({}, SuperSettingsAPI.queryParams);
       csrfParam = document.querySelector("meta[name=csrf-param]");
@@ -52,11 +58,10 @@
       }
       fetchOptions["method"] = "POST";
       fetchOptions["body"] = JSON.stringify(params);
-      headers["Content-Type"] = "application/json";
+      headers.set("Content-Type", "application/json");
     } else {
       queryParams = Object.assign({}, SuperSettingsAPI.queryParams, params);
     }
-    fetchOptions["headers"] = new Headers(headers);
     const url = apiURL(path, queryParams);
 
     fetch(url, fetchOptions)

data/lib/super_settings/configuration.rb

@@ -126,6 +126,39 @@ module SuperSettings
           end
         end
       end
+
+      # Add an after_save callback to the setting model. The block will be called with the
+      # setting object after it is saved.
+      #
+      # @yieldparam setting [SuperSettings::Setting]
+      def after_save(&block)
+        after_save_blocks << block
+      end
+
+      # @return [Array<Proc>] The after_save block
+      # @api private
+      def after_save_blocks
+        @after_save_blocks ||= []
+      end
+
+      # Define how the changed_by attibute on the setting history will be displayed. The block
+      # will be called with the changed_by attribute and should return a string to display.
+      # The block will not be called if the changed_by attribute is nil.
+      #
+      # @example
+      #   define_changed_by_display { |changed_by| User.find_by(id: changed_by)&.name }
+      #
+      # @yield Block of code to call on the controller at request time
+      # @yieldparam changed_by [String] The value of the changed_by attribute
+      def define_changed_by_display(&block)
+        @changed_by_display = block
+      end
+
+      # @return [Proc, nil] The block to call to display the changed_by attribute in setting history
+      # @api private
+      def changed_by_display
+        @changed_by_display if defined?(@changed_by_display)
+      end
     end
 
     # Return the model specific configuration object.
@@ -141,6 +174,7 @@ module SuperSettings
     def initialize
       @model = Model.new
       @controller = Controller.new
+      @deferred_configs = []
     end
 
     # Defer the execution of a block that will be yielded to with the config object. This
@@ -149,15 +183,16 @@ module SuperSettings
     #
     # @api private
     def defer(&block)
-      @block = block
+      @deferred_configs << block
     end
 
     # Call the block deferred during initialization.
     #
     # @api private
     def call
-      @block&.call(self)
-      @block = nil
+      while (block = @deferred_configs.shift)
+        block&.call(self)
+      end
     end
   end
 end

data/lib/super_settings/context/rack_middleware.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SuperSettings
+  module Context
+    # Rack middleware you can use to add a context to your requests so that
+    # settings are not changed during request execution.
+    #
+    # This middleware is automatically added to Rails applications.
+    class RackMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        SuperSettings.context do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/super_settings/context/sidekiq_middleware.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SuperSettings
+  module Context
+    # Sidekiq middleware you can use to add a context to your jobs so that
+    # settings are not changed during job execution.
+    #
+    # @example
+    #   require "super_settings/context/sidekiq_middleware"
+    #
+    #   Sidekiq.configure_server do |config|
+    #     config.server_middleware do |chain|
+    #       chain.add SuperSettings::Context::SidekiqMiddleware
+    #     end
+    #   end
+    #
+    # You can disable the context by setting the `super_settings_context` key
+    # to `false` in the job payload.
+    #
+    # @example
+    #   class MyWorker
+    #     include Sidekiq::Worker
+    #     sidekiq_options super_settings_context: false
+    #   end
+    class SidekiqMiddleware
+      if defined?(Sidekiq::ServerMiddleware)
+        include Sidekiq::ServerMiddleware
+      end
+
+      def call(job_instance, job_payload, queue)
+        if job_payload["super_settings_context"] == false
+          yield
+        else
+          SuperSettings.context do
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_settings/context.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SuperSettings
+  module Context
+  end
+end

data/lib/super_settings/engine.rb

@@ -7,6 +7,26 @@ module SuperSettings
   class Engine < Rails::Engine
     isolate_namespace ::SuperSettings
 
+    initializer("SuperSettings") do
+      Rails.configuration.middleware.unshift(SuperSettings::Context::RackMiddleware)
+
+      if defined?(ActiveJob::Base.around_perform)
+        ActiveJob::Base.around_perform do |job, block|
+          SuperSettings.context(&block)
+        end
+      end
+
+      if defined?(Sidekiq.server?) && Sidekiq.server?
+        require_relative "context/sidekiq_middleware"
+
+        Sidekiq.configure_server do |sidekiq_config|
+          sidekiq_config.server_middleware do |chain|
+            chain.prepend(SuperSettings::Context::SidekiqMiddleware)
+          end
+        end
+      end
+    end
+
     config.after_initialize do
       # Call the deferred initialization block.
       configuration = Configuration.instance
@@ -46,6 +66,10 @@ module SuperSettings
         Setting.cache = (configuration.model.cache || Rails.cache)
         Setting.storage = configuration.model.storage_class
 
+        configuration.model.after_save_blocks.each do |block|
+          Setting.after_save(&block)
+        end
+
         if !SuperSettings.loaded?
           begin
             SuperSettings.load_settings

data/lib/super_settings/history_item.rb

@@ -14,21 +14,21 @@ module SuperSettings
       !!(defined?(@deleted) && @deleted)
     end
 
-    # The method could be overriden to change how the changed_by attribute is displayed.
-    # For instance, you could store a user id in the changed_by column and add an association
-    # on this model.
+    # The display value for the changed_by attribute. This method can be overridden
+    # in the configuration by calling `model.define_changed_by_display` with the block to use
+    # to get the display value for the changed_by attribute. The default value is
+    # the changed_by attribute itself.
     #
-    # @example
-    #   class SuperSettings::HistoryItem
-    #     def changed_by_display
-    #       user = User.find_by(id: changed_by) if changed_by
-    #       user ? user.name : changed_by
-    #     end
-    #   end
-    #
-    # @return [String]
+    # @return [String, nil]
     def changed_by_display
-      changed_by
+      return changed_by if changed_by.nil?
+
+      display_proc = Configuration.instance.model.changed_by_display
+      if display_proc && !changed_by.nil?
+        display_proc.call(changed_by) || changed_by
+      else
+        changed_by
+      end
     end
   end
 end

data/lib/super_settings/local_cache.rb

@@ -54,7 +54,6 @@ module SuperSettings
             @lock.synchronize do
               # For case where one thread could be iterating over the cache while it's updated causing an error
               @cache = @cache.merge(key => value).freeze
-              @hashes = {}
             end
           end
         end
@@ -64,53 +63,6 @@ module SuperSettings
       value
     end
 
-    # Return the setting as structured data. The keys will be split by the specified delimiter
-    # to create a nested hash.
-    #
-    # @example
-    #   Setting with key "a.b.c" and value 1 becomes
-    #
-    #   {
-    #     "a" => {
-    #       "b" => {
-    #         "c" => 1
-    #       }
-    #     }
-    #   }
-    #
-    # See SuperSettings.structured for more details.
-    def structured(key = nil, delimiter: ".", max_depth: nil)
-      key = key.to_s
-      cache_key = [key, delimiter, max_depth]
-      cached_value = @hashes[cache_key]
-      return cached_value if cached_value
-
-      flattened = to_h
-      root_key = ""
-      if Coerce.present?(key)
-        root_key = "#{key}#{delimiter}"
-        reduced_hash = {}
-        flattened.each do |k, v|
-          if k.start_with?(root_key)
-            reduced_hash[k[root_key.length, k.length]] = v
-          end
-        end
-        flattened = reduced_hash
-      end
-
-      structured_hash = {}
-      flattened.each do |key, value|
-        set_nested_hash_value(structured_hash, key, value, 0, delimiter: delimiter, max_depth: max_depth)
-      end
-
-      deep_freeze_hash(structured_hash)
-      @lock.synchronize do
-        @hashes[cache_key] = structured_hash
-      end
-
-      structured_hash
-    end
-
     # Check if the cache includes a key. Note that this will return true if you have tried
     # to fetch a non-existent key since the cache will store that as undefined. This method
     # is provided for testing purposes.
@@ -217,7 +169,6 @@ module SuperSettings
     def reset
       @lock.synchronize do
         @cache = {}.freeze
-        @hashes = {}
         @last_refreshed = nil
         @next_check_at = Time.now + @refresh_interval
         @refreshing = false
@@ -240,7 +191,6 @@ module SuperSettings
       return if Coerce.blank?(setting.key)
       @lock.synchronize do
         @cache = @cache.merge(setting.key => setting.value)
-        @hashes = {}
       end
     end
 
@@ -277,7 +227,7 @@ module SuperSettings
         end
         load_settings(Setting.storage.load_asynchronous?)
       elsif Time.now >= @next_check_at
-        refresh
+        refresh(Setting.storage.load_asynchronous?)
       end
     end
 
@@ -287,7 +237,6 @@ module SuperSettings
         @last_refreshed = refreshed_at_time
         @refreshing = false
         @cache = block.call.freeze
-        @hashes = {}
       end
     end
 

data/lib/super_settings/rack_application.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "rack"
-
 module SuperSettings
   # Rack middleware for serving the REST API. See SuperSettings::RestAPI for more details on usage.
   #
@@ -39,6 +37,13 @@ module SuperSettings
     #     end
     #   end
     def initialize(app = nil, path_prefix = "/", &block)
+      # Requiring rack here so that the gem does not have a hard dependency on it.
+      begin
+        require "rack"
+      rescue LoadError
+        raise LoadError, "SuperSettings::RackApplication requires the rack gem"
+      end
+
       @app = app
       @path_prefix = path_prefix.to_s.chomp("/")
       instance_eval(&block) if block

data/lib/super_settings/setting.rb

@@ -54,6 +54,21 @@ module SuperSettings
         end
       end
 
+      # Add a block of code that will be called when a setting is saved. The block will be
+      # called with a Setting object. The object will have been saved, but the `changes`
+      # hash will still be set indicating what was changed. You can define multiple after_save blocks.
+      #
+      # @yieldparam setting [SuperSetting::Setting]
+      def after_save(&block)
+        after_save_blocks << block
+      end
+
+      # @return [Array<Proc>] Blocks to be called after a setting is saved.
+      # @api private
+      def after_save_blocks
+        @after_save_blocks ||= []
+      end
+
       # Create a new setting with the specified attributes.
       #
       # @param attributes [Hash] hash of attribute names and values
@@ -433,6 +448,7 @@ module SuperSettings
 
         begin
           self.class.clear_last_updated_cache
+          call_after_save_callbacks
         ensure
           clear_changes
         end
@@ -508,6 +524,15 @@ module SuperSettings
       as_json.to_json(options)
     end
 
+    # Get hash of attribute changes. The hash keys are the names of attributes that
+    # have changed and the values are an array with [old value, new value]. The keys
+    # will be one of key, raw_value, value_type, description, deleted, created_at, or updated_at.
+    #
+    # @return [Hash<String, Array>]
+    def changes
+      @changes.dup
+    end
+
     private
 
     # Coerce a value for the appropriate value type.
@@ -618,5 +643,11 @@ module SuperSettings
       end
       attribute_errors << "#{attribute.tr("_", " ")} #{message}"
     end
+
+    def call_after_save_callbacks
+      self.class.after_save_blocks.each do |block|
+        block.call(self)
+      end
+    end
   end
 end

data/lib/super_settings.rb

@@ -3,6 +3,8 @@
 require_relative "super_settings/application"
 require_relative "super_settings/coerce"
 require_relative "super_settings/configuration"
+require_relative "super_settings/context"
+require_relative "super_settings/context/rack_middleware"
 require_relative "super_settings/local_cache"
 require_relative "super_settings/rest_api"
 require_relative "super_settings/rack_application"
@@ -28,7 +30,7 @@ module SuperSettings
     # @param default [String] value to return if the setting value is nil
     # @return [String]
     def get(key, default = nil)
-      val = local_cache[key]
+      val = context_setting(key)
       val.nil? ? default : val.to_s
     end
 
@@ -46,7 +48,7 @@ module SuperSettings
     # @param default [Integer] value to return if the setting value is nil
     # @return [Integer]
     def integer(key, default = nil)
-      val = local_cache[key]
+      val = context_setting(key)
       (val.nil? ? default : val)&.to_i
     end
 
@@ -56,7 +58,7 @@ module SuperSettings
     # @param default [Numeric] value to return if the setting value is nil
     # @return [Float]
     def float(key, default = nil)
-      val = local_cache[key]
+      val = context_setting(key)
       (val.nil? ? default : val)&.to_f
     end
 
@@ -66,7 +68,7 @@ module SuperSettings
     # @param default [Boolean] value to return if the setting value is nil
     # @return [Boolean]
     def enabled?(key, default = false)
-      val = local_cache[key]
+      val = context_setting(key)
       Coerce.boolean(val.nil? ? default : val)
     end
 
@@ -85,7 +87,7 @@ module SuperSettings
     # @param default [Time] value to return if the setting value is nil
     # @return [Time]
     def datetime(key, default = nil)
-      val = local_cache[key]
+      val = context_setting(key)
       Coerce.time(val.nil? ? default : val)
     end
 
@@ -95,36 +97,12 @@ module SuperSettings
     # @param default [Array] value to return if the setting value is nil
     # @return [Array]
     def array(key, default = nil)
-      val = local_cache[key]
+      val = context_setting(key)
       val = default if val.nil?
       return nil if val.nil?
       Array(val).collect { |v| v&.to_s }
     end
 
-    # Get setting values cast to a hash. This method can be used to cast the flat setting key/value
-    # store into a structured data store. It uses a delimiter to define how keys are nested which
-    # defaults to a dot.
-    #
-    # If, for example, you have three keys in you settings +A.B1.C1 = 1+, +A.B1.C2 = 2+, and +A.B2.C3 = 3+, the
-    # nested structure will be:
-    #
-    # +{"A" => {"B1" => {"C1" => 1, "C2" => 2}, "B2" => {"C3" => 3}}}+
-    #
-    # This whole hash would be returned if you called +hash+ without any key. If you called it with the
-    # key "A.B1", it would return
-    #
-    # +{"C1" => 1, "C2" => 2}+
-    #
-    # @param key [String, Symbol] the prefix patter to fetch keys for; default to returning all settings
-    # @param default [Hash] value to return if the setting value is nil
-    # @param delimiter [String] the delimiter to use to define nested keys in the hash; defaults to "."
-    # @return [Hash]
-    def structured(key = nil, default = nil, delimiter: ".", max_depth: nil)
-      value = local_cache.structured(key, delimiter: delimiter, max_depth: max_depth)
-      return (default || {}) if value.empty?
-      value
-    end
-
     # Create settings and update the local cache with the values. If a block is given, then the
     # value will be reverted at the end of the block. This method can be used in tests when you
     # need to inject a specific value into your settings.
@@ -148,6 +126,7 @@ module SuperSettings
         setting.save!
         local_cache.load_settings unless local_cache.loaded?
         local_cache.update_setting(setting)
+
         if block_given?
           yield
         end
@@ -161,6 +140,19 @@ module SuperSettings
       end
     end
 
+    # Define a block where settings will remain unchanged. This is useful to
+    # prevent settings from changing while you are in the middle of a block of
+    # code that depends on the settings.
+    def context(&block)
+      reset_context = Thread.current[:super_settings_context].nil?
+      begin
+        Thread.current[:super_settings_context] ||= {}
+        yield
+      ensure
+        Thread.current[:super_settings_context] = nil if reset_context
+      end
+    end
+
     # Load the settings from the database into the in memory cache.
     #
     # @return [void]
@@ -230,5 +222,22 @@ module SuperSettings
     def local_cache
       @local_cache ||= LocalCache.new(refresh_interval: DEFAULT_REFRESH_INTERVAL)
     end
+
+    def current_context
+      Thread.current[:super_settings_context]
+    end
+
+    def context_setting(key)
+      key = key.to_s
+      context = current_context
+      if context
+        unless context.include?(key)
+          context[key] = local_cache[key]
+        end
+        context[key]
+      else
+        local_cache[key]
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: super_settings
 version: !ruby/object:Gem::Version
-  version: 0.0.1.rc3
+  version: 1.0.0
 platform: ruby
 authors:
 - Brian Durand
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-04 00:00:00.000000000 Z
+date: 2023-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,6 +56,9 @@ files:
 - lib/super_settings/attributes.rb
 - lib/super_settings/coerce.rb
 - lib/super_settings/configuration.rb
+- lib/super_settings/context.rb
+- lib/super_settings/context/rack_middleware.rb
+- lib/super_settings/context/sidekiq_middleware.rb
 - lib/super_settings/controller_actions.rb
 - lib/super_settings/engine.rb
 - lib/super_settings/history_item.rb
@@ -85,11 +88,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.4.12
 signing_key:
 specification_version: 4
 summary: Fast access runtime settings for a Rails application with an included UI