stoplight 5.7.0 → 5.8.0

data/lib/stoplight/wiring/light_factory/config_normalizer.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    class LightFactory
-      # Normalizes user-provided configuration values into canonical forms.
-      #
-      # Handles common user convenience patterns:
-      # - Single error class → Array of error classes
-      # - Numeric cool_off_time → Integer
-      #
-      # @example
-      #   config = Config.empty.with(
-      #     tracked_errors: StandardError,  # Single class
-      #     cool_off_time: 30.5             # Float
-      #   )
-      #
-      #   normalized = ConfigNormalizer.call(config)
-      #   normalized.tracked_errors #=> [StandardError]  # Array
-      #   normalized.cool_off_time  #=> 30               # Integer
-      #
-      # @api private
-      class ConfigNormalizer
-        class << self
-          def call(config) = new(config).call
-        end
-
-        # @!attribute config
-        #   @return [Stoplight::Domain::Config]
-        private attr_reader :config
-
-        # @param [Stoplight::Domain::Config]
-        def initialize(config)
-          @config = config
-        end
-
-        # @return [Stoplight::Domain::Config]
-        def call
-          config
-            .then { |c| normalize_tracked_errors(c) }
-            .then { |c| normalize_skipped_errors(c) }
-            .then { |c| normalize_cool_off_time(c) }
-        end
-
-        private def normalize_tracked_errors(config)
-          if config.tracked_errors.is_a?(Array)
-            config
-          else
-            config.with(tracked_errors: Array(config.tracked_errors))
-          end
-        end
-
-        private def normalize_skipped_errors(config)
-          if config.skipped_errors.is_a?(Array)
-            config
-          else
-            config.with(skipped_errors: Array(config.skipped_errors))
-          end
-        end
-
-        private def normalize_cool_off_time(config)
-          if config.cool_off_time.is_a?(Integer)
-            config
-          else
-            config.with(cool_off_time: config.cool_off_time.to_i)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/light_factory/configuration_pipeline.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    class LightFactory
-      # Orchestrates DSL interpretation, normalization, and validation.
-      #
-      # ConfigurationPipeline is the entry point for transforming raw user settings
-      # into validated domain objects. It coordinates three steps:
-      #
-      # 1. Normalization - Convert user-friendly values to canonical forms
-      # 2. DSL Interpretation - Transform symbols/hashes into strategy objects
-      # 3. Validation - Ensure strategies are compatible with configuration
-      #
-      # @api private
-      class ConfigurationPipeline
-        BASE_DEPENDENCIES = {
-          data_store: Default::DATA_STORE,
-          traffic_recovery: Default::TRAFFIC_RECOVERY,
-          traffic_control: Default::TRAFFIC_CONTROL,
-          notifiers: Default::NOTIFIERS,
-          error_notifier: Default::ERROR_NOTIFIER
-        }.freeze
-        private_constant :BASE_DEPENDENCIES
-
-        private attr_reader :dependency_settings
-        private attr_reader :config_settings
-
-        def self.process(config_settings, dependency_settings)
-          new(config_settings, dependency_settings).process
-        end
-
-        def initialize(config_settings, dependency_settings)
-          @config_settings = config_settings
-          @dependency_settings = dependency_settings
-        end
-
-        def process
-          config = build_config
-          dependencies = build_dependencies
-
-          CompatibilityValidator.call(config, dependencies)
-
-          [config, dependencies]
-        end
-
-        def build_config
-          base_config
-            .with(**config_settings)
-            .then { |cfg| ConfigNormalizer.call(cfg) }
-        end
-
-        def build_dependencies
-          base_dependencies
-            .merge(dependency_settings)
-            .then { |deps| interpret_dsl(deps) }
-        end
-
-        def interpret_dsl(dependencies)
-          dependencies.merge(
-            traffic_control: TrafficControlDsl.call(dependencies.fetch(:traffic_control)),
-            traffic_recovery: TrafficRecoveryDsl.call(dependencies.fetch(:traffic_recovery))
-          )
-        end
-
-        def base_config = Light::DefaultConfig
-
-        def base_dependencies = BASE_DEPENDENCIES
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/public_api.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    # Public API facade for backward compatibility and convenience
-    # @api public
-    module PublicApi
-      # Aliases for domain concepts
-      Color = Domain::Color
-      Error = Domain::Error
-      State = Domain::State
-
-      # Namespace aliases for data stores
-      module DataStore
-        Base = Stoplight::Wiring::DataStore::Base
-        Redis = Stoplight::Wiring::DataStore::Redis
-        Memory = Stoplight::Wiring::DataStore::Memory
-      end
-
-      # Namespace aliases for notifiers
-      module Notifier
-        Base = Domain::StateTransitionNotifier
-        Generic = Infrastructure::Notifier::Generic
-        IO = Infrastructure::Notifier::IO
-        Logger = Infrastructure::Notifier::Logger
-      end
-    end
-  end
-end