clean-architecture 2.0.0 → 3.0.0

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

@@ -0,0 +1,284 @@
+# 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.3.1
+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_52
+  include Dry::Initializer::Mixin::Root
+end
+module Anonymous_Module_52
+  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_53
+  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_53
+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_54
+  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 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_55
+  include Anonymous_Module_54
+  include Dry::Equalizer::Methods
+end
+module Anonymous_Dry_Equalizer_55
+  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_56
+  include Dry::Initializer::Mixin::Root
+end
+module Anonymous_Module_56
+  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_57
+  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_58
+  include Anonymous_Module_57
+  include Dry::Equalizer::Methods
+end
+module Anonymous_Dry_Equalizer_58
+  def cmp?(comparator, other); end
+  def hash; end
+  def inspect; end
+end
+module Anonymous_Module_59
+  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_59
+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
+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_60
+  include Dry::Equalizer::Methods
+  include Enumerable
+end
+module Anonymous_Dry_Equalizer_60
+  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_61
+  include Dry::Equalizer::Methods
+end
+module Anonymous_Dry_Equalizer_61
+  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_62
+  include Anonymous_Module_63
+  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_schema, &block); end
+  def ensure_valid_keys(*keys); end
+  def inherited(klass); end
+  def json(external_schema = nil, &block); end
+  def key_map; end
+  def macros; end
+  def messages; end
+  def params(external_schema = nil, &block); end
+  def rule(*keys, &block); end
+  def rules; end
+  def schema(external_schema = nil, &block); end
+  include Dry::Validation::Macros::Registrar
+end
+module Anonymous_Dry_Equalizer_62
+  def cmp?(comparator, other); end
+  def hash; end
+end
+module Anonymous_Module_63
+  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

@@ -0,0 +1,93 @@
+# 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/equalizer.rbi

@@ -0,0 +1,22 @@
+# 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/equalizer/all/equalizer.rbi
+#
+# equalizer-0.0.11
+class Equalizer < Module
+  def define_cmp_method; end
+  def define_hash_method; end
+  def define_inspect_method; end
+  def define_methods; end
+  def included(descendant); end
+  def initialize(*keys); end
+end
+module Equalizer::Methods
+  def ==(other); end
+  def eql?(other); end
+end

data/sorbet/rbi/gems/i18n.rbi

@@ -0,0 +1,132 @@
+# 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.7.0
+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