clean-architecture 5.0.2 → 6.0.0

data/sorbet/rbi/gems/docile.rbi

@@ -1,32 +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/docile/all/docile.rbi
-#
-# docile-1.3.2
-
-module Docile
-  def dsl_eval(dsl, *args, &block); end
-  def dsl_eval_immutable(dsl, *args, &block); end
-  def dsl_eval_with_block_return(dsl, *args, &block); end
-  def self.dsl_eval(dsl, *args, &block); end
-  def self.dsl_eval_immutable(dsl, *args, &block); end
-  def self.dsl_eval_with_block_return(dsl, *args, &block); end
-  extend Docile::Execution
-end
-module Docile::Execution
-  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-  def self.exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-end
-class Docile::FallbackContextProxy
-  def initialize(receiver, fallback); end
-  def instance_variables; end
-  def method_missing(method, *args, &block); end
-end
-class Docile::ChainingFallbackContextProxy < Docile::FallbackContextProxy
-  def method_missing(method, *args, &block); end
-end

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

@@ -1,139 +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-configurable/all/dry-configurable.rbi
-#
-# dry-configurable-0.11.3
-
-module Dry
-end
-module Dry::Configurable
-  def self.extended(klass); end
-  def self.included(klass); end
-  include Dry::Core::Constants
-end
-class Dry::Configurable::Error < StandardError
-end
-class Dry::Configurable::FrozenConfig < Dry::Configurable::Error
-end
-class Dry::Configurable::Config
-  def [](name); end
-  def []=(name, value); end
-  def _resolved; end
-  def _settings; end
-  def finalize!; end
-  def initialize(settings); end
-  def initialize_copy(source); end
-  def method_missing(meth, *args); end
-  def pristine; end
-  def resolve(meth); end
-  def respond_to_missing?(meth, include_private = nil); end
-  def to_h; end
-  def to_hash; end
-  def update(values); end
-  def values; end
-  include Anonymous_Dry_Equalizer_14
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_14
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Configurable::Setting
-  def clonable_value?; end
-  def constructor; end
-  def default; end
-  def evaluate; end
-  def initialize(name, input: nil, default: nil, **options); end
-  def initialize_copy(source); end
-  def input; end
-  def name; end
-  def nested(settings); end
-  def options; end
-  def pristine; end
-  def reader?; end
-  def value; end
-  def with(new_opts); end
-  def writer?(meth); end
-  def writer_name; end
-  include Anonymous_Dry_Equalizer_15
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_15
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Configurable::Setting::Nested < Dry::Configurable::Setting
-  def constructor; end
-  def pristine; end
-end
-class Dry::Configurable::Settings
-  def <<(setting); end
-  def [](name); end
-  def each(&block); end
-  def elements; end
-  def initialize(elements = nil); end
-  def initialize_copy(source); end
-  def initialize_elements(elements); end
-  def key?(name); end
-  def keys; end
-  def pristine; end
-  include Anonymous_Dry_Equalizer_16
-  include Dry::Equalizer::Methods
-  include Enumerable
-end
-module Anonymous_Dry_Equalizer_16
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Configurable::Compiler
-  def call(ast); end
-  def visit(node); end
-  def visit_constructor(node); end
-  def visit_nested(node); end
-  def visit_setting(node); end
-end
-class Dry::Configurable::DSL
-  def ast; end
-  def compiler; end
-  def initialize(&block); end
-  def setting(name, *args, &block); end
-end
-class Dry::Configurable::DSL::Args
-  def args; end
-  def default; end
-  def ensure_valid_options; end
-  def initialize(args); end
-  def options; end
-  def opts; end
-  def size; end
-  def to_ary; end
-end
-module Dry::Configurable::Methods
-  def configure(&block); end
-  def finalize!; end
-end
-module Dry::Configurable::ClassMethods
-  def __config_dsl__; end
-  def __config_reader__; end
-  def _settings; end
-  def config; end
-  def inherited(klass); end
-  def setting(*args, &block); end
-  def settings; end
-  include Dry::Configurable::Methods
-end
-module Dry::Configurable::InstanceMethods
-  def config; end
-  def finalize!; end
-  def initialize(*arg0); end
-  def initialize_copy(source); end
-  include Dry::Configurable::Methods
-end

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

@@ -1,89 +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/dry-container/all/dry-container.rbi
-#
-# dry-container-0.7.2
-
-module Dry
-end
-class Dry::Container
-  def config; end
-  extend Dry::Configurable
-  extend Dry::Configurable::ClassMethods
-  include Dry::Container::Mixin
-end
-class Dry::Container::Error < StandardError
-end
-class Dry::Container::Namespace
-  def block; end
-  def initialize(name, &block); end
-  def name; end
-end
-class Dry::Container::Item
-  def call; end
-  def callable?; end
-  def initialize(item, options = nil); end
-  def item; end
-  def map(func); end
-  def options; end
-  def value?; end
-end
-class Dry::Container::Item::Memoizable < Dry::Container::Item
-  def call; end
-  def initialize(item, options = nil); end
-  def memoize_mutex; end
-  def raise_not_supported_error; end
-end
-class Dry::Container::Item::Callable < Dry::Container::Item
-  def call; end
-end
-class Dry::Container::Item::Factory
-  def call(item, options = nil); end
-end
-class Dry::Container::Registry
-  def call(container, key, item, options); end
-  def factory; end
-  def initialize; end
-end
-class Dry::Container::Resolver
-  def call(container, key); end
-  def each(container, &block); end
-  def each_key(container, &block); end
-  def key?(container, key); end
-  def keys(container); end
-end
-class Dry::Container::NamespaceDSL < SimpleDelegator
-  def import(namespace); end
-  def initialize(container, namespace, namespace_separator, &block); end
-  def namespace(namespace, &block); end
-  def namespaced(key); end
-  def register(key, *args, &block); end
-  def resolve(key); end
-end
-module Dry::Container::Mixin
-  def [](key); end
-  def _container; end
-  def clone; end
-  def decorate(key, with: nil, &block); end
-  def dup; end
-  def each(&block); end
-  def each_key(&block); end
-  def freeze; end
-  def import(namespace); end
-  def key?(key); end
-  def keys; end
-  def merge(other, namespace: nil); end
-  def namespace(namespace, &block); end
-  def register(key, contents = nil, options = nil, &block); end
-  def resolve(key, &block); end
-  def self.extended(base); end
-  def self.included(base); end
-end
-module Dry::Container::Mixin::Initializer
-  def initialize(*args, &block); end
-end

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

@@ -1,80 +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/dry-core/all/dry-core.rbi
-#
-# dry-core-0.4.9
-
-module Dry
-end
-module Dry::Core
-end
-module Dry::Core::Constants
-  def self.included(base); end
-end
-module Dry::Core::Deprecations
-  def self.[](tag); end
-  def self.announce(name, msg, tag: nil); end
-  def self.deprecated_name_message(old, new = nil, msg = nil); end
-  def self.deprecation_message(name, msg); end
-  def self.logger(output = nil); end
-  def self.set_logger!(output = nil); end
-  def self.warn(msg, tag: nil); end
-end
-class Dry::Core::Deprecations::Tagged < Module
-  def extended(base); end
-  def initialize(tag); end
-end
-module Dry::Core::Deprecations::Interface
-  def deprecate(old_name, new_name = nil, message: nil); end
-  def deprecate_class_method(old_name, new_name = nil, message: nil); end
-  def deprecate_constant(constant_name, message: nil); end
-  def deprecation_tag(tag = nil); end
-  def warn(msg); end
-end
-module Dry::Core::Extensions
-  def available_extension?(name); end
-  def load_extensions(*extensions); end
-  def register_extension(name, &block); end
-  def self.extended(obj); end
-end
-class Dry::Core::InvalidClassAttributeValue < StandardError
-  def initialize(name, value); end
-end
-module Dry::Core::ClassAttributes
-  def defines(*args, type: nil); end
-  include Dry::Core::Constants
-end
-module Dry::Core::Inflector
-  def self.camelize(input); end
-  def self.classify(input); end
-  def self.constantize(input); end
-  def self.demodulize(input); end
-  def self.detect_backend; end
-  def self.inflector; end
-  def self.pluralize(input); end
-  def self.realize_backend(path, backend_factory); end
-  def self.select_backend(name = nil); end
-  def self.singularize(input); end
-  def self.underscore(input); end
-end
-module Dry::Core::DescendantsTracker
-  def add_descendant(descendant); end
-  def descendants; end
-  def inherited(descendant); end
-  def self.extended(base); end
-  def self.setup(target); end
-end
-module Dry::Core::Cache
-  def cache; end
-  def fetch_or_store(*args, &block); end
-  def inherited(klass); end
-  def self.extended(klass); end
-end
-module Dry::Core::Cache::Methods
-  def fetch_or_store(*args, &block); end
-end

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

@@ -1,26 +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/dry-equalizer/all/dry-equalizer.rbi
-#
-# dry-equalizer-0.3.0
-
-module Dry
-  def self.Equalizer(*keys, **options); end
-end
-class Dry::Equalizer < Module
-  def define_cmp_method; end
-  def define_hash_method(immutable:); end
-  def define_inspect_method; end
-  def define_methods(inspect: nil, immutable: nil); end
-  def included(descendant); end
-  def initialize(*keys, **options); end
-end
-module Dry::Equalizer::Methods
-  def ==(other); end
-  def eql?(other); end
-end

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

@@ -1,73 +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/dry-inflector/all/dry-inflector.rbi
-#
-# dry-inflector-0.2.0
-
-module Dry
-end
-class Dry::Inflector
-  def camelize(input); end
-  def camelize_lower(input); end
-  def camelize_upper(input); end
-  def classify(input); end
-  def constantize(input); end
-  def dasherize(input); end
-  def demodulize(input); end
-  def foreign_key(input); end
-  def humanize(input); end
-  def inflections; end
-  def initialize(&blk); end
-  def inspect; end
-  def internal_camelize(input, upper); end
-  def ordinalize(number); end
-  def pluralize(input); end
-  def singularize(input); end
-  def tableize(input); end
-  def to_s; end
-  def uncountable?(input); end
-  def underscore(input); end
-end
-class Dry::Inflector::Rules
-  def apply_to(word); end
-  def each(&blk); end
-  def initialize; end
-  def insert(index, array); end
-end
-class Dry::Inflector::Acronyms
-  def add(rule, replacement); end
-  def apply_to(word, capitalize = nil); end
-  def define_regex_patterns; end
-  def initialize; end
-  def regex; end
-end
-class Dry::Inflector::Inflections
-  def acronym(*words); end
-  def acronyms; end
-  def add_irregular(rule, replacement, target); end
-  def human(rule, replacement); end
-  def humans; end
-  def initialize; end
-  def irregular(singular, plural); end
-  def plural(rule, replacement); end
-  def plurals; end
-  def rule(rule, replacement, target); end
-  def self.build(&blk); end
-  def singular(rule, replacement); end
-  def singulars; end
-  def uncountable(*words); end
-  def uncountables; end
-end
-module Dry::Inflector::Inflections::Defaults
-  def self.acronyms(inflect); end
-  def self.call(inflect); end
-  def self.irregular(inflect); end
-  def self.plural(inflect); end
-  def self.singular(inflect); end
-  def self.uncountable(inflect); end
-end

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

@@ -1,209 +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/dry-initializer/all/dry-initializer.rbi
-#
-# dry-initializer-3.0.3
-
-module Dry::Initializer::UNDEFINED
-end
-module Dry::Initializer
-  def dry_initializer; end
-  def inherited(klass); end
-  def option(name, type = nil, **opts, &block); end
-  def param(name, type = nil, **opts, &block); end
-  extend Dry::Initializer::DSL
-end
-module Dry::Initializer::DSL
-  def [](undefined: nil, **arg1); end
-  def define(procedure = nil, &block); end
-  def extended(klass); end
-  def null; end
-  def self.extended(mod); end
-end
-class Dry::Initializer::Definition
-  def ==(other); end
-  def code; end
-  def default; end
-  def desc; end
-  def inch; end
-  def initialize(**options); end
-  def inspect; end
-  def ivar; end
-  def name; end
-  def null; end
-  def option; end
-  def optional; end
-  def options; end
-  def reader; end
-  def source; end
-  def target; end
-  def to_s; end
-  def to_str; end
-  def type; end
-end
-module Dry::Initializer::Builders
-end
-class Dry::Initializer::Builders::Reader
-  def attribute_line; end
-  def call; end
-  def initialize(definition); end
-  def lines; end
-  def method_lines; end
-  def self.[](definition); end
-  def type_line; end
-  def undef_line; end
-end
-class Dry::Initializer::Builders::Signature
-  def call; end
-  def initialize(config); end
-  def optional_params; end
-  def options; end
-  def required_params; end
-  def self.[](config); end
-end
-class Dry::Initializer::Builders::Attribute
-  def assignment_line; end
-  def call; end
-  def coercion_line; end
-  def default_line; end
-  def definition_line; end
-  def initialize(definition); end
-  def lines; end
-  def optional_reader; end
-  def reader_line; end
-  def required_reader; end
-  def self.[](definition); end
-end
-class Dry::Initializer::Builders::Initializer
-  def call; end
-  def define_line; end
-  def end_line; end
-  def initialize(config); end
-  def lines; end
-  def options_lines; end
-  def params_lines; end
-  def self.[](config); end
-  def undef_line; end
-end
-class Dry::Initializer::Config
-  def add_definition(option, name, type, block, **opts); end
-  def attributes(instance); end
-  def check_order_of_params; end
-  def check_type(previous, current); end
-  def children; end
-  def code; end
-  def definitions; end
-  def extended_class; end
-  def final_definitions; end
-  def finalize; end
-  def inch; end
-  def initialize(extended_class = nil, null: nil); end
-  def mixin; end
-  def null; end
-  def option(name, type = nil, **opts, &block); end
-  def options; end
-  def param(name, type = nil, **opts, &block); end
-  def params; end
-  def parent; end
-  def public_attributes(instance); end
-end
-module Dry::Initializer::Mixin
-  def self.extended(klass); end
-  extend Dry::Initializer::DSL
-  include Dry::Initializer
-end
-module Dry::Initializer::Mixin::Root
-  def initialize(*args); end
-end
-module Dry::Initializer::Mixin::Local
-  def included(klass); end
-  def inspect; end
-  def klass; end
-  def to_s; end
-  def to_str; end
-end
-module Dry::Initializer::Dispatchers::BuildNestedType
-  def build_nested_type(parent, name, block); end
-  def build_struct(klass_name, block); end
-  def call(parent:, source:, target:, type: nil, block: nil, **options); end
-  def check_certainty!(source, type, block); end
-  def check_name!(name, block); end
-  def full_name(parent, name); end
-  extend Dry::Initializer::Dispatchers::BuildNestedType
-end
-module Dry::Initializer::Dispatchers::CheckType
-  def call(source:, type: nil, wrap: nil, **options); end
-  def check_arity!(_source, type, wrap); end
-  def check_if_callable!(source, type); end
-  extend Dry::Initializer::Dispatchers::CheckType
-end
-module Dry::Initializer::Dispatchers::PrepareDefault
-  def call(default: nil, optional: nil, **options); end
-  def callable!(default); end
-  def check_arity!(default); end
-  def invalid!(default); end
-  extend Dry::Initializer::Dispatchers::PrepareDefault
-end
-module Dry::Initializer::Dispatchers::PrepareIvar
-  def call(target:, **options); end
-  def self.call(target:, **options); end
-end
-module Dry::Initializer::Dispatchers::PrepareOptional
-  def call(optional: nil, default: nil, required: nil, **options); end
-  def self.call(optional: nil, default: nil, required: nil, **options); end
-end
-module Dry::Initializer::Dispatchers::PrepareReader
-  def call(target: nil, reader: nil, **options); end
-  def invalid_reader!(target, _reader); end
-  extend Dry::Initializer::Dispatchers::PrepareReader
-end
-module Dry::Initializer::Dispatchers::PrepareSource
-  def call(source:, **options); end
-  def self.call(source:, **options); end
-end
-module Dry::Initializer::Dispatchers::PrepareTarget
-  def call(source:, target: nil, as: nil, **options); end
-  def check_reserved_names!(target); end
-  def check_ruby_name!(target); end
-  extend Dry::Initializer::Dispatchers::PrepareTarget
-end
-module Dry::Initializer::Dispatchers::UnwrapType
-  def call(type: nil, wrap: nil, **options); end
-  def unwrap(type, count); end
-  extend Dry::Initializer::Dispatchers::UnwrapType
-end
-module Dry::Initializer::Dispatchers::WrapType
-  def call(type: nil, wrap: nil, **options); end
-  def wrap_value(value, count, type); end
-  def wrapped_type(type, count); end
-  extend Dry::Initializer::Dispatchers::WrapType
-end
-module Dry::Initializer::Dispatchers
-  def <<(dispatcher); end
-  def call(**options); end
-  def null; end
-  def null=(arg0); end
-  def pipeline; end
-  extend Dry::Initializer::Dispatchers
-end
-class Dry::Initializer::Struct
-  def __hashify(value); end
-  def self.call(options); end
-  def self.new(options); end
-  def to_h; end
-  extend Dry::Initializer
-  include Anonymous_Module_60
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Module_60
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0); end
-  extend Dry::Initializer::Mixin::Local
-end
-module Dry
-end