convenient_service 0.20.0 → 0.21.0

data/lib/convenient_service/service/plugins/can_have_stubbed_results/entities/service_unstub.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveStubbedResults
+        module Entities
+          class ServiceUnstub
+            ##
+            # @param service_class [Class<ConvenientService::Service>]
+            # @return [void]
+            #
+            # @internal
+            #   NOTE: `@arguments = nil` means "match any arguments".
+            #
+            def initialize(service_class:)
+              @service_class = service_class
+              @arguments = nil
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceUnstub]
+            #
+            # @internal
+            #   NOTE: `@arguments = nil` means "match any arguments".
+            #
+            def with_any_arguments(...)
+              @arguments = nil
+
+              self
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceUnstub]
+            #
+            def with_arguments(...)
+              @arguments = Support::Arguments.new(...)
+
+              self
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceUnstub]
+            #
+            def without_arguments
+              @arguments = Support::Arguments.null_arguments
+
+              self
+            end
+
+            ##
+            # @param result_unmock [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultUnmock]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceStub]
+            #
+            def to(result_unmock)
+              @result_unmock = result_unmock.for(service_class, arguments)
+
+              @result_unmock.register
+
+              self
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultUnmock]
+            #
+            def to_return_result_mock
+              @result_unmock = Entities::ResultUnmock.new(service_class: service_class, arguments: arguments)
+            end
+
+            ##
+            # @param other [Object] Can be any type.
+            # @return [Boolean, nil]
+            #
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if service_class != other.service_class
+              return false if arguments != other.arguments
+              return false if result_unmock != other.result_unmock
+
+              true
+            end
+
+            protected
+
+            ##
+            # @!attribute [r] service_class
+            #   @return [Class<ConvenientService::Service>]
+            #
+            attr_reader :service_class
+
+            ##
+            # @!attribute [r] arguments
+            #   @return [ConvenientService::Support::Arguments]
+            #
+            attr_reader :arguments
+
+            ##
+            # @!attribute [r] result_unmock
+            #   @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultUnmock]
+            #
+            attr_reader :result_unmock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_have_stubbed_results/entities.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+require_relative "entities/service_stub"
+require_relative "entities/service_unstub"
+
+require_relative "entities/result_mock"
+require_relative "entities/result_unmock"

data/lib/convenient_service/service/plugins/can_have_stubbed_results.rb

@@ -7,18 +7,5 @@
 
 require_relative "can_have_stubbed_results/commands"
 require_relative "can_have_stubbed_results/concern"
+require_relative "can_have_stubbed_results/entities"
 require_relative "can_have_stubbed_results/middleware"
-
-module ConvenientService
-  module Service
-    module Plugins
-      module CanHaveStubbedResults
-        class << self
-          def set_service_stubbed_result(service, arguments, result)
-            Commands::SetServiceStubbedResult[service: service, arguments: arguments, result: result]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/convenient_service/service/plugins/forbids_convenient_service_entities_as_constructor_arguments/exceptions.rb

@@ -38,6 +38,90 @@ module ConvenientService
             end
           end
 
+          class StatusPassedAsConstructorArgument < ::ConvenientService::Exception
+            def initialize_with_kwargs(selector:, service:, status:)
+              message = <<~TEXT
+                Status of `#{Utils::Class.display_name(status.result.service.class)}` result is passed as constructor argument `#{selector}` to `#{Utils::Class.display_name(service.class)}`.
+
+                It is an antipattern. It neglects the idea of steps.
+
+                Please, convert it to symbol or try to reorganize `#{Utils::Class.display_name(service.class)}` service.
+              TEXT
+
+              initialize(message)
+            end
+          end
+
+          class DataPassedAsConstructorArgument < ::ConvenientService::Exception
+            def initialize_with_kwargs(selector:, service:, data:)
+              message = <<~TEXT
+                Data of `#{Utils::Class.display_name(data.result.service.class)}` result is passed as constructor argument `#{selector}` to `#{Utils::Class.display_name(service.class)}`.
+
+                It is an antipattern. It neglects the idea of steps.
+
+                Please, convert it to hash or try to reorganize `#{Utils::Class.display_name(service.class)}` service.
+              TEXT
+
+              initialize(message)
+            end
+          end
+
+          class MessagePassedAsConstructorArgument < ::ConvenientService::Exception
+            def initialize_with_kwargs(selector:, service:, message:)
+              exception_message = <<~TEXT
+                Message of `#{Utils::Class.display_name(message.result.service.class)}` result is passed as constructor argument `#{selector}` to `#{Utils::Class.display_name(service.class)}`.
+
+                It is an antipattern. It neglects the idea of steps.
+
+                Please, convert it to string or try to reorganize `#{Utils::Class.display_name(service.class)}` service.
+              TEXT
+
+              initialize(exception_message)
+            end
+          end
+
+          class CodePassedAsConstructorArgument < ::ConvenientService::Exception
+            def initialize_with_kwargs(selector:, service:, code:)
+              message = <<~TEXT
+                Code of `#{Utils::Class.display_name(code.result.service.class)}` result is passed as constructor argument `#{selector}` to `#{Utils::Class.display_name(service.class)}`.
+
+                It is an antipattern. It neglects the idea of steps.
+
+                Please, convert it to symbol or try to reorganize `#{Utils::Class.display_name(service.class)}` service.
+              TEXT
+
+              initialize(message)
+            end
+          end
+
+          class FeaturePassedAsConstructorArgument < ::ConvenientService::Exception
+            def initialize_with_kwargs(selector:, service:, feature:)
+              message = <<~TEXT
+                Feature `#{Utils::Class.display_name(feature.class)}` is passed as constructor argument `#{selector}` to `#{Utils::Class.display_name(service.class)}`.
+
+                It is an antipattern. It neglects the idea of steps.
+
+                Please, try to reorganize `#{Utils::Class.display_name(service.class)}` service.
+              TEXT
+
+              initialize(message)
+            end
+          end
+
+          class EntityPassedAsConstructorArgument < ::ConvenientService::Exception
+            def initialize_with_kwargs(selector:, service:, entity:)
+              message = <<~TEXT
+                Convenient Service entity `#{Utils::Class.display_name(entity.class)}` is passed as constructor argument `#{selector}` to `#{Utils::Class.display_name(service.class)}`.
+
+                It is an antipattern. It neglects the idea of steps.
+
+                Please, try to reorganize `#{Utils::Class.display_name(service.class)}` service.
+              TEXT
+
+              initialize(message)
+            end
+          end
+
           class StepPassedAsConstructorArgument < ::ConvenientService::Exception
             def initialize_with_kwargs(selector:, service:, step:)
               message = <<~TEXT

data/lib/convenient_service/service/plugins/forbids_convenient_service_entities_as_constructor_arguments/middleware.rb

@@ -25,9 +25,9 @@ module ConvenientService
           # @return [void]
           #
           def next(*args, **kwargs, &block)
-            args.each_with_index { |value, index| validate!(:args, index, value) }
+            args.each_with_index { |value, index| validate!(index, value) }
 
-            kwargs.each_pair { |key, value| validate!(:kwargs, key, value) }
+            kwargs.each_pair { |key, value| validate!(key, value) }
 
             chain.next(*args, **kwargs, &block)
           end
@@ -35,76 +35,128 @@ module ConvenientService
           private
 
           ##
-          # @param collection_type [Symbol]
           # @param key [Integer, Symbol]
           # @param value [Object] Can be any type.
-          # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::ServicePassedAsConstructorArgument, ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::ResultPassedAsConstructorArgument, ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::StepPassedAsConstructorArgument]
+          # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::ServicePassedAsConstructorArgument, ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::ResultPassedAsConstructorArgument, ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::StatusPassedAsConstructorArgument, ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::DataPassedAsConstructorArgument, ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::MessagePassedAsConstructorArgument, ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::CodePassedAsConstructorArgument, ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::StepPassedAsConstructorArgument, ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::FeaturePassedAsConstructorArgument]
           # @return [void]
           #
-          def validate!(collection_type, key, value)
-            refute_service!(collection_type, key, value)
-            refute_result!(collection_type, key, value)
-            refute_step!(collection_type, key, value)
+          def validate!(key, value)
+            return unless ::ConvenientService::Core.entity?(value)
+
+            refute_service!(key, value)
+            refute_result!(key, value)
+            refute_data!(key, value)
+            refute_message!(key, value)
+            refute_code!(key, value)
+            refute_status!(key, value)
+            refute_step!(key, value)
+            refute_feature!(key, value)
+
+            ::ConvenientService.raise Exceptions::EntityPassedAsConstructorArgument.new(selector: selector_from(key), service: service, entity: value)
           end
 
           ##
-          # @param collection_type [Symbol]
           # @param key [Integer, Symbol]
           # @param value [Object] Can be any type.
           # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::ServicePassedAsConstructorArgument]
           # @return [void]
           #
-          # @internal
-          #   NOTE: `refute` is `!assert`.
-          #   - https://docs.seattlerb.org/minitest
-          #
-          def refute_service!(collection_type, key, value)
+          def refute_service!(key, value)
             return unless ::ConvenientService::Standard::Config.service?(value)
 
-            ::ConvenientService.raise Exceptions::ServicePassedAsConstructorArgument.new(selector: selector_from(collection_type, key), service: service, other_service: value)
+            ::ConvenientService.raise Exceptions::ServicePassedAsConstructorArgument.new(selector: selector_from(key), service: service, other_service: value)
           end
 
           ##
-          # @param collection_type [Symbol]
           # @param key [Integer, Symbol]
           # @param value [Object] Can be any type.
           # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::ResultPassedAsConstructorArgument]
           # @return [void]
           #
-          # @internal
-          #   NOTE: `refute` is `!assert`.
-          #   - https://docs.seattlerb.org/minitest
-          #
-          def refute_result!(collection_type, key, value)
+          def refute_result!(key, value)
             return unless ::ConvenientService::Plugins::Service::HasJSendResult.result?(value)
 
-            ::ConvenientService.raise Exceptions::ResultPassedAsConstructorArgument.new(selector: selector_from(collection_type, key), service: service, result: value)
+            ::ConvenientService.raise Exceptions::ResultPassedAsConstructorArgument.new(selector: selector_from(key), service: service, result: value)
           end
 
           ##
-          # @param collection_type [Symbol]
           # @param key [Integer, Symbol]
           # @param value [Object] Can be any type.
-          # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::StepPassedAsConstructorArgument]
+          # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::DataPassedAsConstructorArgument]
+          # @return [void]
+          #
+          def refute_data!(key, value)
+            return unless ::ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasJSendStatusAndAttributes::Entities::Data.data?(value)
+
+            ::ConvenientService.raise Exceptions::DataPassedAsConstructorArgument.new(selector: selector_from(key), service: service, data: value)
+          end
+
+          ##
+          # @param key [Integer, Symbol]
+          # @param value [Object] Can be any type.
+          # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::MessagePassedAsConstructorArgument]
+          # @return [void]
+          #
+          def refute_message!(key, value)
+            return unless ::ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasJSendStatusAndAttributes::Entities::Message.message?(value)
+
+            ::ConvenientService.raise Exceptions::MessagePassedAsConstructorArgument.new(selector: selector_from(key), service: service, message: value)
+          end
+
+          ##
+          # @param key [Integer, Symbol]
+          # @param value [Object] Can be any type.
+          # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::CodePassedAsConstructorArgument]
+          # @return [void]
+          #
+          def refute_code!(key, value)
+            return unless ::ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasJSendStatusAndAttributes::Entities::Code.code?(value)
+
+            ::ConvenientService.raise Exceptions::CodePassedAsConstructorArgument.new(selector: selector_from(key), service: service, code: value)
+          end
+
+          ##
+          # @param key [Integer, Symbol]
+          # @param value [Object] Can be any type.
+          # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::StatusPassedAsConstructorArgument]
           # @return [void]
           #
-          # @internal
-          #   NOTE: `refute` is `!assert`.
-          #   - https://docs.seattlerb.org/minitest
+          def refute_status!(key, value)
+            return unless ::ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasJSendStatusAndAttributes::Entities::Status.status?(value)
+
+            ::ConvenientService.raise Exceptions::StatusPassedAsConstructorArgument.new(selector: selector_from(key), service: service, status: value)
+          end
+
+          ##
+          # @param key [Integer, Symbol]
+          # @param value [Object] Can be any type.
+          # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::StepPassedAsConstructorArgument]
+          # @return [void]
           #
-          def refute_step!(collection_type, key, value)
+          def refute_step!(key, value)
             return unless ::ConvenientService::Plugins::Service::CanHaveSteps.step?(value)
 
-            ::ConvenientService.raise Exceptions::StepPassedAsConstructorArgument.new(selector: selector_from(collection_type, key), service: service, step: value)
+            ::ConvenientService.raise Exceptions::StepPassedAsConstructorArgument.new(selector: selector_from(key), service: service, step: value)
+          end
+
+          ##
+          # @param key [Integer, Symbol]
+          # @param value [Object] Can be any type.
+          # @raise [ConvenientService::Service::Plugins::ForbidsConvenientServiceEntitiesAsConstructorArguments::Exceptions::FeaturePassedAsConstructorArgument]
+          # @return [void]
+          #
+          def refute_feature!(key, value)
+            return unless ::ConvenientService::Feature::Standard::Config.feature?(value)
+
+            ::ConvenientService.raise Exceptions::FeaturePassedAsConstructorArgument.new(selector: selector_from(key), service: service, feature: value)
           end
 
           ##
-          # @param collection_type [Symbol]
           # @param key [Integer, Symbol]
           # @return [String]
           #
-          def selector_from(collection_type, key)
-            "#{collection_type}[#{key.inspect}]"
+          def selector_from(key)
+            key.instance_of?(::Integer) ? "args[#{key}]" : "kwargs[:#{key}]"
           end
         end
       end

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/concern.rb

@@ -12,10 +12,50 @@ module ConvenientService
         module Entities
           class Result
             ##
-            # @internal
-            #   This concern is needed for `CastResultClass` and `be_success`, `be_error`, `be_failure` matchers.
+            # @api private
+            # @since 1.0.0
             #
             module Concern
+              include Support::Concern
+
+              instance_methods do
+                ##
+                # Returns string representation of result.
+                #
+                # @api public
+                # @since 1.0.0
+                #
+                # @param format [Symbol]
+                # @return [String]
+                #
+                # @note Intended to be used for debugging purposes.
+                #
+                # @example Common usage.
+                #   class Service
+                #     include ConvenientService::Standard::Config
+                #
+                #     def result
+                #       success
+                #     end
+                #   end
+                #
+                #   puts Service.result
+                #   # <Service::Result status: :success>
+                #   # => nil
+                #
+                #   Service.result.to_s
+                #   # => "<Service::Result status: :success>"
+                #
+                #   Service.result.to_s(format: :inspect)
+                #   # => "<Service::Result status: :success>"
+                #
+                #   Service.result.to_s(format: :original)
+                #   # => "#<Service::Result:0x00005639cd363000>"
+                #
+                def to_s(format: :inspect)
+                  (format == :inspect) ? inspect : super()
+                end
+              end
             end
           end
         end

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_called/exceptions.rb

@@ -21,7 +21,7 @@ module ConvenientService
                     #
                     def initialize_with_kwargs(result:)
                       message = <<~TEXT
-                        An `error` result of service `#{ConvenientService::Utils::Class.display_name(result.service.class)}` is called.
+                        An `error` result of service `#{Utils::Class.display_name(result.service.class)}` is called.
 
                         Only the `success` and `failure` results are expected to be called.
 
@@ -31,7 +31,8 @@ module ConvenientService
 
                         If this `error` result is NOT expected, update the service logic.
 
-                        #{result.unsafe_message}
+                        Original `error` result message:
+                        #{Utils::String.tab(result.unsafe_message)}
                       TEXT
 
                       initialize(message)

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_j_send_status_and_attributes/entities/status/concern/instance_methods.rb

@@ -142,9 +142,14 @@ module ConvenientService
                         # @param statuses [Array<ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasJSendStatusAndAttributes::Entities::Status>]
                         # @return [Boolean]
                         #
+                        # @internal
+                        #   NOTE: `any?(arg)` compares with `===`. For this method `==` is mandatory.
+                        #
+                        # rubocop:disable Performance/RedundantEqualityComparisonBlock
                         def in?(statuses)
                           statuses.any? { |status| self == status }
                         end
+                        # rubocop:enable Performance/RedundantEqualityComparisonBlock
 
                         ##
                         # @return [Hash{Symbol => Object}]

data/lib/convenient_service/service.rb

@@ -8,3 +8,19 @@
 require_relative "service/core"
 require_relative "service/plugins"
 require_relative "service/configs"
+
+module ConvenientService
+  ##
+  # Intermediate module/namespace to access core, plugins and configs that can be applied only to services.
+  #
+  # @api private
+  # @since 1.0.0
+  # @return [Module]
+  #
+  # @note Service core expected to be used via {ConvenientService::Service::Core}.
+  # @note Service configs expected to be used via {ConvenientService::Standard::Config} alias.
+  # @note Service plugins expected to be used via {ConvenientService::Plugins::Service} alias.
+  #
+  module Service
+  end
+end

data/lib/convenient_service/specification.rb

@@ -5,50 +5,80 @@
 # @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
 ##
 
-##
-# Convenient Service gem specification.
-# @see https://guides.rubygems.org/specification-reference
-#
-# @internal
-#   IMPORTNANT:
-#     This module must NOT be loaded by the `lib` folder.
-#     It is only intended for `gemspec`.
-#     `bundle` loads it inside specs.
-#
 module ConvenientService
+  ##
+  # Convenient Service gem specification. Used mainly by `convenient_service.gemspec`.
+  #
+  # @since 1.0.0
+  # @see https://guides.rubygems.org/specification-reference
+  # @see https://github.com/marian13/convenient_service/blob/main/convenient_service.gemspec
+  #
+  # @internal
+  #   IMPORTNANT: This module must NOT be loaded by the `lib` folder. It is only intended for `gemspec`. `bundle` loads it inside specs.
+  #   NOTE: `Specification` module was created to be able to test `gemspec` content.
+  #
   module Specification
     ##
+    # Convenient Service gem name.
+    # It is used by the `gem install convenient_service` command or `gem "convenient_service"` Gemfile directive.
+    #
     # @return [String]
+    # @since 1.0.0
     #
     NAME = "convenient_service"
 
     ##
+    # Convenient Service gem author names.
+    #
     # @return [Array<String>]
+    # @since 1.0.0
     #
     AUTHORS = ["Marian Kostyk"].freeze
 
     ##
+    # Convenient Service gem author emails.
+    #
     # @return [Array<String>]
+    # @since 1.0.0
     #
     EMAIL = ["mariankostyk13895@gmail.com"].freeze
 
     ##
+    # Convenient Service gem homepage URL (GitHub repo URL). It contains references to the user docs, api docs, etc.
+    #
     # @return [String]
+    # @since 1.0.0
     #
     HOMEPAGE = "https://github.com/marian13/convenient_service"
 
     ##
+    # Convenient Service gem short summary.
+    #
     # @return [String]
+    # @since 1.0.0
+    #
+    # @internal
+    #   NOTE: Keep summary in sync with the GitHub repo "About" section.
     #
     SUMMARY = <<~TEXT
-      Ruby Service Objects with Steps.
+      Ruby Service Objects with Steps and more.
     TEXT
 
     ##
+    # Convenient Service gem general description.
+    #
     # @return [String]
+    # @since 1.0.0
+    #
+    # @internal
+    #   NOTE: Keep description in sync with Convenient Service User Docs homepage.
     #
     DESCRIPTION = <<~TEXT
-      Yet another approach to revisit the service object pattern in Ruby, but this time focusing on the unique, opinionated, moderately obtrusive, but not mandatory features.
+      Manage complex business logic in Ruby applications using Service Objects with Results and Steps.
+
+      Hide technical details with Configs, Concerns and Middlewares.
+
+      Group related code with Features and Entries.
     TEXT
   end
 end

data/lib/convenient_service/support/backtrace_cleaner.rb

@@ -5,16 +5,10 @@
 # @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
 ##
 
-##
-# @note Other gems are also trying to integrate with Rails Backtrace Cleaner.
-# @see https://github.com/sidekiq/sidekiq/pull/5796
-# @see https://github.com/sidekiq/sidekiq/issues/5589
-# @see https://github.com/appsignal/appsignal-ruby/issues/380
-#
 module ConvenientService
   module Support
     ##
-    # Rails v7.1.2 Backtrace Cleaner descendant.
+    # Rails v8.0.2 Backtrace Cleaner descendant.
     # Has Convenient Service specific silencer - `add_convenient_service_silencer`.
     # By default, it uses only `add_stdlib_silencer` and `add_convenient_service_silencer`.
     #
@@ -23,6 +17,11 @@ module ConvenientService
     # @see https://twitter.com/websebdev/status/1375831554518360065?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1375831554518360065%7Ctwgr%5E459595174e71c0f1aa3826c89f2ffca0c3da6ea3%7Ctwcon%5Es1_&ref_url=https%3A%2F%2Fwww.redditmedia.com%2Fmediaembed%2Fmegii9%2F%3Fresponsive%3Dtrueis_nightmode%3Dtrue
     # @see https://stackoverflow.com/questions/22727219/using-backtracecleaner-in-rails-console
     #
+    # @note Other gems are also trying to integrate with Rails Backtrace Cleaner.
+    # @see https://github.com/sidekiq/sidekiq/pull/5796
+    # @see https://github.com/sidekiq/sidekiq/issues/5589
+    # @see https://github.com/appsignal/appsignal-ruby/issues/380
+    #
     class BacktraceCleaner < Dependencies::Extractions::ActiveSupportBacktraceCleaner::BacktraceCleaner
       ##
       # @return [void]

data/lib/convenient_service/support/middleware/stack_builder/entities/builders/custom.rb

@@ -60,9 +60,13 @@ module ConvenientService
               # @param some_middleware [#call<Hash>]
               # @return [Boolean]
               #
+              #   NOTE: `any?(arg)` compares with `===`. For this method `==` is mandatory.
+              #
+              # rubocop:disable Performance/RedundantEqualityComparisonBlock
               def has?(some_middleware)
                 stack.any? { |middleware| middleware == some_middleware }
               end
+              # rubocop:enable Performance/RedundantEqualityComparisonBlock
 
               ##
               # @return [Boolean]

data/lib/convenient_service/support/middleware/stack_builder/entities/builders/ruby_middleware.rb

@@ -49,9 +49,13 @@ module ConvenientService
               # @param some_middleware [#call<Hash>]
               # @return [Boolean]
               #
+              #   NOTE: `any?(arg)` compares with `===`. For this method `==` is mandatory.
+              #
+              # rubocop:disable Performance/RedundantEqualityComparisonBlock
               def has?(some_middleware)
                 stack.any? { |middleware| middleware == [some_middleware, [], nil] }
               end
+              # rubocop:enable Performance/RedundantEqualityComparisonBlock
 
               ##
               # @return [Boolean]