magick-feature-flags 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec2f109c9d472dc4f5718140075e9ce57f5479e851e347096f59315e8141429f
-  data.tar.gz: 44cb1519755b8d51f397a6103e22822cadff80a663e58b1bc0f70dafa732a7e4
+  metadata.gz: a5124df88b7d429811d4b0f131d01aeeef2dedabc25b598da96fa5f01eb07163
+  data.tar.gz: 72c12e81d29990d6990f0f749effb978c7f9a4d7a316d3455e8ceb508269889d
 SHA512:
-  metadata.gz: 198465d8f50acbbd62e19d0683a3bca9e20ec76c9e72aa8e00873da438e37f2e39efaf7d6740b618f8132c24b5f03b456d1a06b38b0a561d8f89a2e212d02ab7
-  data.tar.gz: a6085c886c4e0461039f6412c14f3d302d7ebe8e50b80e1a65e9cc416cf6ab5bc3964d32c9c372e6b149a1295d0f59393926f779ea0ed84622d21acf08a219c5
+  metadata.gz: 880f57facbd900c562aa10d21708afe0100087a6160ac814cc9d3453233d62cb7b41de1bfe18a831f27ecbd14cfb2b59b238a92f91c4a8fa56d0ae30a62ba125
+  data.tar.gz: cd4addd623241b24d2bc3d08cab687233de382d3c1dc260461484e6b750c637f19dc51368c552694c021f503a30c85e1425016f1af4a7056b8f3cf19f816a299

data/README.md

@@ -166,6 +166,55 @@ 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`:

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,18 @@ 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
-      end
+    def performance_metrics(enabled: true, **_options)
+      @performance_metrics = (PerformanceMetrics.new if enabled)
     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)

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

@@ -69,28 +69,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 +92,7 @@ module Magick
       when :string
         !value.nil? && value != ''
       when :number
-        value.to_f > 0
+        value.to_f.positive?
       else
         false
       end
@@ -110,6 +102,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 +129,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 +162,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 +182,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 +232,7 @@ module Magick
       else
         enable_targeting(:custom_attributes, custom_attrs)
       end
+      true
     end
 
     def set_variants(variants)
@@ -227,6 +245,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 +257,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 +268,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 +281,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?
@@ -297,27 +321,25 @@ module Magick
       @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 +351,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 +362,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)
@@ -362,6 +386,8 @@ module Magick
       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 +395,7 @@ module Magick
 
       @status = new_status.to_sym
       adapter_registry.set(name, 'status', status)
+      true
     end
 
     def delete
@@ -377,6 +404,7 @@ module Magick
       @targeting = {}
       # Also remove from Magick.features if registered
       Magick.features.delete(name.to_s)
+      true
     end
 
     def to_h
@@ -438,7 +466,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 +616,45 @@ 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 enable_targeting(type, value)
       @targeting[type] ||= []
       @targeting[type] << value.to_s unless @targeting[type].include?(value.to_s)
@@ -597,6 +664,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 +680,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 +714,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/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.2'
+  VERSION = '0.8.0'
 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

data/lib/{magick-feature-flags.rb → magick_feature_flags.rb}

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 # Auto-require file for Rails
-# When gem 'magick-feature-flags' is in Gemfile, Rails will try to require this file
+# When gem 'magick-feature-flags' is in Gemfile, Rails will try to require 'magick_feature_flags'
 require 'magick'
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: magick-feature-flags
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Andrew Lobanov
-autorequire: 
+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
@@ -65,7 +65,6 @@ files:
 - lib/generators/magick/install/install_generator.rb
 - lib/generators/magick/install/templates/README
 - lib/generators/magick/install/templates/magick.rb
-- lib/magick-feature-flags.rb
 - lib/magick.rb
 - lib/magick/adapters/base.rb
 - lib/magick/adapters/memory.rb
@@ -98,11 +97,12 @@ files:
 - lib/magick/testing_helpers.rb
 - lib/magick/version.rb
 - lib/magick/versioning.rb
+- lib/magick_feature_flags.rb
 homepage: https://github.com/andrew-woblavobla/magick
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -117,8 +117,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.5.19
+signing_key:
 specification_version: 4
 summary: A performant and memory-efficient feature toggle gem
 test_files: []