simple_feature_flags 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5ef1f22981517d9de71ff3dd332c76b355ea7711b23954f49a1ffe080bbbc3f
-  data.tar.gz: cd1df44c32ae4a3d320af005f34e08bee655e60912c9463069c112e926de2568
+  metadata.gz: 9d732d5d2141046aac302cce21de1487ca8c2d3526a64f7ad1845fc964ab8bec
+  data.tar.gz: 98677ad0f773881b575c7e3e3bb1c28b857544bdb6dbe370f8ad1d9f739848f0
 SHA512:
-  metadata.gz: 653d6ad9e44a2700b20735feec5ae8e4a7a29ce1882c010ea8de203777579c0849dd32c5aa9660a66e9584d8ef63b806d1e3b883c09304bf51cf5674099887eb
-  data.tar.gz: 0c3d7c8cbd3a3e2175a80f01cdb4d6c202d108c172451fefcefc06d7d9e0db8a58a87a46b0f8c624ee78f1bab930037493dee7b1feb3c83ec482849e507758f6
+  metadata.gz: 003561d885bf3e8ea25c6210c1f727453561c761a22bd08607d5b6e4cbfc36182b168b7ffa901d9c4ebc4e71b3499d1a7d4469ec1fd746c8b62ab4dab47a1abc
+  data.tar.gz: a7bc11c251004a5acfb190f435c993d2c8fd02136581ca74035abbdac174ed3345a6ef7f893048698196c437f22fbd925c14a28917f5bffcd18dc243618b9415

data/.vscode/settings.json

@@ -3,7 +3,12 @@
     "Espago",
     "autorun",
     "bindir",
+    "concat",
     "flushdb",
+    "hget",
+    "hgetall",
+    "hset",
+    "klass",
     "optparse",
     "solargraph",
     "testtask"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple_feature_flags (0.1.0)
+    simple_feature_flags (1.0.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -127,30 +127,144 @@ FEATURE_FLAGS = ::SimpleFeatureFlags::RamStorage.new(config_file)
 
 ### Functionality
 
-#### Adding feature flags
+#### Activate a feature
 
-You can add new feature flags programmatically, though we highly encourage you to use the generated `config/simple_feature_flags.yml` file instead. It will make it easier to add and/or remove feature flags automatically on app startup without having to add them manually after merging a branch with new feature flags.
+Activates a feature in the global scope
 
-In case you'd like to add flags programmatically
 ```ruby
-FEATURE_FLAGS.add(:feature_name, 'Description')
 FEATURE_FLAGS.active?(:feature_name) #=> false
 
-# add a new active flag
-FEATURE_FLAGS.add(:active_feature_name, 'Description', true)
-FEATURE_FLAGS.active?(:active_feature_name) #=> true
+FEATURE_FLAGS.activate(:feature_name)
+
+FEATURE_FLAGS.active?(:feature_name) #=> true
 ```
 
-#### Removing feature flags
+#### Deactivate a feature
 
-You can remove feature flags programmatically, though we highly encourage you to use the generated `config/simple_feature_flags.yml` file instead. It will make it easier to add and/or remove feature flags automatically on app startup without having to add them manually after merging a branch with new feature flags.
+Deactivates a feature in the global scope
 
-In case you'd like to remove flags programmatically
 ```ruby
-FEATURE_FLAGS.remove(:feature_name)
+FEATURE_FLAGS.active?(:feature_name) #=> true
+
+FEATURE_FLAGS.deactivate(:feature_name)
+
 FEATURE_FLAGS.active?(:feature_name) #=> false
 ```
 
+#### Activate a feature for a particular record/object
+
+```ruby
+FEATURE_FLAGS.activate_for(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+```
+
+Note that the flag itself has to be `active` in the global scope for any record/object specific settings to work.
+When the flag is `deactivated` it is completely turned off globally and for every specific record/object.
+
+```ruby
+# The flag is deactivated in the global scope to begin with
+FEATURE_FLAGS.active?(:feature_name) #=> false
+
+# We activate it for the first User
+FEATURE_FLAGS.activate_for(:feature_name, User.first)
+
+FEATURE_FLAGS.active?(:feature_name) #=> false
+# It is globally `deactivated` though, so the feature stays inactive for all users
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> false
+
+# Once we activate the flag in the global scope, record specific settings will be applied
+FEATURE_FLAGS.activate(:feature_name)
+
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+
+FEATURE_FLAGS.deactivate(:feature_name)
+
+FEATURE_FLAGS.active?(:feature_name) #=> false
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> false
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+```
+
+There is a convenience method `activate_for!`, which activates the feature in the global scope and for specific records/objects at the same time
+
+```ruby
+# The flag is deactivated in the global scope to begin with
+FEATURE_FLAGS.active?(:feature_name) #=> false
+
+# We activate it in the global scope and for the first User
+FEATURE_FLAGS.activate_for!(:feature_name, User.first)
+
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+```
+
+A feature that is `active` in the global scope is inactive for all specific records, unless it has been activated for them.
+
+```ruby
+# The flag is active in the global scope to begin with
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> false
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+
+FEATURE_FLAGS.activate_for(:feature_name, User.first)
+
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+```
+
+You can also pass an array of objects to activate all of them simultaneously
+
+```ruby
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> false
+FEATURE_FLAGS.active_for?(:feature_name, User.find(2)) #=> false
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+
+FEATURE_FLAGS.activate_for(:feature_name, User.first(2))
+
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.find(2)) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+```
+
+#### Activate the feature for every record
+
+```ruby
+# The flag is active in the global scope to begin with
+FEATURE_FLAGS.active?(:feature_name) #=> true
+# It is also enabled for the first user
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+
+# We force it onto every user
+FEATURE_FLAGS.activate!(:feature_name)
+
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> true
+
+# We can easily return to the previous settings
+FEATURE_FLAGS.activate(:feature_name)
+
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+```
+
+#### Deactivate a feature for a particular record/object
+
+```ruby
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+
+FEATURE_FLAGS.deactivate_for(:feature_name, User.first)
+
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> false
+```
+
+
 #### Run a block of code only when the flag is active
 
 There are two ways of running code only when the feature flag is active
@@ -158,18 +272,51 @@ There are two ways of running code only when the feature flag is active
 ```ruby
 number = 1
 if FEATURE_FLAGS.active?(:feature_name)
-    number += 1
+  number += 1
 end
 
 # or using a block
 
 # this code will run only when the :feature_name flag is active
-FEATURE_FLAGS.with_feature(:feature_name) do
-    number += 1
+FEATURE_FLAGS.when_active(:feature_name) do
+  number += 1
 end
 
 # feature flags that don't exist will return false
 FEATURE_FLAGS.active?(:non_existant) #=> false
+
+if FEATURE_FLAGS.active_for?(:feature_name, User.first)
+  number += 1
+end
+
+# this code will run only if the :feature_name flag is active for the first User
+FEATURE_FLAGS.when_active_for(:feature_name, User.first) do
+  number += 1
+end
+```
+
+#### Adding feature flags
+
+You can add new feature flags programmatically, though we highly encourage you to use the generated `config/simple_feature_flags.yml` file instead. It will make it easier to add and/or remove feature flags automatically on app startup without having to add them manually after merging a branch with new feature flags.
+
+In case you'd like to add flags programmatically
+```ruby
+FEATURE_FLAGS.add(:feature_name, 'Description')
+FEATURE_FLAGS.active?(:feature_name) #=> false
+
+# add a new active flag
+FEATURE_FLAGS.add(:active_feature_name, 'Description', true)
+FEATURE_FLAGS.active?(:active_feature_name) #=> true
+```
+
+#### Removing feature flags
+
+You can remove feature flags programmatically, though we highly encourage you to use the generated `config/simple_feature_flags.yml` file instead. It will make it easier to add and/or remove feature flags automatically on app startup without having to add them manually after merging a branch with new feature flags.
+
+In case you'd like to remove flags programmatically
+```ruby
+FEATURE_FLAGS.remove(:feature_name)
+FEATURE_FLAGS.active?(:feature_name) #=> false
 ```
 
 

data/lib/simple_feature_flags.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module SimpleFeatureFlags
+  NOT_PRESENT = ::Object.new.freeze
+
   class NoSuchCommandError < StandardError; end
 
   class IncorrectWorkingDirectoryError < StandardError; end

data/lib/simple_feature_flags/ram_storage.rb

@@ -17,6 +17,22 @@ module SimpleFeatureFlags
       __active__(feature)
     end
 
+    def active_globally?(feature)
+      flags.dig(feature.to_sym, 'active') == 'globally'
+    end
+
+    def active_for?(feature, object, object_id_method = :id)
+      return false unless active?(feature)
+      return true if active_globally?(feature)
+
+      active_objects_hash = active_objects(feature)
+      active_ids = active_objects_hash[object.class.to_s]
+
+      return false unless active_ids
+
+      active_ids.include? object.public_send(object_id_method)
+    end
+
     def exists?(feature)
       return false if [nil, ''].include? flags[feature.to_sym]
 
@@ -27,12 +43,26 @@ module SimpleFeatureFlags
       flags.dig(feature.to_sym, 'description')
     end
 
-    def with_feature(feature, ignore_file = false, &block)
+    def when_active(feature, ignore_file = false, &block)
       return unless active?(feature, ignore_file)
 
       block.call
     end
 
+    def when_active_for(feature, object, object_id_method = :id, &block)
+      return unless active_for?(feature, object, object_id_method)
+
+      block.call
+    end
+
+    def activate!(feature)
+      return false unless exists?(feature)
+
+      flags[feature.to_sym]['active'] = 'globally'
+
+      true
+    end
+
     def activate(feature)
       return false unless exists?(feature)
 
@@ -41,6 +71,39 @@ module SimpleFeatureFlags
       true
     end
 
+    def activate_for(feature, objects, object_id_method = :id)
+      return false unless exists?(feature)
+
+      objects = [objects] unless objects.is_a? ::Array
+      to_activate_hash = objects_to_hash(objects, object_id_method)
+      active_objects_hash = active_objects(feature)
+
+      to_activate_hash.each do |klass, ids|
+        (active_objects_hash[klass] = ids) && next unless active_objects_hash[klass]
+
+        active_objects_hash[klass].concat(ids).sort!
+      end
+
+      flags[feature.to_sym]['active_for_objects'] = active_objects_hash
+
+      true
+    end
+
+    def activate_for!(feature, objects, object_id_method = :id)
+      return false unless activate_for(feature, objects, object_id_method)
+
+      activate(feature)
+    end
+
+    def deactivate!(feature)
+      return false unless exists?(feature)
+
+      flags[feature.to_sym]['active'] = 'false'
+      flags[feature.to_sym]['active_for_objects'] = nil
+
+      true
+    end
+
     def deactivate(feature)
       return false unless exists?(feature)
 
@@ -49,6 +112,29 @@ module SimpleFeatureFlags
       true
     end
 
+    def active_objects(feature)
+      flags.dig(feature.to_sym, 'active_for_objects') || {}
+    end
+
+    def deactivate_for(feature, objects, object_id_method = :id)
+      return false unless exists?(feature)
+
+      active_objects_hash = active_objects(feature)
+
+      objects_to_deactivate_hash = objects_to_hash(objects, object_id_method)
+
+      objects_to_deactivate_hash.each do |klass, ids_to_remove|
+        active_ids = active_objects_hash[klass]
+        next unless active_ids
+
+        active_ids.reject! { |id| ids_to_remove.include? id }
+      end
+
+      flags[feature.to_sym]['active_for_objects'] = active_objects_hash
+
+      true
+    end
+
     def get(feature)
       return unless exists?(feature)
 
@@ -64,6 +150,8 @@ module SimpleFeatureFlags
       active = case active
                when true, 'true'
                  'true'
+               when 'globally', :globally
+                 'globally'
                else
                  'false'
                end
@@ -102,13 +190,19 @@ module SimpleFeatureFlags
 
     private
 
+    def objects_to_hash(objects, object_id_method = :id)
+      objects = [objects] unless objects.is_a? ::Array
+
+      objects.group_by { |ob| ob.class.to_s }.transform_values { |arr| arr.map(&object_id_method) }
+    end
+
     def __active__(feature)
-      flags.dig(feature.to_sym, 'active') == 'true'
+      %w[true globally].include? flags.dig(feature.to_sym, 'active')
     end
 
     def import_flags_from_file
       changes = YAML.load_file(file)
-      changes = { mandatory: [], remove: [] } unless changes.is_a? Hash
+      changes = { mandatory: [], remove: [] } unless changes.is_a? ::Hash
 
       changes[:mandatory].each do |el|
         mandatory_flags << el['name']

data/lib/simple_feature_flags/redis_storage.rb

@@ -16,6 +16,27 @@ module SimpleFeatureFlags
       __active__(feature)
     end
 
+    def active_globally?(feature)
+      case redis.hget(feature.to_s, 'active')
+      when 'globally'
+        true
+      else
+        false
+      end
+    end
+
+    def active_for?(feature, object, object_id_method = :id)
+      return false unless active?(feature)
+      return true if active_globally?(feature)
+
+      active_objects_hash = active_objects(feature)
+      active_ids = active_objects_hash[object.class.to_s]
+
+      return false unless active_ids
+
+      active_ids.include? object.public_send(object_id_method)
+    end
+
     def exists?(feature)
       return false if [nil, ''].include? redis.hget(feature.to_s, 'name')
 
@@ -26,12 +47,28 @@ module SimpleFeatureFlags
       redis.hget(feature.to_s, 'description')
     end
 
-    def with_feature(feature, _ignore_file = false, &block)
+    def when_active(feature, _ignore_file = false, &block)
       return unless active?(feature)
 
       block.call
     end
 
+    def when_active_for(feature, object, object_id_method = :id, &block)
+      return unless active_for?(feature, object, object_id_method)
+
+      block.call
+    end
+
+    def activate!(feature)
+      return false unless exists?(feature)
+
+      redis.hset(feature.to_s, 'active', 'globally')
+
+      true
+    end
+
+    alias activate_globally activate!
+
     def activate(feature)
       return false unless exists?(feature)
 
@@ -40,6 +77,39 @@ module SimpleFeatureFlags
       true
     end
 
+    def activate_for(feature, objects, object_id_method = :id)
+      return false unless exists?(feature)
+
+      objects = [objects] unless objects.is_a? ::Array
+      to_activate_hash = objects_to_hash(objects, object_id_method)
+      active_objects_hash = active_objects(feature)
+
+      to_activate_hash.each do |klass, ids|
+        (active_objects_hash[klass] = ids) && next unless active_objects_hash[klass]
+
+        active_objects_hash[klass].concat(ids).sort!
+      end
+
+      redis.hset(feature.to_s, 'active_for_objects', active_objects_hash.to_json)
+
+      true
+    end
+
+    def activate_for!(feature, objects, object_id_method = :id)
+      return false unless activate_for(feature, objects, object_id_method)
+
+      activate(feature)
+    end
+
+    def deactivate!(feature)
+      return false unless exists?(feature)
+
+      redis.hset(feature.to_s, 'active', 'false')
+      redis.hset(feature.to_s, 'active_for_objects', '')
+
+      true
+    end
+
     def deactivate(feature)
       return false unless exists?(feature)
 
@@ -48,11 +118,37 @@ module SimpleFeatureFlags
       true
     end
 
+    def active_objects(feature)
+      ::JSON.parse(redis.hget(feature.to_s, 'active_for_objects').to_s)
+    rescue ::JSON::ParserError
+      {}
+    end
+
+    def deactivate_for(feature, objects, object_id_method = :id)
+      return false unless exists?(feature)
+
+      active_objects_hash = active_objects(feature)
+
+      objects_to_deactivate_hash = objects_to_hash(objects, object_id_method)
+
+      objects_to_deactivate_hash.each do |klass, ids_to_remove|
+        active_ids = active_objects_hash[klass]
+        next unless active_ids
+
+        active_ids.reject! { |id| ids_to_remove.include? id }
+      end
+
+      redis.hset(feature.to_s, 'active_for_objects', active_objects_hash.to_json)
+
+      true
+    end
+
     def get(feature)
       return unless exists?(feature)
 
       hash = redis.hgetall(feature.to_s)
       hash['mandatory'] = mandatory_flags.include?(feature.to_s)
+      hash['active_for_objects'] = ::JSON.parse(hash['active_for_objects']) rescue {}
 
       hash
     end
@@ -63,6 +159,8 @@ module SimpleFeatureFlags
       active = case active
                when true, 'true'
                  'true'
+               when 'globally', :globally
+                 'globally'
                else
                  'false'
                end
@@ -105,9 +203,15 @@ module SimpleFeatureFlags
 
     private
 
+    def objects_to_hash(objects, object_id_method = :id)
+      objects = [objects] unless objects.is_a? ::Array
+
+      objects.group_by { |ob| ob.class.to_s }.transform_values { |arr| arr.map(&object_id_method) }
+    end
+
     def __active__(feature)
       case redis.hget(feature.to_s, 'active')
-      when 'true'
+      when 'true', 'globally'
         true
       when 'false'
         false
@@ -116,7 +220,7 @@ module SimpleFeatureFlags
 
     def import_flags_from_file
       changes = YAML.load_file(file)
-      changes = { mandatory: [], remove: [] } unless changes.is_a? Hash
+      changes = { mandatory: [], remove: [] } unless changes.is_a? ::Hash
 
       changes[:mandatory].each do |el|
         mandatory_flags << el['name']

data/lib/simple_feature_flags/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleFeatureFlags
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_feature_flags
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Espago
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-13 00:00:00.000000000 Z
+date: 2021-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler