stoplight 4.1.1 → 5.0.1

data/lib/stoplight/configurable.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  # @api private
-  # @abstract include the module and define +#reconfigure+ method
-  module Configurable
-    # @!attribute [r] configuration
-    #   @return [Stoplight::Configuration]
-    #   @api private
-    attr_reader :configuration
-
-    # Configures data store to be used with this circuit breaker
-    #
-    # @example
-    #   Stoplight('example')
-    #     .with_data_store(Stoplight::DataStore::Memory.new)
-    #
-    # @param data_store [DataStore::Base]
-    # @return [Stoplight::CircuitBreaker]
-    def with_data_store(data_store)
-      reconfigure(configuration.with(data_store: data_store))
-    end
-
-    # Configures cool off time. Stoplight automatically tries to recover
-    # from the red state after the cool off time.
-    #
-    # @example
-    #   Stoplight('example')
-    #     .cool_off_time(60)
-    #
-    # @param cool_off_time [Numeric] number of seconds
-    # @return [Stoplight::CircuitBreaker]
-    def with_cool_off_time(cool_off_time)
-      reconfigure(configuration.with(cool_off_time: cool_off_time))
-    end
-
-    # Configures custom threshold. After this number of failures Stoplight
-    # switches to the red state:
-    #
-    # @example
-    #   Stoplight('example')
-    #     .with_threshold(5)
-    #
-    # @param threshold [Numeric]
-    # @return [Stoplight::CircuitBreaker]
-    def with_threshold(threshold)
-      reconfigure(configuration.with(threshold: threshold))
-    end
-
-    # Configures custom window size which Stoplight uses to count failures. For example,
-    #
-    # @example
-    #   Stoplight('example')
-    #     .with_threshold(5)
-    #     .with_window_size(60)
-    #
-    # The above example will turn to red light only when 5 errors happen
-    # within 60 seconds period.
-    #
-    # @param window_size [Numeric] number of seconds
-    # @return [Stoplight::CircuitBreaker]
-    def with_window_size(window_size)
-      reconfigure(configuration.with(window_size: window_size))
-    end
-
-    # Configures custom notifier
-    #
-    # @example
-    #   io = StringIO.new
-    #   notifier = Stoplight::Notifier::IO.new(io)
-    #   Stoplight('example')
-    #     .with_notifiers([notifier])
-    #
-    # @param notifiers [Array<Notifier::Base>]
-    # @return [Stoplight::CircuitBreaker]
-    def with_notifiers(notifiers)
-      reconfigure(configuration.with(notifiers: notifiers))
-    end
-
-    # @param error_notifier [Proc]
-    # @return [Stoplight::CircuitBreaker]
-    # @api private
-    def with_error_notifier(&error_notifier)
-      reconfigure(configuration.with(error_notifier: error_notifier))
-    end
-
-    private
-
-    # @param [Stoplight::Configuration]
-    # @return [Stoplight::CircuitBreaker]
-    def reconfigure(_configuration)
-      raise NotImplementedError, "#{self.class.name}#reconfigure is not implemented"
-    end
-  end
-end

data/lib/stoplight/configuration.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  # A +Stoplight::Light+ configuration object.
-  class Configuration
-    class << self
-      alias __new_without_defaults__ new
-
-      # It overrides the +Configuration.new+ to inject default settings
-      # @see +Stoplight::Configuration#initialize+
-      def new(**settings)
-        __new_without_defaults__(
-          **default_settings.merge(settings)
-        )
-      end
-
-      private
-
-      # @return [Hash]
-      def default_settings
-        {
-          cool_off_time: Default::COOL_OFF_TIME,
-          data_store: Stoplight.default_data_store,
-          error_notifier: Stoplight.default_error_notifier,
-          notifiers: Stoplight.default_notifiers,
-          threshold: Default::THRESHOLD,
-          window_size: Default::WINDOW_SIZE
-        }
-      end
-    end
-
-    # @!attribute [r] name
-    #   @return [String]
-    attr_reader :name
-
-    # @!attribute [r] cool_off_time
-    #   @return [Numeric]
-    attr_reader :cool_off_time
-
-    # @!attribute [r] data_store
-    #   @return [Stoplight::DataStore::Base]
-    attr_reader :data_store
-
-    # @!attribute [r] error_notifier
-    #   # @return [StandardError => void]
-    attr_reader :error_notifier
-
-    # @!attribute [r] notifiers
-    #   # @return [Array<Notifier::Base>]
-    attr_reader :notifiers
-
-    # @!attribute [r] threshold
-    #   @return [Numeric]
-    attr_reader :threshold
-
-    # @!attribute [r] window_size
-    #   @return [Numeric]
-    attr_reader :window_size
-
-    # @param name [String]
-    # @param cool_off_time [Numeric]
-    # @param data_store [Stoplight::DataStore::Base]
-    # @param error_notifier [Proc]
-    # @param notifiers [Stoplight::Notifier::Base]
-    # @param threshold [Numeric]
-    # @param window_size [Numeric]
-    def initialize(name:, cool_off_time:, data_store:, error_notifier:, notifiers:, threshold:, window_size:)
-      @name = name
-      @cool_off_time = cool_off_time
-      @data_store = data_store
-      @error_notifier = error_notifier
-      @notifiers = notifiers
-      @threshold = threshold
-      @window_size = window_size
-    end
-
-    # @param other [any]
-    # @return [Boolean]
-    def ==(other)
-      other.is_a?(self.class) && settings == other.settings
-    end
-
-    # @param cool_off_time [Numeric]
-    # @param data_store [Stoplight::DataStore::Base]
-    # @param error_notifier [Proc]
-    # @param name [String]
-    # @param notifiers [Stoplight::Notifier::Base]
-    # @param threshold [Numeric]
-    # @param window_size [Numeric]
-    # @return [Stoplight::Configuration]
-    def with(
-      cool_off_time: self.cool_off_time,
-      data_store: self.data_store,
-      error_notifier: self.error_notifier,
-      name: self.name,
-      notifiers: self.notifiers,
-      threshold: self.threshold,
-      window_size: self.window_size
-    )
-      Configuration.new(
-        cool_off_time: cool_off_time,
-        data_store: data_store,
-        error_notifier: error_notifier,
-        name: name,
-        notifiers: notifiers,
-        threshold: threshold,
-        window_size: window_size
-      )
-    end
-
-    protected
-
-    # @return [Hash]
-    def settings
-      {
-        cool_off_time: cool_off_time,
-        data_store: data_store,
-        error_notifier: error_notifier,
-        name: name,
-        notifiers: notifiers,
-        threshold: threshold,
-        window_size: window_size
-      }
-    end
-  end
-end

data/lib/stoplight/light/deprecated.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  class Light
-    # @api private
-    module Deprecated
-      def default_data_store
-        warn '[DEPRECATED] `Stoplight::Light.default_data_store` is deprecated. ' \
-          'Please use `Stoplight.default_data_store` instead.'
-        Stoplight.default_data_store
-      end
-
-      def default_data_store=(value)
-        warn '[DEPRECATED] `Stoplight::Light.default_data_store=` is deprecated. ' \
-          'Please use `Stoplight.default_data_store=` instead.'
-        Stoplight.default_data_store = value
-      end
-
-      def default_notifiers
-        warn '[DEPRECATED] `Stoplight::Light.default_notifiers` is deprecated. ' \
-          'Please use `Stoplight.default_notifiers` instead.'
-        Stoplight.default_notifiers
-      end
-
-      def default_notifiers=(value)
-        warn '[DEPRECATED] `Stoplight::Light.default_notifiers=` is deprecated. ' \
-          'Please use `Stoplight.default_notifiers=` instead.'
-        Stoplight.default_notifiers = value
-      end
-
-      def default_error_notifier
-        warn '[DEPRECATED] `Stoplight::Light.default_error_notifier` is deprecated. ' \
-          'Please use `Stoplight.default_error_notifier` instead.'
-        Stoplight.default_error_notifier
-      end
-
-      def default_error_notifier=(value)
-        warn '[DEPRECATED] `Stoplight::Light.default_error_notifier=` is deprecated. ' \
-          'Please use `Stoplight.default_error_notifier=` instead.'
-        Stoplight.default_error_notifier = value
-      end
-    end
-  end
-end

data/lib/stoplight/light/lockable.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  class Light
-    # The Lockable module implements the behavior of locking and unlocking the light.
-    # Light can be locked in either a State::LOCKED_RED or State::LOCKED_GREEN state.
-    # By locking the light, you force it always to run code with the chosen light color.
-    #
-    # @example
-    #   light = Stoplight('example-locked') { true }
-    #   # => #<Stoplight::Light:..>
-    #   light.run
-    #   # => true
-    #   light.lock(Stoplight::Color::RED)
-    #   # => #<Stoplight::Light:..>
-    #   light.run
-    #   # => Stoplight::Error::RedLight: example-locked
-    #   light.unlock
-    #   # => #<Stoplight::Light:..>
-    #   light.run
-    #   # => true
-    module Lockable
-      # @param color [String] should be either Color::RED or Color::GREEN
-      # @return [Stoplight::Light] returns locked light
-      def lock(color)
-        state = case color
-                when Color::RED then State::LOCKED_RED
-                when Color::GREEN then State::LOCKED_GREEN
-                else raise Error::IncorrectColor
-                end
-
-        safely { data_store.set_state(self, state) }
-
-        self
-      end
-
-      # @return [Stoplight::Light] returns unlocked light
-      def unlock
-        safely { data_store.set_state(self, Stoplight::State::UNLOCKED) }
-
-        self
-      end
-    end
-  end
-end

data/lib/stoplight/light/runnable.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  class Light
-    module Runnable # rubocop:disable Style/Documentation
-      # @return [String]
-      def state
-        _, state = failures_and_state
-        state
-      end
-
-      # @return [String]
-      def color
-        failures, state = failures_and_state
-        failure = failures.first
-
-        if state == State::LOCKED_GREEN then Color::GREEN
-        elsif state == State::LOCKED_RED then Color::RED
-        elsif failures.size < threshold then Color::GREEN
-        elsif failure && Time.now - failure.time >= cool_off_time
-          Color::YELLOW
-        else
-          Color::RED
-        end
-      end
-
-      # @raise [Error::RedLight]
-      def run(&code)
-        code = validate_code(&code)
-        case color
-        when Color::GREEN then run_green(&code)
-        when Color::YELLOW then run_yellow(&code)
-        else run_red
-        end
-      end
-
-      private
-
-      def validate_code(&code)
-        raise ArgumentError, <<~ERROR if block_given? && self.code
-          passing code block into both `Light.new` and `Light#run` is not allowed
-        ERROR
-
-        raise ArgumentError, <<~ERROR unless block_given? || self.code
-          nothing to run. Please, pass a block into `Light#run`
-        ERROR
-
-        code || self.code
-      end
-
-      def run_green(&code)
-        on_failure = lambda do |size, error|
-          notify(Color::GREEN, Color::RED, error) if failures_threshold_breached?(size, threshold)
-        end
-        run_code(nil, on_failure, &code)
-      end
-
-      def failures_threshold_breached?(current_failures_count, max_errors_threshold)
-        current_failures_count == max_errors_threshold
-      end
-
-      def run_yellow(&code)
-        on_success = lambda do |failures|
-          notify(Color::RED, Color::GREEN) unless failures.empty?
-        end
-        run_code(on_success, nil, &code)
-      end
-
-      def run_red
-        raise Error::RedLight, name unless fallback
-
-        fallback.call(nil)
-      end
-
-      def run_code(on_success, on_failure, &code)
-        result = code.call
-        failures = clear_failures
-        on_success&.call(failures)
-        result
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        handle_error(e, on_failure)
-      end
-
-      def handle_error(error, on_failure)
-        error_handler.call(error, Error::HANDLER)
-        size = record_failure(error)
-        on_failure&.call(size, error)
-        raise error unless fallback
-
-        fallback.call(error)
-      end
-
-      def clear_failures
-        safely([]) { data_store.clear_failures(self) }
-      end
-
-      def failures_and_state
-        safely([[], State::UNLOCKED]) { data_store.get_all(self) }
-      end
-
-      def notify(from_color, to_color, error = nil)
-        data_store.with_notification_lock(self, from_color, to_color) do
-          notifiers.each do |notifier|
-            safely { notifier.notify(self, from_color, to_color, error) }
-          end
-        end
-      end
-
-      def record_failure(error)
-        failure = Failure.from_error(error)
-        safely(0) { data_store.record_failure(self, failure) }
-      end
-
-      def safely(default = nil, &code)
-        return yield if data_store == Default::DATA_STORE
-
-        Stoplight("#{name}-safely")
-          .with_data_store(Default::DATA_STORE)
-          .with_fallback do |error|
-            error_notifier.call(error) if error
-            default
-          end
-          .run(&code)
-      end
-    end
-  end
-end

data/lib/stoplight/notifier.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Notifier # rubocop:disable Style/Documentation
-  end
-end

data/spec/spec_helper.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'simplecov'
-
-require 'stoplight'
-require 'timecop'
-require_relative 'support/data_store/base'
-require_relative 'support/light/runnable'
-require_relative 'support/configurable'
-require_relative 'support/database_cleaner'
-require_relative 'support/exception_helpers'
-
-Timecop.safe_mode = true
-
-RSpec.configure do |rspec|
-  rspec.include ExceptionHelpers
-
-  rspec.color = true
-  rspec.disable_monkey_patching!
-  rspec.order = :random
-  rspec.warnings = true
-end

data/spec/stoplight/builder_spec.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'securerandom'
-
-RSpec.describe Stoplight::Builder do
-  let(:name) { SecureRandom.uuid }
-
-  describe '.with' do
-    context 'with only name' do
-      subject(:configuration) { builder.configuration }
-
-      let(:builder) { described_class.with(name: name) }
-
-      it 'sets configuration to default values' do
-        expect(configuration).to have_attributes(
-          name: name,
-          data_store: Stoplight.default_data_store,
-          notifiers: Stoplight.default_notifiers,
-          cool_off_time: Stoplight::Default::COOL_OFF_TIME,
-          threshold: Stoplight::Default::THRESHOLD,
-          window_size: Stoplight::Default::WINDOW_SIZE
-        )
-      end
-    end
-
-    context 'with configured parameters' do
-      subject(:configuration) { builder.configuration }
-
-      let(:builder) { described_class.with(**configured_parameters) }
-      let(:configured_parameters) do
-        {
-          name: name,
-          data_store: 42,
-          notifiers: [43],
-          cool_off_time: 44,
-          threshold: 45,
-          window_size: 46
-        }
-      end
-
-      it 'sets configuration parameters' do
-        expect(configuration).to have_attributes(**configured_parameters)
-      end
-    end
-  end
-
-  describe '.build' do
-    let(:builder) { described_class.new(configuration) }
-    let(:configuration) { instance_double(Stoplight::Configuration, name: name) }
-
-    context 'with code' do
-      subject(:light) { builder.build(&code) }
-
-      let(:code) { -> { 42 } }
-
-      it 'builds new light' do
-        expect(light.configuration).to eq(configuration)
-        expect(light.code).to eq(code)
-      end
-    end
-
-    context 'without code' do
-      subject(:light) { builder.build }
-
-      it 'builds new light' do
-        expect(light.configuration).to eq(configuration)
-        expect(light.code).to eq(nil)
-      end
-    end
-  end
-
-  context 'methods building an instance of light' do
-    let(:builder) { described_class.new(configuration) }
-    let(:configuration) do
-      Stoplight::Configuration.new(
-        name: name,
-        data_store: Stoplight.default_data_store,
-        notifiers: Stoplight.default_notifiers,
-        cool_off_time: Stoplight::Default::COOL_OFF_TIME,
-        threshold: Stoplight::Default::THRESHOLD,
-        window_size: Stoplight::Default::WINDOW_SIZE,
-        error_notifier: Stoplight.default_error_notifier
-      )
-    end
-
-    describe '#with_error_handler' do
-      subject(:light) { builder.with_error_handler(&error_handler) }
-
-      let(:error_handler) { ->(error, handle) {} }
-
-      it 'returns an instance of the Light class with this configuration set' do
-        expect(light.configuration).to be(configuration)
-        expect(light.error_handler).to eq(error_handler)
-      end
-    end
-
-    describe '#with_fallback' do
-      subject(:light) { builder.with_fallback(&fallback) }
-
-      let(:fallback) { ->(error) {} }
-
-      it 'returns an instance of the Light class with this configuration set' do
-        expect(light.configuration).to be(configuration)
-        expect(light.fallback).to eq(fallback)
-      end
-    end
-
-    describe '#run' do
-      it 'yields the block' do
-        expect do |code|
-          builder.run(&code)
-        end.to yield_control
-      end
-    end
-
-    describe '#lock' do
-      context 'when the light is not locked' do
-        it 'locks the light' do
-          expect { builder.lock(Stoplight::Color::RED) }
-            .to change(builder, :color)
-            .from(Stoplight::Color::GREEN)
-            .to(Stoplight::Color::RED)
-        end
-      end
-
-      context 'when the light is locked' do
-        before do
-          builder.lock(Stoplight::Color::RED)
-        end
-
-        it 'does not change the light' do
-          expect { builder.lock(Stoplight::Color::RED) }
-            .not_to change(builder, :color)
-            .from(Stoplight::Color::RED)
-        end
-      end
-    end
-
-    describe '#unlock' do
-      context 'when the light is not locked' do
-        it 'does nothing' do
-          expect { builder.unlock }
-            .not_to change(builder, :color)
-            .from(Stoplight::Color::GREEN)
-        end
-      end
-
-      context 'when the light is locked' do
-        before do
-          builder.lock(Stoplight::Color::RED)
-        end
-
-        it 'unlocks the light' do
-          expect { builder.unlock }
-            .to change(builder, :color)
-            .from(Stoplight::Color::RED)
-            .to(Stoplight::Color::GREEN)
-        end
-      end
-    end
-  end
-
-  it_behaves_like Stoplight::Configurable
-end

data/spec/stoplight/circuit_breaker_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::CircuitBreaker do
-  subject(:circuit_breaker) { klass.new }
-
-  let(:klass) do
-    Class.new { include Stoplight::CircuitBreaker }
-  end
-
-  specify '#with_error_handler' do
-    expect { circuit_breaker.with_error_handler {} }.to raise_error(NotImplementedError)
-  end
-
-  specify '#with_fallback' do
-    expect { circuit_breaker.with_fallback {} }.to raise_error(NotImplementedError)
-  end
-
-  specify '#color' do
-    expect { circuit_breaker.color }.to raise_error(NotImplementedError)
-  end
-
-  specify '#state' do
-    expect { circuit_breaker.state }.to raise_error(NotImplementedError)
-  end
-
-  specify '#name' do
-    expect { circuit_breaker.name }.to raise_error(NotImplementedError)
-  end
-
-  specify '#run' do
-    expect { circuit_breaker.run {} }.to raise_error(NotImplementedError)
-  end
-
-  specify '#lock' do
-    expect { circuit_breaker.lock('red') }.to raise_error(NotImplementedError)
-  end
-
-  specify '#unlock' do
-    expect { circuit_breaker.unlock }.to raise_error(NotImplementedError)
-  end
-end