rollout 2.1.0 → 2.4.5

data/lib/rollout.rb

@@ -1,10 +1,15 @@
-require "rollout/version"
-require "rollout/legacy"
-require "zlib"
+# frozen_string_literal: true
+
+require 'rollout/version'
+require 'zlib'
+require 'set'
+require 'json'
 
 class Rollout
+  RAND_BASE = (2**32 - 1) / 100.0
+
   class Feature
-    attr_accessor :groups, :users, :percentage
+    attr_accessor :groups, :users, :percentage, :data
     attr_reader :name, :options
 
     def initialize(name, string = nil, opts = {})
@@ -12,17 +17,18 @@ class Rollout
       @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)
+        raw_percentage, raw_users, raw_groups, raw_data = string.split('|', 4)
+        @percentage = raw_percentage.to_f
+        @users = users_from_string(raw_users)
+        @groups = groups_from_string(raw_groups)
+        @data = raw_data.nil? || raw_data.strip.empty? ? {} : JSON.parse(raw_data)
       else
         clear
       end
     end
 
     def serialize
-      "#{@percentage}|#{@users.join(",")}|#{@groups.join(",")}"
+      "#{@percentage}|#{@users.to_a.join(',')}|#{@groups.to_a.join(',')}|#{serialize_data}"
     end
 
     def add_user(user)
@@ -43,62 +49,96 @@ class Rollout
     end
 
     def clear
-      @groups = []
-      @users = []
+      @groups = groups_from_string('')
+      @users = users_from_string('')
       @percentage = 0
+      @data = {}
     end
 
     def active?(rollout, user)
-      if user.nil?
-        @percentage == 100
-      else
+      if user
         id = user_id(user)
         user_in_percentage?(id) ||
           user_in_active_users?(id) ||
-            user_in_active_group?(user, rollout)
+          user_in_active_group?(user, rollout)
+      else
+        @percentage == 100
       end
     end
 
+    def user_in_active_users?(user)
+      @users.include?(user_id(user))
+    end
+
     def to_hash
-      {:percentage => @percentage,
-       :groups     => @groups,
-       :users      => @users}
+      {
+        percentage: @percentage,
+        groups: @groups,
+        users: @users
+      }
     end
 
     private
-      def user_id(user)
-        if user.is_a?(Fixnum) ||
-             user.is_a?(String)
-          user.to_s
-        else
-          user.send(id_user_by).to_s
-        end
+
+    def user_id(user)
+      if user.is_a?(Integer) || user.is_a?(String)
+        user.to_s
+      else
+        user.send(id_user_by).to_s
       end
+    end
 
-      def id_user_by
-        @options[:id_user_by] || :id
+    def id_user_by
+      @options[:id_user_by] || :id
+    end
+
+    def user_in_percentage?(user)
+      Zlib.crc32(user_id_for_percentage(user)) < RAND_BASE * @percentage
+    end
+
+    def user_id_for_percentage(user)
+      if @options[:randomize_percentage]
+        user_id(user).to_s + @name.to_s
+      else
+        user_id(user)
       end
+    end
 
-      def user_in_percentage?(user)
-        Zlib.crc32(user_id(user)) % 100 < @percentage
+    def user_in_active_group?(user, rollout)
+      @groups.any? do |g|
+        rollout.active_in_group?(g, user)
       end
+    end
 
-      def user_in_active_users?(user)
-        @users.include?(user_id(user))
+    def serialize_data
+      return '' unless @data.is_a? Hash
+
+      @data.to_json
+    end
+
+    def users_from_string(raw_users)
+      users = (raw_users || '').split(',').map(&:to_s)
+      if @options[:use_sets]
+        users.to_set
+      else
+        users
       end
+    end
 
-      def user_in_active_group?(user, rollout)
-        @groups.any? do |g|
-          rollout.active_in_group?(g, user)
-        end
+    def groups_from_string(raw_groups)
+      groups = (raw_groups || '').split(',').map(&:to_sym)
+      if @options[:use_sets]
+        groups.to_set
+      else
+        groups
       end
+    end
   end
 
   def initialize(storage, opts = {})
     @storage = storage
     @options = opts
-    @groups  = {:all => lambda { |user| true }}
-    @legacy  = Legacy.new(opts[:legacy_storage] || @storage) if opts[:migrate]
+    @groups  = { all: ->(_user) { true } }
   end
 
   def activate(feature)
@@ -108,9 +148,14 @@ class Rollout
   end
 
   def deactivate(feature)
-    with_feature(feature) do |f|
-      f.clear
-    end
+    with_feature(feature, &:clear)
+  end
+
+  def delete(feature)
+    features = (@storage.get(features_key) || '').split(',')
+    features.delete(feature.to_s)
+    @storage.set(features_key, features.join(','))
+    @storage.del(key(feature))
   end
 
   def set(feature, desired_state)
@@ -147,6 +192,25 @@ class Rollout
     end
   end
 
+  def activate_users(feature, users)
+    with_feature(feature) do |f|
+      users.each { |user| f.add_user(user) }
+    end
+  end
+
+  def deactivate_users(feature, users)
+    with_feature(feature) do |f|
+      users.each { |user| f.remove_user(user) }
+    end
+  end
+
+  def set_users(feature, users)
+    with_feature(feature) do |f|
+      f.users = []
+      users.each { |user| f.add_user(user) }
+    end
+  end
+
   def define_group(group, &block)
     @groups[group.to_sym] = block
   end
@@ -156,6 +220,15 @@ class Rollout
     feature.active?(self, user)
   end
 
+  def user_in_active_users?(feature, user = nil)
+    feature = get(feature)
+    feature.user_in_active_users?(user)
+  end
+
+  def inactive?(feature, user = nil)
+    !active?(feature, user)
+  end
+
   def activate_percentage(feature, percentage)
     with_feature(feature) do |f|
       f.percentage = percentage
@@ -170,59 +243,80 @@ class Rollout
 
   def active_in_group?(group, user)
     f = @groups[group.to_sym]
-    f && f.call(user)
+    f&.call(user)
   end
 
   def get(feature)
     string = @storage.get(key(feature))
-    if string || !migrate?
-      Feature.new(feature, string, @options)
-    else
-      info = @legacy.info(feature)
-      f = Feature.new(feature)
-      f.percentage = info[:percentage]
-      f.percentage = 100 if info[:global].include? feature
-      f.groups = info[:groups].map { |g| g.to_sym }
-      f.users = info[:users].map { |u| u.to_s }
-      save(f)
-      f
+    Feature.new(feature, string, @options)
+  end
+
+  def set_feature_data(feature, data)
+    with_feature(feature) do |f|
+      f.data.merge!(data) if data.is_a? Hash
     end
   end
 
+  def clear_feature_data(feature)
+    with_feature(feature) do |f|
+      f.data = {}
+    end
+  end
+
+  def multi_get(*features)
+    return [] if features.empty?
+
+    feature_keys = features.map { |feature| key(feature) }
+    @storage.mget(*feature_keys).map.with_index { |string, index| Feature.new(features[index], string, @options) }
+  end
+
   def features
-    (@storage.get(features_key) || "").split(",").map(&:to_sym)
+    (@storage.get(features_key) || '').split(',').map(&:to_sym)
+  end
+
+  def feature_states(user = nil)
+    multi_get(*features).each_with_object({}) do |f, hash|
+      hash[f.name] = f.active?(self, user)
+    end
+  end
+
+  def active_features(user = nil)
+    multi_get(*features).select do |f|
+      f.active?(self, user)
+    end.map(&:name)
   end
 
   def clear!
     features.each do |feature|
-      with_feature(feature) { |f| f.clear }
+      with_feature(feature, &:clear)
       @storage.del(key(feature))
     end
 
     @storage.del(features_key)
   end
 
+  def exists?(feature)
+    @storage.exists(key(feature))
+  end
+
   private
-    def key(name)
-      "feature:#{name}"
-    end
 
-    def features_key
-      "feature:__features__"
-    end
+  def key(name)
+    "feature:#{name}"
+  end
 
-    def with_feature(feature)
-      f = get(feature)
-      yield(f)
-      save(f)
-    end
+  def features_key
+    'feature:__features__'
+  end
 
-    def save(feature)
-      @storage.set(key(feature.name), feature.serialize)
-      @storage.set(features_key, (features | [feature.name.to_sym]).join(","))
-    end
+  def with_feature(feature)
+    f = get(feature)
+    yield(f)
+    save(f)
+  end
 
-    def migrate?
-      @legacy
-    end
+  def save(feature)
+    @storage.set(key(feature.name), feature.serialize)
+    @storage.set(features_key, (features | [feature.name.to_sym]).join(','))
+  end
 end

data/rollout.gemspec

@@ -1,27 +1,31 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "rollout/version"
+# frozen_string_literal: true
 
-Gem::Specification.new do |s|
-  s.name = "rollout"
-  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"
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'rollout/version'
 
-  s.rubyforge_project = "rollout"
+Gem::Specification.new do |spec|
+  spec.name        = 'rollout'
+  spec.version     = Rollout::VERSION
+  spec.authors     = ['James Golick']
+  spec.email       = ['jamesgolick@gmail.com']
+  spec.description = 'Feature flippers with redis.'
+  spec.summary     = 'Feature flippers with redis.'
+  spec.homepage    = 'https://github.com/FetLife/rollout'
+  spec.license     = 'MIT'
 
-  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"]
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  spec.require_paths = ['lib']
 
-  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_development_dependency "redis"
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.add_dependency 'redis', '~> 4.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'fakeredis'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.4'
+  spec.add_development_dependency 'rubocop', '~> 0.71'
+  spec.add_development_dependency 'simplecov', '~> 0.16'
 end