clean-architecture 5.0.2 → 6.0.0

data/sorbet/rbi/gems/dry-validation.rbi

@@ -1,288 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: true
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/dry-validation/all/dry-validation.rbi
-#
-# dry-validation-1.4.2
-
-module Dry
-end
-module Dry::Validation
-  def self.Contract(options = nil, &block); end
-  def self.macros; end
-  extend Dry::Core::Extensions
-  extend Dry::Validation::Macros::Registrar
-  include Dry::Core::Constants
-end
-class Dry::Validation::InvalidKeysError < StandardError
-end
-class Dry::Validation::MissingMessageError < StandardError
-end
-class Dry::Validation::DuplicateSchemaError < StandardError
-end
-class Dry::Validation::SchemaMissingError < StandardError
-  def initialize(klass); end
-end
-class Dry::Validation::Function
-  def map_keywords(block); end
-  extend Dry::Initializer
-  include Anonymous_Module_48
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Module_48
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def block; end
-  def block_options; end
-  extend Dry::Initializer::Mixin::Local
-end
-module Anonymous_Module_49
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(name, *arg1, **__dry_initializer_options__); end
-  def args; end
-  def block; end
-  def name; end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Validation::Macro < Dry::Validation::Function
-  def extract_block_options(options); end
-  def with(args); end
-  include Anonymous_Module_49
-end
-module Dry::Validation::Macros
-  def self.[](name); end
-  def self.container; end
-  def self.register(name, *args, &block); end
-end
-module Dry::Validation::Macros::Registrar
-  def register_macro(name, *args, &block); end
-end
-class Dry::Validation::Macros::Container
-  def config; end
-  def register(name, *args, &block); end
-  extend Dry::Configurable
-  extend Dry::Configurable::ClassMethods
-  include Dry::Container::Mixin
-end
-class Dry::Validation::Config < Dry::Schema::Config
-  def dup; end
-end
-module Anonymous_Module_50
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def keys; end
-  def macros; end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Validation::Rule < Dry::Validation::Function
-  def add_macro_from_hash(macros, spec); end
-  def call(contract, result); end
-  def each(*macros, &block); end
-  def inspect; end
-  def parse_macros(*args); end
-  def validate(*macros, &block); end
-  include Anonymous_Dry_Equalizer_51
-  include Anonymous_Module_50
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_51
-  def cmp?(comparator, other); end
-  def hash; end
-end
-class Dry::Validation::Failures
-  def failure(message, tokens = nil); end
-  def initialize(path = nil); end
-  def opts; end
-  def path; end
-end
-class Dry::Validation::Evaluator
-  def _options; end
-  def base; end
-  def error?(path); end
-  def failures; end
-  def initialize(contract, **options, &block); end
-  def key(path = nil); end
-  def key?; end
-  def key_name; end
-  def method_missing(meth, *args, &block); end
-  def respond_to_missing?(meth, include_private = nil); end
-  def value; end
-  def with(new_opts, &block); end
-  extend Dry::Initializer
-  include Anonymous_Module_52
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Module_52
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(_contract, *arg1, **__dry_initializer_options__); end
-  def _context; end
-  def _contract; end
-  def block_options; end
-  def keys; end
-  def macros; end
-  def path; end
-  def result; end
-  def values; end
-  extend Dry::Initializer::Mixin::Local
-end
-module Anonymous_Module_53
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Validation::Message < Dry::Schema::Message
-  def base?; end
-  def initialize(text, path:, meta: nil); end
-  def meta; end
-  def path; end
-  def self.[](text, path, meta); end
-  def text; end
-  def to_s; end
-  include Anonymous_Dry_Equalizer_54
-  include Anonymous_Module_53
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_54
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Anonymous_Module_55
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Validation::Message::Localized < Dry::Validation::Message
-  def evaluate(**opts); end
-  include Anonymous_Module_55
-end
-module Dry::Validation::Messages
-end
-class Dry::Validation::Messages::Resolver
-  def [](message:, tokens:, path:, meta: nil); end
-  def call(message:, tokens:, path:, meta: nil); end
-  def initialize(messages); end
-  def message(rule, path:, tokens: nil, locale: nil, full: nil); end
-  def messages; end
-  def parse_token(token); end
-  def parse_tokens(tokens); end
-end
-class Dry::Validation::MessageSet < Dry::Schema::MessageSet
-  def add(message); end
-  def filter(*predicates); end
-  def freeze; end
-  def initialize(messages, options = nil); end
-  def initialize_placeholders!; end
-  def locale; end
-  def messages_map; end
-  def source_messages; end
-  def unique_paths; end
-  def with(other, new_options = nil); end
-end
-class Dry::Validation::Values
-  def [](*args); end
-  def data; end
-  def initialize(data); end
-  def key?(key, hash = nil); end
-  def method_missing(meth, *args, &block); end
-  def respond_to_missing?(meth, include_private = nil); end
-  include Anonymous_Dry_Equalizer_56
-  include Dry::Equalizer::Methods
-  include Enumerable
-end
-module Anonymous_Dry_Equalizer_56
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Validation::Result
-  def [](key); end
-  def add_error(error); end
-  def base_error?(key); end
-  def context; end
-  def error?(key); end
-  def errors(new_options = nil); end
-  def failure?; end
-  def freeze; end
-  def initialize(schema_result, context, options); end
-  def initialize_errors(options = nil); end
-  def inspect; end
-  def key?(key); end
-  def options; end
-  def schema_errors(options); end
-  def schema_result; end
-  def self.new(schema_result, context = nil, options = nil); end
-  def success?; end
-  def to_h; end
-  def values; end
-  include Anonymous_Dry_Equalizer_57
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_57
-  def cmp?(comparator, other); end
-  def hash; end
-end
-module Dry::Schema
-end
-class Dry::Schema::Path
-  def expand; end
-  def multi_value?; end
-end
-class Dry::Schema::Key
-  def to_dot_notation; end
-end
-class Dry::Schema::Key::Hash < Dry::Schema::Key
-  def to_dot_notation; end
-end
-class Dry::Schema::KeyMap
-  def to_dot_notation; end
-end
-class Dry::Validation::Contract
-  def call(input); end
-  def error?(result, spec); end
-  def inspect; end
-  def macro(name, *args); end
-  def messages; end
-  extend Dry::Initializer
-  extend Dry::Validation::Contract::ClassInterface
-  include Anonymous_Dry_Equalizer_58
-  include Anonymous_Module_59
-  include Dry::Equalizer::Methods
-  include Dry::Initializer::Mixin::Root
-end
-module Dry::Validation::Contract::ClassInterface
-  def __schema__; end
-  def build(options = nil, &block); end
-  def config; end
-  def core_schema_opts; end
-  def define(method_name, external_schemas, &block); end
-  def ensure_valid_keys(*keys); end
-  def inherited(klass); end
-  def json(*external_schemas, &block); end
-  def key_map; end
-  def macros; end
-  def messages; end
-  def params(*external_schemas, &block); end
-  def rule(*keys, &block); end
-  def rules; end
-  def schema(*external_schemas, &block); end
-  include Dry::Validation::Macros::Registrar
-end
-module Anonymous_Dry_Equalizer_58
-  def cmp?(comparator, other); end
-  def hash; end
-end
-module Anonymous_Module_59
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def config; end
-  def macros; end
-  def message_resolver; end
-  def rules; end
-  def schema; end
-  extend Dry::Initializer::Mixin::Local
-end

data/sorbet/rbi/gems/duckface-interfaces.rbi

@@ -1,94 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/duckface-interfaces/all/duckface-interfaces.rbi
-#
-# duckface-interfaces-0.0.5
-
-module Duckface
-end
-module Duckface::Constants
-end
-class Duckface::ParameterPair
-  def argument_name_string; end
-  def argument_name_without_leading_underscore; end
-  def for_comparison; end
-  def initialize(parameter_pair); end
-end
-class Duckface::ParameterPairs
-  def for_comparison; end
-  def initialize(parameters); end
-  def parameter_pairs; end
-end
-class Duckface::MethodImplementation
-  def implementation; end
-  def initialize(klass, method_name); end
-  def owner; end
-  def parameters; end
-  def parameters_for_comparison; end
-  def present_in_schema?; end
-  def schema?; end
-end
-class Duckface::CheckSession
-  def correctly; end
-  def initialize; end
-  def methods_not_implemented; end
-  def methods_with_incorrect_signatures; end
-  def notice_method_with_incorrect_signature(method_name); end
-  def notice_not_implemented_method(method_name); end
-  def null?; end
-  def successful?; end
-end
-module Duckface::Services
-end
-class Duckface::Services::CheckClassImplementsInterface
-  def check_method_has_correct_signature(method_name); end
-  def check_method_is_implemented(method_name); end
-  def initialize(implementation_class, interface_class); end
-  def interface_implementation(method_name); end
-  def method_has_correct_signature?(method_name); end
-  def method_implementation(method_name); end
-  def method_implemented?(method_name); end
-  def methods_that_should_be_implemented; end
-  def notice_method_with_incorrect_signature(*args, &block); end
-  def notice_not_implemented_method(*args, &block); end
-  def perform; end
-  extend Forwardable
-end
-module Duckface::ImplementationMethods
-  def check_it_implements(interface_class); end
-  def says_it_implements?(interface_class); end
-end
-class Duckface::NullCheckSession
-  def correctly; end
-  def methods_not_implemented; end
-  def methods_with_incorrect_signatures; end
-  def null?; end
-  def successful?; end
-end
-module Duckface::ObjectSugar
-  def check_it_implements(_interface_class); end
-  def implements_interface(interface_class); end
-  def says_it_implements?(_interface_class); end
-end
-class Class < Module
-  include Duckface::ObjectSugar
-end
-module Duckface::ActsAsInterface
-  def exclude_methods_from_interface_enforcement(*method_names); end
-  def methods_that_should_be_implemented; end
-end
-module Duckface::RSpec
-end
-class Duckface::RSpec::CheckSessionFailureFormatter
-  def formatted_lines; end
-  def incorrect_signature_lines; end
-  def initialize(check_session); end
-  def lines; end
-  def message; end
-  def not_implemented_lines; end
-end

data/sorbet/rbi/gems/i18n.rbi

@@ -1,133 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/i18n/all/i18n.rbi
-#
-# i18n-1.8.2
-
-module I18n
-  def self.interpolate(string, values); end
-  def self.interpolate_hash(string, values); end
-  def self.new_double_nested_cache; end
-  extend I18n::Base
-end
-class I18n::ExceptionHandler
-  def call(exception, _locale, _key, _options); end
-end
-class I18n::ArgumentError < ArgumentError
-end
-class I18n::Disabled < I18n::ArgumentError
-  def initialize(method); end
-end
-class I18n::InvalidLocale < I18n::ArgumentError
-  def initialize(locale); end
-  def locale; end
-end
-class I18n::InvalidLocaleData < I18n::ArgumentError
-  def filename; end
-  def initialize(filename, exception_message); end
-end
-class I18n::MissingTranslation < I18n::ArgumentError
-  include I18n::MissingTranslation::Base
-end
-module I18n::MissingTranslation::Base
-  def initialize(locale, key, options = nil); end
-  def key; end
-  def keys; end
-  def locale; end
-  def message; end
-  def options; end
-  def to_exception; end
-  def to_s; end
-end
-class I18n::MissingTranslationData < I18n::ArgumentError
-  include I18n::MissingTranslation::Base
-end
-class I18n::InvalidPluralizationData < I18n::ArgumentError
-  def count; end
-  def entry; end
-  def initialize(entry, count, key); end
-  def key; end
-end
-class I18n::MissingInterpolationArgument < I18n::ArgumentError
-  def initialize(key, values, string); end
-  def key; end
-  def string; end
-  def values; end
-end
-class I18n::ReservedInterpolationKey < I18n::ArgumentError
-  def initialize(key, string); end
-  def key; end
-  def string; end
-end
-class I18n::UnknownFileType < I18n::ArgumentError
-  def filename; end
-  def initialize(type, filename); end
-  def type; end
-end
-module I18n::Base
-  def available_locales; end
-  def available_locales=(value); end
-  def available_locales_initialized?; end
-  def backend; end
-  def backend=(value); end
-  def config; end
-  def config=(value); end
-  def default_locale; end
-  def default_locale=(value); end
-  def default_separator; end
-  def default_separator=(value); end
-  def eager_load!; end
-  def enforce_available_locales!(locale); end
-  def enforce_available_locales; end
-  def enforce_available_locales=(value); end
-  def exception_handler; end
-  def exception_handler=(value); end
-  def exists?(key, _locale = nil, locale: nil); end
-  def handle_exception(handling, exception, locale, key, options); end
-  def l(object, locale: nil, format: nil, **options); end
-  def load_path; end
-  def load_path=(value); end
-  def locale; end
-  def locale=(value); end
-  def locale_available?(locale); end
-  def localize(object, locale: nil, format: nil, **options); end
-  def normalize_key(key, separator); end
-  def normalize_keys(locale, key, scope, separator = nil); end
-  def reload!; end
-  def t!(key, options = nil); end
-  def t(key = nil, *arg1, throw: nil, raise: nil, locale: nil, **options); end
-  def translate!(key, options = nil); end
-  def translate(key = nil, *arg1, throw: nil, raise: nil, locale: nil, **options); end
-  def transliterate(key, *arg1, throw: nil, raise: nil, locale: nil, replacement: nil, **options); end
-  def with_locale(tmp_locale = nil); end
-end
-class I18n::Config
-  def available_locales; end
-  def available_locales=(locales); end
-  def available_locales_initialized?; end
-  def available_locales_set; end
-  def backend; end
-  def backend=(backend); end
-  def clear_available_locales_set; end
-  def default_locale; end
-  def default_locale=(locale); end
-  def default_separator; end
-  def default_separator=(separator); end
-  def enforce_available_locales; end
-  def enforce_available_locales=(enforce_available_locales); end
-  def exception_handler; end
-  def exception_handler=(exception_handler); end
-  def interpolation_patterns; end
-  def interpolation_patterns=(interpolation_patterns); end
-  def load_path; end
-  def load_path=(load_path); end
-  def locale; end
-  def locale=(locale); end
-  def missing_interpolation_argument_handler; end
-  def missing_interpolation_argument_handler=(exception_handler); end
-end

data/sorbet/rbi/gems/jaro_winkler.rbi

@@ -1,15 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/jaro_winkler/all/jaro_winkler.rbi
-#
-# jaro_winkler-1.5.4
-
-module JaroWinkler
-  def self.distance(*arg0); end
-  def self.jaro_distance(*arg0); end
-end

data/sorbet/rbi/gems/method_source.rbi

@@ -1,64 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/method_source/all/method_source.rbi
-#
-# method_source-0.9.2
-
-module MethodSource
-  def self.comment_helper(source_location, name = nil); end
-  def self.extract_code(source_location); end
-  def self.lines_for(file_name, name = nil); end
-  def self.source_helper(source_location, name = nil); end
-  def self.valid_expression?(str); end
-  extend MethodSource::CodeHelpers
-end
-module MethodSource::ReeSourceLocation
-  def source_location; end
-end
-module MethodSource::SourceLocation
-end
-module MethodSource::SourceLocation::MethodExtensions
-  def source_location; end
-  def trace_func(event, file, line, id, binding, classname); end
-end
-module MethodSource::SourceLocation::ProcExtensions
-  def source_location; end
-end
-module MethodSource::SourceLocation::UnboundMethodExtensions
-  def source_location; end
-end
-module MethodSource::CodeHelpers
-  def comment_describing(file, line_number); end
-  def complete_expression?(str); end
-  def expression_at(file, line_number, options = nil); end
-  def extract_first_expression(lines, consume = nil, &block); end
-  def extract_last_comment(lines); end
-end
-module MethodSource::CodeHelpers::IncompleteExpression
-  def self.===(ex); end
-  def self.rbx?; end
-end
-class MethodSource::SourceNotFoundError < StandardError
-end
-module MethodSource::MethodExtensions
-  def comment; end
-  def self.included(klass); end
-  def source; end
-end
-class Method
-  include MethodSource::MethodExtensions
-  include MethodSource::SourceLocation::MethodExtensions
-end
-class UnboundMethod
-  include MethodSource::MethodExtensions
-  include MethodSource::SourceLocation::UnboundMethodExtensions
-end
-class Proc
-  include MethodSource::MethodExtensions
-  include MethodSource::SourceLocation::ProcExtensions
-end

data/sorbet/rbi/gems/parallel.rbi

@@ -1,82 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parallel/all/parallel.rbi
-#
-# parallel-1.19.1
-
-module Parallel
-  def self.add_progress_bar!(job_factory, options); end
-  def self.all?(*args, &block); end
-  def self.any?(*args, &block); end
-  def self.call_with_index(item, index, options, &block); end
-  def self.create_workers(job_factory, options, &block); end
-  def self.each(array, options = nil, &block); end
-  def self.each_with_index(array, options = nil, &block); end
-  def self.extract_count_from_options(options); end
-  def self.flat_map(*args, &block); end
-  def self.handle_exception(exception, results); end
-  def self.in_processes(options = nil, &block); end
-  def self.in_threads(options = nil); end
-  def self.map(source, options = nil, &block); end
-  def self.map_with_index(array, options = nil, &block); end
-  def self.process_incoming_jobs(read, write, job_factory, options, &block); end
-  def self.replace_worker(job_factory, workers, i, options, blk); end
-  def self.with_instrumentation(item, index, options); end
-  def self.work_direct(job_factory, options, &block); end
-  def self.work_in_processes(job_factory, options, &blk); end
-  def self.work_in_threads(job_factory, options, &block); end
-  def self.worker(job_factory, options, &block); end
-  def self.worker_number; end
-  def self.worker_number=(worker_num); end
-  extend Parallel::ProcessorCount
-end
-module Parallel::ProcessorCount
-  def physical_processor_count; end
-  def processor_count; end
-end
-class Parallel::DeadWorker < StandardError
-end
-class Parallel::Break < StandardError
-end
-class Parallel::Kill < StandardError
-end
-class Parallel::UndumpableException < StandardError
-  def backtrace; end
-  def initialize(original); end
-end
-class Parallel::ExceptionWrapper
-  def exception; end
-  def initialize(exception); end
-end
-class Parallel::Worker
-  def close_pipes; end
-  def initialize(read, write, pid); end
-  def pid; end
-  def read; end
-  def stop; end
-  def thread; end
-  def thread=(arg0); end
-  def wait; end
-  def work(data); end
-  def write; end
-end
-class Parallel::JobFactory
-  def initialize(source, mutex); end
-  def next; end
-  def pack(item, index); end
-  def producer?; end
-  def queue_wrapper(array); end
-  def size; end
-  def unpack(data); end
-end
-class Parallel::UserInterruptHandler
-  def self.kill(thing); end
-  def self.kill_on_ctrl_c(pids, options); end
-  def self.restore_interrupt(old, signal); end
-  def self.trap_interrupt(signal); end
-end