magick-feature-flags 0.7.4 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3180a040250aa0ad2324ae93e18fa71104d95c448149dfaacdfef3e6e27e811
-  data.tar.gz: 1674a42ae320c0693db393a86fe78c4c5d83ad374277269539bd1db361d151c5
+  metadata.gz: a53f3c93e974822f126ed2148d9fb61adf7de3a374ba26acbd834a2a916545a0
+  data.tar.gz: 31dbbacc15565a496e65113364d3eaf5a6a5385251f3654a28ea1c5eb9e9b014
 SHA512:
-  metadata.gz: 3306b269e2ba2217cf4a7eaa08844243a1fbb0b4a2e0877fe4a5935c6f3ccd95337bbfae42eda44f37dd5a2cfa5efb1359814d2698100ae80b86ce1b6e4253ac
-  data.tar.gz: da612304443324312b62c7ed5c0ad113eda11507d6aa436799ce687b689c1085c0a93d3948fc5f1b9ba31e3f7f179a5d1e18caec6c5cecf4f07ff84c4772b141
+  metadata.gz: 9b39439b771eb158d39496758362675db1134ea160311b8af9d51b59e1b40c7440ee425ee7d8f6e28bd02dc3da6498ec24d79744cd5cb7b63f54e13e86fa8cf4
+  data.tar.gz: 0bc2519decc3164d6b3dddd6080bf79c00b9a1ee2473d95b25550edbea8ca8c433912b8655d72c86b993762526781377df27219f1957585990b59942e3597bb8

data/README.md

@@ -166,14 +166,70 @@ feature.enable_for_ip_addresses('192.168.1.0/24', '10.0.0.1')
 feature.enable_for_custom_attribute(:subscription_tier, ['premium', 'enterprise'])
 ```
 
+### Checking Feature Enablement with Objects
+
+You can check if a feature is enabled for an object (like a User model) and its fields:
+
+```ruby
+# Using enabled_for? with an object
+user = User.find(123)
+if Magick.enabled_for?(:premium_features, user)
+  # Feature is enabled for this user
+end
+
+# Or using the feature directly
+feature = Magick[:premium_features]
+if feature.enabled_for?(user)
+  # Feature is enabled for this user
+end
+
+# With additional context
+if Magick.enabled_for?(:premium_features, user, ip_address: request.remote_ip)
+  # Feature is enabled for this user and IP
+end
+
+# Works with ActiveRecord objects, hashes, or simple IDs
+Magick.enabled_for?(:feature, user)           # ActiveRecord object
+Magick.enabled_for?(:feature, { id: 123, role: 'admin' })  # Hash
+Magick.enabled_for?(:feature, 123)            # Simple ID
+```
+
+The `enabled_for?` method automatically extracts:
+- `user_id` from `id` or `user_id` attribute
+- `group` from `group` attribute
+- `role` from `role` attribute
+- `ip_address` from `ip_address` attribute
+- All other attributes for custom attribute matching
+
+### Return Values
+
+All enable/disable methods now return `true` to indicate success:
+
+```ruby
+# All these methods return true on success
+result = feature.enable                    # => true
+result = feature.disable                   # => true
+result = feature.enable_for_user(123)      # => true
+result = feature.enable_for_group('beta')  # => true
+result = feature.enable_percentage_of_users(25)  # => true
+result = feature.set_value(true)          # => true
+```
+
 ### DSL Configuration
 
 Create `config/features.rb`:
 
 ```ruby
 # Boolean features
-boolean_feature :new_dashboard, default: false, description: "New dashboard UI"
-boolean_feature :dark_mode, default: false, description: "Dark mode theme"
+boolean_feature :new_dashboard,
+  default: false,
+  name: "New Dashboard",
+  description: "New dashboard UI"
+
+boolean_feature :dark_mode,
+  default: false,
+  name: "Dark Mode",
+  description: "Dark mode theme"
 
 # String features
 string_feature :api_version, default: "v1", description: "API version"

data/lib/generators/magick/install/templates/magick.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Magick Configuration
 # Generated by: rails generate magick:install
 #

data/lib/magick/adapters/memory.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'thread'
-
 module Magick
   module Adapters
     class Memory < Base

data/lib/magick/adapters/registry.rb

@@ -3,7 +3,7 @@
 module Magick
   module Adapters
     class Registry
-      CACHE_INVALIDATION_CHANNEL = 'magick:cache:invalidate'.freeze
+      CACHE_INVALIDATION_CHANNEL = 'magick:cache:invalidate'
 
       def initialize(memory_adapter, redis_adapter = nil, circuit_breaker: nil, async: false)
         @memory_adapter = memory_adapter
@@ -43,36 +43,36 @@ module Magick
         memory_adapter.set(feature_name, key, value)
 
         # Update Redis if available
-        if redis_adapter
-          update_redis = proc do
-            circuit_breaker.call do
-              redis_adapter.set(feature_name, key, value)
-              # Publish cache invalidation message to notify other processes
-              publish_cache_invalidation(feature_name)
-            end
-          rescue AdapterError => e
-            # Log error but don't fail - memory is updated
-            warn "Failed to update Redis: #{e.message}" if defined?(Rails) && Rails.env.development?
-          end
+        return unless redis_adapter
 
-          if @async && defined?(Thread)
-            Thread.new { update_redis.call }
-          else
-            update_redis.call
+        update_redis = proc do
+          circuit_breaker.call do
+            redis_adapter.set(feature_name, key, value)
+            # Publish cache invalidation message to notify other processes
+            publish_cache_invalidation(feature_name)
           end
+        rescue AdapterError => e
+          # Log error but don't fail - memory is updated
+          warn "Failed to update Redis: #{e.message}" if defined?(Rails) && Rails.env.development?
+        end
+
+        if @async && defined?(Thread)
+          Thread.new { update_redis.call }
+        else
+          update_redis.call
         end
       end
 
       def delete(feature_name)
         memory_adapter.delete(feature_name)
-        if redis_adapter
-          begin
-            redis_adapter.delete(feature_name)
-            # Publish cache invalidation message
-            publish_cache_invalidation(feature_name)
-          rescue AdapterError
-            # Continue even if Redis fails
-          end
+        return unless redis_adapter
+
+        begin
+          redis_adapter.delete(feature_name)
+          # Publish cache invalidation message
+          publish_cache_invalidation(feature_name)
+        rescue AdapterError
+          # Continue even if Redis fails
         end
       end
 
@@ -108,23 +108,21 @@ module Magick
         return unless redis_adapter && defined?(Thread)
 
         @subscriber_thread = Thread.new do
-          begin
-            redis_client = redis_adapter.instance_variable_get(:@redis)
-            return unless redis_client
-
-            @subscriber = redis_client.dup
-            @subscriber.subscribe(CACHE_INVALIDATION_CHANNEL) do |on|
-              on.message do |_channel, feature_name|
-                # Invalidate memory cache for this feature
-                memory_adapter.delete(feature_name)
-              end
+          redis_client = redis_adapter.instance_variable_get(:@redis)
+          return unless redis_client
+
+          @subscriber = redis_client.dup
+          @subscriber.subscribe(CACHE_INVALIDATION_CHANNEL) do |on|
+            on.message do |_channel, feature_name|
+              # Invalidate memory cache for this feature
+              memory_adapter.delete(feature_name)
             end
-          rescue StandardError => e
-            # If subscription fails, log and retry after a delay
-            warn "Cache invalidation subscriber error: #{e.message}" if defined?(Rails) && Rails.env.development?
-            sleep 5
-            retry
           end
+        rescue StandardError => e
+          # If subscription fails, log and retry after a delay
+          warn "Cache invalidation subscriber error: #{e.message}" if defined?(Rails) && Rails.env.development?
+          sleep 5
+          retry
         end
         @subscriber_thread.abort_on_exception = false
       end

data/lib/magick/config.rb

@@ -2,9 +2,8 @@
 
 module Magick
   class Config
-    attr_accessor :adapter_registry, :performance_metrics, :audit_log, :versioning
-    attr_accessor :warn_on_deprecated, :async_updates, :memory_ttl, :circuit_breaker_threshold
-    attr_accessor :circuit_breaker_timeout, :redis_url, :redis_namespace, :environment
+    attr_accessor :adapter_registry, :performance_metrics, :audit_log, :versioning, :warn_on_deprecated,
+                  :async_updates, :memory_ttl, :circuit_breaker_threshold, :circuit_breaker_timeout, :redis_url, :redis_namespace, :environment
 
     def initialize
       @warn_on_deprecated = false
@@ -45,28 +44,26 @@ module Magick
       configure_redis_adapter(url: url, namespace: namespace, **options)
     end
 
-    def performance_metrics(enabled: true, **options)
-      if enabled
-        @performance_metrics = PerformanceMetrics.new
-      else
-        @performance_metrics = nil
+    def performance_metrics(enabled: true, redis_tracking: nil, batch_size: 100, flush_interval: 60, **_options)
+      return unless enabled
+
+      @performance_metrics = PerformanceMetrics.new(batch_size: batch_size, flush_interval: flush_interval)
+      # Enable Redis tracking if Redis adapter is configured (or explicitly set)
+      if redis_tracking.nil?
+        # Auto-enable if Redis adapter exists
+        redis_tracking = !@redis_url.nil? || configure_redis_adapter != nil
       end
+      @performance_metrics.enable_redis_tracking(enable: redis_tracking) if @performance_metrics
     end
 
     def audit_log(enabled: true, adapter: nil)
-      if enabled
-        @audit_log = adapter ? AuditLog.new(adapter) : AuditLog.new
-      else
-        @audit_log = nil
-      end
+      @audit_log = if enabled
+                     adapter ? AuditLog.new(adapter) : AuditLog.new
+                   end
     end
 
     def versioning(enabled: true)
-      if enabled
-        @versioning = Versioning.new(adapter_registry || default_adapter_registry)
-      else
-        @versioning = nil
-      end
+      @versioning = (Versioning.new(adapter_registry || default_adapter_registry) if enabled)
     end
 
     def circuit_breaker(threshold: nil, timeout: nil)
@@ -97,6 +94,11 @@ module Magick
       Magick.audit_log = audit_log if audit_log
       Magick.versioning = versioning if versioning
       Magick.warn_on_deprecated = warn_on_deprecated
+
+      # Enable Redis tracking for performance metrics if Redis adapter is configured
+      if Magick.performance_metrics && adapter_registry.is_a?(Adapters::Registry) && adapter_registry.redis_adapter
+        Magick.performance_metrics.enable_redis_tracking(enable: true)
+      end
     end
 
     private

data/lib/magick/dsl.rb

@@ -70,6 +70,15 @@ module Magick
     def disable_feature(feature_name, user_id: nil)
       Magick[feature_name].disable(user_id: user_id)
     end
+
+    # Check enablement for an object
+    def enabled_for?(feature_name, object, **additional_context)
+      Magick.enabled_for?(feature_name, object, **additional_context)
+    end
+
+    def disabled_for?(feature_name, object, **additional_context)
+      Magick.disabled_for?(feature_name, object, **additional_context)
+    end
   end
 end
 

data/lib/magick/export_import.rb

@@ -5,7 +5,7 @@ require 'json'
 module Magick
   class ExportImport
     def self.export(features_hash)
-      result = features_hash.map do |name, feature|
+      result = features_hash.map do |_name, feature|
         feature.to_h
       end
 
@@ -45,7 +45,9 @@ module Magick
           description: feature_data['description'] || feature_data[:description]
         )
 
-        feature.set_value(feature_data['value'] || feature_data[:value]) if feature_data['value'] || feature_data[:value]
+        if feature_data['value'] || feature_data[:value]
+          feature.set_value(feature_data['value'] || feature_data[:value])
+        end
 
         # Import targeting
         if feature_data['targeting'] || feature_data[:targeting]

data/lib/magick/feature.rb

@@ -8,7 +8,7 @@ module Magick
     VALID_TYPES = %i[boolean string number].freeze
     VALID_STATUSES = %i[active inactive deprecated].freeze
 
-    attr_reader :name, :type, :status, :default_value, :description, :adapter_registry
+    attr_reader :name, :type, :status, :default_value, :description, :display_name, :adapter_registry
 
     def initialize(name, adapter_registry, **options)
       @name = name.to_s
@@ -17,6 +17,7 @@ module Magick
       @status = (options[:status] || :active).to_sym
       @default_value = options.fetch(:default_value, default_for_type)
       @description = options[:description]
+      @display_name = options[:name] || options[:display_name]
       @targeting = {}
       @dependencies = options[:dependencies] ? Array(options[:dependencies]) : []
 
@@ -69,28 +70,20 @@ module Magick
       return false if status == :deprecated && !context[:allow_deprecated]
 
       # Check feature dependencies
-      unless dependencies.empty?
-        return false unless dependencies.all? { |dep_name| Magick.enabled?(dep_name, context) }
-      end
+      return false if !dependencies.empty? && !dependencies.all? { |dep_name| Magick.enabled?(dep_name, context) }
 
       # Check date/time range targeting
-      if targeting[:date_range] && !date_range_active?(targeting[:date_range])
-        return false
-      end
+      return false if targeting[:date_range] && !date_range_active?(targeting[:date_range])
 
       # Check IP address targeting
-      if targeting[:ip_address] && context[:ip_address]
-        return false unless ip_address_matches?(context[:ip_address])
-      end
+      return false if targeting[:ip_address] && context[:ip_address] && !ip_address_matches?(context[:ip_address])
 
       # Check custom attributes
-      if targeting[:custom_attributes]
-        return false unless custom_attributes_match?(context, targeting[:custom_attributes])
-      end
+      return false if targeting[:custom_attributes] && !custom_attributes_match?(context, targeting[:custom_attributes])
 
       # Check complex conditions
-      if targeting[:complex_conditions]
-        return false unless complex_conditions_match?(context, targeting[:complex_conditions])
+      if targeting[:complex_conditions] && !complex_conditions_match?(context, targeting[:complex_conditions])
+        return false
       end
 
       value = get_value(context)
@@ -100,7 +93,7 @@ module Magick
       when :string
         !value.nil? && value != ''
       when :number
-        value.to_f > 0
+        value.to_f.positive?
       else
         false
       end
@@ -110,6 +103,18 @@ module Magick
       !enabled?(context)
     end
 
+    def enabled_for?(object, **additional_context)
+      # Extract context from object
+      context = extract_context_from_object(object)
+      # Merge with any additional context provided
+      context.merge!(additional_context)
+      enabled?(context)
+    end
+
+    def disabled_for?(object, **additional_context)
+      !enabled_for?(object, **additional_context)
+    end
+
     def value(context = {})
       get_value(context)
     end
@@ -125,26 +130,32 @@ module Magick
 
     def enable_for_user(user_id)
       enable_targeting(:user, user_id)
+      true
     end
 
     def disable_for_user(user_id)
       disable_targeting(:user, user_id)
+      true
     end
 
     def enable_for_group(group_name)
       enable_targeting(:group, group_name)
+      true
     end
 
     def disable_for_group(group_name)
       disable_targeting(:group, group_name)
+      true
     end
 
     def enable_for_role(role_name)
       enable_targeting(:role, role_name)
+      true
     end
 
     def disable_for_role(role_name)
       disable_targeting(:role, role_name)
+      true
     end
 
     def enable_percentage_of_users(percentage)
@@ -152,18 +163,19 @@ module Magick
       save_targeting
 
       # Update registered feature instance if it exists
-      if Magick.features.key?(name)
-        Magick.features[name].instance_variable_set(:@targeting, @targeting.dup)
-      end
+      Magick.features[name].instance_variable_set(:@targeting, @targeting.dup) if Magick.features.key?(name)
 
       # Rails 8+ event
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.targeting_added(name, targeting_type: :percentage_users, targeting_value: percentage)
       end
+
+      true
     end
 
     def disable_percentage_of_users
       disable_targeting(:percentage_users)
+      true
     end
 
     def enable_percentage_of_requests(percentage)
@@ -171,40 +183,46 @@ module Magick
       save_targeting
 
       # Update registered feature instance if it exists
-      if Magick.features.key?(name)
-        Magick.features[name].instance_variable_set(:@targeting, @targeting.dup)
-      end
+      Magick.features[name].instance_variable_set(:@targeting, @targeting.dup) if Magick.features.key?(name)
 
       # Rails 8+ event
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.targeting_added(name, targeting_type: :percentage_requests, targeting_value: percentage)
       end
+
+      true
     end
 
     def disable_percentage_of_requests
       disable_targeting(:percentage_requests)
+      true
     end
 
     def enable_for_date_range(start_date, end_date)
       enable_targeting(:date_range, { start: start_date, end: end_date })
+      true
     end
 
     def disable_date_range
       disable_targeting(:date_range)
+      true
     end
 
     def enable_for_ip_addresses(ip_addresses)
       enable_targeting(:ip_address, Array(ip_addresses))
+      true
     end
 
     def disable_ip_addresses
       disable_targeting(:ip_address)
+      true
     end
 
     def enable_for_custom_attribute(attribute_name, values, operator: :equals)
       custom_attrs = targeting[:custom_attributes] || {}
       custom_attrs[attribute_name.to_sym] = { values: Array(values), operator: operator }
       enable_targeting(:custom_attributes, custom_attrs)
+      true
     end
 
     def disable_custom_attribute(attribute_name)
@@ -215,6 +233,7 @@ module Magick
       else
         enable_targeting(:custom_attributes, custom_attrs)
       end
+      true
     end
 
     def set_variants(variants)
@@ -227,6 +246,8 @@ module Magick
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.variant_set(name, variants: variants_array)
       end
+
+      true
     end
 
     def add_dependency(dependency_name)
@@ -237,6 +258,8 @@ module Magick
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.dependency_added(name, dependency_name)
       end
+
+      true
     end
 
     def remove_dependency(dependency_name)
@@ -246,6 +269,8 @@ module Magick
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.dependency_removed(name, dependency_name)
       end
+
+      true
     end
 
     def dependencies
@@ -257,26 +282,26 @@ module Magick
 
       variants = targeting[:variants]
       selected_variant = if variants.length == 1
-        variants.first[:name]
-      else
-        # Weighted random selection
-        total_weight = variants.sum { |v| v[:weight] || 0 }
-        if total_weight == 0
-          variants.first[:name]
-        else
-          random = rand(total_weight)
-          current = 0
-          selected = nil
-          variants.each do |variant|
-            current += (variant[:weight] || 0)
-            if random < current
-              selected = variant[:name]
-              break
-            end
-          end
-          selected || variants.first[:name]
-        end
-      end
+                           variants.first[:name]
+                         else
+                           # Weighted random selection
+                           total_weight = variants.sum { |v| v[:weight] || 0 }
+                           if total_weight.zero?
+                             variants.first[:name]
+                           else
+                             random = rand(total_weight)
+                             current = 0
+                             selected = nil
+                             variants.each do |variant|
+                               current += variant[:weight] || 0
+                               if random < current
+                                 selected = variant[:name]
+                                 break
+                               end
+                             end
+                             selected || variants.first[:name]
+                           end
+                         end
 
       # Rails 8+ event
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
@@ -294,30 +319,29 @@ module Magick
       adapter_registry.set(name, 'status', status)
       adapter_registry.set(name, 'default_value', default_value)
       adapter_registry.set(name, 'description', description) if description
+      adapter_registry.set(name, 'display_name', display_name) if display_name
       @stored_value = value
 
       # Update registered feature instance if it exists
-      if Magick.features.key?(name)
-        Magick.features[name].instance_variable_set(:@stored_value, value)
-      end
+      Magick.features[name].instance_variable_set(:@stored_value, value) if Magick.features.key?(name)
 
       changes = { value: { from: old_value, to: value } }
 
       # Audit log
-      if Magick.audit_log
-        Magick.audit_log.log(
-          name,
-          'set_value',
-          user_id: user_id,
-          changes: changes
-        )
-      end
+      Magick.audit_log&.log(
+        name,
+        'set_value',
+        user_id: user_id,
+        changes: changes
+      )
 
       # Rails 8+ events
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.feature_changed(name, changes: changes, user_id: user_id)
         Magick::Rails::Events.audit_logged(name, action: 'set_value', user_id: user_id, changes: changes)
       end
+
+      true
     end
 
     def enable(user_id: nil)
@@ -329,9 +353,9 @@ module Magick
       when :boolean
         set_value(true, user_id: user_id)
       when :string
-        raise InvalidFeatureValueError, "Cannot enable string feature. Use set_value instead."
+        raise InvalidFeatureValueError, 'Cannot enable string feature. Use set_value instead.'
       when :number
-        raise InvalidFeatureValueError, "Cannot enable number feature. Use set_value instead."
+        raise InvalidFeatureValueError, 'Cannot enable number feature. Use set_value instead.'
       else
         raise InvalidFeatureValueError, "Cannot enable feature of type #{type}"
       end
@@ -340,6 +364,8 @@ module Magick
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.feature_enabled_globally(name, user_id: user_id)
       end
+
+      true
     end
 
     def disable(user_id: nil)
@@ -358,10 +384,15 @@ module Magick
         raise InvalidFeatureValueError, "Cannot disable feature of type #{type}"
       end
 
+      # Cascade disable: disable all features that depend on this one
+      disable_dependent_features(user_id: user_id)
+
       # Rails 8+ event
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.feature_disabled_globally(name, user_id: user_id)
       end
+
+      true
     end
 
     def set_status(new_status)
@@ -369,6 +400,7 @@ module Magick
 
       @status = new_status.to_sym
       adapter_registry.set(name, 'status', status)
+      true
     end
 
     def delete
@@ -377,11 +409,13 @@ module Magick
       @targeting = {}
       # Also remove from Magick.features if registered
       Magick.features.delete(name.to_s)
+      true
     end
 
     def to_h
       {
         name: name,
+        display_name: display_name,
         type: type,
         status: status,
         value: stored_value,
@@ -409,6 +443,7 @@ module Magick
         registered = Magick.features[name]
         registered.instance_variable_set(:@stored_value, @stored_value)
         registered.instance_variable_set(:@status, @status)
+        registered.instance_variable_set(:@display_name, @display_name)
         registered.instance_variable_set(:@targeting, @targeting.dup)
       end
       self
@@ -420,6 +455,8 @@ module Magick
       @stored_value = load_value_from_adapter
       status_value = adapter_registry.get(name, 'status')
       @status = status_value ? status_value.to_sym : status
+      display_name_value = adapter_registry.get(name, 'display_name')
+      @display_name = display_name_value if display_name_value
       targeting_value = adapter_registry.get(name, 'targeting')
       if targeting_value.is_a?(Hash)
         # Normalize keys to symbols and handle nested structures
@@ -438,7 +475,7 @@ module Magick
 
       case type
       when :boolean
-        value == true || value == 'true' || value == 1
+        [true, 'true', 1].include?(value)
       when :string
         value.to_s
       when :number
@@ -588,6 +625,73 @@ module Magick
       (hash_value % 100) < percentage
     end
 
+    def extract_context_from_object(object)
+      context = {}
+
+      # Handle hash/struct-like objects
+      if object.is_a?(Hash)
+        context[:user_id] = object[:user_id] || object['user_id'] || object[:id] || object['id']
+        context[:group] = object[:group] || object['group']
+        context[:role] = object[:role] || object['role']
+        context[:ip_address] = object[:ip_address] || object['ip_address']
+        # Include all other attributes for custom attribute matching
+        object.each do |key, value|
+          next if %i[user_id id group role ip_address].include?(key.to_sym)
+          next if %w[user_id id group role ip_address].include?(key.to_s)
+
+          context[key.to_sym] = value
+        end
+      # Handle ActiveRecord-like objects (respond to methods)
+      elsif object.respond_to?(:id) || object.respond_to?(:user_id)
+        context[:user_id] = object.respond_to?(:user_id) ? object.user_id : object.id
+        context[:group] = object.group if object.respond_to?(:group)
+        context[:role] = object.role if object.respond_to?(:role)
+        context[:ip_address] = object.ip_address if object.respond_to?(:ip_address)
+
+        # For ActiveRecord objects, include all attributes
+        if object.respond_to?(:attributes)
+          object.attributes.each do |key, value|
+            next if %w[id user_id group role ip_address].include?(key.to_s)
+
+            context[key.to_sym] = value
+          end
+        end
+      # Handle simple values (like user_id directly)
+      elsif object.respond_to?(:to_i) && object.to_i.to_s == object.to_s
+        context[:user_id] = object.to_i
+      end
+
+      context
+    end
+
+    def disable_dependent_features(user_id: nil)
+      # Find all features that depend on this feature
+      dependent_features = find_dependent_features
+
+      # Disable each dependent feature
+      dependent_features.each do |dep_feature_name|
+        dep_feature = Magick.features[dep_feature_name.to_s] || Magick[dep_feature_name]
+        next unless dep_feature
+
+        # Only disable if it's currently enabled (to avoid unnecessary operations)
+        if dep_feature.enabled?
+          dep_feature.disable(user_id: user_id)
+        end
+      end
+    end
+
+    def find_dependent_features
+      # Find all features that have this feature in their dependencies
+      dependent_features = []
+      Magick.features.each do |_name, feature|
+        feature_deps = feature.instance_variable_get(:@dependencies) || []
+        if feature_deps.include?(name.to_s) || feature_deps.include?(name.to_sym)
+          dependent_features << feature.name
+        end
+      end
+      dependent_features
+    end
+
     def enable_targeting(type, value)
       @targeting[type] ||= []
       @targeting[type] << value.to_s unless @targeting[type].include?(value.to_s)
@@ -597,6 +701,8 @@ module Magick
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.targeting_added(name, targeting_type: type, targeting_value: value)
       end
+
+      true
     end
 
     def disable_targeting(type, value = nil)
@@ -611,14 +717,16 @@ module Magick
       if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
         Magick::Rails::Events.targeting_removed(name, targeting_type: type, targeting_value: value)
       end
+
+      true
     end
 
     def save_targeting
       adapter_registry.set(name, 'targeting', targeting)
       # Update the feature in Magick.features if it's registered
-      if Magick.features.key?(name)
-        Magick.features[name].instance_variable_set(:@targeting, targeting.dup)
-      end
+      return unless Magick.features.key?(name)
+
+      Magick.features[name].instance_variable_set(:@targeting, targeting.dup)
     end
 
     def default_for_type
@@ -643,22 +751,30 @@ module Magick
     def validate_default_value!
       case type
       when :boolean
-        raise InvalidFeatureValueError, "Default value must be boolean for type :boolean" unless [true, false].include?(default_value)
+        unless [true, false].include?(default_value)
+          raise InvalidFeatureValueError, 'Default value must be boolean for type :boolean'
+        end
       when :string
-        raise InvalidFeatureValueError, "Default value must be a string for type :string" unless default_value.is_a?(String)
+        unless default_value.is_a?(String)
+          raise InvalidFeatureValueError,
+                'Default value must be a string for type :string'
+        end
       when :number
-        raise InvalidFeatureValueError, "Default value must be numeric for type :number" unless default_value.is_a?(Numeric)
+        unless default_value.is_a?(Numeric)
+          raise InvalidFeatureValueError,
+                'Default value must be numeric for type :number'
+        end
       end
     end
 
     def validate_value!(value)
       case type
       when :boolean
-        raise InvalidFeatureValueError, "Value must be boolean for type :boolean" unless [true, false].include?(value)
+        raise InvalidFeatureValueError, 'Value must be boolean for type :boolean' unless [true, false].include?(value)
       when :string
-        raise InvalidFeatureValueError, "Value must be a string for type :string" unless value.is_a?(String)
+        raise InvalidFeatureValueError, 'Value must be a string for type :string' unless value.is_a?(String)
       when :number
-        raise InvalidFeatureValueError, "Value must be numeric for type :number" unless value.is_a?(Numeric)
+        raise InvalidFeatureValueError, 'Value must be numeric for type :number' unless value.is_a?(Numeric)
       end
     end
   end

data/lib/magick/performance_metrics.rb

@@ -24,17 +24,25 @@ module Magick
       end
     end
 
-    def initialize
+    def initialize(batch_size: 100, flush_interval: 60)
       @metrics = []
       @mutex = Mutex.new
       @usage_count = Hash.new(0)
+      @pending_updates = Hash.new(0) # For Redis batching
+      @batch_size = batch_size
+      @flush_interval = flush_interval
+      @last_flush = Time.now
+      @redis_enabled = false
     end
 
     def record(feature_name, operation, duration, success: true)
-      metric = Metric.new(feature_name, operation, duration, success: success)
+      feature_name_str = feature_name.to_s
+      metric = Metric.new(feature_name_str, operation, duration, success: success)
+
       @mutex.synchronize do
         @metrics << metric
-        @usage_count[feature_name.to_s] += 1
+        @usage_count[feature_name_str] += 1
+        @pending_updates[feature_name_str] += 1
         # Keep only last 1000 metrics
         @metrics.shift if @metrics.length > 1000
       end
@@ -44,9 +52,64 @@ module Magick
         Magick::Rails::Events.usage_tracked(feature_name, operation: operation, duration: duration, success: success)
       end
 
+      # Batch flush to Redis if needed
+      flush_to_redis_if_needed
+
       metric
     end
 
+    def flush_to_redis_if_needed
+      return unless @redis_enabled
+      return if @pending_updates.empty?
+
+      should_flush = false
+      @mutex.synchronize do
+        # Flush if we have enough pending updates or enough time has passed
+        if @pending_updates.size >= @batch_size || (Time.now - @last_flush) >= @flush_interval
+          should_flush = true
+        end
+      end
+
+      flush_to_redis if should_flush
+    end
+
+    def flush_to_redis
+      updates_to_flush = nil
+      @mutex.synchronize do
+        return if @pending_updates.empty?
+
+        updates_to_flush = @pending_updates.dup
+        @pending_updates.clear
+        @last_flush = Time.now
+      end
+
+      return if updates_to_flush.nil? || updates_to_flush.empty?
+
+      # Update Redis in batch
+      begin
+        adapter = Magick.adapter_registry || Magick.default_adapter_registry
+        if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_adapter
+          redis = adapter.redis_adapter.instance_variable_get(:@redis)
+          if redis
+            updates_to_flush.each do |feature_name, count|
+              redis_key = "magick:stats:#{feature_name}"
+              redis.incrby(redis_key, count)
+              redis.expire(redis_key, 86400 * 7) # Keep stats for 7 days
+            end
+          end
+        end
+      rescue StandardError => e
+        # Silently fail - don't break feature checks if stats fail
+        warn "Magick: Failed to flush stats to Redis: #{e.message}" if defined?(Rails) && Rails.env.development?
+      end
+    end
+
+    def enable_redis_tracking(enable: true)
+      @redis_enabled = enable
+      # Flush any pending updates when enabling
+      flush_to_redis if enable && !@pending_updates.empty?
+    end
+
     def average_duration(feature_name: nil, operation: nil)
       filtered = @metrics.select do |m|
         (feature_name.nil? || m.feature_name == feature_name.to_s) &&
@@ -59,17 +122,60 @@ module Magick
     end
 
     def usage_count(feature_name)
-      @usage_count[feature_name.to_s] || 0
+      feature_name_str = feature_name.to_s
+      memory_count = @usage_count[feature_name_str] || 0
+
+      # Also check Redis if enabled
+      redis_count = 0
+      if @redis_enabled
+        begin
+          adapter = Magick.adapter_registry || Magick.default_adapter_registry
+          if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_adapter
+            redis = adapter.redis_adapter.instance_variable_get(:@redis)
+            if redis
+              redis_key = "magick:stats:#{feature_name_str}"
+              redis_count = redis.get(redis_key).to_i
+            end
+          end
+        rescue StandardError
+          # Silently fail
+        end
+      end
+
+      memory_count + redis_count
     end
 
     def most_used_features(limit: 10)
-      @usage_count.sort_by { |_name, count| -count }.first(limit).to_h
+      # Combine memory and Redis counts
+      combined_counts = @usage_count.dup
+
+      if @redis_enabled
+        begin
+          adapter = Magick.adapter_registry || Magick.default_adapter_registry
+          if adapter.is_a?(Magick::Adapters::Registry) && adapter.redis_adapter
+            redis = adapter.redis_adapter.instance_variable_get(:@redis)
+            if redis
+              # Get all stats keys
+              redis.keys("magick:stats:*").each do |key|
+                feature_name = key.to_s.sub('magick:stats:', '')
+                redis_count = redis.get(key).to_i
+                combined_counts[feature_name] = (combined_counts[feature_name] || 0) + redis_count
+              end
+            end
+          end
+        rescue StandardError
+          # Silently fail
+        end
+      end
+
+      combined_counts.sort_by { |_name, count| -count }.first(limit).to_h
     end
 
     def clear!
       @mutex.synchronize do
         @metrics.clear
         @usage_count.clear
+        @pending_updates.clear
       end
     end
   end

data/lib/magick/rails/event_subscriber.rb

@@ -20,7 +20,7 @@ module Magick
       end
 
       # Subscribe to a specific event
-      def subscribe_to(event_name, &block)
+      def subscribe_to(event_name)
         return unless Events.rails81?
 
         full_event_name = Events::EVENTS[event_name] || event_name.to_s
@@ -44,7 +44,7 @@ module Magick
     # Default log subscriber for Magick events
     class LogSubscriber
       def emit(event)
-        payload = event[:payload].map { |key, value| "#{key}=#{value}" }.join(" ")
+        payload = event[:payload].map { |key, value| "#{key}=#{value}" }.join(' ')
         source_location = event[:source_location]
         log = "[#{event[:name]}] #{payload}"
         log += " at #{source_location[:filepath]}:#{source_location[:lineno]}" if source_location

data/lib/magick/rails/railtie.rb

@@ -43,20 +43,22 @@ if defined?(Rails)
             else
               # Fallback to config/initializers/features.rb (already loaded by Rails, but check anyway)
               initializer_file = Rails.root.join('config', 'initializers', 'features.rb')
-              if File.exist?(initializer_file)
+              if File.exist?(initializer_file) && !defined?(Magick::Rails::FeaturesLoaded)
                 # Only load if not already loaded (Rails may have already loaded it)
-                load initializer_file unless defined?(Magick::Rails::FeaturesLoaded)
+                load initializer_file
               end
             end
-            Magick::Rails.const_set(:FeaturesLoaded, true) rescue nil
+            begin
+              Magick::Rails.const_set(:FeaturesLoaded, true)
+            rescue StandardError
+              nil
+            end
           end
         end
 
         # Preload features in request store
         config.to_prepare do
-          if defined?(RequestStore)
-            RequestStore.store[:magick_features] ||= {}
-          end
+          RequestStore.store[:magick_features] ||= {} if defined?(RequestStore)
         end
       end
     end

data/lib/magick/rails.rb

@@ -2,6 +2,4 @@
 
 # Rails integration is now in lib/magick/rails/railtie.rb
 # This file is kept for backward compatibility
-if defined?(Rails)
-  require_relative 'rails/railtie'
-end
+require_relative 'rails/railtie' if defined?(Rails)

data/lib/magick/testing_helpers.rb

@@ -7,7 +7,7 @@ module Magick
     end
 
     module ClassMethods
-      def with_feature_enabled(feature_name, &block)
+      def with_feature_enabled(feature_name)
         feature = Magick.features[feature_name.to_s] || Magick[feature_name]
         original_value = feature.value
         feature.set_value(true)
@@ -16,7 +16,7 @@ module Magick
         feature.set_value(original_value)
       end
 
-      def with_feature_disabled(feature_name, &block)
+      def with_feature_disabled(feature_name)
         feature = Magick.features[feature_name.to_s] || Magick[feature_name]
         original_value = feature.value
         feature.set_value(false)
@@ -25,7 +25,7 @@ module Magick
         feature.set_value(original_value)
       end
 
-      def with_feature_value(feature_name, value, &block)
+      def with_feature_value(feature_name, value)
         feature = Magick.features[feature_name.to_s] || Magick[feature_name]
         original_value = feature.value
         feature.set_value(value)

data/lib/magick/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Magick
-  VERSION = '0.7.4'
+  VERSION = '0.8.2'
 end

data/lib/magick/versioning.rb

@@ -61,17 +61,15 @@ module Magick
       feature.set_status(feature_data[:status]) if feature_data[:status]
 
       # Restore targeting
-      if feature_data[:targeting]
-        feature_data[:targeting].each do |type, values|
-          Array(values).each do |value|
-            case type.to_sym
-            when :user
-              feature.enable_for_user(value)
-            when :group
-              feature.enable_for_group(value)
-            when :role
-              feature.enable_for_role(value)
-            end
+      feature_data[:targeting]&.each do |type, values|
+        Array(values).each do |value|
+          case type.to_sym
+          when :user
+            feature.enable_for_user(value)
+          when :group
+            feature.enable_for_group(value)
+          when :role
+            feature.enable_for_role(value)
           end
         end
       end

data/lib/magick.rb

@@ -39,7 +39,7 @@ module Magick
       # Support both old style and new DSL style
       return unless block_given?
 
-      if block.arity == 0
+      if block.arity.zero?
         # New DSL style
         ConfigDSL.configure(&block)
       else
@@ -68,6 +68,15 @@ module Magick
       feature.enabled?(context)
     end
 
+    def enabled_for?(feature_name, object, **additional_context)
+      feature = features[feature_name.to_s] || self[feature_name]
+      feature.enabled_for?(object, **additional_context)
+    end
+
+    def disabled_for?(feature_name, object, **additional_context)
+      !enabled_for?(feature_name, object, **additional_context)
+    end
+
     # Reload a feature from the adapter (useful when feature is changed externally)
     def reload_feature(feature_name)
       feature = features[feature_name.to_s] || self[feature_name]
@@ -82,7 +91,7 @@ module Magick
       features.key?(feature_name.to_s) || (adapter_registry || default_adapter_registry).exists?(feature_name)
     end
 
-    def bulk_enable(feature_names, context = {})
+    def bulk_enable(feature_names, _context = {})
       feature_names.map do |name|
         feature = features[name.to_s] || self[name]
         feature.set_value(true) if feature.type == :boolean
@@ -90,7 +99,7 @@ module Magick
       end
     end
 
-    def bulk_disable(feature_names, context = {})
+    def bulk_disable(feature_names, _context = {})
       feature_names.map do |name|
         feature = features[name.to_s] || self[name]
         feature.set_value(false) if feature.type == :boolean

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: magick-feature-flags
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.8.2
 platform: ruby
 authors:
 - Andrew Lobanov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-18 00:00:00.000000000 Z
+date: 2025-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec