flip_fork 0.1.0

data/lib/flip/facade.rb

@@ -0,0 +1,18 @@
+module Flip
+  module Facade
+
+    def on?(feature)
+      FeatureSet.instance.on? feature
+    end
+
+    def reset
+      FeatureSet.reset
+    end
+
+    def method_missing(method, *parameters)
+      super unless method =~ %r{^(.*)\?$}
+      FeatureSet.instance.on? $1.to_sym
+    end
+
+  end
+end

data/lib/flip/feature_set.rb

@@ -0,0 +1,57 @@
+module Flip
+  class FeatureSet
+
+    def self.instance
+      @instance ||= self.new
+    end
+
+    def self.reset
+      @instance = nil
+    end
+
+    # Sets the default for definitions which fall through the strategies.
+    # Accepts boolean or a Proc to be called.
+    attr_writer :default
+
+    def initialize
+      @definitions = Hash.new { |_, k| raise "No feature declared with key #{k.inspect}" }
+      @strategies = Hash.new { |_, k| raise "No strategy named #{k}" }
+      @default = false
+    end
+
+    # Whether the given feature is switched on.
+    def on? key
+      d = @definitions[key]
+      @strategies.each_value { |s| return s.on?(d) if s.knows?(d) }
+      default_for d
+    end
+
+    # Adds a feature definition to the set.
+    def << definition
+      @definitions[definition.key] = definition
+    end
+
+    # Adds a strategy for determing feature status.
+    def add_strategy(strategy)
+      strategy = strategy.new if strategy.is_a? Class
+      @strategies[strategy.name] = strategy
+    end
+
+    def strategy(klass)
+      @strategies[klass]
+    end
+
+    def default_for(definition)
+      @default.is_a?(Proc) ? @default.call(definition) : @default
+    end
+
+    def definitions
+      @definitions.values
+    end
+
+    def strategies
+      @strategies.values
+    end
+
+  end
+end

data/lib/flip/forbidden.rb

@@ -0,0 +1,7 @@
+module Flip
+  class Forbidden < StandardError
+    def initialize(key)
+      super("requires :#{key} feature")
+    end
+  end
+end

data/lib/flip/version.rb

@@ -0,0 +1,3 @@
+module Flip
+  VERSION = "0.1.0"
+end

data/lib/flip.rb

@@ -0,0 +1,27 @@
+# ActiveSupport dependencies.
+%w{
+  concern
+  inflector
+  core_ext/hash/reverse_merge
+  core_ext/object/blank
+}.each { |name| require "active_support/#{name}" }
+
+# Flip files.
+%w{
+  abstract_strategy
+  controller_filters
+  cookie_strategy
+  database_strategy
+  declarable
+  declaration_strategy
+  definition
+  facade
+  feature_set
+  forbidden
+}.each { |name| require "flip/#{name}" }
+
+require "flip/engine" if defined?(Rails)
+
+module Flip
+  extend Facade
+end

data/lib/generators/flip/install/install_generator.rb

@@ -0,0 +1,9 @@
+class Flip::InstallGenerator < Rails::Generators::Base
+
+  def invoke_generators
+    %w{ model migration routes }.each do |name|
+      generate "flip:#{name}"
+    end
+  end
+
+end

data/lib/generators/flip/migration/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Generates migration to create the features table for the Feature model.
+
+Example:
+    rails generate flip:migration

data/lib/generators/flip/migration/migration_generator.rb

@@ -0,0 +1,22 @@
+require "rails/generators/active_record/migration"
+
+class Flip::MigrationGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  source_root File.expand_path("../templates", __FILE__)
+
+  def create_migration_file
+    migration_template "create_features.rb", "db/migrate/create_features.rb"
+  end
+
+  # Stubbed in railties/lib/rails/generators/migration.rb
+  #
+  # This implementation a simplified version of:
+  #   activerecord/lib/rails/generators/active_record/migration.rb
+  #
+  # See: http://www.ruby-forum.com/topic/203205
+  def self.next_migration_number(dirname)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+end

data/lib/generators/flip/migration/templates/create_features.rb

@@ -0,0 +1,10 @@
+class CreateFeatures < ActiveRecord::Migration
+  def change
+    create_table :features do |t|
+      t.string :key, null: false
+      t.boolean :enabled, null: false, default: false
+
+      t.timestamps null: false
+    end
+  end
+end

data/lib/generators/flip/model/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates the Feature database model class for Flip.
+
+Example:
+    rails generate flip:model
+
+    This will create:
+        app/models/feature.rb (class Feature < ActiveRecord::Base)

data/lib/generators/flip/model/model_generator.rb

@@ -0,0 +1,8 @@
+class Flip::ModelGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+
+  def copy_feature_model_file
+    copy_file "feature.rb", "app/models/feature.rb"
+  end
+
+end

data/lib/generators/flip/model/templates/feature.rb

@@ -0,0 +1,15 @@
+class Feature < ActiveRecord::Base
+  extend Flip::Declarable
+
+  strategy Flip::CookieStrategy
+  strategy Flip::DatabaseStrategy
+  strategy Flip::DeclarationStrategy
+  default false
+
+  # Declare your features here, e.g:
+  #
+  # feature :world_domination,
+  #   default: true,
+  #   description: "Take over the world."
+
+end

data/lib/generators/flip/routes/USAGE

@@ -0,0 +1,7 @@
+Description:
+    Add routes for the Flip control page.
+
+Example:
+    rails generate flip:routes
+
+    This will add routes to app/routes.rb

data/lib/generators/flip/routes/routes_generator.rb

@@ -0,0 +1,7 @@
+class Flip::RoutesGenerator < Rails::Generators::Base
+
+  def add_route
+    route %{mount Flip::Engine => "/flip"}
+  end
+
+end

data/spec/abstract_strategy_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+# Perhaps this is silly, but it provides some
+# coverage to an important base class.
+describe Flip::AbstractStrategy do
+
+  its(:name) { should == "abstract" }
+  its(:description) { should == "" }
+  it { should_not be_switchable }
+
+end

data/spec/controller_filters_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+class ControllerWithFlipFilters
+  include Flip::ControllerFilters
+end
+
+describe ControllerWithFlipFilters do
+
+  describe ".require_feature" do
+
+    it "adds before_filter without options" do
+      ControllerWithFlipFilters.tap do |klass|
+        klass.should_receive(:before_filter).with({})
+        klass.send(:require_feature, :testable)
+      end
+    end
+
+    it "adds before_filter with options" do
+      ControllerWithFlipFilters.tap do |klass|
+        klass.should_receive(:before_filter).with({ only: [ :show ] })
+        klass.send(:require_feature, :testable, only: [ :show ])
+      end
+    end
+
+  end
+
+end

data/spec/cookie_strategy_spec.rb

@@ -0,0 +1,112 @@
+require "spec_helper"
+
+class ControllerWithoutCookieStrategy; end
+class ControllerWithCookieStrategy
+  def self.before_filter(_); end
+  def self.after_filter(_); end
+  def cookies; []; end
+  include Flip::CookieStrategy::Loader
+end
+
+describe Flip::CookieStrategy do
+
+  let(:cookies) do
+    { strategy.cookie_name(:one) => "true",
+      strategy.cookie_name(:two) => "false" }
+  end
+  let(:strategy) do
+    Flip::CookieStrategy.new.tap do |s|
+      s.stub(:cookies) { cookies }
+    end
+  end
+
+  its(:description) { should be_present }
+  it { should be_switchable }
+
+  describe "cookie interrogration" do
+    context "enabled feature" do
+      specify "#knows? is true" do
+        strategy.knows?(:one).should be_true
+      end
+      specify "#on? is true" do
+        strategy.on?(:one).should be_true
+      end
+    end
+    context "disabled feature" do
+      specify "#knows? is true" do
+        strategy.knows?(:two).should be_true
+      end
+      specify "#on? is false" do
+        strategy.on?(:two).should be_false
+      end
+    end
+    context "feature with no cookie present" do
+      specify "#knows? is false" do
+        strategy.knows?(:three).should be_false
+      end
+      specify "#on? is false" do
+        strategy.on?(:three).should be_false
+      end
+    end
+  end
+
+  describe "cookie manipulation" do
+    it "can switch known features on" do
+      strategy.switch! :one, true
+      strategy.on?(:one).should be_true
+    end
+    it "can switch unknown features on" do
+      strategy.switch! :three, true
+      strategy.on?(:three).should be_true
+    end
+    it "can switch features off" do
+      strategy.switch! :two, false
+      strategy.on?(:two).should be_false
+    end
+    it "can delete knowledge of a feature" do
+      strategy.delete! :one
+      strategy.on?(:one).should be_false
+      strategy.knows?(:one).should be_false
+    end
+  end
+
+end
+
+describe Flip::CookieStrategy::Loader do
+
+  it "adds filters when included in controller" do
+    ControllerWithoutCookieStrategy.tap do |klass|
+      klass.should_receive(:before_filter).with(:flip_cookie_strategy_before)
+      klass.should_receive(:after_filter).with(:flip_cookie_strategy_after)
+      klass.send :include, Flip::CookieStrategy::Loader
+    end
+  end
+
+  describe "filter methods" do
+    let(:strategy) { Flip::CookieStrategy.new }
+    let(:controller) { ControllerWithCookieStrategy.new }
+    describe "#flip_cookie_strategy_before" do
+      it "passes controller cookies to CookieStrategy" do
+        controller.should_receive(:cookies).and_return(strategy.cookie_name(:test) => "true")
+        expect {
+          controller.flip_cookie_strategy_before
+        }.to change {
+          [ strategy.knows?(:test), strategy.on?(:test) ]
+        }.from([false, false]).to([true, true])
+      end
+    end
+    describe "#flip_cookie_strategy_after" do
+      before do
+        Flip::CookieStrategy.cookies = { strategy.cookie_name(:test) => "true" }
+      end
+      it "passes controller cookies to CookieStrategy" do
+        expect {
+          controller.flip_cookie_strategy_after
+        }.to change {
+          [ strategy.knows?(:test), strategy.on?(:test) ]
+        }.from([true, true]).to([false, false])
+      end
+    end
+  end
+
+end

data/spec/database_strategy_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+describe Flip::DatabaseStrategy do
+
+  let(:definition) { double("definition").tap{ |d| d.stub(:key) { :one } } }
+  let(:strategy) { Flip::DatabaseStrategy.new(model_klass) }
+  let(:model_klass) do
+    Class.new do
+      extend Flip::Declarable
+      feature :one
+      feature :two, description: "Second one."
+      feature :three, default: true
+    end
+  end
+  let(:enabled_record) { model_klass.new.tap { |m| m.stub(:enabled?) { true } } }
+  let(:disabled_record) { model_klass.new.tap { |m| m.stub(:enabled?) { false } } }
+
+  subject { strategy }
+
+  its(:switchable?) { should be_true }
+  its(:description) { should be_present }
+
+  describe "#knows?" do
+    it "does not know features that cannot be found" do
+      model_klass.stub(:find_by_key) { nil }
+      strategy.knows?(definition).should be_false
+    end
+    it "knows features that can be found" do
+      model_klass.stub(:find_by_key) { disabled_record }
+      strategy.knows?(definition).should be_true
+    end
+  end
+
+  describe "#on?" do
+    it "is true for an enabled record from the database" do
+      model_klass.stub(:find_by_key) { enabled_record }
+      strategy.on?(definition).should be_true
+    end
+    it "is false for a disabled record from the database" do
+      model_klass.stub(:find_by_key) { disabled_record }
+      strategy.on?(definition).should be_false
+    end
+  end
+
+  describe "#switch!" do
+    it "can switch a feature on" do
+      model_klass.should_receive(:find_or_initialize_by_key).with('one').and_return(disabled_record)
+      disabled_record.should_receive(:update_attributes!).with(enabled: true)
+      strategy.switch! :one, true
+    end
+    it "can switch a feature off" do
+      model_klass.should_receive(:find_or_initialize_by_key).with('one').and_return(enabled_record)
+      enabled_record.should_receive(:update_attributes!).with(enabled: false)
+      strategy.switch! :one, false
+    end
+  end
+
+  describe "#delete!" do
+    it "can delete a feature record" do
+      model_klass.should_receive(:find_by_key).with('one').and_return(enabled_record)
+      enabled_record.should_receive(:try).with(:destroy)
+      strategy.delete! :one
+    end
+  end
+
+end

data/spec/declarable_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Flip::Declarable do
+
+  let!(:model_class) do
+    Class.new do
+      extend Flip::Declarable
+
+      strategy Flip::DeclarationStrategy
+      default false
+
+      feature :one
+      feature :two, description: "Second one."
+      feature :three, default: true
+    end
+  end
+
+  subject { Flip::FeatureSet.instance }
+
+  describe "the .on? class method" do
+    context "with default set to false" do
+      it { should_not be_on(:one) }
+      it { should be_on(:three) }
+    end
+    context "with default set to true" do
+      before(:all) { model_class.send(:default, true) }
+      it { should be_on(:one) }
+      it { should be_on(:three) }
+    end
+  end
+
+end

data/spec/declaration_strategy_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Flip::DeclarationStrategy do
+
+  def definition(default)
+    Flip::Definition.new :feature, default: default
+  end
+
+  describe "#knows?" do
+    it "does not know definition with no default specified" do
+      subject.knows?(Flip::Definition.new :feature).should be_false
+    end
+    it "does not know definition with default of nil" do
+      subject.knows?(definition(nil)).should be_false
+    end
+    it "knows definition with default set to true" do
+      subject.knows?(definition(true)).should be_true
+    end
+    it "knows definition with default set to false" do
+      subject.knows?(definition(false)).should be_true
+    end
+  end
+
+  describe "#on? for Flip::Definition" do
+    subject { Flip::DeclarationStrategy.new.on? definition(default) }
+    [
+      { default: true, result: true },
+      { default: false, result: false },
+      { default: proc { true }, result: true, name: "proc returning true" },
+      { default: proc { false }, result: false, name: "proc returning false" },
+    ].each do |parameters|
+      context "with default of #{parameters[:name] || parameters[:default]}" do
+        let(:default) { parameters[:default] }
+        it { should == parameters[:result] }
+      end
+    end
+  end
+
+end

data/spec/definition_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Flip::Definition do
+
+  subject { Flip::Definition.new :the_key, description: "The description" }
+
+  [:key, :name, :to_s].each do |method|
+    its(method) { should == :the_key }
+  end
+
+  its(:description) { should == "The description" }
+  its(:options) { should == { description: "The description" } }
+
+  context "without description specified" do
+    subject { Flip::Definition.new :the_key }
+    its(:description) { should == "The key." }
+  end
+
+end

data/spec/feature_set_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+class NullStrategy < Flip::AbstractStrategy
+  def knows?(d); false; end
+end
+
+class TrueStrategy < Flip::AbstractStrategy
+  def knows?(d); true; end
+  def on?(d); true; end
+end
+
+describe Flip::FeatureSet do
+
+  let :feature_set_with_null_strategy do
+    Flip::FeatureSet.new.tap do |s|
+      s << Flip::Definition.new(:feature)
+      s.add_strategy NullStrategy
+    end
+  end
+
+  let :feature_set_with_null_then_true_strategies do
+    feature_set_with_null_strategy.tap do |s|
+      s.add_strategy TrueStrategy
+    end
+  end
+
+  describe ".instance" do
+    it "returns a singleton instance" do
+      Flip::FeatureSet.instance.should equal(Flip::FeatureSet.instance)
+    end
+    it "can be reset" do
+      instance_before_reset = Flip::FeatureSet.instance
+      Flip::FeatureSet.reset
+      Flip::FeatureSet.instance.should_not equal(instance_before_reset)
+    end
+    it "can be reset multiple times without error" do
+      2.times { Flip::FeatureSet.reset }
+    end
+  end
+
+  describe "#default= and #on? with null strategy" do
+    subject { feature_set_with_null_strategy }
+    it "defaults to false" do
+      subject.on?(:feature).should be_false
+    end
+    it "can default to true" do
+      subject.default = true
+      subject.on?(:feature).should be_true
+    end
+    it "accepts a proc returning true" do
+      subject.default = proc { true }
+      subject.on?(:feature).should be_true
+    end
+    it "accepts a proc returning false" do
+      subject.default = proc { false }
+      subject.on?(:feature).should be_false
+    end
+  end
+
+  describe "feature set with null strategy then always-true strategy" do
+    subject { feature_set_with_null_then_true_strategies }
+    it "returns true due to second strategy" do
+      subject.on?(:feature).should be_true
+    end
+  end
+
+end

data/spec/flip_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Flip do
+
+  before(:all) do
+    Class.new do
+      extend Flip::Declarable
+      strategy Flip::DeclarationStrategy
+      default false
+      feature :one, default: true
+      feature :two, default: false
+    end
+  end
+
+  after(:all) do
+    Flip.reset
+  end
+
+  describe ".on?" do
+    it "returns true for enabled features" do
+      Flip.on?(:one).should be_true
+    end
+    it "returns false for disabled features" do
+      Flip.on?(:two).should be_false
+    end
+  end
+
+  describe "dynamic predicate methods" do
+    its(:one?) { should be_true }
+    its(:two?) { should be_false }
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "flip"