dear_inventory 1.4.0 → 1.5.0

data/sorbet/rbi/gems/rspec-support.rbi

@@ -1,269 +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/rspec-support/all/rspec-support.rbi
-#
-# rspec-support-3.9.0
-
-module RSpec
-  extend RSpec::Support::Warnings
-end
-module RSpec::Support
-  def self.class_of(object); end
-  def self.define_optimized_require_for_rspec(lib, &require_relative); end
-  def self.deregister_matcher_definition(&block); end
-  def self.failure_notifier; end
-  def self.failure_notifier=(callable); end
-  def self.is_a_matcher?(object); end
-  def self.matcher_definitions; end
-  def self.method_handle_for(object, method_name); end
-  def self.notify_failure(failure, options = nil); end
-  def self.register_matcher_definition(&block); end
-  def self.require_rspec_support(f); end
-  def self.rspec_description_for_object(object); end
-  def self.thread_local_data; end
-  def self.warning_notifier; end
-  def self.warning_notifier=(arg0); end
-  def self.with_failure_notifier(callable); end
-end
-module RSpec::Support::Version
-end
-class RSpec::Support::ComparableVersion
-  def <=>(other); end
-  def initialize(string); end
-  def segments; end
-  def string; end
-  include Comparable
-end
-module RSpec::Support::OS
-  def self.windows?; end
-  def self.windows_file_path?; end
-  def windows?; end
-  def windows_file_path?; end
-end
-module RSpec::Support::Ruby
-  def jruby?; end
-  def jruby_9000?; end
-  def jruby_version; end
-  def mri?; end
-  def non_mri?; end
-  def rbx?; end
-  def self.jruby?; end
-  def self.jruby_9000?; end
-  def self.jruby_version; end
-  def self.mri?; end
-  def self.non_mri?; end
-  def self.rbx?; end
-end
-module RSpec::Support::RubyFeatures
-  def caller_locations_supported?; end
-  def fork_supported?; end
-  def kw_args_supported?; end
-  def module_prepends_supported?; end
-  def module_refinement_supported?; end
-  def optional_and_splat_args_supported?; end
-  def required_kw_args_supported?; end
-  def ripper_supported?; end
-  def self.caller_locations_supported?; end
-  def self.fork_supported?; end
-  def self.kw_args_supported?; end
-  def self.module_prepends_supported?; end
-  def self.module_refinement_supported?; end
-  def self.optional_and_splat_args_supported?; end
-  def self.required_kw_args_supported?; end
-  def self.ripper_supported?; end
-  def self.supports_exception_cause?; end
-  def self.supports_rebinding_module_methods?; end
-  def supports_exception_cause?; end
-  def supports_rebinding_module_methods?; end
-end
-module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
-  def self.===(exception); end
-end
-class RSpec::CallerFilter
-  def self.first_non_rspec_line(skip_frames = nil, increment = nil); end
-end
-module RSpec::Support::Warnings
-  def deprecate(deprecated, options = nil); end
-  def warn_deprecation(message, options = nil); end
-  def warn_with(message, options = nil); end
-  def warning(text, options = nil); end
-end
-class RSpec::Support::EncodedString
-  def <<(string); end
-  def ==(*args, &block); end
-  def detect_source_encoding(string); end
-  def empty?(*args, &block); end
-  def encoding(*args, &block); end
-  def eql?(*args, &block); end
-  def initialize(string, encoding = nil); end
-  def lines(*args, &block); end
-  def matching_encoding(string); end
-  def remove_invalid_bytes(string); end
-  def self.pick_encoding(source_a, source_b); end
-  def source_encoding; end
-  def split(regex_or_string); end
-  def to_s; end
-  def to_str; end
-end
-class RSpec::Support::ReentrantMutex
-  def enter; end
-  def exit; end
-  def initialize; end
-  def synchronize; end
-end
-class RSpec::Support::DirectoryMaker
-  def self.directory_exists?(dirname); end
-  def self.generate_path(stack, part); end
-  def self.generate_stack(path); end
-  def self.mkdir_p(path); end
-end
-module RSpec::Support::RecursiveConstMethods
-  def const_defined_on?(mod, const_name); end
-  def constants_defined_on(mod); end
-  def get_const_defined_on(mod, const_name); end
-  def normalize_const_name(const_name); end
-  def recursive_const_defined?(const_name); end
-  def recursive_const_get(const_name); end
-end
-module RSpec::Support::FuzzyMatcher
-  def self.arrays_match?(expected_list, actual_list); end
-  def self.hashes_match?(expected_hash, actual_hash); end
-  def self.values_match?(expected, actual); end
-end
-class RSpec::Support::ObjectFormatter
-  def format(object); end
-  def initialize(max_formatted_output_length = nil); end
-  def max_formatted_output_length; end
-  def max_formatted_output_length=(arg0); end
-  def prepare_array(array); end
-  def prepare_element(element); end
-  def prepare_for_inspection(object); end
-  def prepare_hash(input_hash); end
-  def recursive_structure?(object); end
-  def self.default_instance; end
-  def self.format(object); end
-  def self.prepare_for_inspection(object); end
-  def sort_hash_keys(input_hash); end
-  def truncate_string(str, start_index, end_index); end
-  def with_entering_structure(structure); end
-end
-class RSpec::Support::ObjectFormatter::InspectableItem < Struct
-  def inspect; end
-  def pretty_print(pp); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-  def text; end
-  def text=(_); end
-end
-class RSpec::Support::ObjectFormatter::BaseInspector < Struct
-  def formatter; end
-  def formatter=(_); end
-  def inspect; end
-  def object; end
-  def object=(_); end
-  def pretty_print(pp); end
-  def self.[](*arg0); end
-  def self.can_inspect?(_object); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-end
-class RSpec::Support::ObjectFormatter::TimeInspector < RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-  def self.can_inspect?(object); end
-end
-class RSpec::Support::ObjectFormatter::DateTimeInspector < RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-  def self.can_inspect?(object); end
-end
-class RSpec::Support::ObjectFormatter::BigDecimalInspector < RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-  def self.can_inspect?(object); end
-end
-class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-  def self.can_inspect?(object); end
-end
-class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-  def klass; end
-  def native_object_id; end
-  def self.can_inspect?(object); end
-end
-class RSpec::Support::ObjectFormatter::DelegatorInspector < RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-  def self.can_inspect?(object); end
-end
-class RSpec::Support::ObjectFormatter::InspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-  def self.can_inspect?(object); end
-end
-class RSpec::Support::MethodSignature
-  def arbitrary_kw_args?; end
-  def classify_arity(arity = nil); end
-  def classify_parameters; end
-  def could_contain_kw_args?(args); end
-  def description; end
-  def has_kw_args_in?(args); end
-  def initialize(method); end
-  def invalid_kw_args_from(given_kw_args); end
-  def max_non_kw_args; end
-  def min_non_kw_args; end
-  def missing_kw_args_from(given_kw_args); end
-  def non_kw_args_arity_description; end
-  def optional_kw_args; end
-  def required_kw_args; end
-  def unlimited_args?; end
-  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = nil); end
-end
-class RSpec::Support::MethodSignatureExpectation
-  def empty?; end
-  def expect_arbitrary_keywords; end
-  def expect_arbitrary_keywords=(arg0); end
-  def expect_unlimited_arguments; end
-  def expect_unlimited_arguments=(arg0); end
-  def initialize; end
-  def keywords; end
-  def keywords=(values); end
-  def max_count; end
-  def max_count=(number); end
-  def min_count; end
-  def min_count=(number); end
-end
-class RSpec::Support::BlockSignature < RSpec::Support::MethodSignature
-  def classify_parameters; end
-end
-class RSpec::Support::MethodSignatureVerifier
-  def arbitrary_kw_args?; end
-  def error_message; end
-  def initialize(signature, args = nil); end
-  def invalid_kw_args; end
-  def kw_args; end
-  def max_non_kw_args; end
-  def min_non_kw_args; end
-  def missing_kw_args; end
-  def non_kw_args; end
-  def split_args(*args); end
-  def unlimited_args?; end
-  def valid?; end
-  def valid_non_kw_args?; end
-  def with_expectation(expectation); end
-end
-class RSpec::Support::LooseSignatureVerifier < RSpec::Support::MethodSignatureVerifier
-  def split_args(*args); end
-end
-class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
-  def has_kw_args_in?(args); end
-  def initialize(signature); end
-  def invalid_kw_args_from(_kw_args); end
-  def missing_kw_args_from(_kw_args); end
-  def non_kw_args_arity_description; end
-  def valid_non_kw_args?(*args); end
-end

data/sorbet/rbi/gems/rspec.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/rspec/all/rspec.rbi
-#
-# rspec-3.9.0
-
-module RSpec
-end
-module RSpec::Version
-end

data/sorbet/rbi/gems/rubocop-performance.rbi

@@ -1,277 +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/rubocop-performance/all/rubocop-performance.rbi
-#
-# rubocop-performance-1.5.1
-
-module RuboCop
-end
-module RuboCop::Performance
-end
-module RuboCop::Performance::Version
-end
-module RuboCop::Performance::Inject
-  def self.defaults!; end
-end
-module RuboCop::Cop
-end
-module RuboCop::Cop::Performance
-end
-class RuboCop::Cop::Performance::Caller < RuboCop::Cop::Cop
-  def caller_with_scope_method?(node = nil); end
-  def int_value(node); end
-  def message(node); end
-  def on_send(node); end
-  def slow_caller?(node = nil); end
-end
-class RuboCop::Cop::Performance::CaseWhenSplat < RuboCop::Cop::Cop
-  def autocorrect(when_node); end
-  def indent_for(node); end
-  def inline_fix_branch(corrector, when_node); end
-  def needs_reorder?(when_node); end
-  def new_branch_without_then(node, new_condition); end
-  def new_condition_with_then(node, new_condition); end
-  def non_splat?(condition); end
-  def on_case(case_node); end
-  def reorder_condition(corrector, when_node); end
-  def reordering_correction(when_node); end
-  def replacement(conditions); end
-  def splat_offenses(when_conditions); end
-  def when_branch_range(when_node); end
-  include RuboCop::Cop::Alignment
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Performance::Casecmp < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def build_good_method(arg, variable); end
-  def correction(node, _receiver, method, arg, variable); end
-  def downcase_downcase(node = nil); end
-  def downcase_eq(node = nil); end
-  def eq_downcase(node = nil); end
-  def on_send(node); end
-  def take_method_apart(node); end
-end
-class RuboCop::Cop::Performance::CompareWithBlock < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def compare?(node = nil); end
-  def compare_range(send, node); end
-  def message(send, method, var_a, var_b, args); end
-  def on_block(node); end
-  def replaceable_body?(node = nil, param1, param2); end
-  def slow_compare?(method, args_a, args_b); end
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Performance::Count < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def count_candidate?(node = nil); end
-  def eligible_node?(node); end
-  def on_send(node); end
-  def source_starting_at(node); end
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Performance::Detect < RuboCop::Cop::Cop
-  def accept_first_call?(receiver, body); end
-  def autocorrect(node); end
-  def detect_candidate?(node = nil); end
-  def lazy?(node); end
-  def on_send(node); end
-  def preferred_method; end
-  def register_offense(node, receiver, second_method); end
-end
-class RuboCop::Cop::Performance::DoubleStartEndWith < RuboCop::Cop::Cop
-  def add_offense_for_double_call(node, receiver, method, combined_args); end
-  def autocorrect(node); end
-  def check_for_active_support_aliases?; end
-  def check_with_active_support_aliases(node = nil); end
-  def combine_args(first_call_args, second_call_args); end
-  def on_or(node); end
-  def process_source(node); end
-  def two_start_end_with_calls(node = nil); end
-end
-class RuboCop::Cop::Performance::EndWith < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def literal_at_end?(regex_str); end
-  def on_match_with_lvasgn(node); end
-  def on_send(node); end
-  def redundant_regex?(node = nil); end
-end
-class RuboCop::Cop::Performance::FixedSize < RuboCop::Cop::Cop
-  def allowed_argument?(arg); end
-  def allowed_parent?(node); end
-  def allowed_variable?(var); end
-  def contains_double_splat?(node); end
-  def contains_splat?(node); end
-  def counter(node = nil); end
-  def non_string_argument?(node); end
-  def on_send(node); end
-end
-class RuboCop::Cop::Performance::FlatMap < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def flat_map_candidate?(node = nil); end
-  def offense_for_levels(node, map_node, first_method, flatten); end
-  def offense_for_method(node, map_node, first_method, flatten); end
-  def on_send(node); end
-  def register_offense(node, map_node, first_method, flatten, message); end
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Performance::InefficientHashSearch < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def autocorrect_argument(node); end
-  def autocorrect_hash_expression(node); end
-  def autocorrect_method(node); end
-  def current_method(node); end
-  def inefficient_include?(node = nil); end
-  def message(node); end
-  def on_send(node); end
-  def use_long_method; end
-end
-class RuboCop::Cop::Performance::OpenStruct < RuboCop::Cop::Cop
-  def on_send(node); end
-  def open_struct(node = nil); end
-end
-class RuboCop::Cop::Performance::RangeInclude < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def on_send(node); end
-  def range_include(node = nil); end
-end
-class RuboCop::Cop::Performance::RedundantBlockCall < RuboCop::Cop::Cop
-  def args_include_block_pass?(blockcall); end
-  def autocorrect(node); end
-  def blockarg_assigned?(node0, param1); end
-  def blockarg_calls(node0, param1); end
-  def blockarg_def(node = nil); end
-  def calls_to_report(argname, body); end
-  def on_def(node); end
-end
-class RuboCop::Cop::Performance::RedundantMatch < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def match_call?(node = nil); end
-  def on_send(node); end
-  def only_truthiness_matters?(node = nil); end
-end
-class RuboCop::Cop::Performance::RedundantMerge < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def correct_multiple_elements(node, parent, new_source); end
-  def correct_single_element(node, new_source); end
-  def each_redundant_merge(node); end
-  def indent_width; end
-  def kwsplat_used?(pairs); end
-  def leading_spaces(node); end
-  def max_key_value_pairs; end
-  def message(node); end
-  def modifier_flow_control?(node = nil); end
-  def non_redundant_merge?(node, receiver, pairs); end
-  def non_redundant_pairs?(receiver, pairs); end
-  def non_redundant_value_used?(receiver, node); end
-  def on_send(node); end
-  def redundant_merge_candidate(node = nil); end
-  def rewrite_with_modifier(node, parent, new_source); end
-  def to_assignments(receiver, pairs); end
-end
-class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector
-  def each_with_object_node(node = nil); end
-  def eligible_receiver?; end
-  def initialize(node, receiver); end
-  def node; end
-  def receiver; end
-  def second_argument; end
-  def unwind(receiver); end
-  def value_used?; end
-  extend RuboCop::NodePattern::Macros
-end
-class RuboCop::Cop::Performance::RegexpMatch < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def check_condition(cond); end
-  def correct_operator(corrector, recv, arg, oper = nil); end
-  def correction_range(recv, arg); end
-  def find_last_match(body, range, scope_root); end
-  def last_match_used?(match_node); end
-  def last_matches(node0); end
-  def match_gvar?(sym); end
-  def match_method?(node = nil); end
-  def match_node?(node = nil); end
-  def match_operator?(node = nil); end
-  def match_threequals?(node = nil); end
-  def match_with_int_arg_method?(node = nil); end
-  def match_with_lvasgn?(node); end
-  def message(node); end
-  def modifier_form?(match_node); end
-  def next_match_pos(body, match_node_pos, scope_root); end
-  def on_case(node); end
-  def on_if(node); end
-  def range_to_search_for_last_matches(match_node, body, scope_root); end
-  def scope_body(node); end
-  def scope_root(node); end
-  def search_match_nodes(node0); end
-  def swap_receiver_and_arg(corrector, recv, arg); end
-  extend RuboCop::Cop::TargetRubyVersion
-end
-class RuboCop::Cop::Performance::ReverseEach < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def on_send(node); end
-  def reverse_each?(node = nil); end
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Performance::Size < RuboCop::Cop::Cop
-  def allowed_parent?(node); end
-  def array?(node); end
-  def autocorrect(node); end
-  def eligible_node?(node); end
-  def eligible_receiver?(node); end
-  def hash?(node); end
-  def on_send(node); end
-end
-class RuboCop::Cop::Performance::StartWith < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def literal_at_start?(regex_str); end
-  def on_match_with_lvasgn(node); end
-  def on_send(node); end
-  def redundant_regex?(node = nil); end
-end
-class RuboCop::Cop::Performance::StringReplacement < RuboCop::Cop::Cop
-  def accept_first_param?(first_param); end
-  def accept_second_param?(second_param); end
-  def autocorrect(node); end
-  def first_source(first_param); end
-  def message(node, first_source, second_source); end
-  def method_suffix(node); end
-  def offense(node, first_param, second_param); end
-  def on_send(node); end
-  def range(node); end
-  def remove_second_param(corrector, node, first_param); end
-  def replace_method(node, first, second, first_param, replacement); end
-  def replacement_method(node, first_source, second_source); end
-  def source_from_regex_constructor(node); end
-  def source_from_regex_literal(node); end
-  def string_replacement?(node = nil); end
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Performance::TimesMap < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def check(node); end
-  def message(map_or_collect, count); end
-  def on_block(node); end
-  def on_send(node); end
-  def times_map_call(node = nil); end
-end
-class RuboCop::Cop::Performance::UnfreezeString < RuboCop::Cop::Cop
-  def dup_string?(node = nil); end
-  def on_send(node); end
-  def string_new?(node = nil); end
-  extend RuboCop::Cop::TargetRubyVersion
-end
-class RuboCop::Cop::Performance::UriDefaultParser < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def on_send(node); end
-  def uri_parser_new?(node = nil); end
-end
-class RuboCop::Cop::Performance::ChainArrayAllocation < RuboCop::Cop::Cop
-  def flat_map_candidate?(node = nil); end
-  def on_send(node); end
-  include RuboCop::Cop::RangeHelp
-end