ruby_flipper 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+spec/reports

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ruby_flipper.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    ruby_flipper (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    ci_reporter (1.6.3)
+      builder (>= 2.1.2)
+    diff-lcs (1.1.2)
+    mocha (0.9.10)
+      rake
+    rake (0.8.7)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ci_reporter (~> 1.6.3)
+  mocha (~> 0.9.10)
+  rspec (~> 2.0.1)
+  ruby_flipper!

data/README.rdoc

@@ -0,0 +1,126 @@
+= Ruby Flipper
+
+Ruby Flipper makes it easy to define features and switch them on and off. It's configuration DSL provides a very flexible but still not too verbose syntax to fulfil your flipping needs.
+
+
+== Usage
+
+To use ruby flipper, you have to load a feature definition file somewhere:
+
+  RubyFlipper.load(File.expand_path '../features.rb', __FILE__)
+
+This configuration can be reset by calling:
+
+  RubyFlipper.reset
+
+
+== Feature Definitions
+
+The file loaded by ruby flipper is written in ruby flipper's simple DSL. The most basic feature definition is just a feature with a name. Without any further conditions, the feature is active by default.
+
+  feature :always_on_feature
+
+You can specify conditions that are used to determine whether a feature is active or not in three different ways:
+
+  feature :conditional_feature_with_parameter, false
+  feature :conditional_feature_with_condition_opt, :condition => false
+  feature :conditional_feature_with_conditions_opt, :conditions => false
+
+In the examples above, the features are statically disabled. You can use three different types of conditions.
+
+=== Static Conditions
+
+A static condition is a boolean that is evaluated when the feature definitions are loaded. This can be used to statically activate/deactivate features or make features dependent on variables that don't change during runtime.
+
+  feature :development_feature, Rails.env.development?
+
+This defines a feature that is only active in Rails' development mode.
+
+=== Reference Conditions
+
+A reference condition is a symbol that references another feature. This can be used to make a feature dependent on another feature or extract complex condition definitions and reuse them for several features.
+
+  feature :dependent_feature, :development_feature
+
+This defines a feature that is only active when the feature :development_feature is active.
+
+=== Dynamic Conditions
+
+A dynamic condition is a proc (or anything that responds to :call) that will be evaluated each time the state of a feature is checked. This can be used to activate/deactivate features dynamically depending on variables that change during runtime.
+
+  feature :admin_feature, condition => lambda { User.current.is_admin? }
+
+This defines a feature that is only active when the current user is an admin (the user specific stuff must be implemented somewhere else).
+
+Dynamic conditions can also be given to the feature method as a block:
+
+  feature :admin_feature do
+    User.current.is_admin?
+  end
+
+Within such a proc, you can also check whether another feature is active or not to phrase complex condition dependencies:
+
+  feature :shy_feature do
+    active?(:development_feature) && (active?(:admin_feature) || Time.now.hour < 8)
+  end
+
+This defines a feature that is only active when the feature :development_feature is active and either the feature :admin_feature is active or it is between midnight and 8:00 in the morning (however that might be useful).
+
+=== Combined Conditions
+
+A combined condition is an array of other conditions. Any type of condition can be combined in an array. All conditions have to be met for a feature to be active.
+
+  feature :combined_feature, [:development_feature, lambda { User.current.name == 'patti' }]
+
+This defines a feature that is only enabled when the feature :development_feature is enbled and the current user is 'patti'.
+
+=== More
+
+For more examples, see spec/fixtures/features.rb and spec/ruby_flipper_spec.rb (section .load which is kind of an end-to-end integration test).
+
+
+== Condition Definitions
+
+If you have a lot of dependent features with shared conditions you can clean up your definition file by explicitly defining conditions that aren't used as features but just as conditions real features depend on.
+
+  condition :development, Rails.env.development?
+  condition :admin { User.current.is_admin? }
+  
+  feature :user_administration, :development, :admin
+  feature :new_feature, :development
+
+Of course, you can nest this as deep as you like (features depending on conditions depending on conditions depending on features depending on conditions...), although this might lead to completely incomprehensible rulesets.
+
+The condition method is just an alias to the feature method, so internally, it makes absolutely no difference which method you use. Using both methods just helps you structuring your feature definitions and makes the feature definition file easier to understand.
+
+
+== Usage
+
+Finally, there are two ways to check whether a feature is active or not within your code. You can just give it a block that will only be evaluated when the feature is active:
+
+  feature_active?(:hidden_feature) do
+    # do something for that feature
+  end
+
+or if you need the state of a feature as a boolean value or want to do something when a feature is not active:
+
+  if feature_active?(:hidden_feature)
+    # do something for that feature
+  else
+    # do something else
+  end
+
+This method is defined on Object, so it is available anywhere you might ever need it.
+
+
+== Describing Features
+
+Last and least, you can describe your features, for example when you use ticket numbers or anything other cryptic for your feature names. The description isn't used anywhere yet, but it might make your code more readable.
+
+  feature :feature_452, :development, :description => 'Feature 452: An end user can change his data on his profile page.'
+
+You could also just use comments for that, but giving this to ruby flipper in code enables you to evaluate your features and print lists containing the description.
+
+  RubyFlipper::Feature.all.each do |feature|
+    puts "#{feature.name}: #{feature.description}"
+  end

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'ci/reporter/rake/rspec'
+
+RSpec::Core::RakeTask.new :spec
+task :default => %w(ci:setup:rspec spec)

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/lib/ruby_flipper/condition_context.rb

@@ -0,0 +1,11 @@
+module RubyFlipper
+
+  class ConditionContext
+
+    def active?(*conditions)
+      Feature.new(nil, *conditions).active?
+    end
+
+  end
+
+end

data/lib/ruby_flipper/dsl.rb

@@ -0,0 +1,12 @@
+module RubyFlipper
+
+  class Dsl
+
+    def feature(name, *conditions, &block)
+      Feature.add(name, *conditions, &block)
+    end
+    alias :condition :feature
+
+  end
+
+end

data/lib/ruby_flipper/feature.rb

@@ -0,0 +1,51 @@
+module RubyFlipper
+
+  class Feature
+
+    def self.all
+      @@features ||= {}
+    end
+
+    def self.reset
+      @@features = nil
+    end
+
+    def self.add(name, *conditions, &block)
+      all[name] = new(name, *conditions, &block)
+    end
+
+    def self.find(name)
+      all[name] || raise(NotDefinedError, "'#{name}' is not defined")
+    end
+
+    def self.condition_met?(condition)
+      if condition.is_a?(Symbol)
+        find(condition).active?
+      elsif condition.is_a?(Proc)
+        !!ConditionContext.new.instance_eval(&condition)
+      elsif condition.respond_to?(:call)
+        !!condition.call
+      else
+        !!condition
+      end
+    end
+
+    attr_reader :name, :description, :conditions
+
+    def initialize(name, *conditions, &block)
+      if conditions.last.is_a?(Hash)
+        opts = conditions.pop
+        @description = opts[:description]
+        conditions << opts[:condition]
+        conditions << opts[:conditions]
+      end
+      @name, @conditions = name, [conditions, block].flatten.compact
+    end
+
+    def active?
+      conditions.map {|condition| self.class.condition_met?(condition)}.all?
+    end
+
+  end
+
+end

data/lib/ruby_flipper/object_mixin.rb

@@ -0,0 +1,16 @@
+module RubyFlipper
+
+  module ObjectMixin
+
+    def feature_active?(name)
+      active = Feature.find(name).active?
+      yield if active && block_given?
+      active
+    end
+    alias :condition_met? :feature_active?
+
+  end
+
+end
+
+Object.send :include, RubyFlipper::ObjectMixin

data/lib/ruby_flipper.rb

@@ -0,0 +1,19 @@
+require 'ruby_flipper/object_mixin'
+
+module RubyFlipper
+
+  class NotDefinedError < StandardError; end
+
+  autoload :ConditionContext, 'ruby_flipper/condition_context'
+  autoload :Dsl, 'ruby_flipper/dsl'
+  autoload :Feature, 'ruby_flipper/feature'
+
+  def self.load(file)
+    Dsl.new.instance_eval(IO.read file)
+  end
+
+  def self.reset
+    Feature.reset
+  end
+
+end

data/ruby_flipper.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "ruby_flipper"
+  s.version     = "0.0.2"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Thomas Jachmann"]
+  s.email       = ["self@thomasjachmann.com"]
+  s.homepage    = "https://github.com/blaulabs/ruby_flipper"
+  s.summary     = %q{Make switching features on and off easy.}
+  s.description = %q{Most flexible still least verbose feature flipper for ruby projects.}
+
+  s.rubyforge_project = "ruby_flipper"
+
+  s.add_development_dependency "ci_reporter", "~> 1.6.3"
+  s.add_development_dependency "rspec", "~> 2.0.1"
+  s.add_development_dependency "mocha", "~> 0.9.10"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/fixtures/features.rb

@@ -0,0 +1,38 @@
+# statically configured condition (initially evaluated when configuration is loaded)
+condition :static_is_cherry, FLIPPER_ENV[:static] == 'cherry'
+
+# dynamically configured condition (evaluated on each access)
+condition :dynamic_is_floyd do
+  FLIPPER_ENV[:dynamic] == 'floyd'
+end
+
+# combined condition referencing both above
+condition :combined_is_cherry_and_floyd, :static_is_cherry, :dynamic_is_floyd
+
+# combined condition with static and dynamic
+condition :combined_is_lulu_first_then_gavin, FLIPPER_ENV[:changing] == 'lulu' do
+  FLIPPER_ENV[:changing] == 'gavin'
+end
+
+
+# disabled feature
+feature :disabled, :description => 'disabled feature', :condition => false
+
+# feature referencing a single predefined condition
+feature :floyd, :description => 'just for floyd', :condition => :dynamic_is_floyd
+
+# feature depending on a dynamic condition (lambda)
+feature :philip, :description => 'just for philip', :condition => lambda { FLIPPER_ENV[:dynamic] == 'philip' }
+
+# feature depending on array of a static condition, a predefined condition and a dynamic condition (lambda)
+# given in :conditions (can be both :condition/:conditions)
+feature :patti, :description => 'just for patti', :conditions => [
+  FLIPPER_ENV[:changing] == 'patti',
+  :dynamic_is_floyd,
+  lambda { FLIPPER_ENV[:changing] == 'gavin'}
+]
+
+# feature with a complex combination of dynamic and predifined conditions given as a block
+feature :sue, :description => 'just for sue' do
+  (active?(:static_is_cherry) || active?(:dynamic_is_floyd)) && FLIPPER_ENV[:changing] == 'sue'
+end

data/spec/ruby_flipper/condition_context_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe RubyFlipper::ConditionContext do
+
+  describe '#active?' do
+
+    it 'should return true on an active feature' do
+      RubyFlipper::Feature.add(:referenced, true)
+      subject.active?(:referenced).should == true
+    end
+
+    it 'should return false on an inactive feature' do
+      RubyFlipper::Feature.add(:referenced, false)
+      subject.active?(:referenced).should == false
+    end
+
+    it 'should raise an error when the referenced feature is not defined' do
+      lambda { subject.active?(:referenced) }.should raise_error RubyFlipper::NotDefinedError, '\'referenced\' is not defined'
+    end
+
+    it 'should handle multiple conditions as well' do
+      RubyFlipper::Feature.add(:referenced1, true)
+      RubyFlipper::Feature.add(:referenced2, false)
+      RubyFlipper::Feature.add(:referenced3, true)
+      subject.active?(:referenced1, :referenced2).should == false
+      subject.active?(:referenced1, :referenced3).should == true
+    end
+
+  end
+
+end

data/spec/ruby_flipper/dsl_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe RubyFlipper::Dsl do
+
+  it 'should ensure mocked methods exist' do
+    RubyFlipper::Feature.should respond_to(:add)
+  end
+
+  [:feature, :condition].each do |method|
+
+    describe "##{method}" do
+
+      it 'should call add with only a name' do
+        RubyFlipper::Feature.expects(:add).with(:feature_name).returns(:feature)
+        subject.send(method, :feature_name).should == :feature
+      end
+
+      it 'should call add with a name and conditions' do
+        RubyFlipper::Feature.expects(:add).with(:feature_name, :one, :two).returns(:feature)
+        subject.send(method, :feature_name, :one, :two).should == :feature
+      end
+
+      it 'should call add with a name, conditions and a block' do
+        block = lambda {}
+        # cannot mock this since mocha doesn't allow to test for a proc [thomas, 2010-12-13]
+        feature = subject.send(method, :feature_name, :one, :two, &block)
+        feature.conditions.should == [:one, :two, block]
+      end
+
+    end
+
+  end
+
+end

data/spec/ruby_flipper/feature_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe RubyFlipper::Feature do
+
+  describe '.all' do
+
+    it 'should be a hash' do
+      RubyFlipper::Feature.all.should == {}
+    end
+
+  end
+
+  describe '.reset' do
+
+    it 'should reset the all hash' do
+      RubyFlipper::Feature.add(:inactive, false)
+      RubyFlipper::Feature.all.should_not be_empty
+      RubyFlipper::Feature.reset
+      RubyFlipper::Feature.all.should be_empty
+    end
+
+  end
+
+  describe '.add' do
+
+    it 'should call new with only a name and store the feature' do
+      RubyFlipper::Feature.expects(:new).with(:feature_name).returns(:feature)
+      RubyFlipper::Feature.add(:feature_name).should == :feature
+      RubyFlipper::Feature.all[:feature_name].should == :feature
+    end
+
+    it 'should call add with a name and conditions and store the feature' do
+      RubyFlipper::Feature.expects(:new).with(:feature_name, :one, :two).returns(:feature)
+      RubyFlipper::Feature.add(:feature_name, :one, :two).should == :feature
+      RubyFlipper::Feature.all[:feature_name].should == :feature
+    end
+
+    it 'should call add with a name, conditions and a block and store the feature' do
+      block = lambda {}
+      # cannot mock this since mocha doesn't allow to test for a proc [thomas, 2010-12-13]
+      feature = RubyFlipper::Feature.add(:feature_name, :one, :two, &block)
+      feature.conditions.should == [:one, :two, block]
+      RubyFlipper::Feature.all[:feature_name].should == feature
+    end
+
+  end
+
+  describe '.find' do
+
+    it 'should return the stored feature' do
+      feature = RubyFlipper::Feature.add(:feature_name)
+      RubyFlipper::Feature.find(:feature_name).should == feature
+    end
+
+    it 'should raise an error when the referenced feature is not defined' do
+      lambda { RubyFlipper::Feature.find(:feature_name) }.should raise_error RubyFlipper::NotDefinedError, '\'feature_name\' is not defined'
+    end
+
+  end
+
+  describe '.condition_met?' do
+
+    context 'with a symbol' do
+
+      it 'should return the state of the referenced feature' do
+        RubyFlipper::Feature.add(:referenced, true)
+        RubyFlipper::Feature.condition_met?(:referenced).should == true
+      end
+
+      it 'should raise an error when the referenced feature is not defined' do
+        lambda { RubyFlipper::Feature.condition_met?(:missing) }.should raise_error RubyFlipper::NotDefinedError, '\'missing\' is not defined'
+      end
+
+    end
+
+    {
+      true       => true,
+      'anything' => true,
+      false      => false,
+      nil        => false
+    }.each do |condition, expected|
+
+      it "should call a given proc and return #{expected} when it returns #{condition}" do
+        RubyFlipper::Feature.condition_met?(lambda { condition }).should == expected
+      end
+
+      it "should call anything callable and return #{expected} when it returns #{condition}" do
+        RubyFlipper::Feature.condition_met?(stub(:call => condition)).should == expected
+      end
+
+      it "should return #{expected} when the condition is #{condition}" do
+        RubyFlipper::Feature.condition_met?(condition).should == expected
+      end
+
+    end
+
+    context 'with a complex proc' do
+
+      it 'should return the met? of the combined referenced conditions' do
+        RubyFlipper::Feature.add(:true, true)
+        RubyFlipper::Feature.add(:false, false)
+        RubyFlipper::Feature.condition_met?(lambda { active?(:true) || active?(:false) }).should == true
+        RubyFlipper::Feature.condition_met?(lambda { active?(:true) && active?(:false) }).should == false
+      end
+
+    end
+
+  end
+
+  describe 'initializer' do
+
+    it 'should store the name' do
+      RubyFlipper::Feature.new(:feature_name).name.should == :feature_name
+    end
+
+    it 'should store the description' do
+      RubyFlipper::Feature.new(:feature_name, :description => 'desc').description.should == 'desc'
+    end
+
+    it 'should work with a single static condition' do
+      RubyFlipper::Feature.new(:feature_name, true).conditions.should == [true]
+    end
+
+    it 'should work with multiple static conditions' do
+      RubyFlipper::Feature.new(:feature_name, true, :development).conditions.should == [true, :development]
+    end
+
+    it 'should work with a dynamic condition as parameter' do
+      condition = lambda { true }
+      RubyFlipper::Feature.new(:feature_name, condition).conditions.should == [condition]
+    end
+
+    it 'should work with a dynamic condition as block' do
+      condition = lambda { true }
+      RubyFlipper::Feature.new(:feature_name, &condition).conditions.should == [condition]
+    end
+
+    it 'should work with a combination of static and dynamic conditions' do
+      condition = lambda { true }
+      RubyFlipper::Feature.new(:feature_name, false, :live, condition).conditions.should == [false, :live, condition]
+    end
+
+    it 'should work with conditions given in the opts hash as :condition' do
+      RubyFlipper::Feature.new(:feature_name, :condition => true).conditions.should == [true]
+    end
+
+    it 'should work with conditions given in the opts hash as :conditions' do
+      RubyFlipper::Feature.new(:feature_name, :conditions => false).conditions.should == [false]
+    end
+
+    it 'should work with a combination of arrays, dynamic conditions and conditions given in the opts hash and eliminate nil' do
+      condition = lambda { true }
+      RubyFlipper::Feature.new(:feature_name, [false, nil], :condition => [nil, 'c'], :conditions => ['c1', 'c2'], &condition).conditions.should == [false, 'c', 'c1', 'c2', condition]
+    end
+
+  end
+
+  describe '#active?' do
+
+    it 'should return true when no conditions are given (unconditionally active)' do
+      RubyFlipper::Feature.new(:feature_name).active?.should == true
+    end
+
+    it 'should return false when not all conditions are met (with dynamic)' do
+      RubyFlipper::Feature.new(:feature_name, true, lambda { false }).active?.should == false
+    end
+
+    it 'should return false when not all conditions are met (only static)' do
+      RubyFlipper::Feature.new(:feature_name, false, true).active?.should == false
+    end
+
+    it 'should return true when all conditions are met' do
+      RubyFlipper::Feature.new(:feature_name, true, true).active?.should == true
+    end
+
+  end
+
+end

data/spec/ruby_flipper/object_mixin_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe RubyFlipper::ObjectMixin do
+
+  it 'should be included in Object' do
+    Object.included_modules.should include RubyFlipper::ObjectMixin
+  end
+
+  describe '#feature_active?' do
+
+    subject do
+      # this is not really needed, since one could just call feature_active?
+      # but to be independent of the inclusion in Object (see above), better
+      # create a new subject that is sure to include RubyFlipper::ObjectMixin.
+      Class.new do
+        include RubyFlipper::ObjectMixin
+      end.new
+    end
+
+    context 'with an active feature' do
+
+      before(:each) do
+        RubyFlipper::Feature.add(:active, true)
+      end
+
+      it 'should return true when called without a block' do
+        subject.feature_active?(:active).should == true
+      end
+
+      it 'should execute the block and return true when called with a block' do
+        var = 'before'
+        subject.feature_active?(:active) do
+          var = 'after'
+        end.should == true
+        var.should == 'after'
+      end
+
+    end
+
+    context 'with an inactive feature' do
+
+      before(:each) do
+        RubyFlipper::Feature.add(:inactive, false)
+      end
+
+      it 'should return false when called without a block' do
+        subject.feature_active?(:inactive).should == false
+      end
+
+      it 'should not execute the block and return false when called with a block' do
+        subject.feature_active?(:inactive) do
+          fail 'the given block should not be called'
+        end.should == false
+      end
+
+    end
+
+    context 'with a missing feature' do
+
+      it 'should raise an error when called without a block and the referenced feature is not defined' do
+        lambda { subject.feature_active?(:missing) }.should raise_error RubyFlipper::NotDefinedError, '\'missing\' is not defined'
+      end
+
+      it 'should not execute the block and raise an error when called with a block and the referenced feature is not defined' do
+        lambda { subject.feature_active?(:missing) { fail 'the given block should not be called' } }.should raise_error RubyFlipper::NotDefinedError, '\'missing\' is not defined'
+      end
+
+    end
+
+  end
+
+end

data/spec/ruby_flipper_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+
+describe RubyFlipper do
+
+  describe '.load' do
+
+    def load_features
+      RubyFlipper.load(File.expand_path '../fixtures/features.rb', __FILE__)
+    end
+
+    context 'conditions' do
+
+      context ':static_is_cherry' do
+
+        it 'should not be met when static is not cherry when loading' do
+          load_features
+          RubyFlipper::Feature.find(:static_is_cherry).should_not be_active
+        end
+
+        it 'should not be met when static is not cherry when loading even when it is when called' do
+          load_features
+          FLIPPER_ENV[:static] = 'cherry'
+          RubyFlipper::Feature.find(:static_is_cherry).should_not be_active
+        end
+
+        it 'should be met when static is not cherry when called' do
+          FLIPPER_ENV[:static] = 'cherry'
+          load_features
+          RubyFlipper::Feature.find(:static_is_cherry).should be_active
+        end
+
+      end
+
+      context ':dynamic_is_floyd' do
+
+        it 'should not be met when dynamic is not floyd when called' do
+          load_features
+          RubyFlipper::Feature.find(:dynamic_is_floyd).should_not be_active
+        end
+
+        it 'should not be met when dynamic is not floyd when called even when it was when loaded' do
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          load_features
+          FLIPPER_ENV[:dynamic] = 'sue'
+          RubyFlipper::Feature.find(:dynamic_is_floyd).should_not be_active
+        end
+
+        it 'should be met when dynamic is floyd when called' do
+          load_features
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          RubyFlipper::Feature.find(:dynamic_is_floyd).should be_active
+        end
+
+      end
+
+      context ':combined_is_cherry_and_floyd' do
+
+        it 'should not be met when static is not cherry when loaded even when it is when called and dynamic is floyd' do
+          load_features
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          RubyFlipper::Feature.find(:combined_is_cherry_and_floyd).should_not be_active
+        end
+
+        it 'should not be met when static is cherry but dynamic is not floyd when called even when it was when loaded' do
+          FLIPPER_ENV[:static] = 'cherry'
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          load_features
+          FLIPPER_ENV[:dynamic] = 'sue'
+          RubyFlipper::Feature.find(:combined_is_cherry_and_floyd).should_not be_active
+        end
+
+        it 'should be met when static is cherry when loaded and dynamic is floyd when called even when static is not cherry when called and dynamic was not floyd when called' do
+          FLIPPER_ENV[:static] = 'cherry'
+          load_features
+          FLIPPER_ENV[:static] = 'philip'
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          RubyFlipper::Feature.find(:combined_is_cherry_and_floyd).should be_active
+        end
+
+      end
+
+      context ':combined_is_lulu_first_then_gavin' do
+
+        it 'should not be met when changing is not lulu when loaded even when it is gavin when called' do
+          load_features
+          FLIPPER_ENV[:changing] = 'gavin'
+          RubyFlipper::Feature.find(:combined_is_lulu_first_then_gavin).should_not be_active
+        end
+
+        it 'should not be met when changing is lulu when loaded but it is not gavin when called' do
+          FLIPPER_ENV[:changing] = 'lulu'
+          load_features
+          RubyFlipper::Feature.find(:combined_is_lulu_first_then_gavin).should_not be_active
+        end
+
+        it 'should be met when changing is lulu when loaded gavin when called' do
+          FLIPPER_ENV[:changing] = 'lulu'
+          load_features
+          FLIPPER_ENV[:changing] = 'gavin'
+          RubyFlipper::Feature.find(:combined_is_lulu_first_then_gavin).should be_active
+        end
+
+      end
+
+    end
+
+    context 'features' do
+
+      context ':disabled' do
+
+        it 'should not be active' do
+          load_features
+          RubyFlipper::Feature.find(:disabled).should_not be_active
+        end
+
+      end
+
+      context ':floyd' do
+
+        it 'should not be active when dynamic is not floyd' do
+          load_features
+          RubyFlipper::Feature.find(:floyd).should_not be_active
+        end
+
+        it 'should be active when dynamic is floyd' do
+          load_features
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          RubyFlipper::Feature.find(:floyd).should be_active
+        end
+
+      end
+
+      context ':philip' do
+
+        it 'should not be active when dynamic is not philip' do
+          load_features
+          RubyFlipper::Feature.find(:philip).should_not be_active
+        end
+
+        it 'should be active when dynamic is philip' do
+          load_features
+          FLIPPER_ENV[:dynamic] = 'philip'
+          RubyFlipper::Feature.find(:philip).should be_active
+        end
+
+      end
+
+      context ':patti' do
+
+        it 'should not be active when changing is not patti when loaded' do
+          load_features
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          FLIPPER_ENV[:changing] = 'gavin'
+          RubyFlipper::Feature.find(:patti).should_not be_active
+        end
+
+        it 'should not be active when dynamic is not floyd when called' do
+          FLIPPER_ENV[:changing] = 'patti'
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          load_features
+          FLIPPER_ENV[:dynamic] = 'sue'
+          FLIPPER_ENV[:changing] = 'gavin'
+          RubyFlipper::Feature.find(:patti).should_not be_active
+        end
+
+        it 'should not be active when changing is not gavin when called' do
+          FLIPPER_ENV[:changing] = 'patti'
+          FLIPPER_ENV[:changing] = 'gavin'
+          load_features
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          FLIPPER_ENV[:changing] = 'sue'
+          RubyFlipper::Feature.find(:patti).should_not be_active
+        end
+
+        it 'should be active when changing is patti when loaded, dynamic is floyd when called and changing is gavin when called' do
+          FLIPPER_ENV[:changing] = 'patti'
+          load_features
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          FLIPPER_ENV[:changing] = 'gavin'
+          RubyFlipper::Feature.find(:patti).should be_active
+        end
+
+      end
+
+      context ':sue' do
+
+        it 'should not be active when static is not cherry when loaded and dynamic is not floyd when called' do
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          load_features
+          FLIPPER_ENV[:dynamic] = 'gavin'
+          FLIPPER_ENV[:changing] = 'sue'
+          RubyFlipper::Feature.find(:sue).should_not be_active
+        end
+
+        it 'should not be active when changing is not sue when called' do
+          FLIPPER_ENV[:static] = 'cherry'
+          load_features
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          RubyFlipper::Feature.find(:sue).should_not be_active
+        end
+
+        it 'should be active when static is cherry when loaded and changing is sue when called' do
+          FLIPPER_ENV[:static] = 'cherry'
+          load_features
+          FLIPPER_ENV[:changing] = 'sue'
+          RubyFlipper::Feature.find(:sue).should be_active
+        end
+
+        it 'should be active when dynamic is floyd when called and changing is sue when called' do
+          load_features
+          FLIPPER_ENV[:dynamic] = 'floyd'
+          FLIPPER_ENV[:changing] = 'sue'
+          RubyFlipper::Feature.find(:sue).should be_active
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler.require(:default, :development)
+
+FLIPPER_ENV = {}
+
+Rspec.configure do |config|
+  config.mock_with :mocha
+  config.after(:each) do
+    RubyFlipper.reset
+    FLIPPER_ENV.clear
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification 
+name: ruby_flipper
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Thomas Jachmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-13 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ci_reporter
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 6
+        - 3
+        version: 1.6.3
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 0
+        - 9
+        - 10
+        version: 0.9.10
+  type: :development
+  version_requirements: *id003
+description: Most flexible still least verbose feature flipper for ruby projects.
+email: 
+- self@thomasjachmann.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- autotest/discover.rb
+- lib/ruby_flipper.rb
+- lib/ruby_flipper/condition_context.rb
+- lib/ruby_flipper/dsl.rb
+- lib/ruby_flipper/feature.rb
+- lib/ruby_flipper/object_mixin.rb
+- ruby_flipper.gemspec
+- spec/fixtures/features.rb
+- spec/ruby_flipper/condition_context_spec.rb
+- spec/ruby_flipper/dsl_spec.rb
+- spec/ruby_flipper/feature_spec.rb
+- spec/ruby_flipper/object_mixin_spec.rb
+- spec/ruby_flipper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/blaulabs/ruby_flipper
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ruby_flipper
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Make switching features on and off easy.
+test_files: 
+- spec/fixtures/features.rb
+- spec/ruby_flipper/condition_context_spec.rb
+- spec/ruby_flipper/dsl_spec.rb
+- spec/ruby_flipper/feature_spec.rb
+- spec/ruby_flipper/object_mixin_spec.rb
+- spec/ruby_flipper_spec.rb
+- spec/spec_helper.rb