feature_flipper 1.0.0 → 1.1.0

data/README.md

@@ -39,7 +39,7 @@ more detailed description, a ticket number, a date when it was started, etc.
 Features are always defined in a state, you cannot define a feature which
 doesn't belong to a state.
 
-    in_status :dev do
+    in_state :dev do
       feature :rating_game, :description => 'play a game to get recommendations'
     end
 
@@ -68,11 +68,11 @@ Example config file
 -------------------
 
     FeatureFlipper.features do
-      in_status :dev do
+      in_state :dev do
         feature :rating_game, :description => 'play a game to get recommendations'
       end
 
-      in_status :live do
+      in_state :live do
         feature :city_feed, :description => 'stream of content for each city'
       end
     end
@@ -84,14 +84,15 @@ Example config file
 
 This is your complete features.rb config file. In the example there are two
 states: `:dev` is active on development boxes and `:live` is always active
-(this is the last state a feature is in).
+(this is the last state a feature goes through).
 
 The feature `:rating_game` is still in development and not shown on the
 production site. The feature `:city_feed` is done and already enabled
 everywhere. You transition features between states by just moving the line to
 the new state block.
 
-You can take a look at this example in detail in the 'examples' folder.
+You can take a look at the `static_states.rb` in the 'examples' folder to
+see this in detail.
 
 Cleaning up
 -----------
@@ -100,6 +101,53 @@ The drawback of this approach is that your code can get quite ugly with all
 these if/else branches. So you have to be strict about removing (we call it
 de-featurizing) features after they have gone live.
 
+Dynamic feature groups
+----------------------
+
+As soon as we have the feature_flipper infrastructure in place, we can start
+doing more interesting things with it. For example, dynamic features which
+are enabled on a per user basis. This allows you to release features to
+employees only, to a private beta group, etc.
+
+### Defining dynamic states
+
+A dynamic state is defined a bit different than a normal, static state.
+
+    FeatureFlipper::Config.states = {
+      :dev       => ['development', 'test'].include?(Rails.env),
+      :employees => { :required_state => :dev, :feature_group => :employees }
+    }
+
+It has a required state and a feature group. The feature group defines
+the name of the group of users which should see this feature. The required
+state is the state that gets looked at for all other users that aren't in
+the feature group. The required_state must also be defined as a separate state.
+
+### Setting the feature group
+
+The current feature group is set globally and is active for the whole thread.
+In Rails you would define a before_filter like this:
+
+    class ApplicationController < ActionController::Base
+      before_filter :set_current_feature_group
+      
+      def set_current_feature_group
+        # we need to reset the feature group in each request,
+        # otherwise it persists (which is not want we want).
+        FeatureFlipper.reset_current_feature_groups
+        
+        if logged_in? && current_user.employee?
+          FeatureFlipper.current_feature_groups << :employees
+        end
+      end
+
+It's really important to reset the feature group, otherwise it's not dynamic.
+The condition if someone is in a feature group can be anything: You can
+store it in the database, in Redis, look at request parameters, etc.
+
+Take a look at `dynamic_states.rb` in the examples folder to see this
+in detail.
+
 Meta
 ----
 

data/examples/dynamic_states.rb

@@ -0,0 +1,47 @@
+# Setup
+#
+
+# just need this to make it work from within the library
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+# fake production Rails environment
+module Rails
+  def self.env
+    'production'
+  end
+end
+
+
+# Configuration
+#
+
+require 'feature_flipper'
+
+# set the path to your app specific config file
+FeatureFlipper::Config.path_to_file = "features.rb"
+
+
+# Usage
+#
+
+puts "=== first example:"
+
+# no current_feature_group set, so the required_state of badges is looked at
+if show_feature?(:badges)
+  puts "shiny new badges not live on prod yet"
+else
+  puts "no new badges"
+end
+
+puts "\n=== second example:"
+
+# now we set the current_feature_group. Usually depending on the logged in user
+
+FeatureFlipper.reset_current_feature_groups
+FeatureFlipper.current_feature_groups << :employees
+
+if show_feature?(:badges)
+  puts "shiny new badges for this user"
+else
+  puts "no new badges"
+end

data/examples/features.rb

@@ -4,16 +4,21 @@
 #
 
 FeatureFlipper.features do
-  in_status :dev do
+  in_state :dev do
     feature :rating_game, :description => 'play a game to get recommendations'
   end
 
-  in_status :live do
+  in_state :live do
     feature :city_feed, :description => 'stream of content for each city'
   end
+
+  in_state :employees do
+    feature :badges, :description => 'new badges'
+  end
 end
 
 FeatureFlipper::Config.states = {
-  :dev      => ['development', 'test'].include?(Rails.env),
-  :live     => true
+  :dev       => ['development', 'test'].include?(Rails.env),
+  :employees => { :required_state => :dev, :feature_group => :employees },
+  :live      => true
 }

data/examples/{simple.rb → static_states.rb}

@@ -24,6 +24,8 @@ FeatureFlipper::Config.path_to_file = "features.rb"
 # Usage
 #
 
+puts "=== first example:"
+
 # rating_game is still in development, so shouldn't be shown on production
 if show_feature?(:rating_game)
   puts "Rating Game"
@@ -31,6 +33,8 @@ else
   puts "old stuff"
 end
 
+puts "\n=== second example:"
+
 # city_feed is enabled everywhere
 if show_feature?(:city_feed)
   puts "City Feed"

data/lib/feature_flipper/config.rb

@@ -38,16 +38,20 @@ module FeatureFlipper
       @states = states
     end
 
-    def self.get_status(feature_name)
+    def self.get_state(feature_name)
       feature = features[feature_name]
-      feature ? feature[:status] : nil
+      feature ? feature[:state] : nil
     end
 
-    def self.active_status?(status)
-      active = states[status]
+    def self.active_state?(state)
+      active = states[state]
       if active.is_a?(Hash)
-        group, group_status = active.to_a.flatten
-        FeatureFlipper.current_feature_group == group || states[group_status] == true
+        if active.has_key?(:feature_group)
+          group, required_state = active[:feature_group], active[:required_state]
+        else
+          group, required_state = active.to_a.flatten
+        end
+        (FeatureFlipper.current_feature_groups.include?(group)) || (states[required_state] == true)
       else
         active == true
       end
@@ -56,42 +60,42 @@ module FeatureFlipper
     def self.is_active?(feature_name)
       ensure_config_is_loaded
 
-      status = get_status(feature_name)
-      if status.is_a?(Symbol)
-        active_status?(status)
-      elsif status.is_a?(Proc)
-        status.call == true
+      state = get_state(feature_name)
+      if state.is_a?(Symbol)
+        active_state?(state)
+      elsif state.is_a?(Proc)
+        state.call == true
       else
-        status == true
+        state == true
       end
     end
   end
 
   class Mapper
-    def initialize(status)
-      @status = status
+    def initialize(state)
+      @state = state
     end
 
     def feature(name, options = {})
-      FeatureFlipper::Config.features[name] = options.merge(:status => @status)
+      FeatureFlipper::Config.features[name] = options.merge(:state => @state)
     end
   end
 
-  class StatusMapper
-    def in_status(status, &block)
-      Mapper.new(status).instance_eval(&block)
+  class StateMapper
+    def in_state(state, &block)
+      Mapper.new(state).instance_eval(&block)
     end
   end
 
   def self.features(&block)
-    StatusMapper.new.instance_eval(&block)
+    StateMapper.new.instance_eval(&block)
   end
 
-  def self.current_feature_group
-    Thread.current[:feature_system_current_feature_group]
+  def self.current_feature_groups
+    Thread.current[:feature_system_current_feature_groups] ||= []
   end
 
-  def self.current_feature_group=(feature_group)
-    Thread.current[:feature_system_current_feature_group] = feature_group
+  def self.reset_current_feature_groups
+    current_feature_groups.clear
   end
 end

data/lib/feature_flipper/version.rb

@@ -1,3 +1,3 @@
 module FeatureFlipper
-  Version = VERSION = '1.0.0'
+  Version = VERSION = '1.1.0'
 end

data/test/feature_flipper_test.rb

@@ -27,34 +27,13 @@ context 'hash based FeatureFlipper' do
     assert show_feature?(:proc_feature)
   end
 
-  test 'should show a beta feature to the feature group' do
-    Rails.stubs(:env).returns('production')
-    FeatureFlipper.stubs(:current_feature_group).returns(:beta_users)
-
-    assert show_feature?(:beta_feature)
-  end
-
-  test 'should not show a beta feature if not in the group' do
-    Rails.stubs(:env).returns('production')
-    FeatureFlipper.stubs(:current_feature_group).returns(nil)
-
-    assert !show_feature?(:beta_feature)
-  end
-
-  test 'should always show a beta feature on dev' do
-    Rails.stubs(:env).returns('development')
-    FeatureFlipper.stubs(:current_feature_group).returns(nil)
-
-    assert show_feature?(:beta_feature)
-  end
-
   test 'should be able to get features' do
     FeatureFlipper::Config.ensure_config_is_loaded
     all_features = FeatureFlipper::Config.features
 
     assert_not_nil all_features
     assert all_features.is_a?(Hash)
-    assert_equal :dev, all_features[:dev_feature][:status]
+    assert_equal :dev, all_features[:dev_feature][:state]
     assert_equal 'dev feature', all_features[:dev_feature][:description]
   end
 end
@@ -88,7 +67,48 @@ context 'DSL based FeatureFlipper' do
 
     assert_not_nil all_features
     assert all_features.is_a?(Hash)
-    assert_equal :dev, all_features[:dev_feature][:status]
+    assert_equal :dev, all_features[:dev_feature][:state]
     assert_equal 'dev feature', all_features[:dev_feature][:description]
   end
 end
+
+context 'dynamic feature groups' do
+  setup do
+    FeatureFlipper::Config.path_to_file = 'features.rb'
+    FeatureFlipper::Config.reload_config
+    FeatureFlipper.reset_current_feature_groups
+  end
+
+  test 'should show a beta feature to the feature group' do
+    Rails.stubs(:env).returns('production')
+    FeatureFlipper.current_feature_groups << :beta_users
+
+    assert show_feature?(:beta_feature_old)
+    assert show_feature?(:beta_feature_new)
+  end
+
+  test 'should not show a beta feature if not in the group' do
+    Rails.stubs(:env).returns('production')
+    FeatureFlipper.current_feature_groups << :different_feature_group
+
+    assert !show_feature?(:beta_feature_old)
+    assert !show_feature?(:beta_feature_new)
+  end
+
+  test 'should always show a beta feature on dev' do
+    Rails.stubs(:env).returns('development')
+    FeatureFlipper.current_feature_groups << nil
+
+    assert show_feature?(:beta_feature_old)
+    assert show_feature?(:beta_feature_new)
+  end
+
+  test 'can be in two feature groups at the same time' do
+    Rails.stubs(:env).returns('production')
+    FeatureFlipper.current_feature_groups << :beta_users
+    FeatureFlipper.current_feature_groups << :employees
+
+    assert show_feature?(:beta_feature_new)
+    assert show_feature?(:employee_feature)
+  end
+end

data/test/features.rb

@@ -1,16 +1,20 @@
 FeatureFlipper::Config.features = {
-  :live_feature     => { :status => :live },
-  :disabled_feature => { :status => :disabled },
-  :dev_feature      => { :status => :dev, :description => 'dev feature' },
-  :boolean_feature  => { :status => true },
-  :proc_feature     => { :status => Proc.new { Date.today > Date.today - 84000 } },
-  :beta_feature     => { :status => :beta }
+  :live_feature     => { :state => :live },
+  :disabled_feature => { :state => :disabled },
+  :dev_feature      => { :state => :dev, :description => 'dev feature' },
+  :boolean_feature  => { :state => true },
+  :proc_feature     => { :state => Proc.new { Date.today > Date.today - 84000 } },
+  :beta_feature_old => { :state => :beta_old },
+  :beta_feature_new => { :state => :beta_new },
+  :employee_feature => { :state => :employees }
 }
 
 
 FeatureFlipper::Config.states = {
-  :disabled => false,
-  :dev      => ['development', 'test'].include?(Rails.env),
-  :beta     => { :beta_users => :dev },
-  :live     => true
+  :disabled    => false,
+  :dev         => ['development', 'test'].include?(Rails.env),
+  :beta_old    => { :beta_users => :dev },
+  :beta_new    => { :required_state => :dev, :feature_group => :beta_users },
+  :employees   => { :required_state => :dev, :feature_group => :employees },
+  :live        => true
 }

data/test/features_dsl.rb

@@ -1,17 +1,17 @@
 FeatureFlipper.features do
-  in_status :dev do
+  in_state :dev do
     feature :dev_feature, :description => 'dev feature'
   end
 
-  in_status :live do
+  in_state :live do
     feature :live_feature
   end
 
-  in_status true do
+  in_state true do
     feature :boolean_feature
   end
 
-  in_status Proc.new { Date.today > Date.today - 84000 } do
+  in_state Proc.new { Date.today > Date.today - 84000 } do
     feature :proc_feature
   end
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: feature_flipper
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  prerelease: false
+  segments: 
+  - 1
+  - 1
+  - 0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Florian Munz
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-07 00:00:00 +02:00
+date: 2010-05-21 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -37,8 +42,9 @@ files:
 - test/features.rb
 - test/features_dsl.rb
 - test/test_helper.rb
+- examples/dynamic_states.rb
 - examples/features.rb
-- examples/simple.rb
+- examples/static_states.rb
 has_rdoc: true
 homepage: http://github.com/qype/feature_flipper
 licenses: []
@@ -52,18 +58,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: FeatureFlipper helps you flipping features