active_record_rollout 0.0.1

data/lib/active_record/rollout/flag.rb

@@ -0,0 +1,13 @@
+# Indicates that a specific feature has been rolled out to an individual
+# Table for storing flaggable flag-ins, group flag-ins, or percentage-based
+# flag-ins.
+class ActiveRecord::Rollout::Flag < ActiveRecord::Base
+  self.table_name = :active_record_rollout_flags
+
+  belongs_to :feature
+
+  validates :feature_id, presence: true
+  validates :flaggable_type, presence: true
+
+  attr_accessible :flaggable_type
+end

data/lib/active_record/rollout/flaggable.rb

@@ -0,0 +1,66 @@
+module ActiveRecord::Rollout::Flaggable
+  module ClassMethods
+    # Finds a record by the field set by the :find_by param in
+    # `acts_as_flaggable`. If no :find_by param was provided, :id is used.
+    #
+    # @param [String,Integer] value The value to find the record by.
+    def flaggable_find!(value)
+      send("find_by_#{@active_record_rollout_flaggable_find_by}!", value)
+    end
+  end
+
+  # Returns whether or not the object has access to the given feature. If given
+  # a block, it will call the block if the user has access to the feature.
+  #
+  # If an exception is raised in the block, it will increment the
+  # `failure_count` of the feature and raise the exception.
+  #
+  # @example
+  #   # Exceptions will be tracked in the `failure_count` of :new_user_interface.
+  #   user.has_feature?(:new_user_interface) do
+  #     # ...
+  #   end
+  #
+  # @example
+  #   # Exceptions will *not* be tracked in the `failure_count` of :new_user_interface.
+  #   if user.has_feature?(:new_user_interface)
+  #     # ...
+  #   end
+  #
+  # @param [Symbol] feature_name The name of the
+  #   {ActiveRecord::Rollout::Feature Feature} being checked.
+  # @param [Proc] &block A block to be called if the user is flagged in to the
+  #   feature.
+  def has_feature?(feature_name, &block)
+    if active_record_rollout_features.include? feature_name.to_s
+      match = true
+    else
+      feature = ActiveRecord::Rollout::Feature.find_by_name(feature_name)
+      return false unless feature
+
+      opt_out = opt_out_flags.find_by_feature_id(feature.id)
+      return false if opt_out
+
+      match = feature.match? self
+
+      if match
+        active_record_rollout_features << feature.name.to_s
+      end
+    end
+
+    if match && block_given?
+      begin
+        yield
+      rescue => e
+        feature.increment! :failure_count
+        raise e
+      end
+    end
+
+    match
+  end
+
+  def active_record_rollout_features
+    @active_record_rollout_features ||= []
+  end
+end

data/lib/active_record/rollout/flaggable_flag.rb

@@ -0,0 +1,9 @@
+# An individual record of a certain type may be flagged into a feature with
+# this class.
+class ActiveRecord::Rollout::FlaggableFlag < ActiveRecord::Rollout::Flag
+  belongs_to :flaggable, polymorphic: true
+
+  validates :flaggable_id, presence: true
+
+  attr_accessible :flaggable
+end

data/lib/active_record/rollout/group_flag.rb

@@ -0,0 +1,7 @@
+# A group of flaggable records of a given class may be flagged into a feature
+# with this class.
+class ActiveRecord::Rollout::GroupFlag < ActiveRecord::Rollout::Flag
+  validates :group_name, presence: true
+
+  attr_accessible :group_name
+end

data/lib/active_record/rollout/opt_out_flag.rb

@@ -0,0 +1,9 @@
+# Ensures that a feature will never be available to the associated record,
+# even in the case of, for example, a 100% flag.
+class ActiveRecord::Rollout::OptOutFlag < ActiveRecord::Rollout::Flag
+  belongs_to :flaggable, polymorphic: true
+
+  validates :flaggable_id, presence: true
+
+  attr_accessible :flaggable
+end

data/lib/active_record/rollout/percentage_flag.rb

@@ -0,0 +1,11 @@
+# A percentage of flaggable records of a given class may be flagged into a feature
+# with this class.
+class ActiveRecord::Rollout::PercentageFlag < ActiveRecord::Rollout::Flag
+  validates :percentage,
+    presence: true,
+    numericality: { greater_than: 0, less_than_or_equal_to: 100 }
+
+  validates :feature_id, uniqueness: { scope: :flaggable_type }
+
+  attr_accessible :percentage
+end

data/lib/active_record/rollout/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  class Rollout
+    VERSION = "0.0.1"
+  end
+end

data/lib/generators/active_record_rollout_generator.rb

@@ -0,0 +1,20 @@
+require "active_record/rollout"
+require "rails/generators"
+require "rails/generators/active_record"
+
+class ActiveRecordRolloutGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  extend ActiveRecord::Generators::Migration
+
+  source_root File.expand_path("../templates", __FILE__)
+
+  desc "Creates migration for ActiveRecord::Rollout"
+  def create_migration_file
+    migration_template "migration.rb", "db/migrate/setup_active_record_rollout.rb"
+  end
+
+  desc "Sets up an initializer for ActiveRecord::Rollout"
+  def create_initializer
+    copy_file "active_record_rollout.rb", "config/initializers/active_record_rollout.rb"
+  end
+end

data/lib/generators/templates/active_record_rollout.rb

@@ -0,0 +1,5 @@
+ActiveRecord::Rollout.configure do |config|
+  # config.define_user_group :admins do |user|
+  #   user.admin?
+  # end
+end

data/lib/generators/templates/migration.rb

@@ -0,0 +1,24 @@
+class SetupActiveRecordRollout < ActiveRecord::Migration
+  def change
+    create_table :active_record_rollout_features do |t|
+      t.string :name
+      t.integer :failure_count, default: 0
+      t.timestamps
+    end
+
+    add_index :active_record_rollout_features, :name, unique: true
+
+    create_table :active_record_rollout_flags do |t|
+      t.string  :type
+      t.integer :feature_id
+      t.integer :flaggable_id
+      t.string  :flaggable_type
+      t.string  :group_name
+      t.integer :percentage
+      t.timestamps
+    end
+
+    add_index :active_record_rollout_flags, :type
+    add_index :active_record_rollout_flags, :feature_id
+  end
+end

data/lib/tasks/rollout.rake

@@ -0,0 +1,119 @@
+namespace :rollout do
+  desc "Create a feature"
+  task :create, [:feature] => :environment do |task, args|
+    ActiveRecord::Rollout::Feature.find_or_create_by_name! args[:feature]
+  end
+
+  desc "Destroy a feature"
+  task :destroy, [:feature] => :environment do |task, args|
+    feature = ActiveRecord::Rollout::Feature.find_by_name! args[:feature]
+    feature.destroy
+  end
+
+  desc "Activate a feature for a record"
+  task :activate, [:feature, :flaggable_type, :flaggable_id] => :environment do |task, args|
+    if args.to_a.length < 3 && ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      klass = ActiveRecord::Rollout::Feature.default_flaggable_class_name.constantize
+      record_locator = args[:flaggable_type]
+    else
+      klass = args[:flaggable_type].constantize
+      record_locator = args[:flaggable_id]
+    end
+
+    record = klass.flaggable_find! record_locator
+
+    ActiveRecord::Rollout::Feature.add_record_to_feature record, args[:feature]
+  end
+
+  desc "Deactivate a feature for a record"
+  task :deactivate, [:feature, :flaggable_type, :flaggable_id] => :environment do |task, args|
+    if args.to_a.length < 3 && ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      klass = ActiveRecord::Rollout::Feature.default_flaggable_class_name.constantize
+      record_locator = args[:flaggable_type]
+    else
+      klass = args[:flaggable_type].constantize
+      record_locator = args[:flaggable_id]
+    end
+
+    record = klass.flaggable_find! record_locator
+    ActiveRecord::Rollout::Feature.remove_record_from_feature record, args[:feature]
+  end
+
+  desc "Opt a record out of a feature"
+  task :opt_out, [:feature, :flaggable_type, :flaggable_id] => :environment do |task, args|
+    if args.to_a.length < 3 && ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      klass = ActiveRecord::Rollout::Feature.default_flaggable_class_name.constantize
+      record_locator = args[:flaggable_type]
+    else
+      klass = args[:flaggable_type].constantize
+      record_locator = args[:flaggable_id]
+    end
+
+    record = klass.flaggable_find! record_locator
+    ActiveRecord::Rollout::Feature.opt_record_out_of_feature record, args[:feature]
+  end
+
+  desc "Remove an opt out of a record from a feature"
+  task :un_opt_out, [:feature, :flaggable_type, :flaggable_id] => :environment do |task, args|
+    if args.to_a.length < 3 && ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      klass = ActiveRecord::Rollout::Feature.default_flaggable_class_name.constantize
+      record_locator = args[:flaggable_type]
+    else
+      klass = args[:flaggable_type].constantize
+      record_locator = args[:flaggable_id]
+    end
+
+    record = klass.flaggable_find! record_locator
+    ActiveRecord::Rollout::Feature.un_opt_record_out_of_feature record, args[:feature]
+  end
+
+  desc "Activate a feature for a group"
+  task :activate_group, [:feature, :flaggable_type, :group_name] => :environment do |task, args|
+    if args.to_a.length < 3 && ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      klass = ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      group_name = args[:flaggable_type]
+    else
+      klass = args[:flaggable_type]
+      group_name = args[:group_name]
+    end
+
+    ActiveRecord::Rollout::Feature.add_group_to_feature klass, group_name, args[:feature]
+  end
+
+  desc "Deactivate a feature for a group"
+  task :deactivate_group, [:feature, :flaggable_type, :group_name] => :environment do |task, args|
+    if args.to_a.length < 3 && ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      klass = ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      group_name = args[:flaggable_type]
+    else
+      klass = args[:flaggable_type]
+      group_name = args[:group_name]
+    end
+
+    ActiveRecord::Rollout::Feature.remove_group_from_feature klass, group_name, args[:feature]
+  end
+
+  desc "Activate a feature for a percentage"
+  task :activate_percentage, [:feature, :flaggable_type, :percentage] => :environment do |task, args|
+    if args.to_a.length < 3 && ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      klass = ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      percentage = args[:flaggable_type]
+    else
+      klass = args[:flaggable_type]
+      percentage = args[:percentage]
+    end
+
+    ActiveRecord::Rollout::Feature.add_percentage_to_feature klass, percentage.to_i, args[:feature]
+  end
+
+  desc "Deactivate a feature for a percentage"
+  task :deactivate_percentage, [:feature, :flaggable_type] => :environment do |task, args|
+    if args.to_a.length < 3 && ActiveRecord::Rollout::Feature.default_flaggable_class_name
+      klass = ActiveRecord::Rollout::Feature.default_flaggable_class_name
+    else
+      klass = args[:flaggable_type]
+    end
+
+    ActiveRecord::Rollout::Feature.remove_percentage_from_feature klass, args[:feature]
+  end
+end

data/spec/integration/flag_rollout_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe "flag rollouts" do
+  let(:user) { User.create }
+  let(:feature) { ActiveRecord::Rollout::Feature.create(name: "foo") }
+
+  describe "creating a flag rollout" do
+    before do
+      ActiveRecord::Rollout::Feature.add_record_to_feature user, feature.name
+    end
+
+    it "sets the feature on the user" do
+      feature.match_id?(user).should be_true
+    end
+  end
+
+  describe "removing a flag rollout" do
+    before do
+      ActiveRecord::Rollout::Feature.add_record_to_feature user, feature.name
+      ActiveRecord::Rollout::Feature.remove_record_from_feature user, feature.name
+    end
+
+    it "removes the feature from the user" do
+      feature.match_id?(user).should be_false
+    end
+  end
+end

data/spec/integration/group_rollout_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe "group rollouts" do
+  let(:user) { User.create(name: "foo") }
+  let(:feature) { ActiveRecord::Rollout::Feature.create(name: "foo") }
+  let!(:flag) { feature.group_flags.create(flaggable_type: "User", group_name: "foo_users") }
+
+  describe "creating a group rollout" do
+    before do
+      ActiveRecord::Rollout::Feature.define_user_group "foo_users" do |user|
+        user.name == "foo"
+      end
+    end
+
+    it "sets the feature on the user" do
+      feature.match_groups?(user).should be_true
+    end
+  end
+end
+

data/spec/integration/percentage_rollout_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe "percentage rollouts" do
+  let(:users) { 10.times.collect { User.create } }
+  let(:feature) { ActiveRecord::Rollout::Feature.create(name: "foo") }
+  let!(:flag) { feature.percentage_flags.create(flaggable_type: "User", percentage: 20) }
+
+  describe "creating a percentage rollout" do
+    it "makes the feature available to the given percentage of instances" do
+      users.select { |user| feature.match_percentage?(user) }.length.should eq users.length / 5
+    end
+  end
+end

data/spec/lib/active_record/rollout/acts_as_flaggable_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe ActiveRecord::Rollout::ActsAsFlaggable do
+  subject { User.new }
+
+  it { should have_many :flaggable_flags }
+  it { should have_many :opt_out_flags }
+  it { should have_many(:features).through(:flaggable_flags) }
+
+  it "includes ActiveRecord::Rollout::Flaggable" do
+    subject.class.ancestors.should include ActiveRecord::Rollout::Flaggable
+  end
+
+  describe "#acts_as_flaggable" do
+    context "when given a :find_by parameter" do
+      class Foo < ActiveRecord::Base
+        acts_as_flaggable find_by: :email
+      end
+
+      it "sets the appropriate class variable on the class" do
+        Foo.instance_variable_get("@active_record_rollout_flaggable_find_by").should eq :email
+      end
+    end
+
+    context "when not given a :find_by parameter" do
+      it "uses the default :id value for flaggable_find_by" do
+        User.instance_variable_get("@active_record_rollout_flaggable_find_by").should eq :id
+      end
+    end
+  end
+end

data/spec/lib/active_record/rollout/feature_spec.rb

@@ -0,0 +1,235 @@
+require "spec_helper"
+
+describe ActiveRecord::Rollout::Feature do
+  it { should have_many(:flaggable_flags) }
+  it { should have_many(:group_flags) }
+  it { should have_many(:percentage_flags) }
+  it { should have_many(:opt_out_flags) }
+  it { should have_many(:flags).dependent(:destroy) }
+  it { should validate_presence_of :name }
+  it { should validate_uniqueness_of :name }
+  it { should allow_mass_assignment_of :name }
+
+  describe ".define_{klass}_group" do
+    let(:block) { Proc.new {} }
+    it "defines a group for the given class" do
+      ActiveRecord::Rollout::Feature.should_receive(:define_group_for_class).with("User", :id_is_1)
+      ActiveRecord::Rollout::Feature.define_user_group :id_is_1, block
+    end
+  end
+
+  describe ".add_record_to_feature" do
+    let(:user) { User.create }
+    let!(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+
+    before do
+      ActiveRecord::Rollout::Feature.add_record_to_feature user, :foo
+    end
+
+    it "creats a flag for the given instance and feature" do
+      user.features.should include feature
+    end
+  end
+
+  describe ".remove_record_from_feature" do
+    let(:user) { User.create }
+    let!(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+
+    before do
+      ActiveRecord::Rollout::Feature.add_record_to_feature user, :foo
+      ActiveRecord::Rollout::Feature.remove_record_from_feature user, :foo
+    end
+
+    it "creats a flag for the given instance and feature" do
+      user.features.should_not include feature
+    end
+  end
+
+  describe ".opt_record_out_of_feature" do
+    let(:user) { User.create }
+    let!(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+
+    before do
+      ActiveRecord::Rollout::Feature.add_percentage_to_feature "User", 100, "foo"
+      ActiveRecord::Rollout::Feature.opt_record_out_of_feature user, "foo"
+    end
+
+    it "opts the record out of the feature" do
+      user.has_feature?("foo").should be_false
+    end
+  end
+
+  describe ".un_opt_record_out_of_feature" do
+    let(:user) { User.create }
+    let!(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+
+    before do
+      ActiveRecord::Rollout::Feature.add_percentage_to_feature "User", 100, "foo"
+      ActiveRecord::Rollout::Feature.opt_record_out_of_feature user, "foo"
+      ActiveRecord::Rollout::Feature.un_opt_record_out_of_feature user, "foo"
+    end
+
+    it "opts the record out of the feature" do
+      user.has_feature?("foo").should be_true
+    end
+  end
+
+  describe ".add_group_to_feature" do
+    let!(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+
+    before do
+      ActiveRecord::Rollout::Feature.define_user_group :bar do
+      end
+      ActiveRecord::Rollout::Feature.add_group_to_feature "User", :bar, "foo"
+    end
+
+    it "creates a flag for the given group and feature" do
+      feature.group_flags.where(flaggable_type: "User", group_name: "bar").first.should_not be_nil
+    end
+  end
+
+  describe ".remove_group_from_feature" do
+    let!(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+
+    before do
+      ActiveRecord::Rollout::Feature.define_user_group :bar do
+      end
+      ActiveRecord::Rollout::Feature.add_group_to_feature "User", :bar, "foo"
+      ActiveRecord::Rollout::Feature.remove_group_from_feature "User", :bar, "foo"
+    end
+
+    it "destroys flags for the given group and feature" do
+      feature.group_flags.where(flaggable_type: "User", group_name: "bar").first.should be_nil
+    end
+  end
+
+  describe ".add_percentage_to_feature" do
+    let!(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+
+    before do
+      ActiveRecord::Rollout::Feature.add_percentage_to_feature "User", 50, "foo"
+    end
+
+    it "creates a flag for the given percentage and feature" do
+      feature.percentage_flags.where(flaggable_type: "User", percentage: 50).first.should_not be_nil
+    end
+  end
+
+  describe ".remove_percentage_from_feature" do
+    let!(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+
+    before do
+      ActiveRecord::Rollout::Feature.add_percentage_to_feature "User", 50, "foo"
+      ActiveRecord::Rollout::Feature.remove_percentage_from_feature "User", "foo"
+    end
+
+    it "creates a flag for the given percentage and feature" do
+      feature.percentage_flags.where(flaggable_type: "User").first.should be_nil
+    end
+  end
+
+  describe ".define_group_for_class" do
+    let(:block) { Proc.new {} }
+    before do
+      ActiveRecord::Rollout::Feature.send :define_group_for_class, "User", "user_id_1", &block
+    end
+
+    it "defines a group for the given class" do
+      ActiveRecord::Rollout::Feature.defined_groups["User"].should eq({ "user_id_1" => block })
+    end
+  end
+
+  describe "#match?" do
+    let(:user) { User.create }
+    let(:feature) { ActiveRecord::Rollout::Feature.create(name: "foo") }
+
+    it "checks if the user is flagged individually" do
+      feature.should_receive(:match_id?).with(user)
+      feature.match?(user)
+    end
+
+    it "checks if the user is flagged as part of a percentage" do
+      feature.should_receive(:match_percentage?).with(user)
+      feature.match?(user)
+    end
+
+    it "checks if the user is flagged as part of a group" do
+      feature.should_receive(:match_groups?).with(user)
+      feature.match?(user)
+    end
+  end
+
+  describe "#match_id?" do
+    let(:user) { User.create }
+    let(:user2) { User.create }
+    let!(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+
+    before do
+      ActiveRecord::Rollout::Feature.add_record_to_feature user, :foo
+    end
+
+    context "when the feature exists for the instance" do
+      it "returns true" do
+        feature.match_id?(user).should be_true
+      end
+    end
+
+    context "when the feature does not exist for the instance" do
+      it "returns false" do
+        feature.match_id?(user2).should be_false
+      end
+    end
+  end
+
+  describe "#match_percentage?" do
+    let(:user) { User.create }
+    let(:feature) { ActiveRecord::Rollout::Feature.create!(name: "foo") }
+    let!(:flag) { feature.percentage_flags.create(flaggable_type: "User", percentage: 50) }
+
+    context "when the user's ID matches `id % 10 < percentage / 10" do
+      it "returns true" do
+        user.stub(:id) { 1 }
+        feature.match_percentage?(user).should be_true
+      end
+    end
+
+    context "when the user's ID does not match `id % 10 < percentage / 10" do
+      it "returns false" do
+        user.stub(:id) { 5 }
+        feature.match_percentage?(user).should be_false
+      end
+    end
+  end
+
+  describe "#match_groups?" do
+    let!(:user) { User.create(name: "foo") }
+    let!(:user2) { User.create(name: "bar") }
+    let!(:organization) { Organization.create(name: "foo") }
+    let(:feature) { ActiveRecord::Rollout::Feature.create!(name: "baz") }
+    let!(:flag) { feature.group_flags.create(flaggable_type: "User", group_name: "foo_users") }
+
+    before do
+      ActiveRecord::Rollout::Feature.define_user_group "foo_users" do |user|
+        user.name == "foo"
+      end
+    end
+
+    context "when the instance matches the block" do
+      it "returns true" do
+        feature.match_groups?(user).should be_true
+      end
+    end
+
+    context "when the instance does not match the block" do
+      it "returns false" do
+        feature.match_groups?(user2).should be_false
+      end
+    end
+
+    context "when the instance is not of the type of the block" do
+      it "returns false" do
+        feature.match_groups?(organization).should be_false
+      end
+    end
+  end
+end