simple_feature_flags 0.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5ef1f22981517d9de71ff3dd332c76b355ea7711b23954f49a1ffe080bbbc3f
-  data.tar.gz: cd1df44c32ae4a3d320af005f34e08bee655e60912c9463069c112e926de2568
+  metadata.gz: 27f8966e824b5b17fd9c76095203e7bb4999d7332e64dcc32c43dcc8784541b2
+  data.tar.gz: 907626c29e851f93aeddd9e1be8d63dac9c85f7fb13ad0424bddbf83fe1e58d1
 SHA512:
-  metadata.gz: 653d6ad9e44a2700b20735feec5ae8e4a7a29ce1882c010ea8de203777579c0849dd32c5aa9660a66e9584d8ef63b806d1e3b883c09304bf51cf5674099887eb
-  data.tar.gz: 0c3d7c8cbd3a3e2175a80f01cdb4d6c202d108c172451fefcefc06d7d9e0db8a58a87a46b0f8c624ee78f1bab930037493dee7b1feb3c83ec482849e507758f6
+  metadata.gz: 420763922a049e720412d3dff1a9461c953ab4be1e7d4991b5b0b15f96d22d162c2a169071a31bd528fc3f87dc8f59bfc2c95ae21c6e0751a34b0a7187d8c4e4
+  data.tar.gz: 6403704ba929bfa87268e30676f1b15d520796be973485457ddf55ddccd81f6cbb922c4015decfd8dd95fa009c3305e0030e3881471989784dbabc53d33f9a10

data/.vscode/settings.json

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

data/Gemfile.lock

@@ -1,56 +1,56 @@
 PATH
   remote: .
   specs:
-    simple_feature_flags (0.1.0)
+    simple_feature_flags (1.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
     backport (1.2.0)
-    benchmark (0.1.1)
-    bundler-audit (0.8.0)
+    benchmark (0.2.0)
+    bundler-audit (0.9.0.1)
       bundler (>= 1.2.0, < 3)
       thor (~> 1.0)
     byebug (11.1.3)
-    diff-lcs (1.4.4)
+    diff-lcs (1.5.0)
     e2mmap (0.1.0)
     jaro_winkler (1.5.4)
     kramdown (2.3.1)
       rexml
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
-    mini_portile2 (2.6.1)
-    minitest (5.14.4)
-    nokogiri (1.12.3)
-      mini_portile2 (~> 2.6.1)
+    mini_portile2 (2.7.1)
+    minitest (5.15.0)
+    nokogiri (1.13.1)
+      mini_portile2 (~> 2.7.0)
       racc (~> 1.4)
-    parallel (1.20.1)
-    parser (3.0.2.0)
+    parallel (1.21.0)
+    parser (3.1.0.0)
       ast (~> 2.4.1)
-    racc (1.5.2)
-    rainbow (3.0.0)
+    racc (1.6.0)
+    rainbow (3.1.1)
     rake (12.3.3)
-    redis (4.4.0)
+    redis (4.6.0)
     redis-namespace (1.8.1)
       redis (>= 3.0.4)
-    regexp_parser (2.1.1)
-    reverse_markdown (2.0.0)
+    regexp_parser (2.2.1)
+    reverse_markdown (2.1.1)
       nokogiri
     rexml (3.2.5)
-    rubocop (1.19.0)
+    rubocop (1.25.1)
       parallel (~> 1.10)
-      parser (>= 3.0.0.0)
+      parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.9.1, < 2.0)
+      rubocop-ast (>= 1.15.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.9.1)
+    rubocop-ast (1.15.2)
       parser (>= 3.0.1.1)
     ruby-progressbar (1.11.0)
-    solargraph (0.43.0)
+    solargraph (0.44.3)
       backport (~> 1.2)
       benchmark
       bundler (>= 1.17.2)
@@ -65,10 +65,12 @@ GEM
       thor (~> 1.0)
       tilt (~> 2.0)
       yard (~> 0.9, >= 0.9.24)
-    thor (1.1.0)
+    thor (1.2.1)
     tilt (2.0.10)
-    unicode-display_width (2.0.0)
-    yard (0.9.26)
+    unicode-display_width (2.1.0)
+    webrick (1.7.0)
+    yard (0.9.27)
+      webrick (~> 1.7.0)
 
 PLATFORMS
   ruby

data/README.md

@@ -66,14 +66,14 @@ This initializer in turn makes use of the generated config file `config/simple_f
 :mandatory:
 # example flag - it will be created with these properties if there is no such flag in Redis/RAM
 # - name: example
-#   active: 'true' # 'false' is the default value
+#   active: 'globally' # %w[globally partially false] 'false' is the default value
 #   description: example
 
 - name: example_flag
   description: This is an example flag which will be automatically added when you start your app (it will be disabled)
 
 - name: example_active_flag
-  active: 'true'
+  active: 'globally'
   description: This is an example flag which will be automatically added when you start your app (it will be enabled)
 
 # nothing will happen if flag that is to be removed does not exist in Redis/RAM
@@ -127,30 +127,186 @@ 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
+FEATURE_FLAGS.active_globally?(:feature_name) #=> false
+FEATURE_FLAGS.active_partially?(: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.inactive?(:feature_name) #=> true
+FEATURE_FLAGS.inactive_globally?(:feature_name) #=> true
+FEATURE_FLAGS.inactive_partially?(:feature_name) #=> true
+
+FEATURE_FLAGS.activate(:feature_name) # or FEATURE_FLAGS.activate_globally(:feature_name)
+
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_globally?(:feature_name) #=> true
+FEATURE_FLAGS.active_partially?(:feature_name) #=> false
+
+FEATURE_FLAGS.inactive?(:feature_name) #=> false
+FEATURE_FLAGS.inactive_globally?(:feature_name) #=> false
+FEATURE_FLAGS.inactive_partially?(: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.inactive?(:feature_name) #=> false
+
+FEATURE_FLAGS.deactivate(:feature_name)
+
 FEATURE_FLAGS.active?(:feature_name) #=> false
+FEATURE_FLAGS.inactive?(:feature_name) #=> true
+```
+
+#### Activate a feature for a particular record/object
+
+```ruby
+FEATURE_FLAGS.active_partially?(:feature_name) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> false
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+
+FEATURE_FLAGS.inactive_partially?(:feature_name) #=> false
+FEATURE_FLAGS.inactive_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.inactive_for?(:feature_name, User.last) #=> true
+
+FEATURE_FLAGS.activate_for(:feature_name, User.first) #=> true
+
+FEATURE_FLAGS.active_partially?(:feature_name) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> true
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+
+FEATURE_FLAGS.inactive_partially?(:feature_name) #=> false
+FEATURE_FLAGS.inactive_for?(:feature_name, User.first) #=> false
+FEATURE_FLAGS.inactive_for?(:feature_name, User.last) #=> true
 ```
 
+Note that the flag itself has to be active `partially` 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
+FEATURE_FLAGS.active_partially?(:feature_name) #=> false
+FEATURE_FLAGS.active_globally?(:feature_name) #=> false
+
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> false
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+
+# We activate it for the first User
+FEATURE_FLAGS.activate_for(:feature_name, User.first)
+
+FEATURE_FLAGS.active?(:feature_name) #=> false
+FEATURE_FLAGS.active_partially?(:feature_name) #=> false
+FEATURE_FLAGS.active_globally?(: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
+FEATURE_FLAGS.active_for?(:feature_name, User.last) #=> false
+
+# Once we activate the flag partially, record specific settings will be applied
+FEATURE_FLAGS.activate_partially(:feature_name)
+
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_partially?(:feature_name) #=> true
+FEATURE_FLAGS.active_globally?(:feature_name) #=> false
+
+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_partially?(:feature_name) #=> false
+FEATURE_FLAGS.active_globally?(: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 partially 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
+FEATURE_FLAGS.active_partially?(:feature_name) #=> false
+FEATURE_FLAGS.active_globally?(: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_partially?(:feature_name) #=> true
+FEATURE_FLAGS.active_globally?(:feature_name) #=> false
+
+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 partially
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_partially?(:feature_name) #=> true
+FEATURE_FLAGS.active_globally?(:feature_name) #=> false
+
+# 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_partially?(:feature_name) #=> false
+FEATURE_FLAGS.active_globally?(: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_partially(:feature_name)
+
+FEATURE_FLAGS.active?(:feature_name) #=> true
+FEATURE_FLAGS.active_partially?(:feature_name) #=> false
+FEATURE_FLAGS.active_globally?(: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 +314,113 @@ 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
+
+if FEATURE_FLAGS.inactive?(:feature_name)
+  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
+# this code will run only when the :feature_name flag is active (either partially or globally)
+FEATURE_FLAGS.when_active(:feature_name) do
+  number += 1
+end
+
+# the opposite
+FEATURE_FLAGS.when_inactive(:feature_name) do
+  number += 1
+end
+
+# this code will run only when the :feature_name flag is active globally
+FEATURE_FLAGS.when_active_globally(:feature_name) do
+  number += 1
+end
+
+# the opposite
+FEATURE_FLAGS.when_inactive_globally(:feature_name) do
+  number += 1
+end
+
+# this code will run only when the :feature_name flag is active partially (only for specific records/users)
+FEATURE_FLAGS.when_active_partially(:feature_name) do
+  number += 1
+end
+
+# the opposite
+FEATURE_FLAGS.when_inactive_partially(:feature_name) do
+  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
+
+# the opposite
+FEATURE_FLAGS.when_inactive_for(:feature_name, User.first) do
+  number += 1
 end
 
 # feature flags that don't exist will return false
 FEATURE_FLAGS.active?(:non_existant) #=> false
+FEATURE_FLAGS.inactive?(:non_existant) #=> true
+
+if FEATURE_FLAGS.active_for?(:feature_name, User.first)
+  number += 1
+end
+
+if FEATURE_FLAGS.inactive_for?(:feature_name, User.first)
+  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
+FEATURE_FLAGS.active_partially?(:feature_name) #=> false
+FEATURE_FLAGS.active_globally?(:feature_name) #=> false
+FEATURE_FLAGS.active_for?(:feature_name, User.first) #=> false
+
+# add a new globally active flag
+FEATURE_FLAGS.add(:active_feature, 'Description', :globally)
+
+FEATURE_FLAGS.active?(:active_feature) #=> true
+FEATURE_FLAGS.active_partially?(:active_feature) #=> false
+FEATURE_FLAGS.active_globally?(:active_feature) #=> true
+FEATURE_FLAGS.active_for?(:active_feature, User.first) #=> true
+
+# add a new partially active flag
+FEATURE_FLAGS.add(:feature_active_partially, 'Description', :partially)
+
+FEATURE_FLAGS.active?(:feature_active_partially) #=> true
+FEATURE_FLAGS.active_partially?(:feature_active_partially) #=> true
+FEATURE_FLAGS.active_globally?(:feature_active_partially) #=> false
+FEATURE_FLAGS.active_for?(:feature_active_partially, User.first) #=> false
+```
+
+#### 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
+FEATURE_FLAGS.active_partially?(:feature_name) #=> false
+FEATURE_FLAGS.active_globally?(:feature_name) #=> false
+
+FEATURE_FLAGS.inactive?(:feature_name) #=> true
+FEATURE_FLAGS.inactive_partially?(:feature_name) #=> true
+FEATURE_FLAGS.inactive_globally?(:feature_name) #=> true
 ```
 
 

data/exe/simple_feature_flags

@@ -3,7 +3,6 @@
 
 $LOAD_PATH.unshift("#{__dir__}/../lib")
 
-require 'byebug'
 require 'simple_feature_flags'
 
 ::SimpleFeatureFlags::Cli::Runner.new.run

data/lib/example_files/config/initializers/simple_feature_flags.rb

@@ -2,8 +2,8 @@
 # Redis has 16 DBs (0 to 15)
 
 FEATURE_FLAGS = if ::Rails.env.test?
-                  # Use TestRamStorage in tests to make them faster
-                  ::SimpleFeatureFlags::TestRamStorage.new("#{::Rails.root.to_s}/config/simple_feature_flags.yml")
+                  # Use RamStorage in tests to make them faster
+                  ::SimpleFeatureFlags::RamStorage.new("#{::Rails.root.to_s}/config/simple_feature_flags.yml")
                 else
                   redis = ::Redis.new(host: '127.0.0.1', port: 6379, db: 0)
                   # We recommend using the `redis-namespace` gem to avoid key conflicts with Sidekiq or Resque

data/lib/example_files/config/simple_feature_flags.yml

@@ -3,17 +3,17 @@
 :mandatory:
 # example flag - it will be created with these properties if there is no such flag in Redis/RAM
 # - name: example
-#   active: 'true' # 'false' is the default value
+#   active: 'globally' # %w[globally partially false] 'false' is the default value
 #   description: example
 
 - name: example_flag
   description: This is an example flag which will be automatically added when you start your app (it will be disabled)
 
 - name: example_active_flag
-  active: 'true'
+  active: 'globally'
   description: This is an example flag which will be automatically added when you start your app (it will be enabled)
 
 # nothing will happen if flag that is to be removed does not exist in Redis/RAM
 # An array of Feature Flag names that will be removed on app startup
 :remove:
-- flag_to_be_removed
+- flag_to_be_removed

data/lib/simple_feature_flags/cli/command/generate.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require 'byebug'
 
 module SimpleFeatureFlags
   module Cli
@@ -37,6 +36,41 @@ module SimpleFeatureFlags
           puts '----------'
           puts "- #{::File.join(destination_dir, 'config')}"
           print_dir_tree(example_config_dir, 1)
+
+          return unless options.ui
+
+          file_gsub(routes_rb, /.routes.draw do/) do |match|
+            "#{match}\n  mount #{WEB_UI_CLASS_NAME}.new => '/admin/simple_feature_flags'\n"
+          end
+
+          ui_config_line = <<~CONF
+            #{UI_CLASS_NAME}.configure do |config|
+              config.instance = FEATURE_FLAGS
+              config.featurable_class_names = %w[User]
+            end
+          CONF
+
+          file_append(initializer_file, ui_config_line)
+          file_append(gemfile, %(gem '#{UI_GEM}'))
+
+          puts "\nModified:"
+          puts '----------'
+          puts "* #{routes_rb}"
+          puts "* #{gemfile}"
+
+          puts "\nBundling..."
+          system 'bundle'
+        end
+
+        def file_gsub(file_path, regexp, &block)
+          new_content = File.read(file_path).gsub(regexp, &block)
+          File.open(file_path, 'wb') { |file| file.write(new_content) }
+        end
+
+        def file_append(file_path, line)
+          new_content = File.read(file_path)
+          new_content = "#{new_content}\n#{line}\n"
+          File.open(file_path, 'wb') { |file| file.write(new_content) }
         end
 
         def print_dir_tree(dir, embed_level = 0)
@@ -54,6 +88,18 @@ module SimpleFeatureFlags
           end
         end
 
+        def initializer_file
+          ::File.join(destination_dir, 'config', 'initializers', 'simple_feature_flags.rb')
+        end
+
+        def gemfile
+          ::File.join(destination_dir, 'Gemfile')
+        end
+
+        def routes_rb
+          ::File.join(destination_dir, 'config', 'routes.rb')
+        end
+
         def example_config_dir
           ::File.join(::File.expand_path(__dir__), '..', '..', '..', 'example_files', 'config')
         end

data/lib/simple_feature_flags/cli/options.rb

@@ -5,10 +5,11 @@ require 'optparse'
 module SimpleFeatureFlags
   module Cli
     class Options
-      attr_reader :opt_parser, :generate, :help, :rails
+      attr_reader :opt_parser, :generate, :help, :rails, :ui
 
       def initialize(args)
         @rails = true
+        @ui = false
 
         @opt_parser = ::OptionParser.new do |opts|
           opts.banner = 'Usage: simple_feature_flags [options]'
@@ -31,6 +32,7 @@ module SimpleFeatureFlags
           opts.separator ''
           opts.separator 'Modifiers:'
 
+          opts.on('--[no-]ui', '--[no-]web-ui', "Add the #{UI_GEM} gem and mount it in routes") { |u| @ui = u }
           opts.on('--[no-]rails', 'Use generators suited for Rails apps') { |r| @rails = r }
         end
 

data/lib/simple_feature_flags/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SimpleFeatureFlags
+  class Configuration
+    attr_accessor :default_id_method
+
+    def initialize
+      @default_id_method = :id
+    end
+  end
+end

data/lib/simple_feature_flags/ram_storage.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'yaml'
+
 module SimpleFeatureFlags
   class RamStorage
     attr_reader :file, :mandatory_flags, :flags
@@ -13,8 +15,59 @@ module SimpleFeatureFlags
       import_flags_from_file
     end
 
-    def active?(feature, _ignore_file = false)
-      __active__(feature)
+    def active(feature)
+      case flags.dig(feature.to_sym, 'active')
+      when 'globally', :globally
+        :globally
+      when 'partially', :partially
+        :partially
+      when 'true', true
+        true
+      when 'false', false
+        false
+      end
+    end
+
+    def active?(feature)
+      return true if active(feature)
+
+      false
+    end
+
+    def inactive?(feature)
+      !active?(feature)
+    end
+
+    def active_globally?(feature)
+      ACTIVE_GLOBALLY.include? flags.dig(feature.to_sym, 'active')
+    end
+
+    def inactive_globally?(feature)
+      !active_globally?(feature)
+    end
+
+    def active_partially?(feature)
+      ACTIVE_PARTIALLY.include? flags.dig(feature.to_sym, 'active')
+    end
+
+    def inactive_partially?(feature)
+      !active_partially?(feature)
+    end
+
+    def active_for?(feature, object, object_id_method = CONFIG.default_id_method)
+      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 inactive_for?(feature, object, object_id_method = CONFIG.default_id_method)
+      !active_for?(feature, object, object_id_method)
     end
 
     def exists?(feature)
@@ -27,16 +80,101 @@ module SimpleFeatureFlags
       flags.dig(feature.to_sym, 'description')
     end
 
-    def with_feature(feature, ignore_file = false, &block)
-      return unless active?(feature, ignore_file)
+    def when_active(feature)
+      return unless active?(feature)
+
+      yield
+    end
+
+    def when_inactive(feature)
+      return unless inactive?(feature)
+
+      yield
+    end
+
+    def when_active_globally(feature)
+      return unless active_globally?(feature)
+
+      yield
+    end
+
+    def when_inactive_globally(feature)
+      return unless inactive_globally?(feature)
+
+      yield
+    end
+
+    def when_active_partially(feature)
+      return unless active_partially?(feature)
+
+      yield
+    end
+
+    def when_inactive_partially(feature)
+      return unless inactive_partially?(feature)
+
+      yield
+    end
+
+    def when_active_for(feature, object, object_id_method = CONFIG.default_id_method)
+      return unless active_for?(feature, object, object_id_method)
+
+      yield
+    end
+
+    def when_inactive_for(feature, object, object_id_method = CONFIG.default_id_method)
+      return unless inactive_for?(feature, object, object_id_method)
 
-      block.call
+      yield
     end
 
     def activate(feature)
       return false unless exists?(feature)
 
-      flags[feature.to_sym]['active'] = 'true'
+      flags[feature.to_sym]['active'] = 'globally'
+
+      true
+    end
+
+    alias activate_globally activate
+
+    def activate_partially(feature)
+      return false unless exists?(feature)
+
+      flags[feature.to_sym]['active'] = 'partially'
+
+      true
+    end
+
+    def activate_for(feature, objects, object_id_method = CONFIG.default_id_method)
+      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).uniq!.sort!
+      end
+
+      flags[feature.to_sym]['active_for_objects'] = active_objects_hash
+
+      true
+    end
+
+    def activate_for!(feature, objects, object_id_method = CONFIG.default_id_method)
+      return false unless activate_for(feature, objects, object_id_method)
+
+      activate_partially(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
@@ -49,6 +187,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 = CONFIG.default_id_method)
+      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)
 
@@ -61,9 +222,10 @@ module SimpleFeatureFlags
     def add(feature, description, active = 'false')
       return false if exists?(feature)
 
-      active = case active
-               when true, 'true'
-                 'true'
+      active = if ACTIVE_GLOBALLY.include?(active)
+                 'globally'
+               elsif ACTIVE_PARTIALLY.include?(active)
+                 'partially'
                else
                  'false'
                end
@@ -102,13 +264,15 @@ module SimpleFeatureFlags
 
     private
 
-    def __active__(feature)
-      flags.dig(feature.to_sym, 'active') == 'true'
+    def objects_to_hash(objects, object_id_method = CONFIG.default_id_method)
+      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 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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'yaml'
+
 module SimpleFeatureFlags
   class RedisStorage
     attr_reader :file, :redis, :mandatory_flags
@@ -12,8 +14,59 @@ module SimpleFeatureFlags
       import_flags_from_file
     end
 
-    def active?(feature, _ignore_file = false)
-      __active__(feature)
+    def active(feature)
+      case redis.hget(feature.to_s, 'active')
+      when 'globally'
+        :globally
+      when 'partially'
+        :partially
+      when 'true'
+        true
+      when 'false'
+        false
+      end
+    end
+
+    def active?(feature)
+      return true if active(feature)
+
+      false
+    end
+
+    def inactive?(feature)
+      !active?(feature)
+    end
+
+    def active_globally?(feature)
+      ACTIVE_GLOBALLY.include? redis.hget(feature.to_s, 'active')
+    end
+
+    def inactive_globally?(feature)
+      !active_globally?(feature)
+    end
+
+    def active_partially?(feature)
+      ACTIVE_PARTIALLY.include? redis.hget(feature.to_s, 'active')
+    end
+
+    def inactive_partially?(feature)
+      !active_partially?(feature)
+    end
+
+    def active_for?(feature, object, object_id_method = CONFIG.default_id_method)
+      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 inactive_for?(feature, object, object_id_method = CONFIG.default_id_method)
+      !active_for?(feature, object, object_id_method)
     end
 
     def exists?(feature)
@@ -26,16 +79,101 @@ module SimpleFeatureFlags
       redis.hget(feature.to_s, 'description')
     end
 
-    def with_feature(feature, _ignore_file = false, &block)
+    def when_active(feature)
       return unless active?(feature)
 
-      block.call
+      yield
+    end
+
+    def when_inactive(feature)
+      return unless inactive?(feature)
+
+      yield
+    end
+
+    def when_active_globally(feature)
+      return unless active_globally?(feature)
+
+      yield
+    end
+
+    def when_inactive_globally(feature)
+      return unless inactive_globally?(feature)
+
+      yield
+    end
+
+    def when_active_partially(feature)
+      return unless active_partially?(feature)
+
+      yield
+    end
+
+    def when_inactive_partially(feature)
+      return unless inactive_partially?(feature)
+
+      yield
+    end
+
+    def when_active_for(feature, object, object_id_method = CONFIG.default_id_method)
+      return unless active_for?(feature, object, object_id_method)
+
+      yield
+    end
+
+    def when_inactive_for(feature, object, object_id_method = CONFIG.default_id_method)
+      return unless inactive_for?(feature, object, object_id_method)
+
+      yield
     end
 
     def activate(feature)
       return false unless exists?(feature)
 
-      redis.hset(feature.to_s, 'active', 'true')
+      redis.hset(feature.to_s, 'active', 'globally')
+
+      true
+    end
+
+    alias activate_globally activate
+
+    def activate_partially(feature)
+      return false unless exists?(feature)
+
+      redis.hset(feature.to_s, 'active', 'partially')
+
+      true
+    end
+
+    def activate_for(feature, objects, object_id_method = CONFIG.default_id_method)
+      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).uniq!.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 = CONFIG.default_id_method)
+      return false unless activate_for(feature, objects, object_id_method)
+
+      activate_partially(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
@@ -48,11 +186,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 = CONFIG.default_id_method)
+      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
@@ -60,9 +224,10 @@ module SimpleFeatureFlags
     def add(feature, description, active = 'false')
       return false if exists?(feature)
 
-      active = case active
-               when true, 'true'
-                 'true'
+      active = if ACTIVE_GLOBALLY.include?(active)
+                 'globally'
+               elsif ACTIVE_PARTIALLY.include?(active)
+                 'partially'
                else
                  'false'
                end
@@ -105,18 +270,15 @@ module SimpleFeatureFlags
 
     private
 
-    def __active__(feature)
-      case redis.hget(feature.to_s, 'active')
-      when 'true'
-        true
-      when 'false'
-        false
-      end
+    def objects_to_hash(objects, object_id_method = CONFIG.default_id_method)
+      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 import_flags_from_file
-      changes = YAML.load_file(file)
-      changes = { mandatory: [], remove: [] } unless changes.is_a? Hash
+      changes = ::YAML.load_file(file)
+      changes = { mandatory: [], remove: [] } unless changes.is_a? ::Hash
 
       changes[:mandatory].each do |el|
         mandatory_flags << el['name']

data/lib/simple_feature_flags/test_ram_storage.rb

@@ -2,10 +2,10 @@
 
 module SimpleFeatureFlags
   class TestRamStorage < RamStorage
-    def active?(feature, ignore_file = false)
-      raise(FlagNotDefinedError, "Feature Flag `#{feature}` is not defined as mandatory in #{file}") if !ignore_file && !mandatory_flags.include?(feature.to_s)
+    def active?(feature)
+      raise(FlagNotDefinedError, "Feature Flag `#{feature}` is not defined as mandatory in #{file}") unless mandatory_flags.include?(feature.to_s)
 
-      __active__(feature)
+      super
     end
   end
 end

data/lib/simple_feature_flags/version.rb

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

data/lib/simple_feature_flags.rb

@@ -1,11 +1,27 @@
 # frozen_string_literal: true
 
+require 'json'
+
+Dir[File.expand_path('simple_feature_flags/*.rb', __dir__)].sort.each { |file| require file }
+
 module SimpleFeatureFlags
+  NOT_PRESENT = ::Object.new.freeze
+  UI_GEM = 'simple_feature_flags-ui'
+  UI_CLASS_NAME = '::SimpleFeatureFlags::Ui'
+  WEB_UI_CLASS_NAME = '::SimpleFeatureFlags::Ui::Web'
+
+  ACTIVE_GLOBALLY = ::Set['globally', :globally, 'true', true].freeze
+  ACTIVE_PARTIALLY = ::Set['partially', :partially].freeze
+
   class NoSuchCommandError < StandardError; end
 
   class IncorrectWorkingDirectoryError < StandardError; end
 
   class FlagNotDefinedError < StandardError; end
-end
 
-Dir[File.expand_path('simple_feature_flags/*.rb', __dir__)].sort.each { |file| require file }
+  CONFIG = Configuration.new
+
+  def self.configure(&block)
+    block.call(CONFIG)
+  end
+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.2.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: 2022-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -169,6 +169,7 @@ files:
 - lib/simple_feature_flags/cli/command/generate.rb
 - lib/simple_feature_flags/cli/options.rb
 - lib/simple_feature_flags/cli/runner.rb
+- lib/simple_feature_flags/configuration.rb
 - lib/simple_feature_flags/ram_storage.rb
 - lib/simple_feature_flags/redis_storage.rb
 - lib/simple_feature_flags/test_ram_storage.rb