feature_flipper 1.3.0 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c3632c7d610b676c1221bcfa84bedd1bc95847e
+  data.tar.gz: 449a0a967eba941e1fad80ded4d69d142fe2d0a9
+SHA512:
+  metadata.gz: 6420b8810495627b15340ae99042546f4887a8ee6e0427178ea75c23b2ccdfdda816ec26f8307cf3513e40fa74eeafaa6a08392310ac91bde215b672740c5eef
+  data.tar.gz: 6da97940ac703df35ca10d8f5c923c67c1aa1c2088abe9368e3aa41c9d473ed774c8a74c154955808e1dc2b2903f5930c34939511822a3ed1fba92ad3692a9b8

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.1

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -1,12 +1,15 @@
 FeatureFlipper
 ==============
 
+[![Gem Version](https://badge.fury.io/rb/feature_flipper.svg)](https://rubygems.org/gems/feature_flipper)
+[![Build Status](https://travis-ci.org/theflow/feature_flipper.svg?branch=master)](https://travis-ci.org/theflow/feature_flipper)
+
 FeatureFlipper is a simple library that allows you to restrict certain blocks
 of code to certain environments. This is mainly useful in projects where
 you deploy your application from HEAD and don't use branches.
 
-Read more about the motivation in the
-[introductory blog post](http://engineering.qype.com/2010/06/03/how-we-work-flipping-features/).
+Read more about using feature flips here:
+[Feature Toggles](http://martinfowler.com/articles/feature-toggles.html).
 
 Install
 -------
@@ -18,35 +21,39 @@ FeatureFlipper is packaged as a gem:
 In your project you have to configure the path to the app specific
 configuration file after requiring FeatureFlipper:
 
-    require 'feature_flipper'
-    FeatureFlipper::Config.path_to_file = "#{RAILS_ROOT}/config/features.rb"
+```ruby
+require 'feature_flipper'
+FeatureFlipper::Config.path_to_file = "#{Rails.root}/config/features.rb"
+```
 
 Example config file
 -------------------
 
-    FeatureFlipper.features do
-      in_state :development do
-        feature :rating_game, :description => 'play a game to get recommendations'
-      end
+```ruby
+FeatureFlipper.features do
+  in_state :development do
+    feature :rating_game, :description => 'play a game to get recommendations'
+  end
 
-      in_state :live do
-        feature :city_feed, :description => 'stream of content for each city'
-      end
-    end
+  in_state :live do
+    feature :city_feed, :description => 'stream of content for each city'
+  end
+end
 
-    FeatureFlipper::Config.states = {
-      :development => ['development', 'test'].include?(Rails.env),
-      :live        => true
-    }
+FeatureFlipper.states do
+  state :development, ['development', 'test'].include?(Rails.env)
+  state :live, true
+end
+```
 
 This is your complete features.rb config file. In the example there are two
-states: `:development` is active on development boxes and `:live` is always active
+states: `:development` is active on development servers and `:live` is always active
 (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.
+the new state block and deploying your code.
 
 You can take a look at the `static_states.rb` in the examples folder to
 see this in detail.
@@ -61,7 +68,7 @@ FeatureFlipper cares about:
  * features
 
 You first define multiple 'states' which normally depend on the environment
-(for example: the state 'development' is only active on development boxes).
+(for example: the state 'development' is only active on development servers).
 After that you add 'features' which correspond to logical chunks of work in
 your project. These features then move through the different states
 as they get developed (for example: :development -> :staging -> :live).
@@ -73,18 +80,23 @@ 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_state :development do
-      feature :rating_game, :description => 'play a game to get recommendations'
-    end
+```ruby
+in_state :development do
+  feature :rating_game, :description => 'play a game to get recommendations'
+end
+```
 
 ### Defining states
 
 A state is just a name and a boolean check. The check needs to evaluate to
 `true` when it is active. For a Rails app you can just use environments:
 
-    FeatureFlipper::Config.states = {
-      :development => ['development', 'test'].include?(Rails.env)
-    }
+```ruby
+FeatureFlipper.states do
+  state :development, ['development', 'test'].include?(Rails.env)
+  state :staging, ['staging', development', 'test'].include?(Rails.env)
+end
+```
 
 Usage
 -----
@@ -92,21 +104,16 @@ Usage
 In your code you then use the `show_feature?` method to branch depending on
 wether a feature is active or not:
 
-    if show_feature?(:rating_game)
-      # new code
-    else
-      # old code
-    end
+```ruby
+if show_feature?(:rating_game)
+  # new code
+else
+  # old code
+end
+```
 
 The `show_feature?` method is defined on Object, so you can use it everywhere.
 
-Cleaning up
------------
-
-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 features
-(we call it de-featurizing) after they have gone live.
-
 Dynamic feature groups
 ----------------------
 
@@ -117,41 +124,20 @@ employees only or 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 = {
-      :development => ['development', 'test'].include?(Rails.env),
-      :employees   => { :required_state => :development, :feature_group => :employees }
-    }
-
-It has a required state and a feature group. The feature group defines
-a symbolic name for the group of users who should see this feature. You
-can name this whatever you want. The required state is the state that gets
-looked at for all other users that aren't in the feature group. The required
-state (:development) must be a defined, static state.
-
-### Setting the feature group
-
-The 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_active_feature_group
-      
-      def set_active_feature_group
-        # we need to reset the feature group in each request,
-        # otherwise it's also active for the following requests.
-        FeatureFlipper.reset_active_feature_groups
-        
-        if logged_in? && current_user.employee?
-          FeatureFlipper.active_feature_groups << :employees
-        end
-      end
-
-Don't forget to reset the feature group, without it the feature group
-is active forever. 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, based on the current time, etc.
+A dynamic state is defined using a Proc:
+
+```ruby
+FeatureFlipper.states do
+  state :development, ['development', 'test'].include?(Rails.env)
+  state :employees, Proc.new { |feature_name| respond_to?(:current_user, true) && current_user.employee? }
+end
+```
+
+The Proc get's evaluated in the context of where you call the `show_feature?`
+method from, so it depends on your app what you can do there. In a typical Rails
+app you could do checks on the current user, as shown above. This way the condition
+if someone should see a feature or not can be anything: You can store it in the
+database, in Redis, look at request parameters, based on the current time, etc.
 
 Take a look at `dynamic_states.rb` in the examples folder to see this
 in detail.
@@ -159,16 +145,7 @@ in detail.
 Meta
 ----
 
-* Code: `git clone git://github.com/qype/feature_flipper.git`
-* Home: <http://github.com/qype/feature_flipper>
-* Bugs: <http://github.com/qype/feature_flipper/issues>
-
-This project uses [Semantic Versioning][sv].
-
-Author
-------
-
-Florian Munz, Qype GmbH - florian@qype.com
-
+* Home: <https://github.com/theflow/feature_flipper>
+* Bugs: <https://github.com/theflow/feature_flipper/issues>
 
-[sv]: http://semver.org/
+This project uses [Semantic Versioning](http://semver.org/).

data/Rakefile

@@ -1,13 +1,9 @@
-require 'rake'
 require 'rake/testtask'
 
-desc 'Default: run unit tests'
-task :default => :test
-
-desc 'run the feature_flipper tests'
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
   t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
 end
+
+task :default => :test

data/examples/dynamic_states.rb

@@ -1,16 +1,30 @@
 # Setup
 #
 
-# just need this to make it work from within the library
+# just need this to make it works from within the library
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 
-# fake production Rails environment
+# stub production Rails environment
 module Rails
   def self.env
     'production'
   end
 end
 
+# stub current_user method
+class User
+  def initialize(employee)
+    @employee = employee
+  end
+
+  def employee?
+    @employee == true
+  end
+end
+
+def current_user
+  @current_user
+end
 
 # Configuration
 #
@@ -18,7 +32,7 @@ end
 require 'feature_flipper'
 
 # set the path to your app specific config file
-FeatureFlipper::Config.path_to_file = "features.rb"
+FeatureFlipper::Config.path_to_file = File.expand_path('features.rb', File.dirname(__FILE__))
 
 
 # Usage
@@ -26,7 +40,10 @@ FeatureFlipper::Config.path_to_file = "features.rb"
 
 puts "=== first example:"
 
-# no active feature_group set, so the required_state of badges is looked at
+# mock current user to not be a employee
+@current_user = User.new(false)
+
+# current user it not an employee and we are on prod, so no new badges
 if show_feature?(:badges)
   puts "shiny new badges not live on prod yet"
 else
@@ -35,13 +52,11 @@ end
 
 puts "\n=== second example:"
 
-# now we set the active feature_group. Usually depending on the logged in user
-
-FeatureFlipper.reset_active_feature_groups
-FeatureFlipper.active_feature_groups << :employees
+# mock current user to be a employee
+@current_user = User.new(true)
 
 if show_feature?(:badges)
-  puts "shiny new badges for this user"
+  puts "shiny new badges for this employee"
 else
   puts "no new badges"
 end

data/examples/features.rb

@@ -17,8 +17,8 @@ FeatureFlipper.features do
   end
 end
 
-FeatureFlipper::Config.states = {
-  :development => ['development', 'test'].include?(Rails.env),
-  :employees   => { :required_state => :development, :feature_group => :employees },
-  :live        => true
-}
+FeatureFlipper.states do
+  state :development, ['development', 'test'].include?(Rails.env)
+  state :employees, Proc.new { |feature_name| respond_to?(:current_user, true) && current_user.employee? }
+  state :live, true
+end

data/examples/static_states.rb

@@ -1,7 +1,7 @@
 # Setup
 #
 
-# just need this to make it work from within the library
+# just need this to make it works from within the library
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 
 # fake production Rails environment
@@ -18,7 +18,7 @@ end
 require 'feature_flipper'
 
 # set the path to your app specific config file
-FeatureFlipper::Config.path_to_file = "features.rb"
+FeatureFlipper::Config.path_to_file = File.expand_path('features.rb', File.dirname(__FILE__))
 
 
 # Usage

data/feature_flipper.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name            = 'feature_flipper'
+  s.version         = '2.0.0'
+  s.authors         = ['Florian Munz']
+  s.email           = 'surf@theflow.de'
+
+  s.summary         = 'FeatureFlipper helps you flipping features'
+  s.description     = <<desc
+FeatureFlipper is a simple library that allows you to restrict certain blocks
+of code to certain environments. This is mainly useful in projects where
+you deploy your application from HEAD and don't use branches.
+desc
+  s.homepage        = 'http://github.com/theflow/feature_flipper'
+  s.license         = 'MIT'
+
+  s.files           = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  s.require_paths   = ['lib']
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest', "~> 5.0"
+end

data/lib/feature_flipper/config.rb

@@ -4,7 +4,7 @@ module FeatureFlipper
     @states   = {}
 
     def self.path_to_file
-      @path_to_file || File.join(Rails.root, 'config', 'features.rb')
+      @path_to_file
     end
 
     def self.path_to_file=(path_to_file)
@@ -19,6 +19,9 @@ module FeatureFlipper
     end
 
     def self.reload_config
+      @features = {}
+      @states   = {}
+
       @config_loaded = false
     end
 
@@ -38,44 +41,37 @@ module FeatureFlipper
       @states = states
     end
 
-    def self.active_features
-      features.keys.select { |feature| is_active?(feature) }
-    end
-
     def self.get_state(feature_name)
       feature = features[feature_name]
       feature ? feature[:state] : nil
     end
 
-    def self.active_state?(state)
-      active = states[state]
-      if active.is_a?(Hash)
-        if active.has_key?(:feature_group)
-          group, required_state = active[:feature_group], active[:required_state]
+    def self.active_state?(state, feature_name, context = nil)
+      condition = states[state]
+      if condition.is_a?(Proc)
+        if context
+          context.instance_exec(feature_name, &condition)
         else
-          group, required_state = active.to_a.flatten
+          condition.call(feature_name) == true
         end
-        (FeatureFlipper.active_feature_groups.include?(group)) || (states[required_state] == true)
       else
-        active == true
+        condition == true
       end
     end
 
-    def self.is_active?(feature_name)
+    def self.is_active?(feature_name, context = nil)
       ensure_config_is_loaded
 
       state = get_state(feature_name)
-      if state.is_a?(Symbol)
-        active_state?(state)
-      elsif state.is_a?(Proc)
-        state.call == true
-      else
-        state == true
-      end
+      active_state?(state, feature_name, context)
+    end
+
+    def self.active_features(context = nil)
+      self.features.collect { |key, value| self.is_active?(key, context) ? key : nil }.compact
     end
   end
 
-  class Mapper
+  class FeatureMapper
     def initialize(state)
       @state = state
     end
@@ -85,21 +81,23 @@ module FeatureFlipper
     end
   end
 
-  class StateMapper
+  class FeaturesMapper
     def in_state(state, &block)
-      Mapper.new(state).instance_eval(&block)
+      FeatureMapper.new(state).instance_eval(&block)
     end
   end
 
-  def self.features(&block)
-    StateMapper.new.instance_eval(&block)
+  class StatesMapper
+    def state(name, condition = false)
+      FeatureFlipper::Config.states[name] = condition
+    end
   end
 
-  def self.active_feature_groups
-    Thread.current[:feature_system_active_feature_groups] ||= []
+  def self.features(&block)
+    FeaturesMapper.new.instance_eval(&block)
   end
 
-  def self.reset_active_feature_groups
-    active_feature_groups.clear
+  def self.states(&block)
+    StatesMapper.new.instance_eval(&block)
   end
 end

data/lib/feature_flipper/show.rb

@@ -7,11 +7,11 @@ module FeatureFlipper
     end
 
     def show_feature?(feature_name)
-      FeatureFlipper::Config.is_active?(feature_name)
+      FeatureFlipper::Config.is_active?(feature_name, self)
     end
-    
+
     def active_features
-      FeatureFlipper::Config.active_features
+      FeatureFlipper::Config.active_features(self)
     end
   end
 end

metadata

@@ -1,73 +1,87 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: feature_flipper
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 1.3.0
+version: !ruby/object:Gem::Version
+  version: 2.0.0
 platform: ruby
-authors: 
+authors:
 - Florian Munz
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-02-28 00:00:00 +01:00
-default_executable: 
-dependencies: []
-
+date: 2017-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.0'
 description: |
   FeatureFlipper is a simple library that allows you to restrict certain blocks
   of code to certain environments. This is mainly useful in projects where
   you deploy your application from HEAD and don't use branches.
-
 email: surf@theflow.de
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
 - README.md
 - Rakefile
-- LICENSE
-- lib/feature_flipper/config.rb
-- lib/feature_flipper/show.rb
-- lib/feature_flipper/version.rb
-- lib/feature_flipper.rb
-- test/feature_flipper_test.rb
-- test/features.rb
-- test/features_dsl.rb
-- test/test_helper.rb
 - examples/dynamic_states.rb
 - examples/features.rb
 - examples/static_states.rb
-has_rdoc: true
-homepage: http://github.com/qype/feature_flipper
-licenses: []
-
+- feature_flipper.gemspec
+- lib/feature_flipper.rb
+- lib/feature_flipper/config.rb
+- lib/feature_flipper/show.rb
+homepage: http://github.com/theflow/feature_flipper
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.0
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: FeatureFlipper helps you flipping features
 test_files: []
-

data/lib/feature_flipper/version.rb

@@ -1,3 +0,0 @@
-module FeatureFlipper
-  Version = VERSION = '1.3.0'
-end

data/test/feature_flipper_test.rb

@@ -1,126 +0,0 @@
-require 'test_helper'
-
-context 'hash based FeatureFlipper' do
-  setup do
-    FeatureFlipper::Config.path_to_file = 'features.rb'
-    FeatureFlipper::Config.reload_config
-  end
-
-  test 'should show enabled features' do
-    assert show_feature?(:live_feature)
-  end
-
-  test 'should not show disabled features' do
-    assert !show_feature?(:disabled_feature)
-  end
-
-  test 'should not show a feature when on a higher environment' do
-    Rails.stubs(:env).returns('production')
-    assert !show_feature?(:dev_feature)
-  end
-
-  test 'show feature should work with booleans' do
-    assert show_feature?(:boolean_feature)
-  end
-
-  test 'show feature should work with procs' do
-    assert show_feature?(:proc_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][:state]
-    assert_equal 'dev feature', all_features[:dev_feature][:description]
-  end
-end
-
-context 'DSL based FeatureFlipper' do
-  setup do
-    FeatureFlipper::Config.path_to_file = 'features_dsl.rb'
-    FeatureFlipper::Config.reload_config
-  end
-
-  test 'should show enabled features' do
-    assert show_feature?(:live_feature)
-  end
-
-  test 'should not show a feature when on a higher environment' do
-    Rails.stubs(:env).returns('production')
-    assert !show_feature?(:dev_feature)
-  end
-
-  test 'show feature should work with booleans' do
-    assert show_feature?(:boolean_feature)
-  end
-
-  test 'show feature should work with procs' do
-    assert show_feature?(:proc_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][:state]
-    assert_equal 'dev feature', all_features[:dev_feature][:description]
-  end
-
-  test 'should be able to get active features' do
-    Rails.stubs(:env).returns('production')
-    FeatureFlipper::Config.ensure_config_is_loaded
-    active_features = FeatureFlipper::Config.active_features
-
-    assert_equal 3, active_features.size
-    assert active_features.include?(:live_feature)
-    assert active_features.include?(:boolean_feature)
-    assert active_features.include?(:proc_feature)
-  end
-
-end
-
-context 'dynamic feature groups' do
-  setup do
-    FeatureFlipper::Config.path_to_file = 'features.rb'
-    FeatureFlipper::Config.reload_config
-    FeatureFlipper.reset_active_feature_groups
-  end
-
-  test 'should show a beta feature to the feature group' do
-    Rails.stubs(:env).returns('production')
-    FeatureFlipper.active_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.active_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.active_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.active_feature_groups << :beta_users
-    FeatureFlipper.active_feature_groups << :employees
-
-    assert show_feature?(:beta_feature_new)
-    assert show_feature?(:employee_feature)
-  end
-end

data/test/features.rb

@@ -1,20 +0,0 @@
-FeatureFlipper::Config.features = {
-  :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_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,23 +0,0 @@
-FeatureFlipper.features do
-  in_state :dev do
-    feature :dev_feature, :description => 'dev feature'
-  end
-
-  in_state :live do
-    feature :live_feature
-  end
-
-  in_state true do
-    feature :boolean_feature
-  end
-
-  in_state Proc.new { Date.today > Date.today - 84000 } do
-    feature :proc_feature
-  end
-end
-
-
-FeatureFlipper::Config.states = {
-  :dev      => ['development', 'test'].include?(Rails.env),
-  :live     => true
-}

data/test/test_helper.rb

@@ -1,38 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-
-require 'mocha'
-
-##
-# test/spec/mini 5
-# http://gist.github.com/307649
-# chris@ozmm.org
-#
-def context(*args, &block)
-  return super unless (name = args.first) && block
-  require 'test/unit'
-  klass = Class.new(defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase) do
-    def self.test(name, &block)
-      define_method("test_#{name.to_s.gsub(/\W/,'_')}", &block) if block
-    end
-    def self.xtest(*args) end
-    def self.context(*args, &block) instance_eval(&block) end
-    def self.setup(&block)
-      define_method(:setup) { self.class.setups.each { |s| instance_eval(&s) } }
-      setups << block
-    end
-    def self.setups; @setups ||= [] end
-    def self.teardown(&block) define_method(:teardown, &block) end
-  end
-  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
-  klass.class_eval &block
-end
-
-
-module Rails
-  def self.env
-    'test'
-  end
-end
-
-require 'feature_flipper'