abstract_feature_branch 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a94572977e6efa72fc039c72a7674229b158a774
-  data.tar.gz: 4afc8329e8a7122248ba1be4fd4af84d8f58f386
+  metadata.gz: 10b3189e83e418a64b851efe68587d4277cc370d
+  data.tar.gz: 4089ac0e1c27b0ae0df91e17fa20312ec65b941b
 SHA512:
-  metadata.gz: b35df2e5e4fbdc3430c88ef4642895296063a2479584fceeed1c89d43dd95675905198d28edae0dbcdd1d5ce5952c73a7837046827feec60d253a46b6a8bea13
-  data.tar.gz: 9ecc727ef80cae0d170e123fd310db95154ad7da8d12ddc7732e72e523bcf20a50781a0b88c256c3dcce273e6d22be2b1a68f53e2d67b860d1d78f6dfcb99161
+  metadata.gz: f1238ecd211de61432380e60b0f85fbcd8a50c03cb9f54588ec0257ca0d6f9a8227087442f1749bfe3027de9108fe38c73eb857c4d681dc564b74492c03838eb
+  data.tar.gz: 6569fd5e1a1b298e8a9c7791bd0f0fdbdde1b5c7076d47373a4cd27e49ec994c2c25bd1a61b69387ccb00f7ce94de7f97883e7cbc8199a91f888f3ebddd9fab4

data/.travis.yml

@@ -18,8 +18,12 @@ matrix:
       gemfile: ruby187.Gemfile
     - rvm: 1.8.7
       gemfile: Gemfile
+    - rvm: 1.8.7
+      gemfile: ruby187.Gemfile
     - rvm: ree
       gemfile: Gemfile
+    - rvm: jruby-18mode
+      gemfile: Gemfile
     - rvm: jruby-18mode
       gemfile: ruby187.Gemfile
     - rvm: jruby-19mode

data/README.md

@@ -29,6 +29,7 @@ Requirements
 ------------
 - Ruby ~> 2.0.0, ~> 1.9 or ~> 1.8.7
 - (Optional) Rails ~> 4.0.0, ~> 3.0 or ~> 2.0
+- (Optional) Redis server
 
 Setup
 -----
@@ -109,18 +110,6 @@ single-line logic:
 
 Note that <code>feature_branch</code> returns nil and does not execute the block if the feature is disabled or non-existent.
 
-- Declaratively feature branch two paths of logic, one that runs when feature1 is enabled and one that runs when it is disabled:
-
->     feature_branch :feature1,
->                    :true => lambda {
->                      # perform logic
->                    },
->                    :false => lambda {
->                      # perform alternate logic
->                    }
-
-Note that <code>feature_branch</code> executes the false branch if the feature is non-existent.
-
 - Imperatively check if a feature is enabled or not:
 
 >     if feature_enabled?(:feature1)
@@ -131,6 +120,41 @@ Note that <code>feature_branch</code> executes the false branch if the feature i
 
 Note that <code>feature_enabled?</code> returns false if the feature is disabled and nil if the feature is non-existent (practically the same effect, but nil can sometimes be useful to detect if a feature is referenced).
 
+### Per-User Feature Enablement
+
+It is possible to restrict enablement of features per specific users. This works in concert with having a feature enabled
+in features.yml (or one of the overrides like features.local.yml or environment variable overrides)
+
+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.
+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)
+
+Use alternate version of <code>feature_branch</code> and <code>feature_enabled?</code> passing extra <code>user_id</code> argument
+
+Examples:
+
+>     feature_branch :feature1, current_user.email do
+>       # THIS WILL EXECUTE
+>     end
+
+>     if feature_enabled?(:feature2, current_user.email)
+>       # THIS ONE WILL NOT EXECUTE
+>     else
+>       # THIS ONE WILL EXECUTE
+>     end
+
+>     feature_branch :feature1, another_user.email do
+>       # THIS WILL NOT EXECUTE
+>     end
+
+>     if feature_enabled?(:feature2, another_user.email)
+>       # THIS ONE WILL EXECUTE (assuming feature2 is enabled in features.yml)
+>     else
+>       # THIS ONE WILL NOT EXECUTE
+>     end
+
 Recommendations
 ---------------
 
@@ -167,7 +191,7 @@ simply switching off the URL route to them. Example:
 >       :website
 >     )
 
-- In Rails 4 and 3.1+ with the asset pipeline, wrap newly added CSS or JavaScript using .erb format. Example (renamed projects.css.scss to projects.css.scss.erb and wrapped CSS with an abstract feature branch block):
+- In Rails 4 and 3.1+ with the asset pipeline, wrap newly added CSS or JavaScript using .erb format ([gotcha and alternative solution](#gotcha-with-abstract-feature-branching-in-css-and-js-files)). Example (renamed projects.css.scss to projects.css.scss.erb and wrapped CSS with an abstract feature branch block):
 
 >     <% feature_branch :project_gallery do %>
 >     .exclude_display {
@@ -191,11 +215,11 @@ simply switching off the URL route to them. Example:
 it is **strongly recommended** that its feature branching code is plucked out of the codebase to simplify and improve
 future maintainability given that it is no longer needed at that point.
 
-- Once <code>config/features.yml</code> grows too big (e.g. 20+ features), it is **strongly recommended* to split it into
+- Once <code>config/features.yml</code> grows too big (e.g. 20+ features), it is **strongly recommended** to split it into
 multiple context-specific feature files by utilizing the context generator mentioned above: <pre>rails g abstract_feature_branch:context context_path</pre>
 
 - When working on a new feature locally that the developer does not want others on the team to see yet, the feature
-can be enabled in <code>config/features.local.yml</code> only as it is git ignored, and disabled in <code>config/features.yml</code>
+can be enabled in <code>config/features.local.yml</code> only as it is git ignored while the feature is disabled in <code>config/features.yml</code>
 
 - When troubleshooting a deployed feature by simulating a non-development environment (e.g. staging or production) locally,
 the developer can disable it temporarily in <code>config/features.local.yml</code> (git ignored) under the non-development environment,
@@ -231,7 +255,7 @@ Heroku
 Environment variable overrides can be extremely helpful on Heroku as they allow developers to enable/disable features
 at runtime without a redeploy.
 
-Examples:
+### Examples
 
 Enabling a new feature without a redeploy:
 <pre>heroku config:add ABSTRACT_FEATURE_BRANCH_FEATURE3=true -a heroku_application_name</pre>
@@ -242,12 +266,12 @@ Disabling a buggy recently deployed feature without a redeploy:
 Removing an environment variable override:
 <pre>heroku config:remove ABSTRACT_FEATURE_BRANCH_FEATURE2 -a heroku_application_name</pre>
 
-Recommendation:
+### 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.
 
-Gotcha with abstract feature branching in CSS and JS files:
+### Gotcha with abstract feature branching in CSS and JS files
 
 If you've used abstract feature branching in CSS or JS files via ERB, setting environment variable overrides won't
 affect them as you need asset recompilation in addition to it, which can only be triggered by changing a CSS or JS
@@ -256,7 +280,7 @@ overrides have been recommended above as an emergency or temporary measure. If t
 variable overrides to alter the style or JavaScript behavior of a page back and forth without a redeploy, **one solution**
 is to do additional abstract feature branching in HTML templates (e.g. ERB or [HAML](http://haml.info) to
 link to different stylesheets and JS files, use different CSS classes, or invoke different JavaScript methods per branch
-of HTML for example.
+of HTML for example.)
 
 Feature Configuration Load Order
 --------------------------------
@@ -275,6 +299,11 @@ 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):
 
+>     require 'redis'
+>
+>     # Storage for user features, customizable over here (right now, only a Redis client is supported)
+>     AbstractFeatureBranch.user_features_storage = Redis.new
+>
 >     # Application root where config/features.yml or config/features/ is found
 >     AbstractFeatureBranch.application_root = Rails.root
 >
@@ -388,6 +417,16 @@ Note that the beautifier ignores comments at the top, but deletes entire line co
 after invoking the rake task, **verify** that your feature file contents are to your satisfaction before committing the
 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.  
+
+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.   
+
+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
 ---------------------------------------
 
@@ -401,15 +440,12 @@ Contributing to abstract_feature_branch
 
 Committers
 ---------------------------------------
-[Annas "Andy" Maleh (Author)](https://github.com/AndyObtiva)
+* [Annas "Andy" Maleh (Author)](https://github.com/AndyObtiva)
 
 Contributors
 ---------------------------------------
-[Christian Nennemann](https://github.com/XORwell)
-
-Feedback and Idea Providers
----------------------------------------
-[Ben Downey](https://github.com/bnd5k)
+* [Christian Nennemann](https://github.com/XORwell)
+* [Ben Downey](https://github.com/bnd5k)
 
 Copyright
 ---------------------------------------

data/RELEASE_NOTES.md

@@ -1,8 +1,8 @@
 Release Notes
 -------------
 
-Version 0.9.0:
-- Added configuration support for feature cacheability
+Version 1.0.0:
+- Added configuration support for feature cacheability. Completed documentation, adding more details.
 
 Version 0.9.0:
 - Added support for runtime read of feature files in development to ease local testing (trading off performance)
@@ -52,4 +52,4 @@ Version 0.3.0:
 
 Version 0.2.0:
 - Support an "else" block to execute when a feature is off (via <code>:true</code> and <code>:false</code> lambda arguments)
-- Support ability to check if a feature is enabled or not (via <code>feature_enabled?</code>)
+- Support ability to check if a feature is enabled or not (via <code>feature_enabled?</code>)

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/abstract_feature_branch.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "abstract_feature_branch"
-  s.version = "1.0.0"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Annas \"Andy\" Maleh"]
-  s.date = "2013-11-26"
+  s.date = "2014-01-14"
   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.extra_rdoc_files = [
     "LICENSE.txt",
@@ -42,6 +42,7 @@ Gem::Specification.new do |s|
     "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",
@@ -73,13 +74,16 @@ Gem::Specification.new do |s|
 
     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.6"])
       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.6"])
       s.add_dependency(%q<jeweler>, ["= 1.8.8"])
     end
   else
     s.add_dependency(%q<deep_merge>, ["= 1.0.0"])
+    s.add_dependency(%q<redis>, ["= 3.0.6"])
     s.add_dependency(%q<jeweler>, ["= 1.8.8"])
   end
 end

data/lib/abstract_feature_branch.rb

@@ -13,132 +13,153 @@ require 'logger' unless defined?(Rails) && Rails.logger
 require 'deep_merge' unless {}.respond_to?(:deep_merge!)
 
 module AbstractFeatureBranch
-  def self.application_root
-    @application_root ||= initialize_application_root
-  end
-  def self.application_root=(path)
-    @application_root = path
-  end
-  def self.initialize_application_root
-    self.application_root = defined?(Rails) ? Rails.root : '.'
-  end
-  def self.application_environment
-    @application_environment ||= initialize_application_environment
-  end
-  def self.application_environment=(environment)
-    @application_environment = environment
-  end
-  def self.initialize_application_environment
-    self.application_environment = defined?(Rails) ? Rails.env.to_s : ENV['APP_ENV'] || 'development'
-  end
-  def self.logger
-    @logger ||= initialize_logger
-  end
-  def self.logger=(logger)
-    @logger = logger
-  end
-  def self.initialize_logger
-    self.logger = defined?(Rails) && Rails.logger ? Rails.logger : Logger.new(STDOUT)
-  end
-  def self.cacheable
-    @cacheable ||= initialize_cacheable
-  end
-  def self.cacheable=(cacheable)
-    @cacheable = cacheable
-  end
-  def self.initialize_cacheable
-    self.cacheable = {
-      :development => false,
-      :test => true,
-      :staging => true,
-      :production => true
-    }
-  end
-  def self.environment_variable_overrides
-    @environment_variable_overrides ||= load_environment_variable_overrides
-  end
-  def self.load_environment_variable_overrides
-    @environment_variable_overrides = featureize_keys(select_feature_keys(booleanize_values(downcase_keys(ENV))))
-  end
-  def self.local_features
-    @local_features ||= load_local_features
-  end
-  def self.load_local_features
-    @local_features = {}
-    Dir.glob(File.join(application_root, 'config', 'features', '**', '*.local.yml')).each do |feature_configuration_file|
-      @local_features.deep_merge!(downcase_feature_hash_keys(YAML.load_file(feature_configuration_file)))
-    end
-    main_local_features_file = File.join(application_root, 'config', 'features.local.yml')
-    @local_features.deep_merge!(downcase_feature_hash_keys(YAML.load_file(main_local_features_file))) if File.exists?(main_local_features_file)
-    @local_features
-  end
-  def self.features
-    @features ||= load_features
-  end
-  def self.load_features
-    @features = {}
-    Dir.glob(File.join(application_root, 'config', 'features', '**', '*.yml')).each do |feature_configuration_file|
-      @features.deep_merge!(downcase_feature_hash_keys(YAML.load_file(feature_configuration_file)))
-    end
-    main_features_file = File.join(application_root, 'config', 'features.yml')
-    @features.deep_merge!(downcase_feature_hash_keys(YAML.load_file(main_features_file))) if File.exists?(main_features_file)
-    @features
-  end
-  # performance optimization via caching of feature values resolved through environment variable overrides and local features
-  def self.environment_features(environment)
-    @environment_features ||= {}
-    @environment_features[environment] ||= load_environment_features(environment)
-  end
-  def self.load_environment_features(environment)
-    @environment_features ||= {}
-    features[environment] ||= {}
-    local_features[environment] ||= {}
-    @environment_features[environment] = features[environment].merge(local_features[environment]).merge(environment_variable_overrides)
-  end
-  def self.application_features
-    unload_application_features unless cacheable?
-    environment_features(application_environment)
-  end
-  def self.load_application_features
-    AbstractFeatureBranch.load_environment_variable_overrides
-    AbstractFeatureBranch.load_features
-    AbstractFeatureBranch.load_local_features
-    AbstractFeatureBranch.load_environment_features(application_environment)
-  end
-  def self.unload_application_features
-    @environment_variable_overrides = nil
-    @features = nil
-    @local_features = nil
-    @environment_features = nil
-  end
-  def self.cacheable?
-    value = downcase_keys(cacheable)[application_environment]
-    value = (application_environment != 'development') if value.nil?
-    value
-  end
+  ENV_FEATURE_PREFIX = "abstract_feature_branch_"
 
-  private
+  class << self
+    def application_root
+      @application_root ||= initialize_application_root
+    end
+    def application_root=(path)
+      @application_root = path
+    end
+    def initialize_application_root
+      self.application_root = defined?(Rails) ? Rails.root : '.'
+    end
+    def application_environment
+      @application_environment ||= initialize_application_environment
+    end
+    def application_environment=(environment)
+      @application_environment = environment
+    end
+    def initialize_application_environment
+      self.application_environment = defined?(Rails) ? Rails.env.to_s : ENV['APP_ENV'] || 'development'
+    end
+    def logger
+      @logger ||= initialize_logger
+    end
+    def logger=(logger)
+      @logger = logger
+    end
+    def initialize_logger
+      self.logger = defined?(Rails) && Rails.logger ? Rails.logger : Logger.new(STDOUT)
+    end
+    def cacheable
+      @cacheable ||= initialize_cacheable
+    end
+    def cacheable=(cacheable)
+      @cacheable = cacheable
+    end
+    def initialize_cacheable
+      self.cacheable = {
+        :development => false,
+        :test => true,
+        :staging => true,
+        :production => true
+      }
+    end
+    def user_features_storage
+      @user_features_storage ||= initialize_user_features_storage
+    end
+    def user_features_storage=(user_features_storage)
+      @user_features_storage = user_features_storage
+    end
+    def initialize_user_features_storage
+      require 'redis'
+      self.user_features_storage = Redis.new
+    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))))
+    end
+    def local_features
+      @local_features ||= load_local_features
+    end
+    def load_local_features
+      @local_features = {}
+      Dir.glob(File.join(application_root, 'config', 'features', '**', '*.local.yml')).each do |feature_configuration_file|
+        @local_features.deep_merge!(downcase_feature_hash_keys(YAML.load_file(feature_configuration_file)))
+      end
+      main_local_features_file = File.join(application_root, 'config', 'features.local.yml')
+      @local_features.deep_merge!(downcase_feature_hash_keys(YAML.load_file(main_local_features_file))) if File.exists?(main_local_features_file)
+      @local_features
+    end
+    def features
+      @features ||= load_features
+    end
+    def load_features
+      @features = {}
+      Dir.glob(File.join(application_root, 'config', 'features', '**', '*.yml')).each do |feature_configuration_file|
+        @features.deep_merge!(downcase_feature_hash_keys(YAML.load_file(feature_configuration_file)))
+      end
+      main_features_file = File.join(application_root, 'config', 'features.yml')
+      @features.deep_merge!(downcase_feature_hash_keys(YAML.load_file(main_features_file))) if File.exists?(main_features_file)
+      @features
+    end
+    # performance optimization via caching of feature values resolved through environment variable overrides and local features
+    def environment_features(environment)
+      @environment_features ||= {}
+      @environment_features[environment] ||= load_environment_features(environment)
+    end
+    def load_environment_features(environment)
+      @environment_features ||= {}
+      features[environment] ||= {}
+      local_features[environment] ||= {}
+      @environment_features[environment] = features[environment].merge(local_features[environment]).merge(environment_variable_overrides)
+    end
+    def application_features
+      unload_application_features unless cacheable?
+      environment_features(application_environment)
+    end
+    def load_application_features
+      AbstractFeatureBranch.load_environment_variable_overrides
+      AbstractFeatureBranch.load_features
+      AbstractFeatureBranch.load_local_features
+      AbstractFeatureBranch.load_environment_features(application_environment)
+    end
+    def unload_application_features
+      @environment_variable_overrides = nil
+      @features = nil
+      @local_features = nil
+      @environment_features = nil
+    end
+    def cacheable?
+      value = downcase_keys(cacheable)[application_environment]
+      value = (application_environment != 'development') if value.nil?
+      value
+    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)
+        else
+          user_features_storage.srem("#{ENV_FEATURE_PREFIX}#{name.to_s.downcase}", user_id)
+        end
+      end
+    end
 
-  ENV_FEATURE_PREFIX = "abstract_feature_branch_"
+    private
 
-  def self.featureize_keys(hash)
-    Hash[hash.map {|k, v| [k.sub(ENV_FEATURE_PREFIX, ''), v]}]
-  end
+    def featureize_keys(hash)
+      Hash[hash.map {|k, v| [k.sub(ENV_FEATURE_PREFIX, ''), v]}]
+    end
 
-  def self.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
-  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
+    end
 
-  def self.booleanize_values(hash)
-    Hash[hash.map {|k, v| [k, v.to_s.downcase == 'true']}]
-  end
+    def booleanize_values(hash)
+      Hash[hash.map {|k, v| [k, v.to_s.downcase == 'true']}]
+    end
 
-  def self.downcase_keys(hash)
-    Hash[hash.map {|k, v| [k.to_s.downcase, v]}]
-  end
+    def downcase_keys(hash)
+      Hash[hash.map {|k, v| [k.to_s.downcase, v]}]
+    end
 
-  def self.downcase_feature_hash_keys(hash)
-    Hash[(hash || {}).map {|k, v| [k, v && downcase_keys(v)]}]
+    def downcase_feature_hash_keys(hash)
+      Hash[(hash || {}).map {|k, v| [k, v && downcase_keys(v)]}]
+    end
   end
 end
 

data/lib/ext/feature_branch.rb

@@ -1,24 +1,25 @@
 class Object
   raise 'Abstract feature branch conflicts with another Ruby library' if respond_to?(:feature_branch)
-  def self.feature_branch(feature_name, branches = {}, &feature_work)
-    branches[:true] ||= feature_work
-    branches[:false] ||= lambda {}
-    feature_branch_symbol_value = (!!feature_enabled?(feature_name)).to_s.to_sym
-    branches[feature_branch_symbol_value].call
+  def self.feature_branch(feature_name, user_id = nil, &feature_work)
+    if feature_enabled?(feature_name, user_id)
+      feature_work.call
+    end
   end
 
   raise 'Abstract feature branch conflicts with another Ruby library' if respond_to?(:feature_enabled?)
-  def self.feature_enabled?(feature_name)
-    AbstractFeatureBranch.application_features[feature_name.to_s.downcase]
+  def self.feature_enabled?(feature_name, user_id = nil)
+    normalized_feature_name = feature_name.to_s.downcase
+    AbstractFeatureBranch.application_features[normalized_feature_name] &&
+      (user_id.nil? || AbstractFeatureBranch.user_features_storage.sismember("#{AbstractFeatureBranch::ENV_FEATURE_PREFIX}#{normalized_feature_name}", user_id))
   end
 
   raise 'Abstract feature branch conflicts with another Ruby library' if Object.new.respond_to?(:feature_branch)
-  def feature_branch(feature_name, branches = {}, &feature_work)
-    Object.feature_branch(feature_name.to_s, branches, &feature_work)
+  def feature_branch(feature_name, user_id = nil, &feature_work)
+    Object.feature_branch(feature_name.to_s, user_id, &feature_work)
   end
 
   raise 'Abstract feature branch conflicts with another Ruby library' if Object.new.respond_to?(:feature_enabled?)
-  def feature_enabled?(feature_name)
-    Object.feature_enabled?(feature_name.to_s)
+  def feature_enabled?(feature_name, user_id = nil)
+    Object.feature_enabled?(feature_name.to_s, user_id)
   end
 end

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

@@ -1,3 +1,8 @@
+require 'redis'
+
+# Storage for user features, customizable over here (right now, only a Redis client is supported)
+AbstractFeatureBranch.user_features_storage = Redis.new
+
 # Application root where config/features.yml or config/features/ is found
 AbstractFeatureBranch.application_root = Rails.root
 
@@ -17,4 +22,4 @@ AbstractFeatureBranch.cacheable = {
 }
 
 # Pre-load application features to improve performance of first web-page hit
-AbstractFeatureBranch.load_application_features unless Rails.env.development?
+AbstractFeatureBranch.load_application_features unless Rails.env.development?

data/spec/ext/feature_branch__feature_branch_per_user_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe 'feature_branch object extensions' do
+  before do
+    @app_env_backup = AbstractFeatureBranch.application_environment
+    @app_root_backup = AbstractFeatureBranch.application_root
+    AbstractFeatureBranch.logger.warn 'Environment variable ABSTRACT_FEATURE_BRANCH_FEATURE1 already set, potentially conflicting with another test' if ENV.keys.include?('ABSTRACT_FEATURE_BRANCH_FEATURE1')
+    AbstractFeatureBranch.logger.warn 'Environment variable Abstract_Feature_Branch_Feature2 already set, potentially conflicting with another test' if ENV.keys.include?('Abstract_Feature_Branch_Feature2')
+    AbstractFeatureBranch.logger.warn 'Environment variable abstract_feature_branch_feature3 already set, potentially conflicting with another test' if ENV.keys.include?('abstract_feature_branch_feature3')
+    AbstractFeatureBranch.user_features_storage.flushall
+  end
+  after do
+    ENV.delete('ABSTRACT_FEATURE_BRANCH_FEATURE1')
+    ENV.delete('Abstract_Feature_Branch_Feature2')
+    ENV.delete('abstract_feature_branch_feature3')
+    AbstractFeatureBranch.application_root = @app_root_backup
+    AbstractFeatureBranch.application_environment = @app_env_backup
+    AbstractFeatureBranch.unload_application_features
+    AbstractFeatureBranch.user_features_storage.flushall
+  end
+  describe '#feature_branch' do
+    context 'per user' do
+      it 'feature branches correctly after storing feature configuration per user in a separate process (ensuring persistence)' do
+        user_id = 'email1@example.com'
+        Process.fork do
+          AbstractFeatureBranch.initialize_user_features_storage
+          AbstractFeatureBranch.toggle_features_for_user(user_id, :feature1 => true, :feature2 => false, :feature3 => true, :feature5 => true)
+        end
+        Process.wait
+        features_enabled = []
+        feature_branch :feature1, user_id do
+          features_enabled << :feature1
+        end
+        feature_branch :feature2, user_id do
+          features_enabled << :feature2
+        end
+        feature_branch :feature3, user_id do
+          features_enabled << :feature3
+        end
+        feature_branch :feature5, user_id do
+          features_enabled << :feature5
+        end
+        feature_branch :feature5, 'otheruser@example.com' do
+          features_enabled << :feature5_otheruser
+        end
+        features_enabled.should include(:feature1)
+        features_enabled.should_not include(:feature2)
+        features_enabled.should_not include(:feature3)
+        features_enabled.should include(:feature5)
+        features_enabled.should_not include(:feature5_otheruser)
+      end
+      it 'update feature branching (disabling some features) after having stored feature configuration per user in a separate process (ensuring persistence)' do
+        user_id = 'email1@example.com'
+        Process.fork do
+          AbstractFeatureBranch.initialize_user_features_storage
+          AbstractFeatureBranch.toggle_features_for_user(user_id, :feature1 => true, :feature2 => false, :feature3 => true, :feature5 => true)
+          AbstractFeatureBranch.toggle_features_for_user(user_id, :feature1 => false, :feature2 => true, :feature3 => false, :feature5 => false)
+        end
+        Process.wait
+        features_enabled = []
+        feature_branch :feature1, user_id do
+          features_enabled << :feature1
+        end
+        feature_branch :feature2, user_id do
+          features_enabled << :feature2
+        end
+        feature_branch :feature3, user_id do
+          features_enabled << :feature3
+        end
+        feature_branch :feature5, user_id do
+          features_enabled << :feature5
+        end
+        features_enabled.should_not include(:feature1)
+        features_enabled.should include(:feature2)
+        features_enabled.should_not include(:feature3)
+        features_enabled.should_not include(:feature5)
+      end
+
+    end
+  end
+  describe 'self#feature_branch' do
+    after do
+      Object.send(:remove_const, :TestObject)
+    end
+    # No need to retest all instance test cases, just a spot check due to implementation reuse
+    it 'feature branches instance level behavior (case-insensitive feature names)' do
+      class TestObject
+        def self.features_enabled
+          @features_enabled ||= []
+        end
+        def self.hit_me
+          feature_branch :feature1 do
+            self.features_enabled << :feature1
+          end
+          feature_branch :feature2 do
+            self.features_enabled << :feature2
+          end
+          feature_branch :feature3 do
+            self.features_enabled << :feature3
+          end
+        end
+      end
+      TestObject.hit_me
+      TestObject.features_enabled.should include(:feature1)
+      TestObject.features_enabled.should include(:feature2)
+      TestObject.features_enabled.should_not include(:feature3)
+    end
+  end
+end

data/spec/ext/feature_branch__feature_branch_spec.rb

@@ -44,27 +44,6 @@ describe 'feature_branch object extensions' do
       end
       return_value.should be_nil
     end
-    it 'supports an alternate branch of behavior for turned off features' do
-      feature_behaviors = []
-      feature_branch :feature1,
-                     :true => lambda {feature_behaviors << :feature1_true},
-                     :false => lambda {feature_behaviors << :feature1_false}
-      feature_branch :feature3,
-                     :true => lambda {feature_behaviors << :feature3_true},
-                     :false => lambda {feature_behaviors << :feature3_false}
-      feature_behaviors.should include(:feature1_true)
-      feature_behaviors.should_not include(:feature1_false)
-      feature_behaviors.should_not include(:feature3_true)
-      feature_behaviors.should include(:feature3_false)
-    end
-    it 'executes alternate branch for an invalid feature name' do
-      feature_behaviors = []
-      feature_branch :invalid_feature_that_does_not_exist,
-                     :true => lambda {feature_behaviors << :main_branch},
-                     :false => lambda {feature_behaviors << :alternate_branch}
-      feature_behaviors.should_not include(:main_branch)
-      feature_behaviors.should include(:alternate_branch)
-    end
     it 'allows environment variables (case-insensitive booleans) to override configuration file' do
       ENV['ABSTRACT_FEATURE_BRANCH_FEATURE1'] = 'FALSE'
       ENV['Abstract_Feature_Branch_Feature2'] = 'False'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abstract_feature_branch
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Annas "Andy" Maleh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-26 00:00:00.000000000 Z
+date: 2014-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge
@@ -24,6 +24,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.6
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
@@ -92,6 +106,7 @@ files:
 - 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