rolloutbr 2.0.1br

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTAxOWIyZTk5ZWM1YzFlMzkzNzFhMDJmOGUzZDUwOWY2MGIyY2NkYw==
+  data.tar.gz: !binary |-
+    NTQ3MGYxNTEwM2FlM2ZjYmYzZWY2OGY5YjlmZGY5NmMxODQ1Nzg3Zg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MTM5YmUwNTFkZGY2M2FiZjg5YWRiNjM1ZTlkNWU2NmNkN2U1YTdlYzkwYTll
+    N2Q2NWU1ZTU5ODdjMzE5MWJjNTBjYjEwZDA3YzZiZGU5MTY5ZGUzZGQwMDMz
+    Y2UzOTlmN2RjZjNlNWViMjhkN2QwODQ5NTgyMTgyNTU0MjkyMzg=
+  data.tar.gz: !binary |-
+    YzQ1MzFhOTllNzBlNWRhOWE4NjVmZmM4YjM3ODFiZDQ1MzYzYjRhODNmYjZk
+    YjFkMWRkOTI0NzdjYmUyZTQ5YmI3ZWUxZTUzN2VjYWY3NjM5MTE3NWNjNTE1
+    YjAwZWMzNjIzYWFkYTlmYzE3OTVmNzFhMmZiNDZiMDVkN2E2Yzg=

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+*.gem
+
+## PROJECT::SPECIFIC

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    rollout (2.0.0a)
+      redis
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bourne (1.0)
+      mocha (= 0.9.8)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    mocha (0.9.8)
+      rake
+    rake (0.9.2.2)
+    redis (3.0.2)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bourne (= 1.0)
+  bundler (>= 1.0.0)
+  jeweler (~> 1.6.4)
+  mocha (= 0.9.8)
+  rollout!
+  rspec (~> 2.10.0)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 James Golick
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,119 @@
+= rollout
+
+Feature flippers.
+
+== MAKE SURE TO READ THIS: 2.0 Changes and Migration Path
+
+As of rollout-2.x, only one key is used per feature for performance reasons. The data format is <tt>percentage|user_id,user_id,...|group,_group...</tt>. This has the effect of making concurrent feature modifications unsafe, but in practice, I doubt this will actually be a problem.
+
+This also has the effect of rollout no longer being dependent on redis. Just give it something that responds to <tt>set(key,value)</tt> and <tt>get(key)</tt>.
+
+If you have been using the 1.x format, you can initialize Rollout with <tt>:migrate => true</tt> and it'll do its best to automatically migrate your old features to the new format. There will be some performance impact, but it should be limited and short-lived since each feature only needs to get migrated once.
+
+== Rollout::Legacy
+
+If you'd prefer to continue to use the old layout in redis, <tt>Rollout::Legacy</tt> is a copy and paste of the old code :-).
+
+== Install it
+
+  gem install rollout
+
+== How it works
+
+Initialize a rollout object. I assign it to a global var.
+
+  $redis   = Redis.new
+  $rollout = Rollout.new($redis)
+
+Check whether a feature is active for a particular user:
+  
+  $rollout.active?(:chat, User.first) # => true/false
+
+Check whether a feature is active globally:
+
+  $rollout.active?(:chat)
+
+You can activate features using a number of different mechanisms.
+
+== Groups
+
+Rollout ships with one group by default: "all", which does exactly what it sounds like. 
+
+You can activate the all group for the chat feature like this:
+
+  $rollout.activate_group(:chat, :all)
+
+You might also want to define your own groups. We have one for our caretakers:
+
+  $rollout.define_group(:caretakers) do |user|
+    user.caretaker?
+  end
+
+You can activate multiple groups per feature.
+
+Deactivate groups like this:
+
+  $rollout.deactivate_group(:chat, :all)
+
+== Specific Users
+
+You might want to let a specific user into a beta test or something. If that user isn't part of an existing group, you can let them in specifically:
+  
+  $rollout.activate_user(:chat, @user)
+
+Deactivate them like this:
+
+  $rollout.deactivate_user(:chat, @user)
+
+== User Percentages
+
+If you're rolling out a new feature, you might want to test the waters by slowly enabling it for a percentage of your users.
+
+  $rollout.activate_percentage(:chat, 20)
+
+The algorithm for determining which users get let in is this:
+
+  user.id % 10 < percentage / 10
+
+So, for 20%, users 0, 1, 10, 11, 20, 21, etc would be allowed in. Those users would remain in as the percentage increases.
+
+Deactivate all percentages like this:
+
+  $rollout.deactivate_percentage(:chat)
+
+_Note that activating a feature for 100% of users will also make it active "globally". That is when calling Rollout#active? without a user object._
+
+== Feature is broken
+
+Deactivate everybody at once:
+
+  $rollout.deactivate(:chat)
+
+For many of our features, we keep track of error rates using redis, and deactivate them automatically when a threshold is reached to prevent service failures from cascading. See http://github.com/jamesgolick/degrade for the failure detection code.
+
+== Namespacing
+
+Rollout separates its keys from other keys in the data store using the "feature" keyspace.
+
+If you're using redis, you can namespace keys further to support multiple environments by using the http://github.com/defunkt/redis-namespace gem.
+
+  $ns = Redis::Namespace.new(Rails.env, :redis => $redis)
+  $rollout = Rollout.new($ns)
+  $rollout.activate_group(:chat, :all)
+  
+This example would use the "development:feature:chat:groups" key.
+
+== misc/check_rollout.rb
+
+In our infrastructure, rollout obviously allows us to progressively enable new features but we also use it to automatically disable features and services that break or fail to prevent them from causing cascading failures and wiping out our entire system.
+
+When a feature reaches "maturity" - in other words, expected to be at 100% rollout all the time - we use check_rollout.rb to setup nagios alerts on the rollouts so that we get paged if one of them gets disabled.
+
+
+== Implementations in other languages
+
+* Python: http://github.com/asenchi/proclaim
+
+== Copyright
+
+Copyright (c) 2010 James Golick, BitLove, Inc. See LICENSE for details.

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/lib/rollout/legacy.rb

@@ -0,0 +1,134 @@
+class Rollout
+  class Legacy
+    def initialize(redis)
+      @redis  = redis
+      @groups = {"all" => lambda { |user| true }}
+    end
+
+    def activate_globally(feature)
+      @redis.sadd(global_key, feature)
+    end
+
+    def deactivate_globally(feature)
+      @redis.srem(global_key, feature)
+    end
+
+    def activate_group(feature, group)
+      @redis.sadd(group_key(feature), group)
+    end
+
+    def deactivate_group(feature, group)
+      @redis.srem(group_key(feature), group)
+    end
+
+    def deactivate_all(feature)
+      @redis.del(group_key(feature))
+      @redis.del(user_key(feature))
+      @redis.del(percentage_key(feature))
+      deactivate_globally(feature)
+    end
+
+    def activate_user(feature, user)
+      @redis.sadd(user_key(feature), user.id)
+    end
+
+    def deactivate_user(feature, user)
+      @redis.srem(user_key(feature), user.id)
+    end
+
+    def define_group(group, &block)
+      @groups[group.to_s] = block
+    end
+
+    def active?(feature, user = nil)
+      if user
+        active_globally?(feature) ||
+          user_in_active_group?(feature, user) ||
+            user_active?(feature, user) ||
+              user_within_active_percentage?(feature, user)
+      else
+        active_globally?(feature)
+      end
+    end
+
+    def activate_percentage(feature, percentage)
+      @redis.set(percentage_key(feature), percentage)
+    end
+
+    def deactivate_percentage(feature)
+      @redis.del(percentage_key(feature))
+    end
+
+    def info(feature = nil)
+      if feature
+        {
+          :percentage => (active_percentage(feature) || 0).to_i,
+          :groups     => active_groups(feature).map { |g| g.to_sym },
+          :users      => active_user_ids(feature),
+          :global     => active_global_features
+        }
+      else
+        {
+          :global     => active_global_features
+        }
+      end
+    end
+
+    private
+      def key(name)
+        "feature:#{name}"
+      end
+
+      def group_key(name)
+        "#{key(name)}:groups"
+      end
+
+      def user_key(name)
+        "#{key(name)}:users"
+      end
+
+      def percentage_key(name)
+        "#{key(name)}:percentage"
+      end
+
+      def global_key
+        "feature:__global__"
+      end
+
+      def active_groups(feature)
+        @redis.smembers(group_key(feature)) || []
+      end
+
+      def active_user_ids(feature)
+        @redis.smembers(user_key(feature)).map { |id| id.to_i }
+      end
+
+      def active_global_features
+        (@redis.smembers(global_key) || []).map(&:to_sym)
+      end
+
+      def active_percentage(feature)
+        @redis.get(percentage_key(feature))
+      end
+
+      def active_globally?(feature)
+        @redis.sismember(global_key, feature)
+      end
+
+      def user_in_active_group?(feature, user)
+        active_groups(feature).any? do |group|
+          @groups.key?(group) && @groups[group].call(user)
+        end
+      end
+
+      def user_active?(feature, user)
+        @redis.sismember(user_key(feature), user.id)
+      end
+
+      def user_within_active_percentage?(feature, user)
+        percentage = active_percentage(feature)
+        return false if percentage.nil?
+        user.id % 100 < percentage.to_i
+      end
+  end
+end

data/lib/rollout/version.rb

@@ -0,0 +1,3 @@
+class Rollout
+  VERSION = "2.0.1br"
+end

data/lib/rollout.rb

@@ -0,0 +1,211 @@
+require "rollout/legacy"
+require "zlib"
+
+class Rollout
+  class Feature
+    attr_reader :name, :groups, :users, :percentage
+    attr_writer :percentage, :groups, :users
+
+    def initialize(name, string = nil)
+      @name = name
+      if string
+        raw_percentage,raw_users,raw_groups = string.split("|")
+        @percentage = raw_percentage.to_i
+        @users = (raw_users || "").split(",").map(&:to_s)
+        @groups = (raw_groups || "").split(",").map(&:to_sym)
+      else
+        clear
+      end
+    end
+
+    def serialize
+      "#{@percentage}|#{@users.join(",")}|#{@groups.join(",")}"
+    end
+
+    def add_user(user)
+      @users << user.id.to_s unless @users.include?(user.id.to_s)
+    end
+
+    def remove_user(user)
+      @users.delete(user.id.to_s)
+    end
+
+    def add_group(group)
+      @groups << group.to_sym unless @groups.include?(group.to_sym)
+    end
+
+    def remove_group(group)
+      @groups.delete(group.to_sym)
+    end
+
+    def clear
+      @groups = []
+      @users = []
+      @percentage = 0
+    end
+
+    def active?(rollout, user)
+      if user.nil?
+        @percentage == 100
+      else
+        user_in_percentage?(user) ||
+          user_in_active_users?(user) ||
+            user_in_active_group?(user, rollout)
+      end
+    end
+
+    def to_hash
+      {:percentage => @percentage,
+       :groups     => @groups,
+       :users      => @users}
+    end
+
+    private
+      def user_in_percentage?(user)
+        Zlib.crc32(user.id.to_s) % 100 < @percentage
+      end
+
+      def user_in_active_users?(user)
+        @users.include?(user.id.to_s)
+      end
+
+      def user_in_active_group?(user, rollout)
+        @groups.any? do |g|
+          rollout.active_in_group?(g, user)
+        end
+      end
+  end
+
+  @@storage_hash = {}
+  @@cleared = Time.now
+  puts @@cleared
+
+  def initialize(storage, opts = {})
+    @storage  = storage
+    @groups = {:all => lambda { |user| true }}
+    @legacy = Legacy.new(@storage) if opts[:migrate]
+  end
+
+  def activate(feature)
+    with_feature(feature) do |f|
+      f.percentage = 100
+    end
+  end
+
+  def deactivate(feature)
+    with_feature(feature) do |f|
+      f.clear
+    end
+  end
+
+  def activate_group(feature, group)
+    with_feature(feature) do |f|
+      f.add_group(group)
+    end
+  end
+
+  def deactivate_group(feature, group)
+    with_feature(feature) do |f|
+      f.remove_group(group)
+    end
+  end
+
+  def activate_user(feature, user)
+    with_feature(feature) do |f|
+      f.add_user(user)
+    end
+  end
+
+  def deactivate_user(feature, user)
+    with_feature(feature) do |f|
+      f.remove_user(user)
+    end
+  end
+
+  def define_group(group, &block)
+    @groups[group.to_sym] = block
+  end
+
+  def active?(feature, user = nil)
+    feature = get(feature)
+    feature.active?(self, user)
+  end
+
+  def activate_percentage(feature, percentage)
+    with_feature(feature) do |f|
+      f.percentage = percentage
+    end
+  end
+
+  def deactivate_percentage(feature)
+    with_feature(feature) do |f|
+      f.percentage = 0
+    end
+  end
+
+  def active_in_group?(group, user)
+    f = @groups[group.to_sym]
+    f && f.call(user)
+  end
+
+  def period
+    @period ||= 60
+  end
+
+  def get(feature, force=false)
+    puts "force: #{force}"
+    puts "!@@cleared: #{!@@cleared}"
+    puts "Time.now: #{Time.now}"
+    puts "@@cleared + period: #{@@cleared + period}"
+    puts "Comp: #{Time.now >= (@@cleared + period)}"
+    if force || !@@cleared || Time.now >= (@@cleared + period)
+      puts "forced"
+      @@storage_hash = {}
+      @@cleared = Time.now
+    end
+    if @@storage_hash[feature].nil?
+      puts "nil"
+      @@storage_hash[feature] = @storage.get(key(feature)) || '0||'
+    end
+    string = @@storage_hash[feature]
+    if string || !migrate?
+      Feature.new(feature, string)
+    else
+      info = @legacy.info(feature)
+      f = Feature.new(feature)
+      f.percentage = info[:percentage]
+      f.groups = info[:groups].map { |g| g.to_sym }
+      f.users = info[:users].map { |u| u.to_s }
+      save(f)
+      f
+    end
+  end
+
+  def features
+    (@storage.get(features_key) || "").split(",").map(&:to_sym)
+  end
+
+  private
+    def key(name)
+      "feature:#{name}"
+    end
+
+    def features_key
+      "feature:__features__"
+    end
+
+    def with_feature(feature)
+      f = get(feature)
+      yield(f)
+      save(f)
+    end
+
+    def save(feature)
+      @storage.set(key(feature.name), feature.serialize)
+      @storage.set(features_key, (features | [feature.name]).join(","))
+    end
+
+    def migrate?
+      @legacy
+    end
+end

data/misc/check_rollout.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "yajl"
+require "open-uri"
+
+output = Yajl::Parser.parse(open(ARGV[0]))
+percentage = output["percentage"].to_i
+
+puts Yajl::Encoder.encode(output)
+
+if percentage == 100
+  exit(0)
+else
+  exit(2)
+end

data/rollout.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rollout/version"
+
+Gem::Specification.new do |s|
+  s.name = "rolloutbr"
+  s.version = Rollout::VERSION
+  s.authors = ["James Golick"]
+  s.email       = ["jamesgolick@gmail.com"]
+  s.description = "Feature flippers with redis."
+  s.summary = "Feature flippers with redis."
+  s.homepage = "https://github.com/jamesgolick/rollout"
+
+  s.require_paths = ["lib"]
+
+  s.rubyforge_project = "rollout"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", "~> 2.10.0"
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "jeweler", "~> 1.6.4"
+  s.add_development_dependency "bourne", "1.0"
+  s.add_development_dependency "mocha", "0.9.8"
+
+  s.add_runtime_dependency "redis"
+end

data/spec/legacy_spec.rb

@@ -0,0 +1,222 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Rollout::Legacy" do
+  before do
+    @redis   = Redis.new
+    @rollout = Rollout::Legacy.new(@redis)
+  end
+
+  describe "when a group is activated" do
+    before do
+      @rollout.define_group(:fivesonly) { |user| user.id == 5 }
+      @rollout.activate_group(:chat, :fivesonly)
+    end
+
+    it "the feature is active for users for which the block evaluates to true" do
+      @rollout.should be_active(:chat, stub(:id => 5))
+    end
+
+    it "is not active for users for which the block evaluates to false" do
+      @rollout.should_not be_active(:chat, stub(:id => 1))
+    end
+
+    it "is not active if a group is found in Redis but not defined in Rollout" do
+      @rollout.activate_group(:chat, :fake)
+      @rollout.should_not be_active(:chat, stub(:id => 1))
+    end
+  end
+
+  describe "the default all group" do
+    before do
+      @rollout.activate_group(:chat, :all)
+    end
+
+    it "evaluates to true no matter what" do
+      @rollout.should be_active(:chat, stub(:id => 0))
+    end
+  end
+
+  describe "deactivating a group" do
+    before do
+      @rollout.define_group(:fivesonly) { |user| user.id == 5 }
+      @rollout.activate_group(:chat, :all)
+      @rollout.activate_group(:chat, :fivesonly)
+      @rollout.deactivate_group(:chat, :all)
+    end
+
+    it "deactivates the rules for that group" do
+      @rollout.should_not be_active(:chat, stub(:id => 10))
+    end
+
+    it "leaves the other groups active" do
+      @rollout.should be_active(:chat, stub(:id => 5))
+    end
+  end
+
+  describe "deactivating a feature completely" do
+    before do
+      @rollout.define_group(:fivesonly) { |user| user.id == 5 }
+      @rollout.activate_group(:chat, :all)
+      @rollout.activate_group(:chat, :fivesonly)
+      @rollout.activate_user(:chat, stub(:id => 51))
+      @rollout.activate_percentage(:chat, 100)
+      @rollout.activate_globally(:chat)
+      @rollout.deactivate_all(:chat)
+    end
+
+    it "removes all of the groups" do
+      @rollout.should_not be_active(:chat, stub(:id => 0))
+    end
+
+    it "removes all of the users" do
+      @rollout.should_not be_active(:chat, stub(:id => 51))
+    end
+
+    it "removes the percentage" do
+      @rollout.should_not be_active(:chat, stub(:id => 24))
+    end
+
+    it "removes globally" do
+      @rollout.should_not be_active(:chat)
+    end
+  end
+
+  describe "activating a specific user" do
+    before do
+      @rollout.activate_user(:chat, stub(:id => 42))
+    end
+
+    it "is active for that user" do
+      @rollout.should be_active(:chat, stub(:id => 42))
+    end
+
+    it "remains inactive for other users" do
+      @rollout.should_not be_active(:chat, stub(:id => 24))
+    end
+  end
+
+  describe "deactivating a specific user" do
+    before do
+      @rollout.activate_user(:chat, stub(:id => 42))
+      @rollout.activate_user(:chat, stub(:id => 24))
+      @rollout.deactivate_user(:chat, stub(:id => 42))
+    end
+
+    it "that user should no longer be active" do
+      @rollout.should_not be_active(:chat, stub(:id => 42))
+    end
+
+    it "remains active for other active users" do
+      @rollout.should be_active(:chat, stub(:id => 24))
+    end
+  end
+
+  describe "activating a feature globally" do
+    before do
+      @rollout.activate_globally(:chat)
+    end
+
+    it "activates the feature" do
+      @rollout.should be_active(:chat)
+    end
+  end
+
+  describe "activating a feature for a percentage of users" do
+    before do
+      @rollout.activate_percentage(:chat, 20)
+    end
+
+    it "activates the feature for that percentage of the users" do
+      (1..120).select { |id| @rollout.active?(:chat, stub(:id => id)) }.length.should == 39
+    end
+  end
+
+  describe "activating a feature for a percentage of users" do
+    before do
+      @rollout.activate_percentage(:chat, 20)
+    end
+
+    it "activates the feature for that percentage of the users" do
+      (1..200).select { |id| @rollout.active?(:chat, stub(:id => id)) }.length.should == 40
+    end
+  end
+
+  describe "activating a feature for a percentage of users" do
+    before do
+      @rollout.activate_percentage(:chat, 5)
+    end
+
+    it "activates the feature for that percentage of the users" do
+      (1..100).select { |id| @rollout.active?(:chat, stub(:id => id)) }.length.should == 5
+    end
+  end
+
+
+  describe "deactivating the percentage of users" do
+    before do
+      @rollout.activate_percentage(:chat, 100)
+      @rollout.deactivate_percentage(:chat)
+    end
+
+    it "becomes inactivate for all users" do
+      @rollout.should_not be_active(:chat, stub(:id => 24))
+    end
+  end
+
+  describe "deactivating the feature globally" do
+    before do
+      @rollout.activate_globally(:chat)
+      @rollout.deactivate_globally(:chat)
+    end
+
+    it "becomes inactivate" do
+      @rollout.should_not be_active(:chat)
+    end
+  end
+
+  describe "#info" do
+    context "global features" do
+      let(:features) { [:signup, :chat, :table] }
+
+      before do
+        features.each do |f|
+          @rollout.activate_globally(f)
+        end
+      end
+
+      it "returns all global features" do
+        @rollout.info.should eq({ :global => features.reverse })
+      end
+    end
+
+    describe "with a percentage set" do
+      before do
+        @rollout.activate_percentage(:chat, 10)
+        @rollout.activate_group(:chat, :caretakers)
+        @rollout.activate_group(:chat, :greeters)
+        @rollout.activate_globally(:signup)
+        @rollout.activate_user(:chat, stub(:id => 42))
+      end
+
+      it "returns info about all the activations" do
+        @rollout.info(:chat).should == {
+          :percentage => 10,
+          :groups     => [:greeters, :caretakers],
+          :users      => [42],
+          :global     => [:signup]
+        }
+      end
+    end
+
+    describe "without a percentage set" do
+      it "defaults to 0" do
+        @rollout.info(:chat).should == {
+          :percentage => 0,
+          :groups     => [],
+          :users      => [],
+          :global     => []
+        }
+      end
+    end
+  end
+end

data/spec/rollout_spec.rb

@@ -0,0 +1,274 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Rollout" do
+  before do
+    @redis   = Redis.new
+    @rollout = Rollout.new(@redis)
+  end
+
+  describe "when a group is activated" do
+    before do
+      @rollout.define_group(:fivesonly) { |user| user.id == 5 }
+      @rollout.activate_group(:chat, :fivesonly)
+    end
+
+    it "the feature is active for users for which the block evaluates to true" do
+      @rollout.should be_active(:chat, stub(:id => 5))
+    end
+
+    it "is not active for users for which the block evaluates to false" do
+      @rollout.should_not be_active(:chat, stub(:id => 1))
+    end
+
+    it "is not active if a group is found in Redis but not defined in Rollout" do
+      @rollout.activate_group(:chat, :fake)
+      @rollout.should_not be_active(:chat, stub(:id => 1))
+    end
+  end
+
+  describe "the default all group" do
+    before do
+      @rollout.activate_group(:chat, :all)
+    end
+
+    it "evaluates to true no matter what" do
+      @rollout.should be_active(:chat, stub(:id => 0))
+    end
+  end
+
+  describe "deactivating a group" do
+    before do
+      @rollout.define_group(:fivesonly) { |user| user.id == 5 }
+      @rollout.activate_group(:chat, :all)
+      @rollout.activate_group(:chat, :some)
+      @rollout.activate_group(:chat, :fivesonly)
+      @rollout.deactivate_group(:chat, :all)
+      @rollout.deactivate_group(:chat, "some")
+    end
+
+    it "deactivates the rules for that group" do
+      @rollout.should_not be_active(:chat, stub(:id => 10))
+    end
+
+    it "leaves the other groups active" do
+      @rollout.get(:chat).groups.should == [:fivesonly]
+    end
+  end
+
+  describe "deactivating a feature completely" do
+    before do
+      @rollout.define_group(:fivesonly) { |user| user.id == 5 }
+      @rollout.activate_group(:chat, :all)
+      @rollout.activate_group(:chat, :fivesonly)
+      @rollout.activate_user(:chat, stub(:id => 51))
+      @rollout.activate_percentage(:chat, 100)
+      @rollout.activate(:chat)
+      @rollout.deactivate(:chat)
+    end
+
+    it "removes all of the groups" do
+      @rollout.should_not be_active(:chat, stub(:id => 0))
+    end
+
+    it "removes all of the users" do
+      @rollout.should_not be_active(:chat, stub(:id => 51))
+    end
+
+    it "removes the percentage" do
+      @rollout.should_not be_active(:chat, stub(:id => 24))
+    end
+
+    it "removes globally" do
+      @rollout.should_not be_active(:chat)
+    end
+  end
+
+  describe "activating a specific user" do
+    before do
+      @rollout.activate_user(:chat, stub(:id => 42))
+    end
+
+    it "is active for that user" do
+      @rollout.should be_active(:chat, stub(:id => 42))
+    end
+
+    it "remains inactive for other users" do
+      @rollout.should_not be_active(:chat, stub(:id => 24))
+    end
+  end
+
+  describe "activating a specific user with a string id" do
+    before do
+      @rollout.activate_user(:chat, stub(:id => 'user-72'))
+    end
+
+    it "is active for that user" do
+      @rollout.should be_active(:chat, stub(:id => 'user-72'))
+    end
+
+    it "remains inactive for other users" do
+      @rollout.should_not be_active(:chat, stub(:id => 'user-12'))
+    end
+  end
+
+  describe "deactivating a specific user" do
+    before do
+      @rollout.activate_user(:chat, stub(:id => 42))
+      @rollout.activate_user(:chat, stub(:id => 4242))
+      @rollout.activate_user(:chat, stub(:id => 24))
+      @rollout.deactivate_user(:chat, stub(:id => 42))
+      @rollout.deactivate_user(:chat, stub(:id => "4242"))
+    end
+
+    it "that user should no longer be active" do
+      @rollout.should_not be_active(:chat, stub(:id => 42))
+    end
+
+    it "remains active for other active users" do
+      @rollout.get(:chat).users.should == %w(24)
+    end
+  end
+
+  describe "activating a feature globally" do
+    before do
+      @rollout.activate(:chat)
+    end
+
+    it "activates the feature" do
+      @rollout.should be_active(:chat)
+    end
+  end
+
+  describe "activating a feature for a percentage of users" do
+    before do
+      @rollout.activate_percentage(:chat, 20)
+    end
+
+    it "activates the feature for that percentage of the users" do
+      (1..120).select { |id| @rollout.active?(:chat, stub(:id => id)) }.length.should be_within(1).of(20)
+    end
+  end
+
+  describe "activating a feature for a percentage of users" do
+    before do
+      @rollout.activate_percentage(:chat, 20)
+    end
+
+    it "activates the feature for that percentage of the users" do
+      (1..200).select { |id| @rollout.active?(:chat, stub(:id => id)) }.length.should be_within(5).of(40)
+    end
+  end
+
+  describe "activating a feature for a percentage of users" do
+    before do
+      @rollout.activate_percentage(:chat, 5)
+    end
+
+    it "activates the feature for that percentage of the users" do
+      (1..100).select { |id| @rollout.active?(:chat, stub(:id => id)) }.length.should be_within(2).of(5)
+    end
+  end
+
+  describe "activating a feature for a group as a string" do
+    before do
+      @rollout.define_group(:admins) { |user| user.id == 5 }
+      @rollout.activate_group(:chat, 'admins')
+    end
+
+    it "the feature is active for users for which the block evaluates to true" do
+      @rollout.should be_active(:chat, stub(:id => 5))
+    end
+
+    it "is not active for users for which the block evaluates to false" do
+      @rollout.should_not be_active(:chat, stub(:id => 1))
+    end
+  end
+
+  describe "deactivating the percentage of users" do
+    before do
+      @rollout.activate_percentage(:chat, 100)
+      @rollout.deactivate_percentage(:chat)
+    end
+
+    it "becomes inactivate for all users" do
+      @rollout.should_not be_active(:chat, stub(:id => 24))
+    end
+  end
+
+  describe "deactivating the feature globally" do
+    before do
+      @rollout.activate(:chat)
+      @rollout.deactivate(:chat)
+    end
+
+    it "becomes inactivate" do
+      @rollout.should_not be_active(:chat)
+    end
+  end
+
+  describe "keeps a list of features" do
+    it "saves the feature" do
+      @rollout.activate(:chat)
+      @rollout.features.should be_include(:chat)
+    end
+
+    it "does not contain doubles" do
+      @rollout.activate(:chat)
+      @rollout.activate(:chat)
+      @rollout.features.size.should == 1
+    end
+  end
+
+  describe "#get" do
+    before do
+      @rollout.activate_percentage(:chat, 10)
+      @rollout.activate_group(:chat, :caretakers)
+      @rollout.activate_group(:chat, :greeters)
+      @rollout.activate(:signup)
+      @rollout.activate_user(:chat, stub(:id => 42))
+    end
+
+    it "returns the feature object" do
+      feature = @rollout.get(:chat)
+      feature.groups.should == [:caretakers, :greeters]
+      feature.percentage.should == 10
+      feature.users.should == %w(42)
+      feature.to_hash.should == {
+        :groups => [:caretakers, :greeters],
+        :percentage => 10,
+        :users => %w(42)
+      }
+
+      feature = @rollout.get(:signup)
+      feature.groups.should be_empty
+      feature.users.should be_empty
+      feature.percentage.should == 100
+    end
+  end
+
+  describe "migration mode" do
+    before do
+      @legacy = Rollout::Legacy.new(@redis)
+      @legacy.activate_percentage(:chat, 12)
+      @legacy.activate_user(:chat, stub(:id => 42))
+      @legacy.activate_user(:chat, stub(:id => 24))
+      @legacy.activate_group(:chat, :dope_people)
+      @rollout = Rollout.new(@redis, :migrate => true)
+    end
+
+    it "imports the settings from the legacy rollout once" do
+      @rollout.get(:chat).to_hash.should == {
+        :percentage => 12,
+        :users => %w(24 42),
+        :groups => [:dope_people]
+      }
+      @legacy.deactivate_all(:chat)
+      @rollout.get(:chat).to_hash.should == {
+        :percentage => 12,
+        :users => %w(24 42),
+        :groups => [:dope_people]
+      }
+      @redis.get("feature:chat").should_not be_nil
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rollout'
+require 'rspec'
+require 'bourne'
+require 'redis'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.before { Redis.new.flushdb }
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: rolloutbr
+version: !ruby/object:Gem::Version
+  version: 2.0.1br
+platform: ruby
+authors:
+- James Golick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+- !ruby/object:Gem::Dependency
+  name: bourne
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Feature flippers with redis.
+email:
+- jamesgolick@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- VERSION
+- lib/rollout.rb
+- lib/rollout/legacy.rb
+- lib/rollout/version.rb
+- misc/check_rollout.rb
+- rollout.gemspec
+- spec/legacy_spec.rb
+- spec/rollout_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+homepage: https://github.com/jamesgolick/rollout
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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: 1.3.1
+requirements: []
+rubyforge_project: rollout
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Feature flippers with redis.
+test_files:
+- spec/legacy_spec.rb
+- spec/rollout_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb