stoplight 5.5.0 → 5.7.0

data/lib/stoplight/infrastructure/dependency_injection/container.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module DependencyInjection
-      # Generic dependency injection container for managing object dependencies.
-      #
-      # This is a low-level infrastructure component that provides the mechanism for
-      # dependency resolution. It has no knowledge of Stoplight's domain concepts and
-      # could theoretically be used in any Ruby application.
-      #
-      # The container supports three resolution strategies:
-      #
-      # 1. **Direct dependencies** - Pre-configured values stored in the container
-      # 2. **Lazy initialization** - Dependencies that are transformed on first access
-      # 3. **Factories** - Dependencies computed dynamically from other dependencies
-      #
-      # @example Basic usage with direct dependencies
-      #   container = Container.new
-      #   container.register(:logger, Logger.new)
-      #   container.resolve(:logger) #=> #<Logger...>
-      #
-      # @example Using lazy initialization
-      #   container.register(:redis, "redis://localhost:6379") do |url|
-      #     Redis.new(url)
-      #   end
-      #   container.resolve(:redis) #=> #<Redis @connection_string="redis://localhost:6379">
-      #
-      # @example Using factories for computed dependencies
-      #   container.register(:config, my_config)
-      #   container.factory(:service) do
-      #     MyService.new(config: resolve(:config))
-      #   end
-      #   container.resolve(:service) #=> #<MyService...>
-      #
-      # @example Building a container with DSL
-      #   container = Container.define do
-      #     register(:port, 3000)
-      #     register(:host, "localhost")
-      #
-      #     factory(:server) do
-      #       Server.new(host: resolve(:host), port: resolve(:port))
-      #     end
-      #   end
-      #
-      # @api private
-      class Container
-        # @!attribute [r] dependencies
-        #   Stores registered dependency values
-        #   @return [Hash{Symbol => Object}]
-        protected attr_reader :dependencies
-
-        # @!attribute [r] factories
-        #   Stores factory blocks for computed dependencies
-        #   @return [Hash{Symbol => Proc}]
-        protected attr_reader :factories
-
-        # @!attribute [r] initializers
-        #   Stores optional transformation blocks for dependencies
-        #   @return [Hash{Symbol => Proc}]
-        protected attr_reader :initializers
-
-        class << self
-          # Define a container using a DSL block.
-          #
-          # This is a convenience method for creating and configuring a container
-          # in a single expression.
-          #
-          # @yield Block evaluated in the context of the new container
-          # @return [Stoplight::Infrastructure::DependencyInjection::Container] Configured container instance
-          #
-          # @example
-          #   container = Container.define do
-          #     register(:redis_url, "redis://localhost:6379")
-          #     factory(:redis) { Redis.new(resolve(:redis_url)) }
-          #   end
-          def define(&definition)
-            new.define(&definition)
-          end
-        end
-
-        # Creates a new dependency injection container.
-        #
-        # @param dependencies [Hash{Symbol => Object}]
-        # @param factories [Hash{Symbol => Proc}]
-        # @param initializers [Hash{Symbol => Proc}]
-        def initialize(dependencies: {}, factories: {}, initializers: {})
-          @dependencies = dependencies
-          @initializers = initializers
-          @factories = factories
-        end
-
-        # Evaluate a configuration block in the context of this container.
-        #
-        # @yield Block evaluated in the context of the container
-        # @return [Stoplight::Infrastructure::DependencyInjection::Container] self for method chaining
-        #
-        # @example
-        #   container = Container.new
-        #   container.define do
-        #     register(:port, 8080)
-        #     factory(:server) { Server.new(port: resolve(:port)) }
-        #   end
-
-        def define(&definition)
-          instance_eval(&definition)
-          freeze
-          self
-        end
-
-        # Registers a dependency value with optional lazy initialization.
-        #
-        # The initializer block is called every time the dependency is resolved,
-        # receiving the registered value as an argument. This allows for delayed
-        # object construction or transformation of simple values into complex objects.
-        #
-        # @param name [Symbol] The dependency key
-        # @param value [Object] The dependency value (may be transformed by initializer)
-        # @yield [value] Optional transformation block
-        # @yieldparam value [Object] The registered value
-        # @yieldreturn [Object] The transformed value to return when resolving
-        # @return [Stoplight::Infrastructure::DependencyInjection::Container] self for method chaining
-        #
-        # @example Register a simple dependency
-        #   container.register(:port, 3000)
-        #   container.resolve(:port) #=> 3000
-        #
-        # @example Register with lazy initialization
-        #   container.register(:redis, "redis://localhost:6379") do |url|
-        #     Redis.new(url)
-        #   end
-        #   container.resolve(:redis) #=> #<Redis...>
-        #
-        # @example Initialization is applied on every resolution
-        #   container.register(:timestamp, Time.now, &:to_i)
-        #   container.resolve(:timestamp) #=> 1234567890
-        #
-        #   # Update the value
-        #   container.register(:timestamp, Time.now + 60)
-        #   container.resolve(:timestamp) #=> 1234567950 (new timestamp)
-        #
-        def register(name, value, &initializer)
-          dependencies[name] = value
-          initializers[name] = initializer if block_given?
-          self
-        end
-
-        # Resolves a dependency by name.
-        #
-        # Resolution order:
-        # 1. Direct dependency with initializer (value is transformed)
-        # 2. Direct dependency without initializer (value returned as-is)
-        # 3. Factory (block evaluated in container context)
-        # 4. Raises {Stoplight::Infrastructure::DependencyInjection::UnresolvedDependencyError}
-        #
-        # @param name [Symbol] The dependency key
-        # @return [Object] The resolved dependency value
-        # @raise [Stoplight::Infrastructure::DependencyInjection::UnresolvedDependencyError] if dependency is not registered
-        #
-        def resolve(name)
-          if dependencies.key?(name)
-            value = dependencies[name]
-            if initializers.key?(name)
-              initializer = initializers[name]
-              instance_exec(value, &initializer)
-            else
-              value
-            end
-          elsif factories.key?(name)
-            factory = factories[name]
-            instance_eval(&factory)
-          else
-            raise UnresolvedDependencyError, name
-          end
-        end
-
-        # Registers a factory for computing dependencies dynamically.
-        #
-        # Factories are evaluated lazily when the dependency is resolved.
-        # The factory block is evaluated in the container's context, giving
-        # it access to the +#resolve+ method for accessing other dependencies.
-        #
-        # Unlike +#register+ with an initializer, factories are not cached -
-        # they are executed every time the dependency is resolved.
-        #
-        # @param key [Symbol] The dependency key
-        # @yield Factory block evaluated in container context
-        # @yieldreturn [Object] The computed dependency value
-        # @return [Stoplight::Infrastructure::DependencyInjection::Container] self for method chaining
-        #
-        def factory(key, &factory)
-          factories[key] = factory
-          self
-        end
-
-        # Returns all registered dependency keys.
-        #
-        # This includes both direct dependencies and factory definitions.
-        #
-        # @return [Array<Symbol>] All registered dependency keys
-        #
-        # @example
-        #   container.register(:port, 3000)
-        #   container.factory(:server) { Server.new }
-        #   container.keys #=> [:port, :server]
-        #
-        def keys
-          factories.keys | dependencies.keys
-        end
-
-        # Creates a new container with merged dependencies.
-        #
-        # This is an immutable operation - the original container is not modified.
-        # Factories and initializers are copied to the new container.
-        #
-        # @param new_dependencies [Hash{Symbol => Object}] Dependencies to merge/override
-        # @return [Stoplight::Infrastructure::DependencyInjection::Container] New container with merged dependencies
-        #
-        # @example Creating specialized containers
-        #   base = Container.define do
-        #     register(:host, "localhost")
-        #     register(:port, 3000)
-        #   end
-        #
-        #   production = base.with(host: "prod.example.com", port: 80)
-        #   staging = base.with(host: "staging.example.com", port: 8080)
-        #
-        #   base.resolve(:port) #=> 3000
-        #   production.resolve(:port) #=> 80
-        #   staging.resolve(:port) #=> 8080
-
-        def with(**new_dependencies)
-          self.class.new(
-            dependencies: {**dependencies, **new_dependencies},
-            factories:,
-            initializers:
-          )
-        end
-
-        def ==(other)
-          other.is_a?(self.class) &&
-            other.dependencies == dependencies &&
-            other.factories == factories &&
-            other.initializers == initializers
-        end
-      end
-    end
-  end
-end

data/lib/stoplight/infrastructure/dependency_injection/unresolved_dependency_error.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module DependencyInjection
-      class UnresolvedDependencyError < Domain::Error::Base
-        def initialize(key)
-          super("Unable to resolve dependency: `#{key}`")
-        end
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/container.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    # This container implements an instance of +Stoplight::Infrastructure::DependencyInjection::Container+
-    # with Stoplight-specific wiring knowledge. It defines how to construct and connect
-    # all the components needed for a circuit breaker to function.
-    #
-    # ## Default Configuration
-    #
-    # The container is pre-configured with sensible defaults:
-    # - Data Store - in-memory storage
-    # - STDERR notifier
-    # - No-op error notifier
-    # - Consecutive failure detection
-    # - Consecutive success recovery
-    #
-    # @see Infrastructure::DependencyInjection::Container Generic DI container
-    # @see Stoplight::Wiring::LightFactory Factory that uses this container
-    # @api private
-    Container = Infrastructure::DependencyInjection::Container.define do
-      register(:config, Light::DefaultConfig)
-      register(:error_notifier, Default::ERROR_NOTIFIER)
-      register(:traffic_control, Default::TRAFFIC_CONTROL)
-      register(:traffic_recovery, Default::TRAFFIC_RECOVERY)
-
-      register(:data_store, Default::DATA_STORE) do |data_store|
-        FailSafeDataStore.wrap(
-          data_store:,
-          error_notifier: resolve(:error_notifier)
-        )
-      end
-
-      register(:notifiers, Default::NOTIFIERS) do |notifiers|
-        error_notifier = resolve(:error_notifier)
-        notifiers.map { |notifier| Wiring::FailSafeNotifier.wrap(notifier:, error_notifier:) }
-      end
-
-      factory(:green_run_strategy) do
-        Domain::Strategies::GreenRunStrategy.new(
-          config: resolve(:config),
-          request_tracker: resolve(:request_tracker)
-        )
-      end
-
-      factory(:yellow_run_strategy) do
-        Domain::Strategies::YellowRunStrategy.new(
-          config: resolve(:config),
-          data_store: resolve(:data_store),
-          notifiers: resolve(:notifiers),
-          request_tracker: resolve(:recovery_probe_tracker)
-        )
-      end
-
-      factory(:red_run_strategy) do
-        Domain::Strategies::RedRunStrategy.new(
-          config: resolve(:config)
-        )
-      end
-
-      factory(:request_tracker) do
-        Domain::Tracker::Request.new(
-          data_store: resolve(:data_store),
-          traffic_control: resolve(:traffic_control),
-          notifiers: resolve(:notifiers),
-          config: resolve(:config)
-        )
-      end
-
-      factory(:recovery_probe_tracker) do
-        Domain::Tracker::RecoveryProbe.new(
-          data_store: resolve(:data_store),
-          traffic_recovery: resolve(:traffic_recovery),
-          notifiers: resolve(:notifiers),
-          config: resolve(:config)
-        )
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/fail_safe_data_store.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module Stoplight
-  module Wiring
-    # A wrapper around a data store that provides fail-safe mechanisms using a
-    # circuit breaker. It ensures that operations on the data store can gracefully
-    # handle failures by falling back to default values when necessary.
-    #
-    # @api private
-    class FailSafeDataStore < Domain::DataStore
-      class << self
-        # Wraps a data store with fail-safe mechanisms.
-        #
-        # @param data_store [Stoplight::DataStore::Base] The data store to wrap.
-        # @param error_notifier [Proc] called when wrapped data store fails
-        # @return [Stoplight::DataStore::Base, FailSafe] The original data store if it is already
-        #   a +Memory+ or +FailSafe+ instance, otherwise a new +FailSafe+ instance.
-        def wrap(data_store:, error_notifier:)
-          case data_store
-          in Infrastructure::DataStore::Memory
-            data_store
-          in self if data_store.error_notifier == error_notifier
-            data_store
-          in self
-            new(data_store: data_store.data_store, error_notifier:)
-          else
-            new(data_store:, error_notifier:)
-          end
-        end
-      end
-
-      # @!attribute data_store
-      #  @return [Stoplight::DataStore::Base] The underlying primary data store being used
-      attr_reader :data_store
-
-      # @!attribute error_notifier
-      #   @return [Proc]
-      attr_reader :error_notifier
-
-      # @!attribute failover_data_store
-      #   @return [Stoplight::DataStore::Base] The fallback data store used when the primary fails.
-      private attr_reader :failover_data_store
-
-      # @!attribute circuit_breaker
-      #   @return [Stoplight::Light] The circuit breaker used to handle data store failures.
-      private attr_reader :circuit_breaker
-
-      # @param data_store [Stoplight::Domain::DataStore]
-      # @param error_notifier [Proc]
-      def initialize(data_store:, error_notifier:, failover_data_store: Wiring::Default::DATA_STORE)
-        @data_store = data_store
-        @error_notifier = error_notifier
-        @failover_data_store = failover_data_store
-        @circuit_breaker = Stoplight.system_light("data_store:fail_safe:#{data_store.class.name}")
-      end
-
-      def names
-        with_fallback(:names) do
-          data_store.names
-        end
-      end
-
-      def get_metadata(config, *args, **kwargs)
-        with_fallback(:get_metadata, config, *args, **kwargs) do
-          data_store.get_metadata(config, *args, **kwargs)
-        end
-      end
-
-      def record_failure(config, *args, **kwargs)
-        with_fallback(:record_failure, config, *args, **kwargs) do
-          data_store.record_failure(config, *args, **kwargs)
-        end
-      end
-
-      def record_success(config, *args, **kwargs)
-        with_fallback(:record_success, config, *args, **kwargs) do
-          data_store.record_success(config, *args, **kwargs)
-        end
-      end
-
-      def record_recovery_probe_success(config, *args, **kwargs)
-        with_fallback(:record_recovery_probe_success, config, *args, **kwargs) do
-          data_store.record_recovery_probe_success(config, *args, **kwargs)
-        end
-      end
-
-      def record_recovery_probe_failure(config, *args, **kwargs)
-        with_fallback(:record_recovery_probe_failure, config, *args, **kwargs) do
-          data_store.record_recovery_probe_failure(config, *args, **kwargs)
-        end
-      end
-
-      def set_state(config, *args, **kwargs)
-        with_fallback(:set_state, config, *args, **kwargs) do
-          data_store.set_state(config, *args, **kwargs)
-        end
-      end
-
-      def transition_to_color(config, *args, **kwargs)
-        with_fallback(:transition_to_color, config, *args, **kwargs) do
-          data_store.transition_to_color(config, *args, **kwargs)
-        end
-      end
-
-      def ==(other)
-        other.is_a?(self.class) && other.data_store == data_store && other.error_notifier == error_notifier
-      end
-
-      # @param method_name [Symbol] protected method name
-      private def with_fallback(method_name, *args, **kwargs, &code)
-        fallback = proc do |error|
-          config = args.first
-          error_notifier.call(error) if config && error
-          @failover_data_store.public_send(method_name, *args, **kwargs)
-        end
-
-        circuit_breaker.run(fallback, &code)
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/fail_safe_notifier.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    # A wrapper around a notifier that provides fail-safe mechanisms using a
-    # circuit breaker. It ensures that a notification can gracefully
-    # handle failures.
-    #
-    # @api private
-    class FailSafeNotifier < Domain::StateTransitionNotifier
-      # @!attribute [r] notifier
-      #   @return [Stoplight::Domain::StateTransitionNotifier] The underlying notifier being wrapped.
-      attr_reader :notifier
-
-      # @!attribute [r] error_notifier
-      #   @return [Stoplight::Domain::StateTransitionNotifier] The underlying notifier being wrapped.
-      attr_reader :error_notifier
-
-      class << self
-        # Wraps a notifier with fail-safe mechanisms.
-        #
-        # @param notifier [Stoplight::Domain::StateTransitionNotifier] The notifier to wrap.
-        # @param error_notifier [Proc] called when wrapped data store fails
-        # @return [Stoplight::Notifier::FailSafe] The original notifier if it is already
-        #   a +FailSafe+ instance, otherwise a new +FailSafe+ instance.
-        def wrap(notifier:, error_notifier:)
-          case notifier
-          in self if notifier.error_notifier == error_notifier
-            notifier
-          in self
-            new(notifier: notifier.notifier, error_notifier:)
-          else
-            new(notifier:, error_notifier:)
-          end
-        end
-      end
-
-      # Initializes a new instance of the +FailSafe+ class.
-      #
-      # @param notifier [Stoplight::Domain::StateTransitionNotifier] The notifier to wrap.
-      # @param error_notifier [Proc] called when wrapped data store fails
-      def initialize(notifier:, error_notifier:)
-        @notifier = notifier
-        @error_notifier = error_notifier
-      end
-
-      # Sends a notification using the wrapped notifier with fail-safe mechanisms.
-      #
-      # @param config [Stoplight::Domain::Config] The light configuration.
-      # @param from_color [String] The initial color of the light.
-      # @param to_color [String] The target color of the light.
-      # @param error [Exception, nil] An optional error to include in the notification.
-      # @return [void]
-      def notify(config, from_color, to_color, error = nil)
-        fallback = proc do |exception|
-          error_notifier.call(exception) if exception
-          nil
-        end
-
-        circuit_breaker.run(fallback) do
-          notifier.notify(config, from_color, to_color, error)
-        end
-      end
-
-      # @return [Boolean]
-      def ==(other)
-        other.is_a?(self.class) && notifier == other.notifier
-      end
-
-      # @return [Stoplight::Light] The circuit breaker used to handle failures.
-      private def circuit_breaker
-        @circuit_breaker ||= Stoplight.system_light(
-          "stoplight:notifier:fail_safe:#{notifier.class.name}",
-          notifiers: []
-        )
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/system_container.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    SystemContainer = Container.with(
-      traffic_recovery: Domain::TrafficRecovery::ConsecutiveSuccesses.new
-    )
-  end
-end

data/lib/stoplight/wiring/system_light_factory.rb

@@ -1,17 +0,0 @@
-# frozon_string_literal: true
-
-module Stoplight
-  module Wiring
-    # Factory for internal system lights used by the Stoplight itself.
-    #
-    # System lights are isolated from user configuration to prevent
-    # user settings from breaking the library's own circuit breakers.
-    # For example, the FailSafe data store wrapper uses a system light
-    # to protect against data store failures.
-    #
-    # @api private
-    SystemLightFactory = Wiring::LightFactory.new(
-      Wiring::SystemContainer.with(config: Light::SystemConfig)
-    )
-  end
-end