abstract_feature_branch 1.2.2 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 171dc3b05d9257bd90a08f4675cb4be9649e0c1e
-  data.tar.gz: caa97d72c5866c47023ce82bba130b747e526936
+SHA256:
+  metadata.gz: 52ff8ed098aa83bdd70eda839fa74b291c95993fb9859e2cc5ed8c0752bfa213
+  data.tar.gz: 9b5e6915905904be0b87690a73b1dfe14ec8893b2659383545bac23b0fe76978
 SHA512:
-  metadata.gz: 92bc2cf8e35055a73a2e44a276b89cd5d3a27b2e499ed176243f836046392bb2f38109aa50b38a75b6c8ab254dc7695796ee0fb5b89d5e8ea652dc29ffc76edb
-  data.tar.gz: b63edde1fb4b6beeece611e173dc002a56ff00a577d10003d769b1f21945a9b9e924663b87dfdefe673b3093c741e4ce6becc65e9f7d5af85b6b32efee1de76f
+  metadata.gz: 2f948fd18d057bed300d4cb9eb89e36b784ec2e8a445edaeaf2d742866884828795e8873de02ea9d1794604757dee8d6af2b63934a4f7fcd5b7c0d65aa1171ec
+  data.tar.gz: c4a1ddc94547f390e2960ddc97a20034cf7bd3dbaa378e17060ae38509b019897d0364913573856254269217c22731de15e7e1e8c8825b1d30c0615521ee6610

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Change Log
+
+## 1.3.1
+
+- Support Redis `ConnectionPool` `AbstractFeatureBranch::Configuration#feature_store`
+
+## 1.3.0
+
+- Officially support newer `redis` client gem version 5
+- Support (general-user) Redis Overrides (similar to Environment Variable Overrides)
+- Remove `redis` gem from required dependencies to allow using `abstract_feature_branch` without Redis
+- Make configuration of Redis optional in generated Rails initializer
+- Provide alias of `AbstractFeatureBranch::Configuration#feature_store` to `AbstractFeatureBranch::Configuration#user_features_storage` (plus corresponding aliases `feature_store=` and `initialize_feature_store`)
+- Document support for Rails 7 and Redis Server 7
+- Add gem post install instructions, including how to run the Rails generators and install/use Redis

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Annas "Andy" Maleh
+Copyright (c) 2012-2022 Andy Maleh
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,21 +1,13 @@
-Abstract Feature Branch
-=======================
+# Abstract Feature Branch 1.3.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)
 [![Code Climate](https://codeclimate.com/github/AndyObtiva/abstract_feature_branch.png)](https://codeclimate.com/github/AndyObtiva/abstract_feature_branch)
 
-**As Featured In**
-
-[![Factor 75](https://dzd6ppgm28vds.cloudfront.net/assets/logo-b190de0b423855600e216d490fc160ad.png)](https://www.factor75.com)..[![Character Business Card](https://characterbusinesscard.s3.amazonaws.com/assets/Character-Business-Card-Logo-Desktop-44eb97b18b0a100488ba9c322343b91a.png)](https://www.characterbusinesscard.com)..[![Early Shares](http://early-shares-assets-production.s3.amazonaws.com/assets/logo2x-67fadfc8bb942ba92cca60c464010f1f.png)](https://www.earlyshares.com)
-
-
-
 abstract_feature_branch is a Rails gem that enables developers to easily branch by abstraction as per this pattern:
 http://paulhammant.com/blog/branch_by_abstraction.html
 
-It is a productivity and fault tolerance enhancing team practice that has been utilized by professional software development
-teams at large corporations, such as [Sears](http://www.sears.com) and [Groupon](http://www.groupon.com).
+It is a productivity and fault tolerance enhancing team practice.
 
 It 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.
@@ -34,9 +26,10 @@ context-specific feature files if needed.
 
 Requirements
 ------------
-- Ruby ~> 2.0.0, ~> 1.9 or ~> 1.8.7
-- (Optional) Rails ~> 4.0.0, ~> 3.0 or ~> 2.0
-- (Optional) Redis server
+- Ruby (between `~> 3.1.0` and `~> 1.8.7`) ([click for a list of tested Ruby versions](https://travis-ci.org/AndyObtiva/abstract_feature_branch))
+- [Optional] Rails (between `~> 7.0` and `~> 2.0`)
+- [Optional] Redis Server (between `~> 7.0` and `~> 2.0`)
+- [Optional] Redis client gem (between `~> 5.0` and `~> 3.0`)
 
 Setup
 -----
@@ -44,25 +37,27 @@ Setup
 ### Rails Application Use
 
 1. Configure Rubygem
-   - Rails (~> 4.0.0 or ~> 3.0): Add the following to Gemfile <pre>gem 'abstract_feature_branch', '1.2.2'</pre>
-   - Rails (~> 2.0): Add the following to config/environment.rb <pre>config.gem 'abstract_feature_branch', :version => '1.2.2'</pre>
+   - With `rails` between `~> 7.0` and `~> 2.0`: Add the following to Gemfile <pre>gem 'abstract_feature_branch', '~> 1.3.1'</pre>
+   - With `rails` `~> 2.0` only: Add the following to config/environment.rb <pre>config.gem 'abstract_feature_branch', :version => '1.3.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 for per-user feature enablement, or troubleshooting a specific Rails environment feature configuration)
+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, or troubleshooting a specific Rails environment feature configuration)
+5. [Optional] Redis Server (between `~> 7.0` and `~> 3.0`): Install view [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` <pre>gem 'redis', '~> 5.0.5'</pre>
 
 ### Ruby Application General Use
 
-1. <pre>gem install abstract_feature_branch -v 1.2.2</pre>
+1. <pre>gem install abstract_feature_branch -v 1.3.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))
-5. (Optional) Create <code>config/features/[context_path].yml</code> under <code>AbstractFeatureBranch.application_root</code> (more details under [**instructions**](#instructions))
-6. (Optional) Add code <code>AbstractFeatureBranch.application_root = "[your_application_path]"</code> to configure the location of feature files (it defaults to <code>'.'</code>)
-7. (Optional) Add code <code>AbstractFeatureBranch.application_environment = "[your_application_environment]"</code> (it defaults to <code>'development'</code>). Alternatively, you can set <code>ENV['APP_ENV']</code> before the <code>require</code> statement or an an external environment variable.
-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.user_features_storage = Redis.new(options)</code> to configure Redis for per-user feature enablement
+4. [Optional] Create <code>config/features.local.yml</code> under <code>AbstractFeatureBranch.application_root</code>  (more details under [**instructions**](#instructions))
+5. [Optional] Create <code>config/features/[context_path].yml</code> under <code>AbstractFeatureBranch.application_root</code> (more details under [**instructions**](#instructions))
+6. [Optional] Add code <code>AbstractFeatureBranch.application_root = "[your_application_path]"</code> to configure the location of feature files (it defaults to <code>'.'</code>)
+7. [Optional] Add code <code>AbstractFeatureBranch.application_environment = "[your_application_environment]"</code> (it defaults to <code>'development'</code>). Alternatively, you can set <code>ENV['APP_ENV']</code> before the <code>require</code> statement or an an external environment variable.
+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 or per-user feature enablement
 
 Instructions
 ------------
@@ -264,6 +259,45 @@ The benefits can be achieved more easily via <code>config/features.local.yml</co
 However, environment variable overrides are implemented to support overriding feature configuration for a Heroku deployed
 application more easily.
 
+Redis Overrides
+---------------
+
+Prerequisites: Redis server and client (`redis` gem) and optional Redis configuration of `AbstractFeatureBranch.feature_store` in `config/initializers/abstract_feature_branch.rb` (`Redis` `ConnectionPool` instance is recommended for Production environments)
+
+To be able to override feature configuration in a production environment, you can utilize Redis Overrides.
+
+Alternatively, you may use Redis Overrides as your main source of feature configuration if you prefer that instead of relying on YAML files.
+
+You can override feature configuration with Redis hash values by calling `AbstractFeatureBranch#set_store_feature` in `rails console` (or `irb` after requiring `redis` and `abstract_feature_branch`):
+
+```ruby
+AbstractFeatureBranch.set_store_feature('feature1', true)
+```
+
+Behind the scenes, that is the equivalent of the following Redis client invocation, which stores a hash value in a `abstract_feature_branch` key:
+
+```ruby
+AbstractFeatureBranch.configuration.feature_store.hset('abstract_feature_branch', 'feature1', 'true')
+```
+
+To remove a Redis override, you can run the following in `rails console` (or `irb`):
+
+```ruby
+AbstractFeatureBranch.delete_store_feature('feature1')
+```
+
+To get a Redis override value, you can run the following in `rails console` (or `irb`):
+
+```ruby
+AbstractFeatureBranch.get_store_feature('feature1')
+```
+
+To get an array of all Redis Override features, you can run the following in `rails console` (or `irb`):
+
+```ruby
+AbstractFeatureBranch.get_store_features
+```
+
 Heroku
 ------
 
@@ -284,7 +318,7 @@ Removing an environment variable override:
 ### Recommendation
 
 It is recommended that you use environment variable overrides on Heroku only as an emergency or temporary measure.
-Afterward, make the change officially in config/features.yml, deploy, and remove the environment variable override for the long term.
+Afterward, make the change official in config/features.yml, deploy, and remove the environment variable override for the long term.
 
 ### Gotcha with abstract feature branching in CSS and JS files
 
@@ -308,18 +342,21 @@ the former if overlap in features occurs:
 3. Context-specific local feature file overrides: <code>config/features/**/*.local.yml</code>
 4. Main local feature file override: <code>config/features.local.yml</code>
 5. Environment variable overrides
+6. Redis overrides
 
 Rails Initializer
 -----------------
 
-Here is the content of the generated initializer (<code>config/initializers/abstract_feature_branch.rb</code>), which contains instructions on how to customize via [dependency injection](http://en.wikipedia.org/wiki/Dependency_injection):
+Here is the content of the generated initializer [with `redis` client gem added] (<code>config/initializers/abstract_feature_branch.rb</code>), which contains instructions on how to customize via [dependency injection](http://en.wikipedia.org/wiki/Dependency_injection):
 
->     require 'redis'
+>     # Storage system for features (other than YAML/Env-Vars). Right now, only Redis and ConnectionPool are supported.
+>     # AbstractFeatureBranch.feature_store = Redis.new
+>
+>     # Storage can be a Redis ConnectionPool instance
+>     # AbstractFeatureBranch.feature_store = ConnectionPool.new { Redis.new }
 >
->     # Storage for user features, customizable over here. Right now, only a Redis client is supported.
 >     # The following example line works with Heroku Redis To Go while still operating on local Redis for local development
->     # AbstractFeatureBranch.user_features_storage = Redis.new(:url => ENV['REDISTOGO_URL'])
->     AbstractFeatureBranch.user_features_storage = Redis.new
+>     # AbstractFeatureBranch.feature_store = Redis.new(:url => ENV['REDISTOGO_URL'])
 >
 >     # Application root where config/features.yml or config/features/ is found
 >     AbstractFeatureBranch.application_root = Rails.root
@@ -342,8 +379,6 @@ Here is the content of the generated initializer (<code>config/initializers/abst
 >     # Pre-load application features to improve performance of first web-page hit
 >     AbstractFeatureBranch.load_application_features unless Rails.env.development?
 
-TODO Document in Heroku (:url => ENV['REDISTOGO_URL'])
-
 Rake Task
 ---------
 
@@ -437,15 +472,14 @@ after invoking the rake task, **verify** that your feature file contents are to
 task changes.
 
 Feature Branches vs Branch by Abstraction
----------
+-----------------------------------------
 
-Although feature branches and branching by abstraction are similar, there are different situations that recommend each approach.  
+Although feature branches and branching by abstraction are similar, there are different situations that recommend each approach.
 
-Feature branching leverages your version control software (VCS) to create a branch that is independent of your main branch.  Once you write your feature, you integrate it with the rest of your code base. Featuring branching is ideal for developing features that can be completed within the one or two iterations.  But it can become cumbersome with larger features due to the fact your code is isolated and quickly falls out of sync with your main branch.  You will have to regularly rebase with your main branch or devote substantial time to resolving merge conflicts.   
+Feature branching leverages your version control software (VCS) to create a branch that is independent of your main branch.  Once you write your feature, you integrate it with the rest of your code base. Feature branching is ideal for developing features that can be completed within the one or two iterations.  But it can become cumbersome with larger features due to the fact your code is isolated and quickly falls out of sync with your main branch.  You will have to regularly rebase with your main branch or devote substantial time to resolving merge conflicts.
 
 Branching by abstraction, on the other hand, is ideal for substantial features, i.e. ones which take many iterations to complete.  This approach to branching takes place outside of your VCS.  Instead, you build your feature, but wrap the code inside configurable flags.  These configuration flags will allow for different behavior, depending on the runtime environment.  For example, a feature would be set to "on" when your app runs in development mode, but "off" when running in "production" mode.  This approach avoids the pain of constantly rebasing or resolving a myriad of merge conflict when you do attempt to integrate your feature into the larger app.
 
-
 Contributing to abstract_feature_branch
 ---------------------------------------
 
@@ -459,17 +493,14 @@ Contributing to abstract_feature_branch
 
 Committers
 ---------------------------------------
-* [Annas "Andy" Maleh (Author)](https://github.com/AndyObtiva)
+* [Andy Maleh (Author)](https://github.com/AndyObtiva)
 
 Contributors
 ---------------------------------------
-* [Christian Nennemann](https://github.com/XORwell)
-* [Ben Downey](https://github.com/bnd5k)
 * [Mark Moschel](https://github.com/mmosche2)
 
 Copyright
 ---------------------------------------
 
-Copyright (c) 2013 Annas "Andy" Maleh. See LICENSE.txt for
+Copyright (c) 2012-2022 Andy Maleh. See [LICENSE.txt](LICENSE.txt) for
 further details.
-

data/VERSION

@@ -1 +1 @@
-1.2.2
+1.3.1

data/abstract_feature_branch.gemspec

@@ -2,36 +2,32 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: abstract_feature_branch 1.3.1 ruby lib
 
 Gem::Specification.new do |s|
-  s.name = "abstract_feature_branch"
-  s.version = "1.2.2"
+  s.name = "abstract_feature_branch".freeze
+  s.version = "1.3.1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Annas \"Andy\" Maleh"]
-  s.date = "2014-02-23"
-  s.description = "abstract_feature_branch is a Rails gem that enables developers to easily branch by abstraction as per this pattern:\nhttp://paulhammant.com/blog/branch_by_abstraction.html\n\nIt is a productivity and fault tolerance enhancing team practice that has been utilized by professional software development\nteams at large corporations, such as Sears and Groupon.\n\nIt provides the ability to wrap blocks of code with an abstract feature branch name, and then\nspecify 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, regardless of whether all are\ncompleted by the next release date or not, thus increasing team productivity by preventing integration delays.\nDevelopers then disable in-progress features until they are ready to be switched on in production, yet enable them\nlocally 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\nfor a high risk feature.\n\nabstract_feature_branch additionally supports DDD's pattern of\nBounded Contexts by allowing developers to configure\ncontext-specific feature files if needed.\n"
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Annas \"Andy\" Maleh".freeze]
+  s.date = "2022-12-12"
+  s.description = "abstract_feature_branch is a Rails gem that enables developers to easily branch by abstraction as per this pattern:\nhttp://paulhammant.com/blog/branch_by_abstraction.html\n\nIt is a productivity and fault tolerance enhancing team practice.\n\nIt provides the ability to wrap blocks of code with an abstract feature branch name, and then\nspecify 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, regardless of whether all are\ncompleted by the next release date or not, thus increasing team productivity by preventing integration delays.\nDevelopers then disable in-progress features until they are ready to be switched on in production, yet enable them\nlocally 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\nfor a high risk feature.\n\nabstract_feature_branch additionally supports DDD's pattern of\nBounded Contexts by allowing developers to configure\ncontext-specific feature files if needed.\n".freeze
   s.extra_rdoc_files = [
+    "CHANGELOG.md",
     "LICENSE.txt",
     "README.md"
   ]
   s.files = [
-    ".coveralls.yml",
-    ".travis.yml",
+    "CHANGELOG.md",
     "LICENSE.txt",
     "README.md",
-    "RELEASE_NOTES.md",
     "VERSION",
     "abstract_feature_branch.gemspec",
-    "config/features/admin.local.yml",
-    "config/features/admin.yml",
-    "config/features/internal/wiki.local.yml",
-    "config/features/internal/wiki.yml",
-    "config/features/public.local.yml",
-    "config/features/public.yml",
     "lib/abstract_feature_branch.rb",
     "lib/abstract_feature_branch/configuration.rb",
     "lib/abstract_feature_branch/file_beautifier.rb",
+    "lib/abstract_feature_branch/redis/connection_pool_to_redis_adapter.rb",
     "lib/ext/feature_branch.rb",
     "lib/generators/abstract_feature_branch/context_generator.rb",
     "lib/generators/abstract_feature_branch/install_generator.rb",
@@ -39,53 +35,32 @@ Gem::Specification.new do |s|
     "lib/generators/templates/config/features.local.yml",
     "lib/generators/templates/config/features.yml",
     "lib/generators/templates/config/initializers/abstract_feature_branch.rb",
-    "lib/generators/templates/lib/tasks/abstract_feature_branch.rake",
-    "ruby187.Gemfile",
-    "ruby187.Gemfile.lock",
-    "spec/abstract_feature_branch/file_beautifier_spec.rb",
-    "spec/ext/feature_branch__feature_branch_per_user_spec.rb",
-    "spec/ext/feature_branch__feature_branch_spec.rb",
-    "spec/ext/feature_branch__feature_enabled_spec.rb",
-    "spec/fixtures/application_development_config/config/features.reference.yml",
-    "spec/fixtures/application_no_config/no_config",
-    "spec/fixtures/application_rails_config/config/features.local.yml",
-    "spec/fixtures/application_rails_config/config/features.yml",
-    "spec/fixtures/application_ugly_config_reference/config/another_application_configuration.yml",
-    "spec/fixtures/application_ugly_config_reference/config/database.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features.local.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features/admin.local.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features/admin.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features/empty.local.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features/feature_empty_config.local.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features/including_comments.local.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features/internal/wiki.local.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features/internal/wiki.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features/public.local.yml",
-    "spec/fixtures/application_ugly_config_reference/config/features/public.yml"
+    "lib/generators/templates/lib/tasks/abstract_feature_branch.rake"
   ]
-  s.homepage = "http://github.com/AndyObtiva/abstract_feature_branch"
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "2.0.6"
-  s.summary = "abstract_feature_branch is a Rails gem that enables developers to easily branch by abstraction as per this pattern: http://paulhammant.com/blog/branch_by_abstraction.html"
+  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.rubygems_version = "3.3.6".freeze
+  s.summary = "abstract_feature_branch is a Rails gem that enables developers to easily branch by abstraction as per this pattern: http://paulhammant.com/blog/branch_by_abstraction.html".freeze
 
   if s.respond_to? :specification_version then
     s.specification_version = 4
+  end
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<deep_merge>, ["= 1.0.0"])
-      s.add_runtime_dependency(%q<redis>, ["~> 3.0.0"])
-      s.add_development_dependency(%q<jeweler>, ["= 1.8.8"])
-    else
-      s.add_dependency(%q<deep_merge>, ["= 1.0.0"])
-      s.add_dependency(%q<redis>, ["~> 3.0.0"])
-      s.add_dependency(%q<jeweler>, ["= 1.8.8"])
-    end
+  if s.respond_to? :add_runtime_dependency then
+    s.add_runtime_dependency(%q<deep_merge>.freeze, ["~> 1.0.0"])
+    s.add_development_dependency(%q<jeweler>.freeze, ["~> 2.3.9"])
+    s.add_development_dependency(%q<bundler>.freeze, [">= 2.1.4"])
+    s.add_development_dependency(%q<rspec>.freeze, ["= 2.14.1"])
+    s.add_development_dependency(%q<rdoc>.freeze, ["= 5.1.0"])
+    s.add_development_dependency(%q<psych>.freeze, ["= 3.3.4"])
   else
-    s.add_dependency(%q<deep_merge>, ["= 1.0.0"])
-    s.add_dependency(%q<redis>, ["~> 3.0.0"])
-    s.add_dependency(%q<jeweler>, ["= 1.8.8"])
+    s.add_dependency(%q<deep_merge>.freeze, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>.freeze, ["~> 2.3.9"])
+    s.add_dependency(%q<bundler>.freeze, [">= 2.1.4"])
+    s.add_dependency(%q<rspec>.freeze, ["= 2.14.1"])
+    s.add_dependency(%q<rdoc>.freeze, ["= 5.1.0"])
+    s.add_dependency(%q<psych>.freeze, ["= 3.3.4"])
   end
 end
 

data/lib/abstract_feature_branch/configuration.rb

@@ -1,3 +1,5 @@
+require 'abstract_feature_branch/redis/connection_pool_to_redis_adapter'
+
 module AbstractFeatureBranch
   class Configuration
     def application_root
@@ -41,15 +43,28 @@ module AbstractFeatureBranch
         :production => true
       }
     end
-    def user_features_storage
-      @user_features_storage ||= initialize_user_features_storage
+    
+    def feature_store
+      @feature_store ||= initialize_feature_store
     end
-    def user_features_storage=(user_features_storage)
-      @user_features_storage = user_features_storage
+    alias user_features_storage feature_store
+    
+    def feature_store=(feature_store)
+      if feature_store.nil?
+        @feature_store = nil
+      else
+        @feature_store = feature_store.is_a?(::ConnectionPool) ? AbstractFeatureBranch::Redis::ConnectionPoolToRedisAdapter.new(feature_store) : feature_store
+      end
     end
-    def initialize_user_features_storage
-      require 'redis'
-      self.user_features_storage = Redis.new
+    alias user_features_storage= feature_store=
+    
+    def initialize_feature_store
+      self.feature_store = ::Redis.new
+    rescue => e
+      logger.debug { "Redis is not enabled!" }
+      logger.debug { e.full_message }
+      nil
     end
+    alias initialize_user_features_storage initialize_feature_store
   end
 end

data/lib/abstract_feature_branch/redis/connection_pool_to_redis_adapter.rb

@@ -0,0 +1,34 @@
+module AbstractFeatureBranch
+  module Redis
+    # Adapts a ConnectionPool instance to the Redis object interface
+    class ConnectionPoolToRedisAdapter
+      attr_reader :connection_pool
+      
+      def initialize(connection_pool)
+        @connection_pool = connection_pool
+      end
+      
+      def respond_to?(method_name, include_private = false, &block)
+        result = false
+        @connection_pool.with do |connection|
+          result ||= connection.respond_to?(method_name, include_private, &block)
+        end
+        result || super
+      end
+      
+      def method_missing(method_name, *args, &block)
+        connection_can_respond_to = nil
+        result = nil
+        @connection_pool.with do |connection|
+          connection_can_respond_to = connection.respond_to?(method_name, true)
+          result = connection.send(method_name, *args, &block) if connection_can_respond_to
+        end
+        if connection_can_respond_to
+          result
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/abstract_feature_branch.rb

@@ -11,26 +11,44 @@ rescue Bundler::BundlerError => e
 end
 require 'logger' unless defined?(Rails) && Rails.logger
 require 'deep_merge' unless {}.respond_to?(:deep_merge!)
+require 'forwardable'
 
-require File.join(File.dirname(__FILE__), 'abstract_feature_branch', 'configuration')
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'abstract_feature_branch/configuration'
 
 module AbstractFeatureBranch
   ENV_FEATURE_PREFIX = "abstract_feature_branch_"
+  REDIS_HKEY = "abstract_feature_branch"
 
   class << self
     extend Forwardable
-    def_delegators :configuration, :application_root, :application_root=, :initialize_application_root, :application_environment, :application_environment=, :initialize_application_environment, :logger, :logger=, :initialize_logger, :cacheable, :cacheable=, :initialize_cacheable, :user_features_storage, :user_features_storage=, :initialize_user_features_storage
+    def_delegators :configuration, :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=, :initialize_feature_store, :user_features_storage, :user_features_storage=, :initialize_user_features_storage
 
     def configuration
       @configuration ||= Configuration.new
     end
 
+    def redis_overrides
+      load_redis_overrides
+    end
+    def load_redis_overrides
+      return {} if feature_store.nil?
+      
+      redis_feature_hash = get_store_features.inject({}) do |output, feature|
+        output.merge(feature => get_store_feature(feature))
+      end
+      
+      downcase_keys(redis_feature_hash)
+    end
+
     def environment_variable_overrides
       @environment_variable_overrides ||= load_environment_variable_overrides
     end
     def load_environment_variable_overrides
-      @environment_variable_overrides = featureize_keys(select_feature_keys(booleanize_values(downcase_keys(ENV))))
+      @environment_variable_overrides = featureize_keys(downcase_keys(booleanize_values(select_feature_keys(ENV))))
     end
+    
     def local_features
       @local_features ||= load_local_features
     end
@@ -38,6 +56,7 @@ module AbstractFeatureBranch
       @local_features = {}
       load_specific_features(@local_features, '.local.yml')
     end
+    
     def features
       @features ||= load_features
     end
@@ -45,6 +64,7 @@ module AbstractFeatureBranch
       @features = {}
       load_specific_features(@features, '.yml')
     end
+    
     # performance optimization via caching of feature values resolved through environment variable overrides and local features
     def environment_features(environment)
       @environment_features ||= {}
@@ -54,7 +74,9 @@ module AbstractFeatureBranch
       @environment_features ||= {}
       features[environment] ||= {}
       local_features[environment] ||= {}
-      @environment_features[environment] = features[environment].merge(local_features[environment]).merge(environment_variable_overrides)
+      @environment_features[environment] = features[environment].
+        merge(local_features[environment]).
+        merge(environment_variable_overrides)
     end
     def application_features
       unload_application_features unless cacheable?
@@ -77,12 +99,58 @@ module AbstractFeatureBranch
       value = (application_environment != 'development') if value.nil?
       value
     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?
+      feature = feature.to_s
+      return delete_store_feature(feature) if value.nil?
+      value = 'true' if value == true
+      value = 'false' if value == false
+      feature_store.hset(REDIS_HKEY, feature, value)
+    end
+    
+    # Gets feature value (true or false) from storage (e.g. Redis client)
+    def get_store_feature(feature)
+      raise 'Feature storage (e.g. Redis) is not setup!' if feature_store.nil?
+      feature = feature.to_s
+      value = feature_store.hget(REDIS_HKEY, feature)
+      if value.nil?
+        matching_feature = get_store_features.find { |store_feature| store_feature.downcase == feature.downcase }
+        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'
+      value.to_s.downcase == 'true'
+    end
+    
+    # Gets feature value (true or false) from storage (e.g. Redis client)
+    def delete_store_feature(feature)
+      raise 'Feature storage (e.g. Redis) is not setup!' if feature_store.nil?
+      feature = feature.to_s
+      feature_store.hdel(REDIS_HKEY, feature)
+    end
+    
+    # Gets features array (all features) from storage (e.g. Redis client)
+    def get_store_features
+      raise 'Feature storage (e.g. Redis) is not setup!' if feature_store.nil?
+      feature_store.hkeys(REDIS_HKEY)
+    end
+    
+    # Gets features array (all features) from storage (e.g. Redis client)
+    def clear_store_features
+      raise 'Feature storage (e.g. Redis) is not setup!' if feature_store.nil?
+      feature_store.hkeys(REDIS_HKEY).each do |feature|
+        feature_store.hdel(REDIS_HKEY, feature)
+      end
+    end
+    
     def toggle_features_for_user(user_id, features)
       features.each do |name, value|
         if value
-          user_features_storage.sadd("#{ENV_FEATURE_PREFIX}#{name.to_s.downcase}", user_id)
+          feature_store.sadd("#{ENV_FEATURE_PREFIX}#{name.to_s.downcase}", user_id)
         else
-          user_features_storage.srem("#{ENV_FEATURE_PREFIX}#{name.to_s.downcase}", user_id)
+          feature_store.srem("#{ENV_FEATURE_PREFIX}#{name.to_s.downcase}", user_id)
         end
       end
     end
@@ -103,7 +171,7 @@ module AbstractFeatureBranch
     end
 
     def select_feature_keys(hash)
-      hash.reject {|k, v| !k.start_with?(ENV_FEATURE_PREFIX)} # using reject for Ruby 1.8 compatibility as select returns an array in it
+      hash.reject {|k, v| !k.downcase.start_with?(ENV_FEATURE_PREFIX)} # using reject for Ruby 1.8 compatibility as select returns an array in it
     end
 
     def booleanize_values(hash)

data/lib/ext/feature_branch.rb

@@ -10,9 +10,10 @@ class Object
   def self.feature_enabled?(feature_name, user_id = nil)
     normalized_feature_name = feature_name.to_s.downcase
 
-    value = AbstractFeatureBranch.application_features[normalized_feature_name]
+    redis_override_value = AbstractFeatureBranch.get_store_feature(normalized_feature_name) rescue nil
+    value = !redis_override_value.nil? ? redis_override_value : AbstractFeatureBranch.application_features[normalized_feature_name]
     if value == 'per_user'
-      value = AbstractFeatureBranch.user_features_storage.sismember("#{AbstractFeatureBranch::ENV_FEATURE_PREFIX}#{normalized_feature_name}", user_id)
+      value = !user_id.nil? && AbstractFeatureBranch.user_features_storage.sismember("#{AbstractFeatureBranch::ENV_FEATURE_PREFIX}#{normalized_feature_name}", user_id)
     end
     value
   end
@@ -26,4 +27,4 @@ class Object
   def feature_enabled?(feature_name, user_id = nil)
     Object.feature_enabled?(feature_name.to_s, user_id)
   end
-end
+end