clean-architecture 2.0.0 → 3.0.0

data/sorbet/rbi/gems/stackprof.rbi

@@ -0,0 +1,51 @@
+# 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/stackprof/all/stackprof.rbi
+#
+# stackprof-0.2.13
+module StackProf
+  def self.results(*arg0); end
+  def self.run(*arg0); end
+  def self.running?; end
+  def self.sample; end
+  def self.start(*arg0); end
+  def self.stop; end
+end
+class StackProf::Report
+  def +(other); end
+  def add_lines(a, b); end
+  def callers_for(addr); end
+  def convert_to_d3_flame_graph_format(name, stacks, depth); end
+  def data; end
+  def files; end
+  def flamegraph_row(f, x, y, weight, addr); end
+  def frames(sort_by_total = nil); end
+  def initialize(data); end
+  def max_samples; end
+  def modeline; end
+  def normalized_frames; end
+  def overall_samples; end
+  def print_alphabetical_flamegraph(f = nil, skip_common = nil); end
+  def print_callgrind(f = nil); end
+  def print_d3_flamegraph(f = nil, skip_common = nil); end
+  def print_debug; end
+  def print_dump(f = nil); end
+  def print_file(filter, f = nil); end
+  def print_files(sort_by_total = nil, limit = nil, f = nil); end
+  def print_flamegraph(f, skip_common, alphabetical = nil); end
+  def print_graphviz(options = nil, f = nil); end
+  def print_json(f = nil); end
+  def print_method(name, f = nil); end
+  def print_stackcollapse; end
+  def print_text(sort_by_total = nil, limit = nil, select_files = nil, reject_files = nil, select_names = nil, reject_names = nil, f = nil); end
+  def print_timeline_flamegraph(f = nil, skip_common = nil); end
+  def root_frames; end
+  def source_display(f, file, lines, range = nil); end
+  def version; end
+  def walk_method(name); end
+end

data/sorbet/rbi/gems/thread_safe.rbi

@@ -0,0 +1,81 @@
+# 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/thread_safe/all/thread_safe.rbi
+#
+# thread_safe-0.3.6
+module ThreadSafe
+end
+module Threadsafe
+  def self.const_missing(name); end
+end
+class SynchronizedDelegator < SimpleDelegator
+  def initialize(obj); end
+  def method_missing(method, *args, &block); end
+  def setup; end
+  def teardown; end
+end
+class ThreadSafe::NonConcurrentCacheBackend
+  def [](key); end
+  def []=(key, value); end
+  def _get(key); end
+  def _set(key, value); end
+  def clear; end
+  def compute(key); end
+  def compute_if_absent(key); end
+  def compute_if_present(key); end
+  def delete(key); end
+  def delete_pair(key, value); end
+  def dupped_backend; end
+  def each_pair; end
+  def get_and_set(key, value); end
+  def get_or_default(key, default_value); end
+  def initialize(options = nil); end
+  def initialize_copy(other); end
+  def key?(key); end
+  def merge_pair(key, value); end
+  def pair?(key, expected_value); end
+  def replace_if_exists(key, new_value); end
+  def replace_pair(key, old_value, new_value); end
+  def size; end
+  def store_computed_value(key, new_value); end
+  def value?(value); end
+end
+class ThreadSafe::MriCacheBackend < ThreadSafe::NonConcurrentCacheBackend
+  def []=(key, value); end
+  def clear; end
+  def compute(key); end
+  def compute_if_absent(key); end
+  def compute_if_present(key); end
+  def delete(key); end
+  def delete_pair(key, value); end
+  def get_and_set(key, value); end
+  def merge_pair(key, value); end
+  def replace_if_exists(key, new_value); end
+  def replace_pair(key, old_value, new_value); end
+end
+class ThreadSafe::Cache < ThreadSafe::MriCacheBackend
+  def [](key); end
+  def each_key; end
+  def each_value; end
+  def empty?; end
+  def fetch(key, default_value = nil); end
+  def fetch_or_store(key, default_value = nil); end
+  def get(key); end
+  def initialize(options = nil, &block); end
+  def initialize_copy(other); end
+  def key(value); end
+  def keys; end
+  def marshal_dump; end
+  def marshal_load(hash); end
+  def populate_from(hash); end
+  def put(key, value); end
+  def put_if_absent(key, value); end
+  def raise_fetch_no_key; end
+  def validate_options_hash!(options); end
+  def values; end
+end

data/sorbet/rbi/gems/timecop.rbi

@@ -0,0 +1,97 @@
+# 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/timecop/all/timecop.rbi
+#
+# timecop-0.9.1
+class Time
+  def self.mock_time; end
+  def self.new(*args); end
+  def self.new_with_mock_time(*args); end
+  def self.new_without_mock_time(*arg0); end
+  def self.now_with_mock_time; end
+  def self.now_without_mock_time; end
+end
+class Date
+  def self.closest_wday(wday); end
+  def self.mock_date; end
+  def self.mocked_time_stack_item; end
+  def self.parse_with_mock_date(*args); end
+  def self.parse_without_mock_date(*arg0); end
+  def self.strptime_with_mock_date(str = nil, fmt = nil, start = nil); end
+  def self.strptime_without_mock_date(*arg0); end
+  def self.today_with_mock_date; end
+  def self.today_without_mock_date(*arg0); end
+end
+class DateTime < Date
+  def self.mock_time; end
+  def self.mocked_time_stack_item; end
+  def self.now_with_mock_time; end
+  def self.now_without_mock_time(*arg0); end
+  def self.parse_with_mock_date(*args); end
+  def self.parse_without_mock_date(*arg0); end
+end
+class Timecop
+  def baseline; end
+  def baseline=(b); end
+  def initialize; end
+  def return(&block); end
+  def return_to_baseline; end
+  def self.allocate; end
+  def self.baseline; end
+  def self.baseline=(baseline); end
+  def self.freeze(*args, &block); end
+  def self.frozen?; end
+  def self.instance; end
+  def self.new(*arg0); end
+  def self.return(&block); end
+  def self.return_to_baseline; end
+  def self.safe_mode=(safe); end
+  def self.safe_mode?; end
+  def self.scale(*args, &block); end
+  def self.send_travel(mock_type, *args, &block); end
+  def self.thread_safe; end
+  def self.thread_safe=(t); end
+  def self.top_stack_item; end
+  def self.travel(*args, &block); end
+  def set_baseline(b); end
+  def set_stack(s); end
+  def stack; end
+  def thread_safe; end
+  def thread_safe=(t); end
+  def travel(mock_type, *args, &block); end
+  def unmock!; end
+  extend Singleton::SingletonClassMethods
+  include Singleton
+end
+class Timecop::TimeStackItem
+  def compute_travel_offset; end
+  def date(date_klass = nil); end
+  def datetime(datetime_klass = nil); end
+  def day; end
+  def hour; end
+  def initialize(mock_type, *args); end
+  def min; end
+  def mock_type; end
+  def month; end
+  def parse_time(*args); end
+  def rational_to_utc_offset(rational); end
+  def scaled_time; end
+  def scaling_factor; end
+  def sec; end
+  def time(time_klass = nil); end
+  def time_klass; end
+  def times_are_equal_within_epsilon(t1, t2, epsilon_in_seconds); end
+  def travel_offset; end
+  def travel_offset_days; end
+  def utc_offset; end
+  def utc_offset_to_rational(utc_offset); end
+  def year; end
+end
+class Timecop::SafeModeException < StandardError
+  def initialize; end
+end

data/sorbet/rbi/gems/unicode-display_width.rbi

@@ -0,0 +1,16 @@
+# 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/unicode-display_width/all/unicode-display_width.rbi
+#
+# unicode-display_width-1.6.0
+module Unicode
+end
+module Unicode::DisplayWidth
+  def self.emoji_extra_width_of(string, ambiguous = nil, overwrite = nil, _ = nil); end
+  def self.of(string, ambiguous = nil, overwrite = nil, options = nil); end
+end

data/sorbet/rbi/gems/virtus.rbi

@@ -0,0 +1,421 @@
+# 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/virtus/all/virtus.rbi
+#
+# virtus-1.0.5
+module Virtus
+  def self.coerce; end
+  def self.coerce=(value); end
+  def self.coercer(&block); end
+  def self.config(&block); end
+  def self.configuration; end
+  def self.extended(object); end
+  def self.finalize; end
+  def self.included(object); end
+  def self.model(options = nil, &block); end
+  def self.module(options = nil, &block); end
+  def self.value_object(options = nil, &block); end
+  def self.warn(msg); end
+end
+class Virtus::Equalizer < Module
+  def <<(key); end
+  def define_cmp_method; end
+  def define_hash_method; end
+  def define_inspect_method; end
+  def define_methods; end
+  def include_comparison_methods; end
+  def initialize(name, keys = nil); end
+end
+module Virtus::Equalizer::Methods
+  def ==(other); end
+  def eql?(other); end
+end
+module Virtus::Options
+  def accept_options(*new_options); end
+  def accepted_options; end
+  def add_accepted_options(new_options); end
+  def define_option_method(option); end
+  def inherited(descendant); end
+  def options; end
+  def set_options(new_options); end
+end
+module Virtus::TypeLookup
+  def determine_type(class_or_name); end
+  def determine_type_and_cache(class_or_name); end
+  def determine_type_from_descendant(descendant); end
+  def determine_type_from_primitive(primitive); end
+  def determine_type_from_string(string); end
+  def primitive; end
+  def self.extended(model); end
+end
+module Virtus::Model
+  def self.extended(descendant); end
+  def self.included(descendant); end
+end
+module Virtus::Model::Core
+  def self.extended(descendant); end
+  def self.included(descendant); end
+end
+module Virtus::Model::Constructor
+  def self.included(descendant); end
+end
+module Virtus::Model::MassAssignment
+  def self.extended(descendant); end
+  def self.included(descendant); end
+end
+module Virtus::Extensions
+  def self.extended(object); end
+end
+module Virtus::Extensions::Methods
+  def attribute(name, type = nil, options = nil); end
+  def attribute_set; end
+  def self.extended(descendant); end
+  def values(&block); end
+end
+module Virtus::Extensions::AllowedWriterMethods
+  def allowed_writer_methods; end
+end
+module Virtus::ConstMissingExtensions
+  def const_missing(name); end
+end
+module Virtus::ClassInclusions
+  def self.included(descendant); end
+end
+module Virtus::ClassInclusions::Methods
+  def allowed_writer_methods; end
+  def attribute_set; end
+end
+module Virtus::ModuleExtensions
+  def attribute(name, type = nil, options = nil); end
+  def define_attributes(object); end
+  def extended(object); end
+  def included(object); end
+  def self.extended(mod); end
+  def self.setup(mod, inclusions = nil, attribute_definitions = nil); end
+  include Virtus::ConstMissingExtensions
+end
+class Virtus::Configuration
+  def coerce; end
+  def coerce=(arg0); end
+  def coercer(&block); end
+  def constructor; end
+  def constructor=(arg0); end
+  def finalize; end
+  def finalize=(arg0); end
+  def initialize(options = nil); end
+  def mass_assignment; end
+  def mass_assignment=(arg0); end
+  def nullify_blank; end
+  def nullify_blank=(arg0); end
+  def required; end
+  def required=(arg0); end
+  def strict; end
+  def strict=(arg0); end
+  def to_h; end
+end
+class Virtus::Builder
+  def add_extended_hook; end
+  def add_included_hook; end
+  def config; end
+  def extensions; end
+  def initialize(conf, mod = nil); end
+  def mod; end
+  def options; end
+  def self.call(options, &block); end
+  def self.pending; end
+  def with_hook_context; end
+end
+class Virtus::ModelBuilder < Virtus::Builder
+end
+class Virtus::ModuleBuilder < Virtus::Builder
+  def add_included_hook; end
+end
+class Virtus::ValueObjectBuilder < Virtus::Builder
+  def extensions; end
+  def options; end
+end
+class Virtus::Builder::HookContext
+  def attribute_method; end
+  def builder; end
+  def config; end
+  def constructor?; end
+  def finalize?; end
+  def initialize(builder, config); end
+  def initialize_attribute_method; end
+  def mass_assignment?; end
+  def modules; end
+end
+module Virtus::ClassMethods
+  def allowed_methods; end
+  def assert_valid_name(name); end
+  def attribute_set; end
+  def attributes; end
+  def inherited(descendant); end
+  def self.extended(descendant); end
+  include Virtus::ConstMissingExtensions
+  include Virtus::Extensions::Methods
+end
+module Virtus::InstanceMethods
+  def [](name); end
+  def []=(name, value); end
+  def allowed_methods; end
+  def assert_valid_name(name); end
+  def freeze; end
+  def reset_attribute(attribute_name); end
+  def set_default_attributes!; end
+  def set_default_attributes; end
+end
+module Virtus::InstanceMethods::Constructor
+  def initialize(attributes = nil); end
+end
+module Virtus::InstanceMethods::MassAssignment
+  def attributes; end
+  def attributes=(attributes); end
+  def to_h; end
+  def to_hash; end
+end
+module Virtus::ValueObject
+  def self.included(base); end
+end
+module Virtus::ValueObject::InstanceMethods
+  def clone; end
+  def dup; end
+  def with(attribute_updates); end
+end
+module Virtus::ValueObject::AllowedWriterMethods
+  def allowed_writer_methods; end
+end
+module Virtus::ValueObject::ClassMethods
+  def attribute(name, type, options = nil); end
+  def equalizer; end
+end
+class Virtus::Coercer
+  def call(input); end
+  def initialize(type); end
+  def primitive; end
+  def success?(primitive, input); end
+  def type; end
+end
+class Virtus::AttributeSet < Module
+  def <<(attribute); end
+  def [](name); end
+  def []=(name, attribute); end
+  def coerce(attributes); end
+  def define_reader_method(attribute, method_name, visibility); end
+  def define_writer_method(attribute, method_name, visibility); end
+  def each; end
+  def finalize; end
+  def get(object); end
+  def initialize(parent = nil, attributes = nil); end
+  def merge(attributes); end
+  def merge_attributes(attributes); end
+  def reset; end
+  def self.create(descendant); end
+  def set(object, attributes); end
+  def set_defaults(object, filter = nil); end
+  def skip_default?(object, attribute); end
+  def update_index(name, attribute); end
+  include Enumerable
+end
+class Virtus::Attribute
+  def coerce(input); end
+  def coercer; end
+  def coercible?; end
+  def default_value; end
+  def define_accessor_methods(attribute_set); end
+  def finalize; end
+  def finalized?; end
+  def initialize(type, options); end
+  def lazy?; end
+  def nullify_blank?; end
+  def options; end
+  def primitive; end
+  def rename(name); end
+  def required?; end
+  def self.accessor(value = nil); end
+  def self.build(type, options = nil); end
+  def self.build_coercer(type, options = nil); end
+  def self.build_type(definition); end
+  def self.coerce(value = nil); end
+  def self.default(value = nil); end
+  def self.finalize(value = nil); end
+  def self.lazy(value = nil); end
+  def self.merge_options!(*arg0); end
+  def self.nullify_blank(value = nil); end
+  def self.primitive(value = nil); end
+  def self.required(value = nil); end
+  def self.strict(value = nil); end
+  def strict?; end
+  def type; end
+  def value_coerced?(value); end
+  extend DescendantsTracker
+  include Anonymous_Equalizer_51
+  include Equalizer::Methods
+end
+class Virtus::Attribute::DefaultValue
+  def call(*arg0); end
+  def initialize(value); end
+  def self.build(*args); end
+  def value; end
+  extend DescendantsTracker
+end
+class Virtus::Attribute::DefaultValue::FromClonable < Virtus::Attribute::DefaultValue
+  def call(*arg0); end
+  def self.handle?(value); end
+end
+class Virtus::Attribute::DefaultValue::FromCallable < Virtus::Attribute::DefaultValue
+  def call(*args); end
+  def self.handle?(value); end
+end
+class Virtus::Attribute::DefaultValue::FromSymbol < Virtus::Attribute::DefaultValue
+  def call(instance, _); end
+  def self.handle?(value); end
+end
+module Anonymous_Equalizer_51
+  def cmp?(comparator, other); end
+  def hash; end
+  def inspect; end
+end
+class Virtus::PendingAttribute
+  def determine_type; end
+  def finalize; end
+  def finalized?; end
+  def initialize(type, options); end
+  def name; end
+  def options; end
+  def type; end
+end
+class Virtus::TypeDefinition
+  def initialize(type); end
+  def initialize_primitive; end
+  def pending?; end
+  def primitive; end
+  def type; end
+end
+class Virtus::Attribute::Builder
+  def attribute; end
+  def determine_coercer; end
+  def determine_visibility; end
+  def initialize(type_definition, options); end
+  def initialize_attribute; end
+  def initialize_class; end
+  def initialize_coercer; end
+  def initialize_default_value; end
+  def initialize_options(options); end
+  def initialize_type; end
+  def klass; end
+  def options; end
+  def self.call(type, options = nil); end
+  def self.determine_type(klass, default = nil); end
+  def type; end
+  def type_definition; end
+end
+class Virtus::Attribute::Coercer < Virtus::Coercer
+  def call(value); end
+  def coercers; end
+  def initialize(type, coercers); end
+  def method; end
+  def success?(primitive, value); end
+end
+module Virtus::Attribute::Accessor
+  def defined?(instance); end
+  def get(instance); end
+  def instance_variable_name; end
+  def name; end
+  def public_reader?; end
+  def public_writer?; end
+  def self.extended(descendant); end
+  def set(instance, value); end
+  def set_default_value(instance); end
+end
+module Virtus::Attribute::Coercible
+  def set(instance, value); end
+end
+module Virtus::Attribute::Strict
+  def coerce(*arg0); end
+end
+module Virtus::Attribute::LazyDefault
+  def get(instance); end
+end
+module Virtus::Attribute::NullifyBlank
+  def coerce(input); end
+end
+class Virtus::Attribute::Boolean < Virtus::Attribute
+  def define_accessor_methods(attribute_set); end
+  def self.build_type(*arg0); end
+  def value_coerced?(value); end
+end
+class Virtus::Attribute::Collection < Virtus::Attribute
+  def coerce(value); end
+  def finalize; end
+  def finalized?; end
+  def member_type; end
+  def self.build_type(definition); end
+  def self.merge_options!(type, options); end
+end
+class Virtus::Attribute::Collection::Type < Struct
+  def coercion_method; end
+  def member_type; end
+  def member_type=(_); end
+  def primitive; end
+  def primitive=(_); end
+  def self.[](*arg0); end
+  def self.axiom_type?(type); end
+  def self.infer(type, primitive); end
+  def self.infer_member_type(type); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def self.pending?(primitive); end
+end
+class Virtus::Attribute::Hash < Virtus::Attribute
+  def coerce(*arg0); end
+  def finalize; end
+  def finalized?; end
+  def key_type; end
+  def self.build_type(definition); end
+  def self.merge_options!(type, options); end
+  def value_type; end
+end
+class Virtus::Attribute::Hash::Type < Struct
+  def coercion_method; end
+  def key_type; end
+  def key_type=(_); end
+  def primitive; end
+  def self.[](*arg0); end
+  def self.axiom_type?(type); end
+  def self.determine_type(type); end
+  def self.infer(type); end
+  def self.infer_key_and_value_types(type); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def self.pending?(primitive); end
+  def value_type; end
+  def value_type=(_); end
+end
+class Virtus::Attribute::EmbeddedValue < Virtus::Attribute
+  def self.build_coercer(type, _options); end
+  def self.build_type(definition); end
+  def self.handles?(klass); end
+end
+class Virtus::Attribute::EmbeddedValue::FromStruct < Virtus::Coercer
+  def call(input); end
+end
+class Virtus::Attribute::EmbeddedValue::FromOpenStruct < Virtus::Coercer
+  def call(input); end
+end
+class Virtus::CoercionError < StandardError
+  def attribute; end
+  def attribute_name; end
+  def attribute_name?; end
+  def build_message; end
+  def initialize(output, attribute); end
+  def output; end
+  def target_type; end
+end