feature_flagger 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb31f06b2fbb4faf49b9a560ffa6d97b774272dcd5ad6e660628b08380acf44d
-  data.tar.gz: 75207d7df33cc3f418a1b798d027c4ef701fbfd2aa15f17dc147e066a6f540c5
+  metadata.gz: 33983c979f6382f528796cbab4e51e80000c6855f50702602f451e2fb9cad666
+  data.tar.gz: 766cc624063a0a2516a2509c70f6bf6b397cc4ffcda6ee2333f36ac45d74f99a
 SHA512:
-  metadata.gz: b47eb06400b71e1e5fb46effbb5429f9e2299227ea5bb7f555fc31d2b4c913d938f59be84816dd0a55b281ba3a35c6d2768b2d4c0f3b33db48ece7b56cedfdf9
-  data.tar.gz: b3c596059e1055c2a3a003961e74091cabb888c71e1f46f1c564097428e717444735195d11b02cc5dee95b032222308b4ac9798b34e8465f1a88c623239ad5ce
+  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
@@ -111,13 +115,6 @@ To clean it up, execute or schedule the rake:
 
     $ bundle exec rake feature_flagger:cleanup_removed_rollouts
 
-## Upgrading
-
-When upgrading from `1.1.x` to `1.2.x` the following command must be executed
-to ensure the data stored in Redis storage is right. Check [#67](https://github.com/ResultadosDigitais/feature_flagger/pull/67) and [#68](https://github.com/ResultadosDigitais/feature_flagger/pull/68) for more info.
-
-    $ bundle exec rake feature_flagger:migrate_to_resource_keys
-
 ## Contributing
 
 Bug reports and pull requests are welcome!

data/lib/feature_flagger.rb

@@ -1,14 +1,18 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 require 'feature_flagger/version'
 require 'feature_flagger/storage/redis'
-require 'feature_flagger/storage/feature_keys_migration'
 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,58 +10,45 @@ 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_id)
-      resource_name = Storage::Keys.extract_resource_name_from_feature_key(
-        feature_key
-      )
-
+    def release(feature_key, resource_name, resource_id)
       @storage.add(feature_key, resource_name, resource_id)
     end
 
-    def releases(resource_name, resource_id)
-      @storage.fetch_releases(resource_name, resource_id, RELEASED_FEATURES)
+    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)
-      resource_name = Storage::Keys.extract_resource_name_from_feature_key(
-        feature_key
-      )
-
+    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
 
-    # DEPRECATED: this method will be removed from public api on v2.0 version.
-    # use instead the feature_keys method.
     def search_keys(query)
       @storage.search_keys(query)
     end
-
-    def feature_keys
-      @storage.feature_keys
-    end
   end
 end

data/lib/feature_flagger/core_ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'active_support/core_ext/string/inflections'
 rescue LoadError

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,19 +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.feature_keys
-      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,15 +22,13 @@ module FeatureFlagger
       self.class.release_id(feature_flagger_identifier, *feature_key)
     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)
+    def releases
+      self.class.release_keys(feature_flagger_identifier)
     end
 
-    def releases
-      resource_name = self.class.feature_flagger_model_settings.entity_name
-      FeatureFlagger.control.releases(resource_name, id)
+    def unrelease(*feature_key)
+      feature = Feature.new(feature_key, feature_flagger_name)
+      FeatureFlagger.control.unrelease(feature.key, feature_flagger_name, id)
     end
 
     private
@@ -37,74 +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_model_settings.entity_name)
-        FeatureFlagger.control.unrelease(feature.key, resource_id)
+        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
@@ -114,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,3 +1,5 @@
+# frozen_string_literal: true
+
 if defined?(Rails)
   module FeatureFlagger
     class Railtie < Rails::Railtie

data/lib/feature_flagger/storage/feature_keys_migration.rb

@@ -1,57 +1,54 @@
 # frozen_string_literal: true
 
 module FeatureFlagger
-    module Storage
-      class FeatureKeysMigration
+  module Storage
+    class FeatureKeysMigration
+      def initialize(from_redis, to_control)
+        @from_redis = from_redis
+        @to_control = to_control
+      end
 
-        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
 
-        # call migrates features key from the old fashioned to the new
-        # format.
-        #
-        # It must replicate feature keys with changes:
-        #
-        # from "avenue:traffic_lights" => 42
-        # to   "avenue:42" => traffic_lights
-        def call
-          @from_redis.scan_each(match: "*", count: FeatureFlagger::Storage::Redis::SCAN_EACH_BATCH_SIZE) do |redis_key|
-            # filter out resource_keys
-            next if redis_key.start_with?("#{FeatureFlagger::Storage::Redis::RESOURCE_PREFIX}:")
-
-            migrate_key(redis_key)
-          end
-        end
+      private
 
-        private
+      def migrate_key(key)
+        return migrate_release_to_all(key) if feature_released_to_all?(key)
 
-        def migrate_key(key)
-          return migrate_release_to_all(key) if feature_released_to_all?(key)
+        migrate_release(key)
+      end
 
-          migrate_release(key)
-        end
+      def migrate_release_to_all(key)
+        features = @from_redis.smembers(key)
 
-        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)
 
-          features.each do |feature_key|
-            @to_control.release_to_all(feature_key)
-          end
+          @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 feature_released_to_all?(key)
+        FeatureFlagger::Control::RELEASED_FEATURES == key
+      end
 
-        def migrate_release(key)
-          resource_ids = @from_redis.smembers(key)
+      def migrate_release(key)
+        return false if key =~ /(\d+).*/
 
-          resource_ids.each do |id|
-            @to_control.release(key, id)
-          end
-        end
+        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,13 +1,12 @@
+# frozen_string_literal: true
+
 require 'redis'
 require 'redis-namespace'
-require_relative './keys'
 
 module FeatureFlagger
   module Storage
     class Redis
       DEFAULT_NAMESPACE = :feature_flagger
-      RESOURCE_PREFIX = "_r".freeze
-      SCAN_EACH_BATCH_SIZE = 1000.freeze
 
       def initialize(redis)
         @redis = redis
@@ -15,107 +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 fetch_releases(resource_name, resource_id, global_key)
-        resource_key = resource_key(resource_name, resource_id)
-        releases = @redis.sunion(resource_key, global_key)
-
-        releases.select{ |release| release.start_with?(resource_name) }
-      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_id)
-        resource_key = resource_key(resource_name, resource_id)
-
+      def add(feature_key, resource_name, resource_ids)
         @redis.multi do |redis|
-          redis.sadd(feature_key, resource_id)
-          redis.sadd(resource_key, feature_key)
+          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_id)
-        resource_key = resource_key(resource_name, resource_id)
-
+      def remove(feature_key, resource_name, resource_ids)
         @redis.multi do |redis|
-          redis.srem(feature_key, resource_id)
-          redis.srem(resource_key, feature_key)
+          Array(resource_ids).each do |resource_id|
+            redis.srem("#{resource_name}:#{resource_id}", feature_key)
+          end
         end
       end
 
-      def remove_all(global_key, feature_key)
-        @redis.srem(global_key, feature_key)
-        remove_feature_key_from_resources(feature_key)
-      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
 
-      def add_all(global_key, key)
-        @redis.sadd(global_key, key)
-        remove_feature_key_from_resources(key)
+        @redis.smembers("#{resource_name}:#{global_features_key}")
       end
 
-      def all_values(key)
-        @redis.smembers(key)
-      end
+      def remove_all(feature_key, resource_name)
+        keys = search_keys("#{resource_name}:*")
 
-      # DEPRECATED: this method will be removed from public api on v2.0 version.
-      # use instead the feature_keys method.
-      def search_keys(query)
-        @redis.scan_each(match: query)
+        @redis.multi do |redis|
+          keys.map do |key|
+            redis.srem(key, feature_key)
+          end
+        end
       end
 
-      def feature_keys
-        feature_keys = []
+      def add_all(global_features_key, feature_key, resource_name)
+        keys = search_keys("#{resource_name}:*") - ["#{resource_name}:#{global_features_key}"]
 
-        @redis.scan_each(match: "*") do |key|
-          # Reject keys related to feature responsible for return
-          # released features for a given account.
-          next if key.start_with?("#{RESOURCE_PREFIX}:")
+        add(feature_key, resource_name, global_features_key)
 
-          feature_keys << key
+        @redis.multi do |redis|
+          keys.map do |key|
+            redis.srem(key.to_s, feature_key)
+          end
         end
-
-        feature_keys
       end
 
-      def synchronize_feature_and_resource
-        FeatureFlagger::Storage::FeatureKeysMigration.new(
-          @redis,
-          FeatureFlagger.control,
-        ).call
-      end
+      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
 
-      private
+        query.map do |key, in_redis|
+          next unless in_redis.value == true
 
-      def resource_key(resource_name, resource_id)
-        FeatureFlagger::Storage::Keys.resource_key(
-          RESOURCE_PREFIX,
-          resource_name,
-          resource_id,
-        )
+          key.gsub("#{resource_name}:", '')
+        end.compact
       end
 
-      def remove_feature_key_from_resources(feature_key)
-        cursor = 0
-        resource_name = feature_key.split(":").first
-
-        loop do
-          cursor, resource_ids = @redis.sscan(feature_key, cursor, count: SCAN_EACH_BATCH_SIZE)
-
-          @redis.multi do |redis|
-            resource_ids.each do |resource_id|
-              key = resource_key(resource_name, resource_id)
-              redis.srem(key, feature_key)
-              redis.srem(feature_key, resource_id)
-            end
-          end
-
-          break if cursor == "0"
-        end
+      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.2.1"
+  VERSION = '2.0.0'
 end

data/lib/tasks/feature_flagger.rake

@@ -1,40 +1,55 @@
+# frozen_string_literal: true
+
 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
+  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
 
-  desc "Synchronizes resource_keys with feature_keys, recommended to apps that installed feature flagger before v.1.2.0"
-  task :migrate_to_resource_keys => :environment do
-    storage = FeatureFlagger.config.storage
-    storage.synchronize_feature_and_resource
+  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, [:entity_name, :feature_key] => :environment do |_, args|
+  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, [:entity_name, :feature_key] => :environment do |_, args|
-    entity, entity_ids = args.entity_name.constantize, args.extras
+  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, [:entity_name, :feature_key] => :environment do |_, args|
+  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, [:entity_name, :feature_key] => :environment do |_, args|
+  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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feature_flagger
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Nando Sousa
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-10 00:00:00.000000000 Z
+date: 2020-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -53,6 +53,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         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
@@ -95,20 +109,6 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: '0.17'
-- !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
 description: Management tool to make it easier rollouting features to customers.
 email:
 - nandosousafr@gmail.com
@@ -124,12 +124,13 @@ files:
 - 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/keys.rb
 - lib/feature_flagger/storage/redis.rb
 - lib/feature_flagger/version.rb
 - lib/tasks/feature_flagger.rake
@@ -152,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Partial release your features.

data/lib/feature_flagger/storage/keys.rb

@@ -1,21 +0,0 @@
-module FeatureFlagger
-  module Storage
-    module Keys
-      MINIMUM_VALID_FEATURE_PATH = 2.freeze
-
-      def self.resource_key(prefix, resource_name, resource_id)
-        "#{prefix}:#{resource_name}:#{resource_id}"
-      end
-
-      def self.extract_resource_name_from_feature_key(feature_key)
-        feature_paths = feature_key.split(':')
-
-        raise InvalidResourceNameError if feature_paths.size < MINIMUM_VALID_FEATURE_PATH
-
-        feature_paths.first
-      end
-
-      class InvalidResourceNameError < StandardError; end
-    end
-  end
-end