feature_flagger 0.7.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7a86dad466ea3472db2912775bba5d1b7412b86d
-  data.tar.gz: fe6eefd07a2d78b1b52661ff06a15399c30881ca
+SHA256:
+  metadata.gz: 33983c979f6382f528796cbab4e51e80000c6855f50702602f451e2fb9cad666
+  data.tar.gz: 766cc624063a0a2516a2509c70f6bf6b397cc4ffcda6ee2333f36ac45d74f99a
 SHA512:
-  metadata.gz: 176eaee71d771fbe687ae92e099f39f1fc268eef4cc8ff8c382692d6af4a027243472046f49efdf40727811f3b1c569cc70482efd558be9ff86a15c7c9bf49dc
-  data.tar.gz: 22593e2d0c21ed1b7712d6bb8c7dc38efafe9e3cad89b939674188271b96605eda29d2ac2625ac4dcfdb8a785664ed64db9a311aeab47f058f466391243d4c2f
+  metadata.gz: 3ea819eac2381595cab508f5d8e83a2e20c3b2516ad413819875ce12392cf61d67b7a1876ffe9a5345e2dc174205b6cf3b72eba8c12fd007baa7045fffefdfc4
+  data.tar.gz: fadce1676c47be30ed5a4fe8845b198448395b75a4a575276fea62eb5f6565318ea9dc27770b21d43418552372c0ec19757f460fefd77a9a15cd017aa386a468

data/README.md

@@ -4,6 +4,14 @@
 
 Partially release your features.
 
+## Working with Docker
+
+Open IRB
+`docker-compose run feature_flagger`
+
+Running tests
+`docker-compose run feature_flagger rspec`
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -24,20 +32,19 @@ Or install it yourself as:
 ## Configuration
 
 By default, feature_flagger uses the REDIS_URL env var to setup it's storage.
-You can configure this by using `configure` like such:
-
-1. In a initializer file (e.g. `config/initializers/feature_flagger.rb`):
+You can set up FeatureFlagger by creating a file called ```config/initializers/feature_flagger``` with the following lines:
 ```ruby
 require 'redis-namespace'
 require 'feature_flagger'
 
 FeatureFlagger.configure do |config|
-  namespaced = ::Redis::Namespace.new("feature_flagger", redis: $redis)
+  redis = Redis.new(host: ENV['REDIS_URL'])
+  namespaced = Redis::Namespace.new('feature_flagger', redis: redis)
   config.storage = FeatureFlagger::Storage::Redis.new(namespaced)
 end
 ```
 
-2. Create a `rollout.yml` in _config_ path and declare a rollout:
+1. Create a `rollout.yml` in _config_ path and declare a rollout:
 ```yml
 account: # model name
   email_marketing: # namespace (optional)
@@ -46,7 +53,7 @@ account: # model name
         @dispatch team uses this rollout to introduce a new email flow for certains users. Read more at [link]
 ```
 
-3. Adds rollout funcionality to your model:
+2. Adds rollout funcionality to your model:
 ```ruby
 class Account < ActiveRecord::Base
   include FeatureFlagger::Model
@@ -64,21 +71,29 @@ account.release(:email_marketing, :new_email_flow)
 #=> true
 
 # Check feature for a given account
-account.rollout?(: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
 
 # If you try to check an inexistent rollout key it will raise an error.
-account.rollout?(:email_marketing, :new_email_flow)
+account.released?(:email_marketing, :new_email_flow)
 FeatureFlagger::KeyNotFoundError: ["account", "email_marketing", "new_email_flo"]
 
 # Check feature for a specific account id
 Account.released_id?(42, :email_marketing, :new_email_flow)
 #=> true
 
+# Release a feature for a specific account id
+Account.release_id(42, :email_marketing, :new_email_flow)
+#=> true
+
 # Get an array with all released Account ids
 Account.all_released_ids_for(:email_marketing, :new_email_flow)
 
@@ -92,7 +107,15 @@ Account.unrelease_to_all(:email_marketing, :new_email_flow)
 Account.released_features_to_all
 ```
 
+## Clean up action
+
+By default when a key is removed from `rollout.yml` file, its data still in the storage.
+
+To clean it up, execute or schedule the rake:
+
+    $ bundle exec rake feature_flagger:cleanup_removed_rollouts
+
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at
-https://github.com/ResultadosDigitais/feature_flagger.
+Bug reports and pull requests are welcome!
+Please take a look at our guidelines [here](CONTRIBUTING.md).

data/lib/feature_flagger.rb

@@ -1,11 +1,19 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 require 'feature_flagger/version'
 require 'feature_flagger/storage/redis'
 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
   class << self

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,16 @@ 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)
+      info_filtered = resource_name ? info[resource_name] : info
+      [].tap do |keys|
+        make_keys_recursively(info_filtered).each { |key| keys.push(join_key(resource_name, key)) }
+      end
     end
 
     private
@@ -16,5 +27,24 @@ module FeatureFlagger
     def default_yaml_filepath
       "#{Rails.root}/config/rollout.yml" if defined?(Rails)
     end
+
+    def make_keys_recursively(hash, keys = [], composed_key = [])
+      unless hash.values[0].is_a?(Hash)
+        keys.push(composed_key)
+        return
+      end
+
+      hash.each do |key, value|
+        composed_key_cloned = composed_key.clone
+        composed_key_cloned.push(key.to_sym)
+        make_keys_recursively(value, keys, composed_key_cloned)
+      end
+      keys
+    end
+
+    def join_key(resource_name, key)
+      key.unshift resource_name if resource_name
+      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,44 +10,45 @@ module FeatureFlagger
       @storage = storage
     end
 
-    def rollout?(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(RELEASED_FEATURES, feature_key)
+    def all_feature_keys(resource_name, resource_id)
+      @storage.all_feature_keys(RELEASED_FEATURES, resource_name, resource_id)
     end
 
-    # <b>DEPRECATED:</b> Please use <tt>release</tt> instead.
-    def release!(feature_key, resource_id)
-      warn "[DEPRECATION] `release!` is deprecated.  Please use `release` instead."
-      release(feature_key, resource_id)
+    def unrelease(feature_key, resource_name, resource_id)
+      @storage.remove(feature_key, resource_name, resource_id)
     end
 
-    def unrelease(feature_key, resource_id)
-      @storage.remove(feature_key, resource_id)
+    def unrelease_to_all(feature_key, resource_name)
+      @storage.remove_all(feature_key, resource_name)
     end
 
-    def unrelease_to_all(feature_key)
-      @storage.remove(RELEASED_FEATURES, feature_key)
+    def resource_ids(feature_key, resource_name)
+      @storage.all_values(feature_key, resource_name)
     end
 
-    # <b>DEPRECATED:</b> Please use <tt>unrelease</tt> instead.
-    def unrelease!(feature_key, resource_id)
-      warn "[DEPRECATION] `unrelease!` is deprecated.  Please use `unrelease` instead."
-      unrelease(feature_key, resource_id)
+    def released_features_to_all(resource_name)
+      @storage.all_feature_keys(RELEASED_FEATURES, resource_name)
     end
 
-    def resource_ids(feature_key)
-      @storage.all_values(feature_key)
+    def released_to_all?(feature_key, resource_name)
+      @storage.has_value?(feature_key, resource_name, RELEASED_FEATURES)
     end
 
-    def released_features_to_all
-      @storage.all_values(RELEASED_FEATURES)
+    def search_keys(query)
+      @storage.search_keys(query)
     end
   end
 end

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

@@ -0,0 +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
+
+      persisted_features - mapped_feature_keys
+    end
+
+    def self.cleanup_detached(resource_name, *feature_key)
+      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
@@ -12,69 +14,113 @@ module FeatureFlagger
       base.extend ClassMethods
     end
 
-    def rollout?(*feature_key)
-      self.class.released_id?(id, feature_key)
-    end
-
-    # <b>DEPRECATED:</b> Please use <tt>release</tt> instead.
-    def release!(*feature_key)
-      warn "[DEPRECATION] `release!` is deprecated.  Please use `release` instead."
-      release(*feature_key)
+    def released?(*feature_key)
+      self.class.released_id?(feature_flagger_identifier, feature_key)
     end
 
     def release(*feature_key)
-      resource_name = self.class.rollout_resource_name
-      feature = Feature.new(feature_key, resource_name)
-      FeatureFlagger.control.release(feature.key, id)
+      self.class.release_id(feature_flagger_identifier, *feature_key)
     end
 
-    # <b>DEPRECATED:</b> Please use <tt>unrelease</tt> instead.
-    def unrelease!(*feature_key)
-      warn "[DEPRECATION] `unrelease!` is deprecated.  Please use `unrelease` instead."
-      unrelease(*feature_key)
+    def releases
+      self.class.release_keys(feature_flagger_identifier)
     end
 
     def unrelease(*feature_key)
-      resource_name = self.class.rollout_resource_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
+
+    def feature_flagger_identifier
+      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, rollout_resource_name)
-        FeatureFlagger.control.rollout?(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_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, rollout_resource_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, rollout_resource_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, rollout_resource_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_name)
+        FeatureFlagger.control.released_to_all?(feature.key, feature_flagger_name)
+      end
+
+      def detached_feature_keys
+        Manager.detached_feature_keys(feature_flagger_name)
       end
 
+      def cleanup_detached(*feature_key)
+        Manager.cleanup_detached(feature_flagger_name, feature_key)
+      end
+
+      def feature_flagger_model_settings
+        @feature_flagger_model_settings ||= FeatureFlagger::ModelSettings.new(
+          identifier_field: :id,
+          entity_name: rollout_resource_name
+        )
+      end
+
+      private
+
       def rollout_resource_name
-        klass_name = self.to_s
+        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.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
 end

data/lib/feature_flagger/model_settings.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module FeatureFlagger
+  class ModelSettings
+    def initialize(arguments)
+      arguments.each do |field, value|
+        public_send("#{field}=", value)
+      end
+    end
+
+    # Public: identifier_field Refers to which field must represent the unique model
+    # id.
+    attr_accessor :identifier_field
+
+    # Public: entity_name to which entity the model is targeting.
+    # Take this yaml file as example:
+    #
+    # account:
+    #   email_marketing:
+    #       whitelabel:
+    #         description: a rollout
+    #         owner: core
+    # account_in_migration:
+    #   email_marketing:
+    #       whitelabel:
+    #         description: a rollout
+    #         owner: core
+    #
+    # class Account < ActiveRecord::Base
+    #   include FeatureFlagger::Model
+    #
+    #   feature_flagger do |config|
+    #     config.identifier_field = :cdp_tenant_id
+    #     config.entity_name = :account_in_migration
+    #   end
+    attr_accessor :entity_name
+  end
+end

data/lib/feature_flagger/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+if defined?(Rails)
+  module FeatureFlagger
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load 'tasks/feature_flagger.rake'
+      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,24 +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 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 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(feature_key, resource_name)
+        keys = search_keys("#{resource_name}:*")
+
+        @redis.multi do |redis|
+          keys.map do |key|
+            redis.srem(key, feature_key)
+          end
+        end
       end
 
-      def add(key, value)
-        @redis.sadd(key, value)
+      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|
+          keys.map do |key|
+            redis.srem(key.to_s, feature_key)
+          end
+        end
       end
 
-      def remove(key, value)
-        @redis.srem(key, value)
+      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 all_values(key)
-        @redis.smembers(key)
+      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 = "0.7.2"
+  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: 0.7.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Nando Sousa
@@ -9,64 +9,78 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-19 00:00:00.000000000 Z
+date: 2020-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
   name: redis-namespace
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        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'
+        version: '0.17'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.17'
 description: Management tool to make it easier rollouting features to customers.
 email:
 - nandosousafr@gmail.com
@@ -108,10 +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/feature_flagger.rake
 homepage: http://github.com/ResultadosDigitais/feature_flagger
 licenses:
 - MIT
@@ -124,17 +146,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Partial release your features.
 test_files: []
-has_rdoc: