abstract_feature_branch 1.4.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0241ac7ec58e588b7ad5705d3e2261d38d34b1cb8b7e354f1e356d36fbea4772
-  data.tar.gz: 25bb7d870cf117cae57df4d9510ba92dd01d6892f9088b33e5d6eb48d52a4eae
+  metadata.gz: 9b05f473f9e1490d0e627cd6ee46bc065fd99054eeec4fe4276b6009650a3ad4
+  data.tar.gz: 657dbe0b15b9ac0827ef3dcbaa748bc571cb7d1ef95b25e44d3ee8c1029bf4ae
 SHA512:
-  metadata.gz: 25e037089e15a21f1620f112c2ce9a5479c10633e2bccdd5760d680c3f490c6a5bdd8a9a981ae8e3f2119623ddc232d8ca67d8efac5260d7e0197bf50458c72d
-  data.tar.gz: 287cda44bd97f86a0dd031747af5be1af7b5c748cc9794aa3d776607dd3db28d25703c67fb6afba10f7b0b725dcbd7694e9f6d3a5995b433628a9b52d204c6a0
+  metadata.gz: cbf7abdfa86da1c21bb55e913809879adc0fb7d049ae047a272dbbdec648f064112036bc1671ed2f66dc0cdec7539d0e6fee0f7d9bc099dcc710229cc8a2d1e4
+  data.tar.gz: 8effdc0bba15209eb0d4366dd719b98bd11c3d5e6f772788156d40a625f2539b17a726ea79ceeedc29576dc58b49a14f1b0a26cabe46a8037473e0fe5c3cc4be

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Change Log
 
+## 1.5.1
+
+- `AbstractFeatureBranch.toggled_features_for_scope(scope)` API method that returns toggled features for a scope (String)
+- `AbstractFeatureBranch.scopes_for_feature(feature)` API method that returns scopes for a (scoped) feature (String or Symbol)
+
+## 1.5.0
+
+- Generalize "Per-User Feature Enablement" as "Scoped Feature Enablement" (using `scoped` value instead of `per_user` value) to scope features by any scope IDs (e.g. entity IDs or value objects)
+- Rename `toggle_features_for_user` to `toggle_features_for_scope`
+
 ## 1.4.0
 
 - Avoid live loading of per-user features when `AbstractFeatureBranch.feature_store_live_fetching` is `false` to ensure better performance through caching.

data/README.md

@@ -1,4 +1,4 @@
-# Abstract Feature Branch 1.4.0
+# Abstract Feature Branch 1.5.1
 [![Gem Version](https://badge.fury.io/rb/abstract_feature_branch.png)](http://badge.fury.io/rb/abstract_feature_branch)
 [![Build Status](https://api.travis-ci.org/AndyObtiva/abstract_feature_branch.png?branch=master)](https://travis-ci.org/AndyObtiva/abstract_feature_branch)
 [![Coverage Status](https://coveralls.io/repos/AndyObtiva/abstract_feature_branch/badge.png?branch=master)](https://coveralls.io/r/AndyObtiva/abstract_feature_branch?branch=master)
@@ -23,8 +23,6 @@ context-specific feature files if needed.
 
 [`abstract_feature_branch`](https://rubygems.org/gems/abstract_feature_branch) is one of the simplest and most minimalistic "Feature Flags" Ruby gems out there as it enables you to get started very quickly by simply leveraging YAML files without having to set up a data store if you do not need it (albeit, you also have the option to use [Redis](https://redis.com) as a very fast in-memory data store).
 
-
-
 Requirements
 ------------
 - Ruby (between `~> 3.1.0` and `~> 1.8.7`)
@@ -38,17 +36,17 @@ Setup
 ### Rails Application Use
 
 1. Configure Rubygem
-   - With `rails` between `~> 7.0` and `~> 2.0`: Add the following to Gemfile <pre>gem 'abstract_feature_branch', '~> 1.4.0'</pre>
-   - With `rails` `~> 2.0` only: Add the following to config/environment.rb <pre>config.gem 'abstract_feature_branch', :version => '1.4.0'</pre>
+   - With `rails` between `~> 7.0` and `~> 2.0`: Add the following to Gemfile <pre>gem 'abstract_feature_branch', '~> 1.5.1'</pre>
+   - With `rails` `~> 2.0` only: Add the following to config/environment.rb <pre>config.gem 'abstract_feature_branch', :version => '1.5.1'</pre>
 2. Generate <code>config/initializers/abstract_feature_branch.rb</code>, <code>lib/tasks/abstract_feature_branch.rake</code>, <code>config/features.yml</code> and <code>config/features.local.yml</code> in your Rails app directory by running <pre>rails g abstract_feature_branch:install</pre>
 3. [Optional] Generate <code>config/features/[context_path].yml</code> in your Rails app directory by running <pre>rails g abstract_feature_branch:context context_path</pre> (more details under [**instructions**](#instructions))
-4. [Optional] Customize configuration in <code>config/initializers/abstract_feature_branch.rb</code> (can be useful for changing location of feature files in Rails application, configuring Redis with a Redis or ConnectionPool instance to use for overrides, and [per-user feature enablement](#per-user-feature-enablement), or troubleshooting a specific Rails environment feature configuration)
+4. [Optional] Customize configuration in <code>config/initializers/abstract_feature_branch.rb</code> (can be useful for changing location of feature files in Rails application, configuring Redis with a Redis or ConnectionPool instance to use for overrides, and [scoped feature enablement](#scoped-feature-enablement) (e.g. per-user), or troubleshooting a specific Rails environment feature configuration)
 5. [Optional] Redis Server (between `~> 7.0` and `~> 3.0`): On the Mac, you can install simply via [Homebrew](https://brew.sh/) with `brew install redis`
 6. [Optional] `redis` client gem (between `~> 5.0` and `~> 3.0`): Add the following to Gemfile above [`abstract_feature_branch`](https://rubygems.org/gems/abstract_feature_branch) <pre>gem 'redis', '~> 5.0.5'</pre>
 
 ### Ruby Application General Use
 
-1. <pre>gem install abstract_feature_branch -v 1.4.0</pre>
+1. <pre>gem install abstract_feature_branch -v 1.5.1</pre>
 2. Add code <code>require 'abstract_feature_branch'</code>
 3. Create <code>config/features.yml</code> under <code>AbstractFeatureBranch.application_root</code> and fill it with content similar to that of the sample <code>config/features.yml</code> mentioned under [**instructions**](#instructions).
 4. [Optional] Create <code>config/features.local.yml</code> under <code>AbstractFeatureBranch.application_root</code>  (more details under [**instructions**](#instructions))
@@ -58,8 +56,8 @@ Setup
 8. [Optional] Add code <code>AbstractFeatureBranch.logger = "[your_application_logger]"</code> (it defaults to a new instance of Ruby <code>Logger</code>. Must use a logger with <code>info</code> and <code>warn</code> methods).
 9. [Optional] Add code <code>AbstractFeatureBranch.cacheable = {[environment] => [true/false]}</code> to indicate cacheability of loaded feature files for enhanced performance (it defaults to true for every environment other than development).
 10. [Optional] Add code <code>AbstractFeatureBranch.load_application_features</code> to pre-load application features for improved first-use performance
-11. [Optional] Add code <code>AbstractFeatureBranch.feature_store = Redis.new(options)</code> to configure Redis for overrides and/or [per-user feature enablement](#per-user-feature-enablement)
-12. [Optional] Set <code>AbstractFeatureBranch.feature_store_live_fetching = true</code> to enable live fetching of features from store (e.g. Redis) to avoid need for app/server restart upon feature changes, with the trade-off of slightly more latency due to making calls to feature store over the network (this affects per-user feature enablement too, pre-caching all user IDs for features on app/server restart when disabled)
+11. [Optional] Add code <code>AbstractFeatureBranch.feature_store = Redis.new(options)</code> to configure Redis for overrides and/or [scoped feature enablement](#scoped-feature-enablement) (e.g. per-user)
+12. [Optional] Set <code>AbstractFeatureBranch.feature_store_live_fetching = true</code> to enable live fetching of features from store (e.g. Redis) to avoid need for app/server restart upon feature changes, with the trade-off of slightly more latency due to making calls to feature store over the network (this affects scoped feature enablement too, pre-caching all user IDs for features on app/server restart when disabled)
 
 Instructions
 ------------
@@ -84,7 +82,7 @@ enabled (true) or disabled (false) per environment (e.g. production).
 >       feature1: true
 >       feature2: true
 >       feature3: false
->       feature4: per_user
+>       feature4: scoped
 >
 >     development:
 >       <<: *defaults
@@ -131,17 +129,17 @@ Note that <code>feature_enabled?</code> returns false if the feature is disabled
 >     AbstractFeatureBranch.environment_features('development')
 >     # => {"feature1"=>true, "feature2"=>false, "feature3"=>false, "feature4"=>true}
 
-### Per-User Feature Enablement
+### Scoped Feature Enablement
 
-It is possible to restrict enablement of features per specific users (or per entities of any kind) by setting a feature value to <code>per_user</code>, and then toggling features for specific users (or other entities).
+It is possible to restrict enablement of features per specific users (or per entities of any kind) by setting a feature value to <code>scoped</code>, and then toggling features for specific users (or other entities).
 
-1. Use <code>toggle_features_for_user</code> in Ruby code to enable features per user ID (e.g. email address or database ID). This loads Redis client gem into memory and stores per-user feature configuration in Redis.
+1. Use <code>toggle_features_for_scope</code> in Ruby code to enable features per scope ID (e.g. entity ID, comma-separated compound ID, JSON string, or value object), which must be a String or a value that is safely-convertable to a String like Integer (e.g. email address or database ID). This loads Redis client gem into memory and stores scoped feature configuration in Redis.
 In the example below, current_user is a method that provides the current signed in user (e.g. using Rails [Devise] (https://github.com/plataformatec/devise) library).
 
->     user_id = current_user.email
->     AbstractFeatureBranch.toggle_features_for_user(user_id, :feature1 => true, :feature2 => false, :feature3 => true, :feature5 => true)
+>     scope = current_user.email
+>     AbstractFeatureBranch.toggle_features_for_scope(scope, :feature1 => true, :feature2 => false, :feature3 => true, :feature5 => true)
 
-Use alternate version of <code>feature_branch</code> and <code>feature_enabled?</code> passing extra <code>user_id</code> argument
+Use alternate version of <code>feature_branch</code> and <code>feature_enabled?</code> passing extra <code>scope</code> argument
 
 Examples:
 
@@ -168,9 +166,17 @@ Examples:
 Note:
 
 If a feature is enabled as <code>true</code> or disabled as <code>false</code> in features.yml (or one of the overrides
-like features.local.yml or environment variable overrides), then it overrides toggled per-user restrictions, becoming
+like features.local.yml or environment variable overrides), then it overrides toggled scoped feature restrictions, becoming
 enabled or disabled globally.
 
+API
+---
+
+`AbstractFeatureBranch.toggle_features_for_scope(scope, feature1: true, feature2: false, ...)`: API method that toggles features (Strings or Symbols) for a scope
+
+`AbstractFeatureBranch.toggled_features_for_scope(scope)`: API method that returns toggled features for a scope (String)
+
+`AbstractFeatureBranch.scopes_for_feature(feature)`: API method that returns scopes for a (scoped) feature (String or Symbol)
 
 Recommendations
 ---------------

data/VERSION

@@ -1 +1 @@
-1.4.0
+1.5.1

data/abstract_feature_branch.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: abstract_feature_branch 1.4.0 ruby lib
+# stub: abstract_feature_branch 1.5.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "abstract_feature_branch".freeze
-  s.version = "1.4.0"
+  s.version = "1.5.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Andy Maleh".freeze]
-  s.date = "2023-02-05"
+  s.date = "2023-02-14"
   s.description = "abstract_feature_branch is a Ruby gem that provides a unique variation on the Branch by Abstraction Pattern by Paul Hammant and the Feature Toggles Pattern by Martin Fowler to enhance team productivity and improve software fault tolerance.\n\nIt provides the ability to wrap blocks of code with an abstract feature branch name, and then specify in a configuration file which features to be switched on or off.\n\nThe goal is to build out upcoming features in the same source code repository branch (i.e. Continuous Integration and Trunk-Based Development), regardless of whether all are completed by the next release date or not, thus increasing team productivity by preventing integration delays. Developers then disable in-progress features until they are ready to be switched on in production, yet enable them locally and in staging environments for in-progress testing.\n\nThis gives developers the added benefit of being able to switch a feature off after release should big problems arise for a high risk feature.\n\nabstract_feature_branch additionally supports Domain Driven Design's pattern of Bounded Contexts by allowing developers to configure context-specific feature files if needed.\n\nabstract_feature_branch is one of the simplest and most minimalistic \"Feature Flags\" Ruby gems out there as it enables you to get started very quickly by simply leveraging YAML files without having to set up a data store if you do not need it (albeit, you also have the option to use Redis as a very fast in-memory data store).\n".freeze
   s.extra_rdoc_files = [
     "CHANGELOG.md",
@@ -39,7 +39,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/AndyObtiva/abstract_feature_branch".freeze
   s.licenses = ["MIT".freeze]
-  s.post_install_message = "\nRails-only post-install instructions:\n\n1) Run the following command to generate the Rails initializer and basic feature files:\n\nrails g abstract_feature_branch:install\n\n2) Optionally, you may run this command to generate feature files per context:\n\nrails g abstract_feature_branch:context context_path\n   \n3) Optionally, install Redis server with [Homebrew](https://brew.sh/) by running:\n\nbrew install redis\n\n4) Optionally, install redis client gem (required with Redis server) by adding the following line to Gemfile above abstract_feature_branch:\n\ngem 'redis', '~> 5.0.5'\n\nAfterwards, run:\n\nbundle\n\n5) Optionally, customize configuration in config/initializers/abstract_feature_branch.rb\n\n(can be useful for changing location of feature files in Rails application,\nconfiguring Redis with a Redis or ConnectionPool instance to use for overrides and per-user feature enablement,\nand/or troubleshooting specific Rails environment feature configurations)\n\n".freeze
+  s.post_install_message = "\nRails-only post-install instructions:\n\n1) Run the following command to generate the Rails initializer and basic feature files:\n\nrails g abstract_feature_branch:install\n\n2) Optionally, you may run this command to generate feature files per context:\n\nrails g abstract_feature_branch:context context_path\n   \n3) Optionally, install Redis server with [Homebrew](https://brew.sh/) by running:\n\nbrew install redis\n\n4) Optionally, install redis client gem (required with Redis server) by adding the following line to Gemfile above abstract_feature_branch:\n\ngem 'redis', '~> 5.0.5'\n\nAfterwards, run:\n\nbundle\n\n5) Optionally, customize configuration in config/initializers/abstract_feature_branch.rb\n\n(can be useful for changing location of feature files in Rails application,\nconfiguring Redis with a Redis or ConnectionPool instance to use for overrides and scoped feature enablement (e.g. per-user),\nand/or troubleshooting specific Rails environment feature configurations)\n\n".freeze
   s.rubygems_version = "3.3.6".freeze
   s.summary = "abstract_feature_branch is a Ruby gem that provides a variation on the Branch by Abstraction Pattern by Paul Hammant and the Feature Toggles Pattern by Martin Fowler (aka Feature Flags) to enable Continuous Integration and Trunk-Based Development.".freeze
 

data/lib/abstract_feature_branch.rb

@@ -20,6 +20,8 @@ require 'abstract_feature_branch/configuration'
 module AbstractFeatureBranch
   ENV_FEATURE_PREFIX = "abstract_feature_branch_"
   REDIS_HKEY = "abstract_feature_branch"
+  VALUE_SCOPED = 'scoped'
+  SCOPED_SPECIAL_VALUES = [VALUE_SCOPED, 'per_user', 'per-user', 'per user']
 
   class << self
     extend Forwardable
@@ -27,7 +29,7 @@ module AbstractFeatureBranch
                    :application_root, :application_root=, :initialize_application_root, :application_environment, :application_environment=, :initialize_application_environment,
                    :logger, :logger=, :initialize_logger, :cacheable, :cacheable=, :initialize_cacheable, :feature_store, :feature_store=, :user_features_storage, :user_features_storage=,
                    :feature_store_live_fetching, :feature_store_live_fetching=
-
+    
     def configuration
       @configuration ||= Configuration.new
     end
@@ -86,23 +88,20 @@ module AbstractFeatureBranch
         merge(redis_overrides)
     end
     
-    def redis_per_user_features
-      @redis_per_user_features ||= load_redis_per_user_features
+    def redis_scoped_features
+      @redis_scoped_features ||= load_redis_scoped_features
     end
-    def load_redis_per_user_features
-      @redis_per_user_features = {}
-      return @redis_per_user_features if AbstractFeatureBranch.configuration.feature_store_live_fetching?
+    def load_redis_scoped_features
+      @redis_scoped_features = {}
+      return @redis_scoped_features if AbstractFeatureBranch.configuration.feature_store_live_fetching?
       
       @environment_features.each do |environment, features|
         features.each do |feature, value|
-          if value == 'per_user'
+          if SCOPED_SPECIAL_VALUES.include?(value.to_s.downcase)
             normalized_feature_name = feature.to_s.downcase
-            @redis_per_user_features[normalized_feature_name] ||= []
+            @redis_scoped_features[normalized_feature_name] ||= []
             begin
-              per_user_feature_user_ids = AbstractFeatureBranch.
-                                            user_features_storage.
-                                            smembers("#{AbstractFeatureBranch::ENV_FEATURE_PREFIX}#{normalized_feature_name}")
-              @redis_per_user_features[normalized_feature_name] += per_user_feature_user_ids
+              @redis_scoped_features[normalized_feature_name] += scopes_for_feature(normalized_feature_name)
             rescue Exception => error
               AbstractFeatureBranch.logger.error "AbstractFeatureBranch encountered an error in retrieving Per-User values for feature \"#{normalized_feature_name}\"! Defaulting to no values...\n\nError: #{error.full_message}\n\n"
               nil
@@ -111,7 +110,7 @@ module AbstractFeatureBranch
         end
       end
       
-      @redis_per_user_features
+      @redis_scoped_features
     end
     
     def application_features
@@ -124,7 +123,7 @@ module AbstractFeatureBranch
       AbstractFeatureBranch.load_features
       AbstractFeatureBranch.load_local_features
       AbstractFeatureBranch.load_environment_features(application_environment)
-      AbstractFeatureBranch.load_redis_per_user_features
+      AbstractFeatureBranch.load_redis_scoped_features
     end
     def unload_application_features
       @redis_overrides = nil
@@ -132,7 +131,7 @@ module AbstractFeatureBranch
       @features = nil
       @local_features = nil
       @environment_features = nil
-      @redis_per_user_features = nil
+      @redis_scoped_features = nil
     end
     
     def cacheable?
@@ -141,6 +140,10 @@ module AbstractFeatureBranch
       value
     end
     
+    def scoped_value?(value)
+      SCOPED_SPECIAL_VALUES.include?(value.to_s.downcase)
+    end
+    
     # Sets feature value (true or false) in storage (e.g. Redis client)
     def set_store_feature(feature, value)
       raise 'Feature storage (e.g. Redis) is not setup!' if feature_store.nil?
@@ -161,7 +164,7 @@ module AbstractFeatureBranch
         value = feature_store.hget(REDIS_HKEY, matching_feature) if matching_feature
       end
       return nil if value.nil?
-      return 'per_user' if value.to_s.downcase == 'per_user'
+      return VALUE_SCOPED if scoped_value?(value)
       value.to_s.downcase == 'true'
     end
     
@@ -186,16 +189,34 @@ module AbstractFeatureBranch
       end
     end
     
-    def toggle_features_for_user(user_id, features)
+    def toggle_features_for_scope(scope, features)
       features.each do |name, value|
         if value
-          feature_store.sadd("#{ENV_FEATURE_PREFIX}#{name.to_s.downcase}", user_id)
+          feature_store.sadd("#{ENV_FEATURE_PREFIX}#{name.to_s.downcase}", scope)
         else
-          feature_store.srem("#{ENV_FEATURE_PREFIX}#{name.to_s.downcase}", user_id)
+          feature_store.srem("#{ENV_FEATURE_PREFIX}#{name.to_s.downcase}", scope)
         end
       end
     end
-
+    alias toggle_features_for_user toggle_features_for_scope
+    
+    def toggled_features_for_scope(scope)
+      AbstractFeatureBranch.feature_store.keys.select do |key|
+        key.start_with?(AbstractFeatureBranch::ENV_FEATURE_PREFIX)
+      end.map do |key|
+        feature = key.sub(AbstractFeatureBranch::ENV_FEATURE_PREFIX, '')
+      end.select do |feature|
+        scopes_for_feature(feature).include?(scope.to_s)
+      end
+    end
+    
+    def scopes_for_feature(feature)
+      normalized_feature_name = feature.to_s.downcase
+      AbstractFeatureBranch.
+        feature_store.
+        smembers("#{AbstractFeatureBranch::ENV_FEATURE_PREFIX}#{normalized_feature_name}")
+    end
+    
     private
 
     def load_specific_features(features_hash, extension)
@@ -219,7 +240,7 @@ module AbstractFeatureBranch
       hash_values = hash.map do |k, v|
         normalized_value = v.to_s.downcase
         boolean_value = normalized_value == 'true'
-        new_value = normalized_value == 'per_user' ? 'per_user' : boolean_value
+        new_value = scoped_value?(normalized_value) ? VALUE_SCOPED : boolean_value
         [k, new_value]
       end
       Hash[hash_values]

data/lib/ext/feature_branch.rb

@@ -1,20 +1,20 @@
 class Object
   class << self
     raise 'Abstract feature branch conflicts with another Ruby library having Object::feature_branch' if respond_to?(:feature_branch)
-    def feature_branch(feature_name, user_id = nil, &feature_work)
-      if feature_enabled?(feature_name, user_id)
+    def feature_branch(feature_name, scope = nil, &feature_work)
+      if feature_enabled?(feature_name, scope)
         feature_work.call
       end
     end
   
     raise 'Abstract feature branch conflicts with another Ruby library having Object::feature_enabled?' if respond_to?(:feature_enabled?)
-    def feature_enabled?(feature_name, user_id = nil)
+    def feature_enabled?(feature_name, scope = nil)
       normalized_feature_name = feature_name.to_s.downcase
   
       redis_override_value = feature_enabled_reddis_override_value(normalized_feature_name)
       value = !redis_override_value.nil? ? redis_override_value : AbstractFeatureBranch.application_features[normalized_feature_name]
-      if value == 'per_user'
-        value = !user_id.nil? && feature_enabled_per_user_value(feature_name, user_id)
+      if AbstractFeatureBranch.scoped_value?(value)
+        value = !scope.nil? && feature_enabled_scoped_value(feature_name, scope)
       end
       value
     end
@@ -33,28 +33,28 @@ class Object
       end
     end
     
-    raise 'Abstract feature branch conflicts with another Ruby library having Object::feature_enabled_per_user_value' if Object.new.respond_to?(:feature_enabled_per_user_value, true)
-    def feature_enabled_per_user_value(normalized_feature_name, user_id)
+    raise 'Abstract feature branch conflicts with another Ruby library having Object::feature_enabled_scoped_value' if Object.new.respond_to?(:feature_enabled_scoped_value, true)
+    def feature_enabled_scoped_value(normalized_feature_name, scope)
       if AbstractFeatureBranch.configuration.feature_store_live_fetching?
         begin
-          AbstractFeatureBranch.user_features_storage.sismember("#{AbstractFeatureBranch::ENV_FEATURE_PREFIX}#{normalized_feature_name}", user_id)
+          AbstractFeatureBranch.feature_store.sismember("#{AbstractFeatureBranch::ENV_FEATURE_PREFIX}#{normalized_feature_name}", scope)
         rescue Exception => error
-          AbstractFeatureBranch.logger.error "AbstractFeatureBranch encountered an error in retrieving Per-User value for feature \"#{normalized_feature_name}\" and user_id #{user_id}! Defaulting to nil value...\n\nError: #{error.full_message}\n\n"
+          AbstractFeatureBranch.logger.error "AbstractFeatureBranch encountered an error in retrieving Per-User value for feature \"#{normalized_feature_name}\" and scope #{scope}! Defaulting to nil value...\n\nError: #{error.full_message}\n\n"
           nil
         end
       else
-        AbstractFeatureBranch.redis_per_user_features[normalized_feature_name]&.include?(user_id.to_s)
+        AbstractFeatureBranch.redis_scoped_features[normalized_feature_name]&.include?(scope.to_s)
       end
     end
   end
   
   raise 'Abstract feature branch conflicts with another Ruby library having Object#feature_branch' if Object.new.respond_to?(:feature_branch)
-  def feature_branch(feature_name, user_id = nil, &feature_work)
-    Object.feature_branch(feature_name.to_s, user_id, &feature_work)
+  def feature_branch(feature_name, scope = nil, &feature_work)
+    Object.feature_branch(feature_name.to_s, scope, &feature_work)
   end
 
   raise 'Abstract feature branch conflicts with another Ruby library having Object#feature_enabled?' if Object.new.respond_to?(:feature_enabled?)
-  def feature_enabled?(feature_name, user_id = nil)
-    Object.feature_enabled?(feature_name.to_s, user_id)
+  def feature_enabled?(feature_name, scope = nil)
+    Object.feature_enabled?(feature_name.to_s, scope)
   end
 end

data/lib/generators/templates/config/initializers/abstract_feature_branch.rb

@@ -9,7 +9,7 @@
 
 # Enable live fetching of feature configuration from storage system (Redis), to update features without app/server restart.
 # false by default to only load features on app/server start for faster performance (requires restart on change)
-# This also affects per-user feature loading from storage system (Redis), pre-caching user IDs for features on app/server
+# This also affects scoped feature loading from storage system (Redis), pre-caching scope IDs for features on app/server
 # restart when false, for better performance.
 AbstractFeatureBranch.feature_store_live_fetching = false
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstract_feature_branch
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-05 00:00:00.000000000 Z
+date: 2023-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge
@@ -164,8 +164,9 @@ post_install_message: "\nRails-only post-install instructions:\n\n1) Run the fol
   following line to Gemfile above abstract_feature_branch:\n\ngem 'redis', '~> 5.0.5'\n\nAfterwards,
   run:\n\nbundle\n\n5) Optionally, customize configuration in config/initializers/abstract_feature_branch.rb\n\n(can
   be useful for changing location of feature files in Rails application,\nconfiguring
-  Redis with a Redis or ConnectionPool instance to use for overrides and per-user
-  feature enablement,\nand/or troubleshooting specific Rails environment feature configurations)\n\n"
+  Redis with a Redis or ConnectionPool instance to use for overrides and scoped feature
+  enablement (e.g. per-user),\nand/or troubleshooting specific Rails environment feature
+  configurations)\n\n"
 rdoc_options: []
 require_paths:
 - lib