ar_rollout 0.0.20 → 0.0.21

data/lib/ar_rollout.rb

@@ -3,87 +3,120 @@ require 'ar_rollout/group.rb'
 require 'ar_rollout/membership.rb'
 require 'ar_rollout/opt_out.rb'
 require 'ar_rollout/helper.rb'
+
 module ArRollout
   @@defined_groups = []
+  @@scanned_features = nil
 
   def self.configure
     yield self
   end
 
-  def self.defined_groups
-    @@defined_groups
+  def self.activate_user(feature, user)
+    permit_user(feature, user)
+    Rollout.find_or_create_by_name_and_user_id!(feature, get_id(user))
   end
 
-  def self.groups
-    (@@defined_groups + Group.select(:name).collect(&:name).collect(&:intern)).uniq.sort
+  def self.deactivate_user(feature, user)
+    Rollout.find_all_by_name_and_user_id(feature, get_id(user)).each(&:destroy)
   end
 
-  def self.define_group(name, &block)
-    @@defined_groups << name
+  def self.omit_user(feature, user)
+    OptOut.find_or_create_by_feature_and_user_id!(feature, get_id(user))
+  end
 
-    Rollout.send :define_method, "match_#{name}?" do |b|
-      block.call(b)
+  def self.permit_user(feature, user)
+    OptOut.find_by_feature_and_user_id(feature, get_id(user)).try(:destroy)
+  end
+
+  def self.activate_group(feature, group)
+    unless defined_groups.include?(group) || Group.find_by_name(group)
+      Group.create!(name: group)
     end
+
+    Rollout.find_or_create_by_name_and_group!(feature, group)
   end
 
-  def self.activate_user(feature, user)
-    return false if feature.nil? || user.nil?
-    res_id = [Fixnum, String].include?(user.class) ? user : user.id
-    Rollout.find_or_create_by_name_and_user_id(feature, res_id)
+  def self.deactivate_group(feature, group)
+    Rollout.find_all_by_name_and_group(feature, group).each(&:destroy)
   end
 
-  def self.deactivate_user(feature, user)
-    res_id = [Fixnum, String].include?(user.class) ? user : user.id
-    Rollout.find_all_by_name_and_user_id(feature, res_id).map(&:destroy)
+  def self.activate_percentage(feature, percentage)
+    Rollout.where(name: feature).where('"percentage" IS NOT NULL').each(&:destroy)
+    Rollout.create!(name: feature, percentage: percentage)
   end
 
-  def self.exclude_user(feature, user)
-    res_id = [Fixnum, String].include?(user.class) ? user : user.id
-    OptOut.create(feature: feature, user_id: res_id)
+  def self.deactivate_percentage(feature)
+    Rollout.where(name: feature).where('"percentage" IS NOT NULL').each(&:destroy)
   end
 
-  def self.activate_group(feature, group)
-    return false if feature.nil? || group.nil?
-    unless defined_groups.include? group
-      get_group(group)
-    end
-    Rollout.find_or_create_by_name_and_group(feature, group)
+  def self.deactivate(feature)
+    Rollout.where(name: feature).destroy_all
+    OptOut.where(feature: feature).destroy_all
   end
 
-  def self.deactivate_group(feature, group)
-    Rollout.find_all_by_name_and_group(feature, group).map(&:destroy)
+  def self.data_groups
+    Group.all
   end
 
-  def self.activate_percentage(feature, percentage)
-    Rollout.where("name = ? and percentage is not null", feature).destroy_all
-    Rollout.create(name: feature, percentage: percentage)
+  def self.defined_groups
+    @@defined_groups
+  end
+
+  def self.groups
+    (defined_groups + data_groups.collect(&:name).collect(&:intern)).uniq.sort
+  end
+
+  def self.active_groups
+    Rollout.where('"group" IS NOT NULL').collect(&:group).uniq.sort
   end
 
   def self.get_group(group)
-    Group.find_or_create_by_name(group)
+    Group.find_or_create_by_name!(group) unless defined_groups.include?(group.intern)
   end
 
-  def self.activate_user_in_group(group, user)
-    res_id = [Fixnum, String].include?(user.class) ? user : user.id
-    Membership.find_or_create_by_group_id_and_user_id(get_group(group).id, res_id)
+  def self.create_group(group)
+    get_group(group)
   end
 
-  def self.deactivate_all(feature)
-    Rollout.find_all_by_name(feature).map(&:destroy)
+  def self.change_group_name(old_name, new_name)
+    if group = Group.find_by_name(old_name)
+      group.update_attributes!(name: new_name)
+      Rollout.find_all_by_group(old_name).each { |rollout| rollout.update_attributes!(group: new_name) }
+    end
   end
 
-  def self.features
-    Rollout.select("distinct(name)").order(:name).map(&:name)
+  def self.add_user_to_group(group, user)
+    Membership.find_or_create_by_group_id_and_user_id!(get_group(group).id, get_id(user))
   end
 
-  def self.active_groups
-    Rollout.where("'group' is NOT NULL").map(&:group).uniq
+  def self.remove_user_from_group(group, user)
+    Membership.find_by_group_id_and_user_id(get_group(group).id, get_id(user)).try(&:destroy)
+  end
+
+  def self.delete_group(group)
+    Group.find_by_name(group).try(:destroy)
+  end
+
+  def self.define_group(name, &block)
+    @@defined_groups << name
+
+    Rollout.send :define_method, "match_#{name}?" do |b|
+      block.call(b)
+    end
+  end
+
+  def self.features
+    scanned_feature_names = scanned_features.collect { |scanned_feature| scanned_feature[0] }
+    Rollout.select('distinct("name")').where('"name" not in (?)', scanned_feature_names).inject(scanned_feature_names) do |arr, rollout|
+      arr << rollout.name
+    end.sort
   end
 
   def self.active?(name, user)
     return false unless user
-    unless OptOut.where(feature: name, user_id: user.id).any?
-      Rollout.where(name: name).where("user_id = ? or user_id is NULL", user.id.to_i).any? do |rollout|
+    unless OptOut.where(feature: name, user_id: get_id(user)).any?
+      Rollout.where(name: name).where('"user_id" = ? OR user_id IS NULL', get_id(user)).any? do |rollout|
         rollout.match?(user)
       end
     end
@@ -92,44 +125,36 @@ module ArRollout
   def self.all_active(user)
     return false unless user
     rollouts = []
-    Rollout.where("user_id = ? or user_id is NULL", user.id.to_i).each do |rollout|
+    Rollout.where("user_id = ? or user_id is NULL", user.id).each do |rollout|
       unless OptOut.where(feature: rollout.name, user_id: user.id).any?
         rollouts << rollout.name if rollout.match?(user)
       end
     end
-    rollouts.uniq
+    rollouts.uniq.sort
   end
 
-  def self.degrade_feature(name)
-    yield
-  rescue StandardError => e
-    Rollout.where(name: name).each do |rollout|
-      rollout.increment!(:failure_count)
-    end
-    raise e
-  end
+  private
 
-  def self.info(feature)
-    {
-      :percentage => (_active_percentage(feature) || 0).to_i,
-      :groups => _active_groups(feature).map { |g| g.to_sym },
-      :users => _active_user_ids(feature)
-    }
+  def self.get_id(user)
+    [Fixnum, String].include?(user.class) ? user.to_i : user.id
   end
 
-private
-   def self._active_groups(feature)
-    Rollout.where('"name" = ? and "group" is not null', feature).map(&:group)
-  end
-
-  def self._active_user_ids(feature)
-    Rollout.where('"name" = ? and "user_id" is not null', feature).map(&:user_id)
-  end
+  def self.scanned_features
+    @@scanned_features ||= Dir["app/views/**/*", 'app/controllers/**/*', 'app/helpers/**/*'].inject({}) do |obj, path|
+      unless File.directory?(path)
+        File.open(path) do |f|
+          f.grep(/rollout\?/) do |line, no|
+            line.scan(/rollout\?\s*\(*:(\w+)/).each do |line|
+              obj[line[0]] ||= []
+              obj[line[0]] << path
+            end
+          end
+        end
+      end
 
-  def self._active_percentage(feature)
-    Rollout.select("percentage").where('"name" = ? and "percentage" is not null', feature).first
+      obj
+    end
   end
-
 end
 
 ActionController::Base.send :include, ArRollout::Controller::Helpers

data/lib/ar_rollout/rollout.rb

@@ -1,5 +1,7 @@
 class Rollout < ActiveRecord::Base
   attr_accessible :name, :group, :user_id, :percentage
+  validates :name, presence: true
+  validate :validate_one_rollout
 
   def match?(user)
     return false unless user
@@ -13,10 +15,13 @@ class Rollout < ActiveRecord::Base
   def match_group?(user)
     if Rollout.method_defined? "match_#{group}?"
       send "match_#{group}?", user
-    elsif group = Group.find_by_name(group) && group.memberships.where('user_id = ?', user.id).any?
-      true
     else
-      false
+      data_group = Group.find_by_name(group)
+      if data_group && data_group.memberships.where('user_id = ?', user.id).any?
+        true
+      else
+        false
+      end
     end
   end
 
@@ -28,4 +33,11 @@ class Rollout < ActiveRecord::Base
     percentage ? ((user.id.to_i % 100) < percentage.to_i) : false
   end
 
+  private
+
+  def validate_one_rollout
+    unless group || user_id || percentage
+      errors.add(:base, 'Must have group, user_id, or percentage')
+    end
+  end
 end

data/lib/ar_rollout/version.rb

@@ -1,3 +1,3 @@
 module ArRollout
-  VERSION = "0.0.20"
+  VERSION = "0.0.21"
 end

data/lib/tasks/ar_rollout_tasks.rake

@@ -1,36 +1,86 @@
 namespace :rollout do
-	desc "Activate a feature for a specific user"
-	task :activate_user, [:feature, :user_id] => :environment do |t, args|
-		ArRollout.activate_user(args.feature,args.user_id)
-	end
-
-	desc "Deactivate a feature for a specific user"
-	task :deactivate_user, [:feature, :user_id] => :environment do |t, args|
-		ArRollout.deactivate_user(args.feature,args.user_id)
-	end
-
-	desc "Activate a feature for a group"
-	task :activate_group, [:feature, :user_id] => :environment do |t, args|
-		ArRollout.activate_group(args.feature,args.user_id)
-	end
-
-	desc "Deactivate a feature for a group"
-	task :deactivate_group, [:feature, :user_id] => :environment do |t, args|
-		ArRollout.deactivate_group(args.feature,args.user_id)
-	end
-
-	desc "Activate a feature for a percentage"
-	task :activate_percentage, [:feature, :percentage] => :environment do |t, args|
-		ArRollout.activate_percentage(args.feature,args.percentage)
-	end
-
-	desc "Deactivate a feature"
-	task :deactivate_all, [:feature] => :environment do |t, args|
-		ArRollout.deactivate_all(args.feature)
-	end
-
-  desc "List all features"
-  task :list, [] => :environment do |t, args|
+  desc "Activate a feature for a specific user"
+  task :activate_user, [:feature, :user_id] => :environment do |t, args|
+    ArRollout.activate_user(args.feature,args.user_id)
+  end
+
+  desc "Deactivate a feature for a specific user"
+  task :deactivate_user, [:feature, :user_id] => :environment do |t, args|
+    ArRollout.deactivate_user(args.feature,args.user_id)
+  end
+
+  desc "Exclude a user from a feature"
+  task :exclude_user, [:feature, :user_id] => :environment do |t, args|
+    ArRollout.omit_user(args.feature, args.user_id)
+  end
+
+  desc "Permit a user to have a feature rolled out to it"
+  task :permit_user, [:feature, :user_id] => :environment do |t, args|
+    ArRollout.permit_user(args.feature, args.user_id)
+  end
+
+  desc "Activate a feature for a group"
+  task :activate_group, [:feature, :group] => :environment do |t, args|
+    ArRollout.activate_group(args.feature,args.group)
+  end
+
+  desc "Deactivate a feature for a group"
+  task :deactivate_group, [:feature, :group] => :environment do |t, args|
+    ArRollout.deactivate_group(args.feature,args.group)
+  end
+
+  desc "Activate a feature for a percentage"
+  task :activate_percentage, [:feature, :percentage] => :environment do |t, args|
+    ArRollout.activate_percentage(args.feature,args.percentage)
+  end
+
+  desc "Deactivate percentage rollout for a feature"
+  task :deactivate_percentage, [:feature] => :environment do |t, args|
+    ArRollout.deactivate_percentage(args.feature)
+  end
+
+  desc "Deactivate a feature"
+  task :deactivate, [:feature] => :environment do |t, args|
+    ArRollout.deactivate(args.feature)
+  end
+
+  desc "List groups"
+  task :groups, [] => :environment do |t, args|
+    puts ArRollout.groups
+  end
+
+  desc "List active groups"
+  task :active_groups, [] => :environment do |t, args|
+    puts ArRollout.active_groups
+  end
+
+  desc "Create a group"
+  task :create_group, [:group] => :environment do |t, args|
+    ArRollout.create_group(args.group)
+  end
+
+  desc "Change a group's name"
+  task :change_group_name, [:old_name, :new_name] => :environment do |t, args|
+    ArRollout.change_group_name(args.old_name, args.new_name)
+  end
+
+  desc "Add a user to a group"
+  task :add_user_to_group, [:group, :user_id] => :environment do |t, args|
+    ArRollout.add_user_to_group(args.group, args.user_id)
+  end
+
+  desc "Remove a user from a group"
+  task :remove_user_from_group, [:group, :user_id] => :environment do |t, args|
+    ArRollout.remove_user_from_group(args.group, args.user_id)
+  end
+
+  desc "Delete a group"
+  task :delete_group, [:group] => :environment do |t, args|
+    ArRollout.delete_group(args.group)
+  end
+
+  desc "List features"
+  task :features, [] => :environment do |t, args|
     puts ArRollout.features
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ar_rollout
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.21
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-04 00:00:00.000000000 Z
+date: 2012-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails