rollout 1.2.0 → 2.0.0a

data/README.rdoc

@@ -1,6 +1,18 @@
 = rollout
 
-Conditionally roll out features with redis.
+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 `percentage|user_id,user_id,...|group,_group...`. 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 `set(key,value)` and `get(key)`
+
+  If you have been using the 1.x format, you can initialize Rollout with `:migrate => true` 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, `Rollout::Legacy` is a copy and paste of the old code :-).
 
 == Install it
 
@@ -17,6 +29,10 @@ 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
@@ -51,7 +67,7 @@ Deactivate them like this:
 
 == User Percentages
 
-If you're rolling out a new feature, you might want to test the waters by slowly letting in a percentage of your users.
+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)
 
@@ -65,19 +81,21 @@ 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_all
+  $rollout.deactivate(:chat)
 
-For some of our less stable features, we are actually measuring the error rate using redis, and deactivating them automatically when it raises above a certain threshold. It's pretty cool. See http://github.com/jamesgolick/degrade for the failure detection code.
+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 on the Redis server using the "feature" keyspace.
+Rollout separates its keys from other keys in the data store using the "feature" keyspace.
 
-You can namespace keys further to support multiple environments by using the http://github.com/defunkt/redis-namespace gem.
+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)
@@ -85,20 +103,17 @@ You can namespace keys further to support multiple environments by using the htt
   
 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
 
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
 == Copyright
 
-Copyright (c) 2010 James Golick, Protose, Inc. See LICENSE for details.
+Copyright (c) 2010 James Golick, BitLove, Inc. See LICENSE for details.

data/lib/rollout.rb

@@ -1,132 +1,188 @@
+require "rollout/legacy"
+
 class Rollout
-  def initialize(redis)
-    @redis  = redis
-    @groups = {"all" => lambda { |user| true }}
+  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_i)
+        @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 unless @users.include?(user.id)
+    end
+
+    def remove_user(user)
+      @users.delete(user.id)
+    end
+
+    def add_group(group)
+      @groups << group unless @groups.include?(group)
+    end
+
+    def remove_group(group)
+      @groups.delete(group)
+    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)
+        user.id % 100 < @percentage
+      end
+
+      def user_in_active_users?(user)
+        @users.include?(user.id)
+      end
+
+      def user_in_active_group?(user, rollout)
+        @groups.any? do |g|
+          rollout.active_in_group?(g, user)
+        end
+      end
   end
 
-  def activate_globally(feature)
-    @redis.sadd(global_key, feature)
+  def initialize(storage, opts = {})
+    @storage  = storage
+    @groups = {:all => lambda { |user| true }}
+    @legacy = Legacy.new(@storage) if opts[:migrate]
   end
 
-  def deactivate_globally(feature)
-    @redis.srem(global_key, feature)
+  def activate(feature)
+    with_feature(feature) do |f|
+      f.percentage = 100
+    end
   end
 
-  def activate_group(feature, group)
-    @redis.sadd(group_key(feature), group)
+  def deactivate(feature)
+    with_feature(feature) do |f|
+      f.clear
+    end
   end
 
-  def deactivate_group(feature, group)
-    @redis.srem(group_key(feature), group)
+  def activate_group(feature, group)
+    with_feature(feature) do |f|
+      f.add_group(group)
+    end
   end
 
-  def deactivate_all(feature)
-    @redis.del(group_key(feature))
-    @redis.del(user_key(feature))
-    @redis.del(percentage_key(feature))
-    deactivate_globally(feature)
+  def deactivate_group(feature, group)
+    with_feature(feature) do |f|
+      f.remove_group(group)
+    end
   end
 
   def activate_user(feature, user)
-    @redis.sadd(user_key(feature), user.id)
+    with_feature(feature) do |f|
+      f.add_user(user)
+    end
   end
 
   def deactivate_user(feature, user)
-    @redis.srem(user_key(feature), user.id)
+    with_feature(feature) do |f|
+      f.remove_user(user)
+    end
   end
 
   def define_group(group, &block)
-    @groups[group.to_s] = block
+    @groups[group] = 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
+    feature = get(feature)
+    feature.active?(self, user)
   end
 
   def activate_percentage(feature, percentage)
-    @redis.set(percentage_key(feature), percentage)
+    with_feature(feature) do |f|
+      f.percentage = percentage
+    end
   end
 
   def deactivate_percentage(feature)
-    @redis.del(percentage_key(feature))
+    with_feature(feature) do |f|
+      f.percentage = 0
+    end
+  end
+
+  def active_in_group?(group, user)
+    f = @groups[group]
+    f && f.call(user)
   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
-      }
+  def get(feature)
+    string = @storage.get(key(feature))
+    if string || !migrate?
+      Feature.new(feature, string)
     else
-      {
-        :global     => active_global_features
-      }
+      info = @legacy.info(feature)
+      f = Feature.new(feature)
+      f.percentage = info[:percentage]
+      f.groups = info[:groups]
+      f.users = info[:users]
+      save(f)
+      f
     end
   end
 
+  def features
+    (@storage.get(features_key) || "").split(",").map(&:to_sym)
+  end
+
   private
     def key(name)
       "feature:#{name}"
     end
 
-    def group_key(name)
-      "#{key(name)}:groups"
-    end
-
-    def user_key(name)
-      "#{key(name)}:users"
+    def features_key
+      "feature:__features__"
     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
+    def with_feature(feature)
+      f = get(feature)
+      yield(f)
+      save(f)
     end
 
-    def user_active?(feature, user)
-      @redis.sismember(user_key(feature), user.id)
+    def save(feature)
+      @storage.set(key(feature.name), feature.serialize)
+      @storage.set(features_key, (features + [feature.name]).join(","))
     end
 
-    def user_within_active_percentage?(feature, user)
-      percentage = active_percentage(feature)
-      return false if percentage.nil?
-      user.id % 100 < percentage.to_i
+    def migrate?
+      @legacy
     end
 end

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

@@ -1,3 +1,3 @@
 class Rollout
-  VERSION = "1.2.0"
+  VERSION = "2.0.0a"
 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/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

@@ -60,8 +60,8 @@ describe "Rollout" do
       @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)
+      @rollout.activate(:chat)
+      @rollout.deactivate(:chat)
     end
 
     it "removes all of the groups" do
@@ -113,7 +113,7 @@ describe "Rollout" do
 
   describe "activating a feature globally" do
     before do
-      @rollout.activate_globally(:chat)
+      @rollout.activate(:chat)
     end
 
     it "activates the feature" do
@@ -165,8 +165,8 @@ describe "Rollout" do
 
   describe "deactivating the feature globally" do
     before do
-      @rollout.activate_globally(:chat)
-      @rollout.deactivate_globally(:chat)
+      @rollout.activate(:chat)
+      @rollout.deactivate(:chat)
     end
 
     it "becomes inactivate" do
@@ -174,49 +174,61 @@ describe "Rollout" do
     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 "the percentage defaults to 0" do
-        @rollout.info(:chat).should == {
-          :percentage => 0,
-          :groups     => [],
-          :users      => [],
-          :global     => []
-        }
-      end
+  it "keeps a list of features" do
+    @rollout.activate(:chat)
+    @rollout.features.should be_include(:chat)
+  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 == [42]
+      feature.to_hash.should == {
+        :groups => [:caretakers, :greeters],
+        :percentage => 10,
+        :users => [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 => [24, 42],
+        :groups => [:dope_people]
+      }
+      @legacy.deactivate_all(:chat)
+      @rollout.get(:chat).to_hash.should == {
+        :percentage => 12,
+        :users => [24, 42],
+        :groups => [:dope_people]
+      }
+      @redis.get("feature:chat").should_not be_nil
     end
   end
 end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: rollout
 version: !ruby/object:Gem::Version
-  version: 1.2.0
-  prerelease: 
+  version: 2.0.0a
+  prerelease: 5
 platform: ruby
 authors:
 - James Golick
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-14 00:00:00.000000000 Z
+date: 2012-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70171348875940 !ruby/object:Gem::Requirement
+  requirement: &70240073640980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 2.10.0
   type: :development
   prerelease: false
-  version_requirements: *70171348875940
+  version_requirements: *70240073640980
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70171348875080 !ruby/object:Gem::Requirement
+  requirement: &70240073640480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *70171348875080
+  version_requirements: *70240073640480
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70171348874140 !ruby/object:Gem::Requirement
+  requirement: &70240073640020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *70171348874140
+  version_requirements: *70240073640020
 - !ruby/object:Gem::Dependency
   name: bourne
-  requirement: &70171348872540 !ruby/object:Gem::Requirement
+  requirement: &70240073639560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -54,10 +54,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70171348872540
+  version_requirements: *70240073639560
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70171348871700 !ruby/object:Gem::Requirement
+  requirement: &70240073639100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -65,10 +65,10 @@ dependencies:
         version: 0.9.8
   type: :development
   prerelease: false
-  version_requirements: *70171348871700
+  version_requirements: *70240073639100
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70171348870700 !ruby/object:Gem::Requirement
+  requirement: &70240073638720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70171348870700
+  version_requirements: *70240073638720
 description: Feature flippers with redis.
 email:
 - jamesgolick@gmail.com
@@ -92,8 +92,11 @@ files:
 - 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
@@ -112,9 +115,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: rollout
 rubygems_version: 1.8.10
@@ -122,6 +125,8 @@ signing_key:
 specification_version: 3
 summary: Feature flippers with redis.
 test_files:
+- spec/legacy_spec.rb
 - spec/rollout_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+has_rdoc: