frontman-ssg 0.0.4 → 0.1.0

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

@@ -0,0 +1,280 @@
+# 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.3
+
+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
+  def self.truffleruby?; end
+  def truffleruby?; 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 self.supports_taint?; end
+  def supports_exception_cause?; end
+  def supports_rebinding_module_methods?; end
+  def supports_taint?; 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::Mutex < Thread::Mutex
+  def self.new; 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
+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
+module RSpec::Support::WithKeywordsWhenNeeded
+  def class_exec(klass, *args, &block); end
+  def self.class_exec(klass, *args, &block); 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
+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
+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

data/sorbet/rbi/gems/rspec.rbi

@@ -0,0 +1,15 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# 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

@@ -0,0 +1,274 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# 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.3.0
+
+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
+  include RuboCop::Cop::SafeMode
+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
+  include RuboCop::Cop::SafeMode
+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_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_lvasgn?(node); end
+  def message(node); end
+  def next_match_pos(body, match_node_pos, scope_root); end
+  def on_case(node); end
+  def on_if(node); 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_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