magick-feature-flags 0.7.0

data/lib/magick/testing_helpers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Magick
+  module TestingHelpers
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def with_feature_enabled(feature_name, &block)
+        feature = Magick.features[feature_name.to_s] || Magick[feature_name]
+        original_value = feature.value
+        feature.set_value(true)
+        yield
+      ensure
+        feature.set_value(original_value)
+      end
+
+      def with_feature_disabled(feature_name, &block)
+        feature = Magick.features[feature_name.to_s] || Magick[feature_name]
+        original_value = feature.value
+        feature.set_value(false)
+        yield
+      ensure
+        feature.set_value(original_value)
+      end
+
+      def with_feature_value(feature_name, value, &block)
+        feature = Magick.features[feature_name.to_s] || Magick[feature_name]
+        original_value = feature.value
+        feature.set_value(value)
+        yield
+      ensure
+        feature.set_value(original_value)
+      end
+    end
+  end
+end
+
+# Include in RSpec
+if defined?(RSpec)
+  RSpec.configure do |config|
+    config.include Magick::TestingHelpers
+  end
+end

data/lib/magick/version.rb

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

data/lib/magick/versioning.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Magick
+  class Versioning
+    class Version
+      attr_reader :version, :feature_data, :timestamp, :created_by
+
+      def initialize(version, feature_data, created_by: nil)
+        @version = version
+        @feature_data = feature_data
+        @timestamp = Time.now
+        @created_by = created_by
+      end
+
+      def to_h
+        {
+          version: version,
+          feature_data: feature_data,
+          timestamp: timestamp.iso8601,
+          created_by: created_by
+        }
+      end
+    end
+
+    def initialize(adapter_registry)
+      @adapter_registry = adapter_registry
+      @versions = {}
+      @mutex = Mutex.new
+    end
+
+    def save_version(feature_name, version: nil, created_by: nil)
+      feature = Magick.features[feature_name.to_s] || Magick[feature_name]
+      version ||= next_version(feature_name)
+      version_data = Version.new(version, feature.to_h, created_by: created_by)
+
+      @mutex.synchronize do
+        @versions[feature_name.to_s] ||= []
+        @versions[feature_name.to_s] << version_data
+        # Store in adapter
+        @adapter_registry.set(feature_name, "version_#{version}", version_data.to_h)
+      end
+
+      # Rails 8+ event
+      if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
+        Magick::Rails::Events.version_saved(feature_name, version: version, created_by: created_by)
+      end
+
+      version_data
+    end
+
+    def rollback(feature_name, version)
+      versions = get_versions(feature_name)
+      target_version = versions.find { |v| v.version == version }
+      return false unless target_version
+
+      feature = Magick.features[feature_name.to_s] || Magick[feature_name]
+      feature_data = target_version.feature_data
+
+      # Restore feature state
+      feature.set_value(feature_data[:value]) if feature_data[:value]
+      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
+          end
+        end
+      end
+
+      # Rails 8+ event
+      if defined?(Magick::Rails::Events) && Magick::Rails::Events.rails8?
+        Magick::Rails::Events.rollback(feature_name, version: version)
+      end
+
+      true
+    end
+
+    def get_versions(feature_name)
+      @versions[feature_name.to_s] || []
+    end
+
+    private
+
+    def next_version(feature_name)
+      versions = get_versions(feature_name)
+      versions.empty? ? 1 : versions.last.version + 1
+    end
+  end
+end

data/lib/magick.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative 'magick/version'
+require_relative 'magick/feature'
+require_relative 'magick/adapters/base'
+require_relative 'magick/adapters/memory'
+require_relative 'magick/adapters/redis'
+require_relative 'magick/adapters/registry'
+require_relative 'magick/targeting/base'
+require_relative 'magick/targeting/user'
+require_relative 'magick/targeting/group'
+require_relative 'magick/targeting/role'
+require_relative 'magick/targeting/percentage'
+require_relative 'magick/targeting/request_percentage'
+require_relative 'magick/errors'
+
+require_relative 'magick/audit_log'
+require_relative 'magick/performance_metrics'
+require_relative 'magick/export_import'
+require_relative 'magick/versioning'
+require_relative 'magick/circuit_breaker'
+require_relative 'magick/testing_helpers'
+require_relative 'magick/feature_dependency'
+require_relative 'magick/config'
+
+# Load DSL early if Rails is present, so it's available in initializers
+require_relative 'magick/dsl' if defined?(Rails)
+
+module Magick
+  class << self
+    attr_accessor :adapter_registry, :default_adapter, :performance_metrics, :audit_log, :versioning,
+                  :warn_on_deprecated
+
+    def configure(&block)
+      @performance_metrics ||= PerformanceMetrics.new
+      @audit_log ||= AuditLog.new
+      @warn_on_deprecated ||= false
+
+      # Support both old style and new DSL style
+      return unless block_given?
+
+      if block.arity == 0
+        # New DSL style
+        ConfigDSL.configure(&block)
+      else
+        # Old style
+        yield self
+      end
+    end
+
+    def [](feature_name)
+      # Return registered feature if it exists, otherwise create new instance
+      features[feature_name.to_s] || Feature.new(feature_name, adapter_registry || default_adapter_registry)
+    end
+
+    def features
+      @features ||= {}
+    end
+
+    def register_feature(name, **options)
+      feature = Feature.new(name, adapter_registry || default_adapter_registry, **options)
+      features[name.to_s] = feature
+      feature
+    end
+
+    def enabled?(feature_name, context = {})
+      feature = features[feature_name.to_s] || self[feature_name]
+      feature.enabled?(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]
+      feature.reload
+    end
+
+    def disabled?(feature_name, context = {})
+      !enabled?(feature_name, context)
+    end
+
+    def exists?(feature_name)
+      features.key?(feature_name.to_s) || (adapter_registry || default_adapter_registry).exists?(feature_name)
+    end
+
+    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
+        feature
+      end
+    end
+
+    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
+        feature
+      end
+    end
+
+    def export(format: :json)
+      case format
+      when :json
+        ExportImport.export_json(features)
+      when :hash
+        ExportImport.export(features)
+      else
+        ExportImport.export(features)
+      end
+    end
+
+    def import(data, format: :json)
+      imported = ExportImport.import(data, adapter_registry || default_adapter_registry)
+      imported.each { |name, feature| features[name] = feature }
+      imported
+    end
+
+    def versioning
+      @versioning ||= Versioning.new(adapter_registry || default_adapter_registry)
+    end
+
+    def reset!
+      @features = {}
+      @adapter_registry = nil
+      @default_adapter = nil
+      @performance_metrics&.clear!
+    end
+
+    private
+
+    def default_adapter_registry
+      @default_adapter_registry ||= begin
+        memory_adapter = Adapters::Memory.new
+        redis_adapter = begin
+          Adapters::Redis.new if defined?(Redis)
+        rescue AdapterError
+          nil
+        end
+        Adapters::Registry.new(memory_adapter, redis_adapter)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: magick-feature-flags
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- Andrew Lobanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.22'
+description: Magick is a better version of Flipper feature-toggle gem. It is absolutely
+  performant and memory efficient.
+email:
+- woblavobla@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/generators/magick/install/install_generator.rb
+- lib/generators/magick/install/templates/README
+- lib/generators/magick/install/templates/magick.rb
+- lib/magick.rb
+- lib/magick/adapters/base.rb
+- lib/magick/adapters/memory.rb
+- lib/magick/adapters/redis.rb
+- lib/magick/adapters/registry.rb
+- lib/magick/audit_log.rb
+- lib/magick/circuit_breaker.rb
+- lib/magick/config.rb
+- lib/magick/dsl.rb
+- lib/magick/errors.rb
+- lib/magick/export_import.rb
+- lib/magick/feature.rb
+- lib/magick/feature_dependency.rb
+- lib/magick/feature_variant.rb
+- lib/magick/performance_metrics.rb
+- lib/magick/rails.rb
+- lib/magick/rails/event_subscriber.rb
+- lib/magick/rails/events.rb
+- lib/magick/rails/railtie.rb
+- lib/magick/targeting/base.rb
+- lib/magick/targeting/complex.rb
+- lib/magick/targeting/custom_attribute.rb
+- lib/magick/targeting/date_range.rb
+- lib/magick/targeting/group.rb
+- lib/magick/targeting/ip_address.rb
+- lib/magick/targeting/percentage.rb
+- lib/magick/targeting/request_percentage.rb
+- lib/magick/targeting/role.rb
+- lib/magick/targeting/user.rb
+- lib/magick/testing_helpers.rb
+- lib/magick/version.rb
+- lib/magick/versioning.rb
+homepage: https://github.com/andrew-woblavobla/magick
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: A performant and memory-efficient feature toggle gem
+test_files: []