feature_flagger 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b54bc71d733eb04b2e52156763557a45f94d9722918b12b09e89a07553b88ee4
-  data.tar.gz: 5984d522ae2d19f324de342db5810cd9bf351c43a9e60e159f8442209f38575f
+  metadata.gz: 33983c979f6382f528796cbab4e51e80000c6855f50702602f451e2fb9cad666
+  data.tar.gz: 766cc624063a0a2516a2509c70f6bf6b397cc4ffcda6ee2333f36ac45d74f99a
 SHA512:
-  metadata.gz: ece7587ed9528ca583e61645bc3e5e9fcb710f37308ebbc8bb278390966e8edec6e8dc0a282fbb5864893623da631a1d4f3bffc0876dd484d3523e8008c90c11
-  data.tar.gz: 9ccdf791f1c7b6c5f10674753ecfbbfb81b4fa69546057e8061b8c0c269c347999503cb4fc868a215073e70cd6b8cb1382c39bcccfb8c11a0fcd2a346601f82d
+  metadata.gz: 3ea819eac2381595cab508f5d8e83a2e20c3b2516ad413819875ce12392cf61d67b7a1876ffe9a5345e2dc174205b6cf3b72eba8c12fd007baa7045fffefdfc4
+  data.tar.gz: fadce1676c47be30ed5a4fe8845b198448395b75a4a575276fea62eb5f6565318ea9dc27770b21d43418552372c0ec19757f460fefd77a9a15cd017aa386a468

data/README.md

@@ -74,6 +74,10 @@ account.release(:email_marketing, :new_email_flow)
 account.released?(:email_marketing, :new_email_flow)
 #=> true
 
+# Get an array with all features for a specific account id
+account.releases
+=> ['email_marketing:new_email_flow']
+
 # Remove feature for given account
 account.unrelease(:email_marketing, :new_email_flow)
 #=> true

data/lib/feature_flagger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 require 'feature_flagger/version'
@@ -6,8 +8,11 @@ require 'feature_flagger/control'
 require 'feature_flagger/model'
 require 'feature_flagger/model_settings'
 require 'feature_flagger/feature'
+require 'feature_flagger/key_resolver'
+require 'feature_flagger/key_decomposer'
 require 'feature_flagger/configuration'
 require 'feature_flagger/manager'
+require 'feature_flagger/storage/feature_keys_migration'
 require 'feature_flagger/railtie'
 
 module FeatureFlagger

data/lib/feature_flagger/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FeatureFlagger
   class Configuration
     attr_accessor :storage, :yaml_filepath
@@ -8,7 +10,9 @@ module FeatureFlagger
     end
 
     def info
-      @info ||= YAML.load_file(yaml_filepath) if yaml_filepath
+      raise 'Missing configuration file.' unless yaml_filepath
+
+      @info ||= YAML.load_file(yaml_filepath)
     end
 
     def mapped_feature_keys(resource_name = nil)
@@ -40,7 +44,7 @@ module FeatureFlagger
 
     def join_key(resource_name, key)
       key.unshift resource_name if resource_name
-      key.join(":")
+      key.join(':')
     end
   end
 end

data/lib/feature_flagger/control.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FeatureFlagger
   class Control
     attr_reader :storage
@@ -8,36 +10,41 @@ module FeatureFlagger
       @storage = storage
     end
 
-    def released?(feature_key, resource_id)
-      @storage.has_value?(RELEASED_FEATURES, feature_key) || @storage.has_value?(feature_key, resource_id)
+    def released?(feature_key, resource_name, resource_id)
+      @storage.has_value?(feature_key, resource_name, RELEASED_FEATURES) ||
+        @storage.has_value?(feature_key, resource_name, resource_id)
+    end
+
+    def release(feature_key, resource_name, resource_id)
+      @storage.add(feature_key, resource_name, resource_id)
     end
 
-    def release(feature_key, resource_id)
-      @storage.add(feature_key, resource_id)
+    def release_to_all(feature_key, resource_name)
+      @storage.add_all(RELEASED_FEATURES, feature_key, resource_name)
     end
 
-    def release_to_all(feature_key)
-      @storage.add_all(RELEASED_FEATURES, feature_key)
+    def all_feature_keys(resource_name, resource_id)
+      @storage.all_feature_keys(RELEASED_FEATURES, resource_name, resource_id)
     end
 
-    def unrelease(feature_key, resource_id)
-      @storage.remove(feature_key, resource_id)
+    def unrelease(feature_key, resource_name, resource_id)
+      @storage.remove(feature_key, resource_name, resource_id)
     end
 
-    def unrelease_to_all(feature_key)
-      @storage.remove_all(RELEASED_FEATURES, feature_key)
+    def unrelease_to_all(feature_key, resource_name)
+      @storage.remove_all(feature_key, resource_name)
     end
 
-    def resource_ids(feature_key)
-      @storage.all_values(feature_key)
+    def resource_ids(feature_key, resource_name)
+      @storage.all_values(feature_key, resource_name)
     end
 
-    def released_features_to_all
-      @storage.all_values(RELEASED_FEATURES)
+    def released_features_to_all(resource_name)
+      @storage.all_feature_keys(RELEASED_FEATURES, resource_name)
     end
 
-    def released_to_all?(feature_key)
-      @storage.has_value?(RELEASED_FEATURES, feature_key)
+    def released_to_all?(feature_key, resource_name)
+      @storage.has_value?(feature_key, resource_name, RELEASED_FEATURES)
     end
 
     def search_keys(query)

data/lib/feature_flagger/core_ext.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+begin
+  require 'active_support/core_ext/string/inflections'
+rescue LoadError
+  unless ''.respond_to?(:constantize)
+    class String
+      def constantize
+        names = split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      end
+    end
+  end
+end

data/lib/feature_flagger/feature.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module FeatureFlagger
+  class KeyNotFoundError < StandardError; end
+
   class Feature
-    def initialize(feature_key, resource_name = nil)
-      @feature_key = resolve_key(feature_key, resource_name)
-      @doc = FeatureFlagger.config.info
+    def initialize(feature_key, resource_name)
+      @key_resolver = KeyResolver.new(feature_key, resource_name.to_s)
+
       fetch_data
     end
 
@@ -11,33 +15,35 @@ module FeatureFlagger
     end
 
     def key
-      @feature_key.join(':')
+      @key_resolver.normalized_key.join(':')
     end
 
     private
 
-    def resolve_key(feature_key, resource_name)
-      key = Array(feature_key).flatten
-      key.insert(0, resource_name) if resource_name
-      key.map(&:to_s)
+    def config_info
+      FeatureFlagger.config.info
     end
 
     def fetch_data
-      @data ||= find_value(@doc, *@feature_key)
-      raise FeatureFlagger::KeyNotFoundError.new(@feature_key) if @data.nil?
+      @data ||= find_value(config_info, *@key_resolver.normalized_key_with_name)
+
+      if @data.nil? || @data["description"].nil?
+        raise FeatureFlagger::KeyNotFoundError, @feature_key
+      end
+
       @data
     end
 
     def find_value(hash, key, *tail)
+      return nil if hash.nil?
+
       value = hash[key]
 
-      if value.nil? || tail.empty?
-        value
-      else
-        find_value(value, *tail)
+      if tail.any?
+        return find_value(value, *tail)
       end
+
+      value
     end
   end
 end
-
-class FeatureFlagger::KeyNotFoundError < StandardError ; end

data/lib/feature_flagger/key_decomposer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module FeatureFlagger
+  class KeyDecomposer
+    def self.decompose(complete_feature_key)
+      decomposed_key = complete_feature_key.split(':')
+      resource_name = decomposed_key.shift
+
+      [resource_name, decomposed_key]
+    end
+  end
+end

data/lib/feature_flagger/key_resolver.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module FeatureFlagger
+  class KeyResolver
+    def initialize(feature_key, resource_name)
+      @feature_key = feature_key
+      @resource_name = resource_name
+    end
+
+    def normalized_key
+      @normalized_key ||= Array(@feature_key).flatten
+                                             .map(&:to_s)
+    end
+
+    def normalized_key_with_name
+      @normalized_key_with_name ||= [@resource_name] + normalized_key
+    end
+  end
+end

data/lib/feature_flagger/manager.rb

@@ -1,18 +1,28 @@
+# frozen_string_literal: true
+
 module FeatureFlagger
   class Manager
+    def self.detached_feature_keys(resource_name)
+      keys = FeatureFlagger.control.search_keys("#{resource_name}:*")
+
+      persisted_features = keys.flat_map do |key|
+        FeatureFlagger.control.all_feature_keys(resource_name, key.sub("#{resource_name}:", ''))
+      end.sort.uniq
+
+      mapped_feature_keys = FeatureFlagger.config.mapped_feature_keys(resource_name).map do |feature|
+        feature.sub("#{resource_name}:", '')
+      end
 
-    def self.detached_feature_keys
-      persisted_features = FeatureFlagger.control.search_keys("*").to_a
-      mapped_feature_keys = FeatureFlagger.config.mapped_feature_keys
       persisted_features - mapped_feature_keys
     end
 
     def self.cleanup_detached(resource_name, *feature_key)
-      complete_feature_key = feature_key.map(&:to_s).insert(0, resource_name.to_s)
-      key_value = FeatureFlagger.config.info.dig(*complete_feature_key)
-      raise "key is still mapped" if key_value
-      FeatureFlagger.control.unrelease_to_all(complete_feature_key.join(':'))
+      feature = Feature.new(feature_key, resource_name)
+      raise 'key is still mapped'
+    rescue FeatureFlagger::KeyNotFoundError => _e
+      # This means the keys is not present in config file anymore
+      key_resolver = KeyResolver.new(feature_key, resource_name)
+      FeatureFlagger.control.unrelease_to_all(key_resolver.normalized_key, resource_name)
     end
-
   end
 end

data/lib/feature_flagger/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FeatureFlagger
   # Model provides convinient methods for Rails Models
   # class Account
@@ -20,10 +22,13 @@ module FeatureFlagger
       self.class.release_id(feature_flagger_identifier, *feature_key)
     end
 
+    def releases
+      self.class.release_keys(feature_flagger_identifier)
+    end
+
     def unrelease(*feature_key)
-      resource_name = self.class.feature_flagger_model_settings.entity_name
-      feature = Feature.new(feature_key, resource_name)
-      FeatureFlagger.control.unrelease(feature.key, id)
+      feature = Feature.new(feature_key, feature_flagger_name)
+      FeatureFlagger.control.unrelease(feature.key, feature_flagger_name, id)
     end
 
     private
@@ -32,69 +37,66 @@ module FeatureFlagger
       public_send(self.class.feature_flagger_model_settings.identifier_field)
     end
 
+    def feature_flagger_name
+      self.class.feature_flagger_model_settings.entity_name
+    end
+
     module ClassMethods
       def feature_flagger
         raise ArgumentError unless block_given?
+
         yield feature_flagger_model_settings
       end
 
       def released_id?(resource_id, *feature_key)
-        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
-        FeatureFlagger.control.released?(feature.key, resource_id)
+        feature = Feature.new(feature_key, feature_flagger_name)
+        FeatureFlagger.control.released?(feature.key, feature_flagger_name, resource_id)
       end
 
       def release_id(resource_id, *feature_key)
-        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
-        FeatureFlagger.control.release(feature.key, resource_id)
+        feature = Feature.new(feature_key, feature_flagger_name)
+        FeatureFlagger.control.release(feature.key, feature_flagger_name, resource_id)
+      end
+
+      def release_keys(resource_id)
+        FeatureFlagger.control.all_feature_keys(feature_flagger_name, resource_id)
+      end
+
+      def unrelease_id(resource_id, *feature_key)
+        feature = Feature.new(feature_key, feature_flagger_name)
+        FeatureFlagger.control.unrelease(feature.key, feature_flagger_name, resource_id)
       end
 
       def all_released_ids_for(*feature_key)
-        feature_key.flatten!
-        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
-        FeatureFlagger.control.resource_ids(feature.key)
+        feature = Feature.new(feature_key, feature_flagger_name)
+        FeatureFlagger.control.resource_ids(feature.key, feature_flagger_name)
       end
 
       def release_to_all(*feature_key)
-        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
-        FeatureFlagger.control.release_to_all(feature.key)
+        feature = Feature.new(feature_key, feature_flagger_name)
+        FeatureFlagger.control.release_to_all(feature.key, feature_flagger_name)
       end
 
       def unrelease_to_all(*feature_key)
-        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
-        FeatureFlagger.control.unrelease_to_all(feature.key)
+        feature = Feature.new(feature_key, feature_flagger_name)
+        FeatureFlagger.control.unrelease_to_all(feature.key, feature_flagger_name)
       end
 
       def released_features_to_all
-        FeatureFlagger.control.released_features_to_all
+        FeatureFlagger.control.released_features_to_all(feature_flagger_name)
       end
 
       def released_to_all?(*feature_key)
-        feature = Feature.new(feature_key, feature_flagger_model_settings.entity_name)
-        FeatureFlagger.control.released_to_all?(feature.key)
+        feature = Feature.new(feature_key, feature_flagger_name)
+        FeatureFlagger.control.released_to_all?(feature.key, feature_flagger_name)
       end
 
       def detached_feature_keys
-        rollout_resource_name = feature_flagger_model_settings.entity_name
-        persisted_features = FeatureFlagger.control.search_keys("#{rollout_resource_name}:*").to_a
-        mapped_feature_keys = FeatureFlagger.config.mapped_feature_keys(rollout_resource_name)
-        (persisted_features - mapped_feature_keys).map { |key| key.sub("#{rollout_resource_name}:",'') }
+        Manager.detached_feature_keys(feature_flagger_name)
       end
 
       def cleanup_detached(*feature_key)
-        complete_feature_key = feature_key.map(&:to_s).insert(0, feature_flagger_model_settings.entity_name)
-        key_value = FeatureFlagger.config.info.dig(*complete_feature_key)
-        raise "key is still mapped" if key_value
-        FeatureFlagger.control.unrelease_to_all(complete_feature_key.join(':'))
-      end
-
-      def rollout_resource_name
-        klass_name = self.to_s
-        klass_name.gsub!(/::/, '_')
-        klass_name.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
-        klass_name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-        klass_name.tr!("-", "_")
-        klass_name.downcase!
-        klass_name
+        Manager.cleanup_detached(feature_flagger_name, feature_key)
       end
 
       def feature_flagger_model_settings
@@ -104,8 +106,20 @@ module FeatureFlagger
         )
       end
 
-      def feature_flagger_identifier
-        public_send(feature_flagger_model_settings.identifier_field)
+      private
+
+      def rollout_resource_name
+        klass_name = to_s
+        klass_name.gsub!(/::/, '_')
+        klass_name.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        klass_name.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        klass_name.tr!('-', '_')
+        klass_name.downcase!
+        klass_name
+      end
+
+      def feature_flagger_name
+        feature_flagger_model_settings.entity_name
       end
     end
   end

data/lib/feature_flagger/model_settings.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module FeatureFlagger
   class ModelSettings
     def initialize(arguments)
       arguments.each do |field, value|
-        self.public_send("#{field}=", value)
+        public_send("#{field}=", value)
       end
     end
 
@@ -12,7 +14,7 @@ module FeatureFlagger
 
     # Public: entity_name to which entity the model is targeting.
     # Take this yaml file as example:
-    # 
+    #
     # account:
     #   email_marketing:
     #       whitelabel:
@@ -33,4 +35,4 @@ module FeatureFlagger
     #   end
     attr_accessor :entity_name
   end
-end
+end

data/lib/feature_flagger/railtie.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 if defined?(Rails)
   module FeatureFlagger
     class Railtie < Rails::Railtie
       rake_tasks do
-        load 'tasks/cleanup.rake'
+        load 'tasks/feature_flagger.rake'
       end
     end
   end
-end
+end

data/lib/feature_flagger/storage/feature_keys_migration.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module FeatureFlagger
+  module Storage
+    class FeatureKeysMigration
+      def initialize(from_redis, to_control)
+        @from_redis = from_redis
+        @to_control = to_control
+      end
+
+      def call
+        @from_redis.keys('*').map { |key| migrate_key(key) }.flatten
+      end
+
+      private
+
+      def migrate_key(key)
+        return migrate_release_to_all(key) if feature_released_to_all?(key)
+
+        migrate_release(key)
+      end
+
+      def migrate_release_to_all(key)
+        features = @from_redis.smembers(key)
+
+        features.map do |feature|
+          resource_name, feature_key = KeyDecomposer.decompose(feature)
+          feature = Feature.new(feature_key, resource_name)
+
+          @to_control.release_to_all(feature.key, resource_name)
+        rescue KeyNotFoundError => _e
+          next
+        end
+      end
+
+      def feature_released_to_all?(key)
+        FeatureFlagger::Control::RELEASED_FEATURES == key
+      end
+
+      def migrate_release(key)
+        return false if key =~ /(\d+).*/
+
+        resource_ids = @from_redis.smembers(key)
+
+        resource_name, feature_key = KeyDecomposer.decompose(key)
+        feature = Feature.new(feature_key, resource_name)
+
+        @to_control.release(feature.key, resource_name, resource_ids)
+      rescue KeyNotFoundError => _e
+        return
+      end
+    end
+  end
+end

data/lib/feature_flagger/storage/redis.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'redis'
 require 'redis-namespace'
 
 module FeatureFlagger
   module Storage
     class Redis
-
       DEFAULT_NAMESPACE = :feature_flagger
 
       def initialize(redis)
@@ -13,42 +14,81 @@ module FeatureFlagger
 
       def self.default_client
         redis = ::Redis.new(url: ENV['REDIS_URL'])
-        ns = ::Redis::Namespace.new(DEFAULT_NAMESPACE, :redis => redis)
+        ns = ::Redis::Namespace.new(DEFAULT_NAMESPACE, redis: redis)
         new(ns)
       end
 
-      def has_value?(key, value)
-        @redis.sismember(key, value)
+      def has_value?(feature_key, resource_name, resource_id)
+        @redis.sismember("#{resource_name}:#{resource_id}", feature_key)
+      end
+
+      def add(feature_key, resource_name, resource_ids)
+        @redis.multi do |redis|
+          Array(resource_ids).each do |resource_id|
+            redis.sadd("#{resource_name}:#{resource_id}", feature_key)
+          end
+        end
       end
 
-      def add(key, value)
-        @redis.sadd(key, value)
+      def remove(feature_key, resource_name, resource_ids)
+        @redis.multi do |redis|
+          Array(resource_ids).each do |resource_id|
+            redis.srem("#{resource_name}:#{resource_id}", feature_key)
+          end
+        end
       end
 
-      def remove(key, value)
-        @redis.srem(key, value)
+      def all_feature_keys(global_features_key, resource_name, resource_id = nil)
+        if resource_id
+          return @redis.sunion(
+            "#{resource_name}:#{global_features_key}",
+            "#{resource_name}:#{resource_id}"
+          )
+        end
+
+        @redis.smembers("#{resource_name}:#{global_features_key}")
       end
 
-      def remove_all(global_key, key)
+      def remove_all(feature_key, resource_name)
+        keys = search_keys("#{resource_name}:*")
+
         @redis.multi do |redis|
-          redis.srem(global_key, key)
-          redis.del(key)
+          keys.map do |key|
+            redis.srem(key, feature_key)
+          end
         end
       end
 
-      def add_all(global_key, key)
+      def add_all(global_features_key, feature_key, resource_name)
+        keys = search_keys("#{resource_name}:*") - ["#{resource_name}:#{global_features_key}"]
+
+        add(feature_key, resource_name, global_features_key)
+
         @redis.multi do |redis|
-          redis.sadd(global_key, key)
-          redis.del(key)
+          keys.map do |key|
+            redis.srem(key.to_s, feature_key)
+          end
         end
       end
 
-      def all_values(key)
-        @redis.smembers(key)
+      def all_values(feature_key, resource_name)
+        keys = search_keys("#{resource_name}:*")
+        query = {}
+        @redis.pipelined do |redis|
+          keys.map do |key|
+            query[key] = redis.sismember(key, feature_key)
+          end
+        end
+
+        query.map do |key, in_redis|
+          next unless in_redis.value == true
+
+          key.gsub("#{resource_name}:", '')
+        end.compact
       end
 
-      def search_keys(query)
-        @redis.scan_each(match: query)
+      def search_keys(pattern)
+        @redis.keys(pattern)
       end
     end
   end

data/lib/feature_flagger/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FeatureFlagger
-  VERSION = "1.1.0"
+  VERSION = '2.0.0'
 end

data/lib/tasks/feature_flagger.rake

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+namespace :feature_flagger do
+  desc "cleaning up keys from storage that are no longer in the rollout.yml file, Usage: `$ bundle exec rake feature_flagger:cleanup_removed_rollouts\[Account\] `"
+  task :cleanup_removed_rollouts, %i[entity_name] => :environment do
+    resource_name = args.entity_name.constantize
+    feature_keys = FeatureFlagger::Manager.detached_feature_keys(resource_name)
+    puts "Found keys to remove: #{feature_keys}"
+    feature_keys.each do |feature_key|
+      FeatureFlagger::Manager.cleanup_detached(resource_name, feature_key)
+    rescue RuntimeError, 'key is still mapped'
+      next
+    end
+  end
+
+  namespace :storage do
+    namespace :redis do
+      desc 'Migrate the old key format to the new one, Usage: `$ bundle exec rake feature_flagger:storage:redis:migrate`'
+      task :migrate => :environment do |_, _args|
+        redis = ::Redis::Namespace.new(
+          FeatureFlagger::Storage::Redis::DEFAULT_NAMESPACE,
+          redis: ::Redis.new(url: ENV['REDIS_URL'])
+        )
+        control = FeatureFlagger.control
+
+        FeatureFlagger::Storage::FeatureKeysMigration.new(redis, control).call
+      end
+    end
+  end
+
+  desc "Release feature to given identifiers, Usage: `$ bundle exec rake feature_flagger:release\[Account,email_marketing:whitelabel,1,2,3,4\]`"
+  task :release, %i[entity_name feature_key] => :environment do |_, args|
+    entity = args.entity_name.constantize
+    entity_ids = args.extras
+    entity.release_id(entity_ids, *args.feature_key.split(':'))
+  end
+
+  desc "Unrelease feature to given identifiers, Usage: `$ bundle exec rake feature_flagger:unrelease\[Account,email_marketing:whitelabel,1,2,3,4\]`"
+  task :unrelease, %i[entity_name feature_key] => :environment do |_, args|
+    entity = args.entity_name.constantize
+    entity_ids = args.extras
+    entity.unrelease_id(entity_ids, *args.feature_key.split(':'))
+  end
+
+  desc "Release one feature to all entity ids, Usage: `$ bundle exec rake feature_flagger:release_to_all\[Account,email_marketing:whitelabel\]`"
+  task :release_to_all, %i[entity_name feature_key] => :environment do |_, args|
+    entity = args.entity_name.constantize
+    entity.release_to_all(*args.feature_key.split(':'))
+  end
+
+  desc "Unrelease one feature to all entity ids, Usage: `$ bundle exec rake feature_flagger:unrelease_to_all\[Account,email_marketing:whitelabel\]`"
+  task :unrelease_to_all, %i[entity_name feature_key] => :environment do |_, args|
+    entity = args.entity_name.constantize
+    entity.unrelease_to_all(*args.feature_key.split(':'))
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feature_flagger
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Nando Sousa
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-14 00:00:00.000000000 Z
+date: 2020-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -43,30 +43,44 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -82,19 +96,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: fakeredis
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: '0.17'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: '0.17'
 description: Management tool to make it easier rollouting features to customers.
 email:
 - nandosousafr@gmail.com
@@ -108,14 +122,18 @@ files:
 - lib/feature_flagger.rb
 - lib/feature_flagger/configuration.rb
 - lib/feature_flagger/control.rb
+- lib/feature_flagger/core_ext.rb
 - lib/feature_flagger/feature.rb
+- lib/feature_flagger/key_decomposer.rb
+- lib/feature_flagger/key_resolver.rb
 - lib/feature_flagger/manager.rb
 - lib/feature_flagger/model.rb
 - lib/feature_flagger/model_settings.rb
 - lib/feature_flagger/railtie.rb
+- lib/feature_flagger/storage/feature_keys_migration.rb
 - lib/feature_flagger/storage/redis.rb
 - lib/feature_flagger/version.rb
-- lib/tasks/cleanup.rake
+- lib/tasks/feature_flagger.rake
 homepage: http://github.com/ResultadosDigitais/feature_flagger
 licenses:
 - MIT
@@ -135,8 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Partial release your features.

data/lib/tasks/cleanup.rake

@@ -1,10 +0,0 @@
-namespace :feature_flagger do
-  desc "cleaning up keys from storage that are no longer in the rollout.yml file"
-  task :cleanup_removed_rollouts => :environment do
-    keys = FeatureFlagger::Manager.detached_feature_keys
-    puts "Found keys to remove: #{keys}"
-    keys.each do |key|
-      FeatureFlagger::Manager.cleanup_detached key
-    end
-  end
-end