sorbet/rbi/gems/rubocop.rbi in cheesy-gallery-0.7.0 vs sorbet/rbi/gems/rubocop.rbi in cheesy-gallery-0.8.0
- old
+ new
@@ -5,11 +5,11 @@
#
# 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/all/rubocop.rbi
#
-# rubocop-1.11.0
+# rubocop-1.13.0
module RuboCop
end
module RuboCop::Version
def self.document_version; end
@@ -56,12 +56,10 @@
include RuboCop::Ext::RegexpParser::Expression::CharacterSet
end
class String
def blank?; end
end
-class Hash
-end
module RuboCop::Ext::ProcessedSource
def comment_config; end
def disabled_line_ranges; end
end
class RuboCop::AST::ProcessedSource
@@ -283,10 +281,11 @@
class RuboCop::Cop::Registry
def ==(other); end
def clear_enrollment_queue; end
def contains_cop_matching?(names); end
def cops; end
+ def department?(name); end
def department_missing?(badge, name); end
def departments; end
def dismiss(cop); end
def each(&block); end
def enabled(config, only = nil, only_safe: nil); end
@@ -297,10 +296,11 @@
def freeze; end
def initialize(cops = nil, options = nil); end
def initialize_copy(reg); end
def length; end
def names; end
+ def names_for_department(department); end
def options; end
def print_warning(name, path); end
def qualified_cop_name(name, path, warn: nil); end
def qualify_badge(badge); end
def registered?(badge); end
@@ -351,10 +351,11 @@
def name; end
def offenses; end
def on_investigation_end; end
def on_new_investigation; end
def on_other_file; end
+ def parse(source, path = nil); end
def processed_source; end
def range_from_node_or_range(node_or_range); end
def ready; end
def relevant_file?(file); end
def reset_investigation; end
@@ -419,11 +420,10 @@
def emulate_v0_callsequence(corrector); end
def find_location(node, loc); end
def offenses; end
def on_investigation_end; end
def on_new_investigation; end
- def parse(source, path = nil); end
def self.all; end
def self.joining_forces; end
def self.qualified_cop_name(name, origin); end
def self.registry; end
def self.support_autocorrect?; end
@@ -947,10 +947,11 @@
def display_column(range); end
def each_bad_alignment(items, base_column); end
def end_of_line_comment(line); end
def indentation(node); end
def offset(node); end
+ def register_offense(offense_node, message_node); end
def within?(inner, outer); end
end
module RuboCop::Cop::AllowedIdentifiers
def allowed_identifier?(name); end
def allowed_identifiers; end
@@ -1060,10 +1061,11 @@
def duplicates?(collection); end
def grouped_duplicates(collection); end
end
module RuboCop::Cop::RangeHelp
def column_offset_between(base_range, range); end
+ def contents_range(node); end
def directions(side); end
def effective_column(range); end
def final_pos(src, pos, increment, continuations, newlines, whitespace); end
def move_pos(src, pos, step, condition, regexp); end
def move_pos_str(src, pos, step, condition, needle); end
@@ -1341,12 +1343,10 @@
def on_send(node); end
def operation_description(node, rhs); end
def part_of_assignment_rhs(node, candidate); end
def part_of_block_body?(candidate, block_node); end
def postfix_conditional?(node); end
- def regular_method_right_hand_side(send_node); end
- def right_hand_side(send_node); end
def valid_method_rhs_candidate?(candidate, node); end
def valid_rhs?(candidate, ancestor); end
def valid_rhs_candidate?(candidate, node); end
def within_node?(inner, outer); end
end
@@ -1409,11 +1409,10 @@
def invalid_percent_array_context?(node); end
def message(_node); end
end
module RuboCop::Cop::PercentLiteral
def begin_source(node); end
- def contents_range(node); end
def percent_literal?(node); end
def process(node, *types); end
def type(node); end
include RuboCop::Cop::RangeHelp
end
@@ -1640,11 +1639,11 @@
def self.align_end(corrector, processed_source, node, align_to); end
def self.alignment_column(align_to); end
def self.autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end
def self.block_comment_within?(expr); end
def self.calculate_range(expr, line_begin_pos, column_delta); end
- def self.correct(processed_source, node, column_delta); end
+ def self.correct(corrector, processed_source, node, column_delta); end
def self.delimited_string_literal?(node); end
def self.each_line(expr); end
def self.inside_string_range(node); end
def self.inside_string_ranges(node); end
def self.processed_source; end
@@ -1816,10 +1815,11 @@
def ignored_gem?(node); end
def on_send(node); end
def precede?(node1, node2); end
def preceding_comment?(node1, node2); end
def preceding_lines(node); end
+ def restrictive_version_specified_gem?(node); end
def version_specified_gem?(node); end
include RuboCop::Cop::DefNode
end
class RuboCop::Cop::Bundler::InsecureProtocolSource < RuboCop::Cop::Base
def insecure_protocol_source?(param0 = nil); end
@@ -1874,48 +1874,52 @@
def gem_spec_with_ruby_version?(node); end
def gem_specification?(param0); end
def on_const(node); end
def ruby_version?(param0 = nil); end
end
-class RuboCop::Cop::Layout::AccessModifierIndentation < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::AccessModifierIndentation < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def check_body(body, node); end
def check_modifier(send_node, end_range); end
def expected_indent_offset; end
- def message(node); end
+ def message(range); end
def on_block(node); end
def on_class(node); end
def on_module(node); end
def on_sclass(node); end
def unexpected_indent_offset; end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::ArgumentAlignment < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::ArgumentAlignment < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def base_column(node, args); end
def fixed_indentation?; end
def message(_node); end
def on_csend(node); end
def on_send(node); end
def target_method_lineno(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
end
-class RuboCop::Cop::Layout::ArrayAlignment < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::ArrayAlignment < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def base_column(node, args); end
def fixed_indentation?; end
- def message(_node); end
+ def message(_range); end
def on_array(node); end
def target_method_lineno(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
end
-class RuboCop::Cop::Layout::AssignmentIndentation < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::AssignmentIndentation < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def check_assignment(node, rhs); end
def leftmost_multiple_assignment(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::CheckAssignment
end
class RuboCop::Cop::Layout::BeginEndAlignment < RuboCop::Cop::Base
def alignment_node(node); end
@@ -1947,15 +1951,15 @@
def style_parameter_name; end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::BlockEndNewline < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::BlockEndNewline < RuboCop::Cop::Base
def delimiter_range(node); end
def message(node); end
def on_block(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
end
class RuboCop::Cop::Layout::CaseIndentation < RuboCop::Cop::Base
def base_column(case_node, base); end
def check_when(when_node); end
@@ -2005,13 +2009,13 @@
def on_heredoc(node); end
def opening_indentation(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Heredoc
end
-class RuboCop::Cop::Layout::ClosingParenthesisIndentation < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::ClosingParenthesisIndentation < RuboCop::Cop::Base
def all_elements_aligned?(elements); end
- def autocorrect(node); end
+ def autocorrect(corrector, node); end
def check(node, elements); end
def check_for_elements(node, elements); end
def check_for_no_elements(node); end
def correct_column_candidates(node, left_paren); end
def expected_column(left_paren, elements); end
@@ -2022,25 +2026,27 @@
def on_begin(node); end
def on_csend(node); end
def on_def(node); end
def on_defs(node); end
def on_send(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
end
-class RuboCop::Cop::Layout::CommentIndentation < RuboCop::Cop::Cop
- def autocorrect(comment); end
- def autocorrect_one(comment); end
- def autocorrect_preceding_comments(comment); end
+class RuboCop::Cop::Layout::CommentIndentation < RuboCop::Cop::Base
+ def autocorrect(corrector, comment); end
+ def autocorrect_one(corrector, comment); end
+ def autocorrect_preceding_comments(corrector, comment); end
def check(comment); end
def correct_indentation(next_line); end
- def investigate(processed_source); end
def less_indented?(line); end
def line_after_comment(comment); end
def message(column, correct_comment_indentation); end
+ def on_new_investigation; end
def own_line_comment?(comment); end
def should_correct?(preceding_comment, reference_comment); end
def two_alternatives?(line); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
end
class RuboCop::Cop::Layout::ConditionPosition < RuboCop::Cop::Base
def check(node); end
def message(condition); end
@@ -2070,23 +2076,24 @@
def proper_dot_position?(node); end
def selector_range(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::ConfigurableEnforcedStyle
end
-class RuboCop::Cop::Layout::ElseAlignment < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::ElseAlignment < RuboCop::Cop::Base
def assignment_node(node); end
- def autocorrect(node); end
+ def autocorrect(corrector, node); end
def base_for_method_definition(node); end
def base_range_of_if(node, base); end
def base_range_of_rescue(node); end
def check_alignment(base_range, else_range); end
def check_assignment(node, rhs); end
def check_nested(node, base); end
def on_case(node); end
def on_case_match(node); end
def on_if(node, base = nil); end
def on_rescue(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::CheckAssignment
include RuboCop::Cop::EndKeywordAlignment
end
class RuboCop::Cop::Layout::EmptyComment < RuboCop::Cop::Base
@@ -2110,10 +2117,12 @@
def heredoc?(node); end
def heredoc_line(node, heredoc_node); end
def last_argument_is_heredoc?(node); end
def last_heredoc_argument(node); end
def next_line_empty?(line); end
+ def next_line_empty_or_enable_directive_comment?(line); end
+ def next_line_enable_directive_comment?(line); end
def next_line_rescue_or_ensure?(node); end
def next_sibling_empty_or_guard_clause?(node); end
def next_sibling_parent_empty_or_else?(node); end
def offense_location(node); end
def on_if(node); end
@@ -2315,13 +2324,13 @@
def on_new_investigation; end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::PrecedingFollowingAlignment
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::FirstArgumentIndentation < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::FirstArgumentIndentation < RuboCop::Cop::Base
def argument_alignment_config; end
- def autocorrect(node); end
+ def autocorrect(corrector, node); end
def bare_operator?(node); end
def base_indentation(node); end
def base_range(send_node, arg_node); end
def column_of(range); end
def comment_lines; end
@@ -2331,47 +2340,51 @@
def on_csend(node); end
def on_new_investigation; end
def on_send(node); end
def previous_code_line(line_number); end
def special_inner_call_indentation?(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::FirstArrayElementIndentation < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::FirstArrayElementIndentation < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def base_description(left_parenthesis); end
def brace_alignment_style; end
def check(array_node, left_parenthesis); end
def check_right_bracket(right_bracket, left_bracket, left_parenthesis); end
def message(base_description); end
def msg(left_parenthesis); end
def on_array(node); end
def on_csend(node); end
def on_send(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::MultilineElementIndentation
end
class RuboCop::Cop::Layout::FirstArrayElementLineBreak < RuboCop::Cop::Base
def assignment_on_same_line?(node); end
def on_array(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::FirstElementLineBreak
end
-class RuboCop::Cop::Layout::FirstHashElementIndentation < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::FirstHashElementIndentation < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def base_description(left_parenthesis); end
def brace_alignment_style; end
def check(hash_node, left_parenthesis); end
def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end
def check_right_brace(right_brace, left_brace, left_parenthesis); end
def message(base_description); end
+ def message_for_right_brace(left_parenthesis); end
def on_csend(node); end
def on_hash(node); end
def on_send(node); end
def separator_style?(first_pair); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::MultilineElementIndentation
end
class RuboCop::Cop::Layout::FirstHashElementLineBreak < RuboCop::Cop::Base
@@ -2390,18 +2403,19 @@
def on_def(node); end
def on_defs(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::FirstElementLineBreak
end
-class RuboCop::Cop::Layout::FirstParameterIndentation < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::FirstParameterIndentation < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def base_description(_); end
def brace_alignment_style; end
def check(def_node); end
def message(base_description); end
def on_def(node); end
def on_defs(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::MultilineElementIndentation
end
class RuboCop::Cop::Layout::HashAlignment < RuboCop::Cop::Base
@@ -2484,45 +2498,48 @@
def unlimited_heredoc_length?; end
def width_message(indentation_width); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Heredoc
end
-class RuboCop::Cop::Layout::IndentationConsistency < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::IndentationConsistency < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def bare_access_modifier?(node); end
def base_column_for_normal_style(node); end
def check(node); end
def check_indented_internal_methods_style(node); end
def check_normal_style(node); end
def on_begin(node); end
def on_kwbegin(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
end
-class RuboCop::Cop::Layout::IndentationStyle < RuboCop::Cop::Cop
- def autocorrect(range); end
- def autocorrect_lambda_for_spaces(range); end
- def autocorrect_lambda_for_tabs(range); end
- def find_offence(line); end
+class RuboCop::Cop::Layout::IndentationStyle < RuboCop::Cop::Base
+ def autocorrect(corrector, range); end
+ def autocorrect_lambda_for_spaces(corrector, range); end
+ def autocorrect_lambda_for_tabs(corrector, range); end
+ def find_offence(line, lineno); end
def in_string_literal?(ranges, tabs_range); end
- def investigate(processed_source); end
def message(_node); end
+ def on_new_investigation; end
def string_literal_ranges(ast); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::IndentationWidth < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::IndentationWidth < RuboCop::Cop::Base
def access_modifier?(param0 = nil); end
def access_modifier_indentation_style; end
- def autocorrect(node); end
+ def autocorrect(corrector, node); end
def check_assignment(node, rhs); end
def check_if(node, body, else_clause, base_loc); end
def check_indentation(base_loc, body_node, style = nil); end
def check_members(base, members); end
def check_members_for_indented_internal_methods_style(members); end
def check_members_for_normal_style(base, members); end
+ def check_rescue?(rescue_node); end
def configured_indentation_width; end
def each_member(members); end
def indentation_consistency_style; end
def indentation_to_check?(base_loc, body_node); end
def indented_internal_methods_style?; end
@@ -2550,10 +2567,11 @@
def other_offense_in_same_range?(node); end
def select_check_member(member); end
def skip_check?(base_loc, body_node); end
def special_modifier?(node); end
def starts_with_access_modifier?(body_node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::CheckAssignment
include RuboCop::Cop::EndKeywordAlignment
include RuboCop::Cop::IgnoredPattern
include RuboCop::Cop::RangeHelp
@@ -2681,64 +2699,83 @@
def on_send(node); end
def single_line_ignoring_receiver?(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::MultilineLiteralBraceLayout
end
-class RuboCop::Cop::Layout::MultilineMethodCallIndentation < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::MultilineMethodCallIndentation < RuboCop::Cop::Base
def align_with_base_message(rhs); end
def alignment_base(node, rhs, given_style); end
- def autocorrect(node); end
+ def autocorrect(corrector, node); end
def base_source; end
def extra_indentation(given_style, parent); end
def message(node, lhs, rhs); end
def no_base_message(lhs, rhs, node); end
def offending_range(node, lhs, rhs, given_style); end
def operation_rhs(node); end
def operator_rhs?(node, receiver); end
def receiver_alignment_base(node); end
def relative_to_receiver_message(rhs); end
def relevant_node?(send_node); end
+ def right_hand_side(send_node); end
def semantic_alignment_base(node, rhs); end
def semantic_alignment_node(node); end
def should_align_with_base?; end
def should_indent_relative_to_receiver?; end
def syntactic_alignment_base(lhs, rhs); end
def validate_config; end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::MultilineExpressionIndentation
end
class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout < RuboCop::Cop::Base
def on_def(node); end
def on_defs(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::MultilineLiteralBraceLayout
end
-class RuboCop::Cop::Layout::MultilineOperationIndentation < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::MultilineOperationIndentation < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def check_and_or(node); end
def message(node, lhs, rhs); end
def offending_range(node, lhs, rhs, given_style); end
def on_and(node); end
def on_or(node); end
def relevant_node?(node); end
+ def right_hand_side(send_node); end
def should_align?(node, rhs, given_style); end
def validate_config; end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::MultilineExpressionIndentation
end
-class RuboCop::Cop::Layout::ParameterAlignment < RuboCop::Cop::Cop
- def autocorrect(node); end
+class RuboCop::Cop::Layout::ParameterAlignment < RuboCop::Cop::Base
+ def autocorrect(corrector, node); end
def base_column(node, args); end
def fixed_indentation?; end
def message(_node); end
def on_def(node); end
def on_defs(node); end
def target_method_lineno(node); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
end
+class RuboCop::Cop::Layout::RedundantLineBreak < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def check_assignment(node, _rhs); end
+ def comment_within?(node); end
+ def configured_to_not_be_inspected?(node); end
+ def convertible_block?(node); end
+ def max_line_length; end
+ def offense?(node); end
+ def on_send(node); end
+ def suitable_as_single_line?(node); end
+ def to_single_line(source); end
+ def too_long?(node); end
+ include RuboCop::Cop::CheckAssignment
+end
class RuboCop::Cop::Layout::RescueEnsureAlignment < RuboCop::Cop::Base
def access_modifier?(node); end
def access_modifier_node(node); end
def alignment_location(alignment_node); end
def alignment_node(node); end
@@ -3129,10 +3166,12 @@
def allowed_method?(node); end
def ambiguous_block_association?(send_node); end
def message(send_node); end
def on_csend(node); end
def on_send(node); end
+ extend RuboCop::Cop::IgnoredMethods::Config
+ include RuboCop::Cop::IgnoredMethods
end
class RuboCop::Cop::Lint::AmbiguousOperator < RuboCop::Cop::Base
def find_offense_node_by(diagnostic); end
def message(diagnostic); end
def offense_node(node); end
@@ -3219,11 +3258,11 @@
def initialize(deprecated:, replacement:, class_constant: nil); end
def replacement_method; end
include RuboCop::AST::Sexp
end
class RuboCop::Cop::Lint::DeprecatedConstants < RuboCop::Cop::Base
- def consntant_name(node, nested_constant_name); end
+ def constant_name(node, nested_constant_name); end
def deprecated_constants; end
def message(good, bad, deprecated_version); end
def on_const(node); end
extend RuboCop::Cop::AutoCorrector
end
@@ -3475,11 +3514,10 @@
end
class RuboCop::Cop::Lint::InterpolationCheck < RuboCop::Cop::Base
def autocorrect(corrector, node); end
def heredoc?(node); end
def on_str(node); end
- def string_or_regex?(node); end
extend RuboCop::Cop::AutoCorrector
end
class RuboCop::Cop::Lint::LambdaWithoutLiteralBlock < RuboCop::Cop::Base
def on_send(node); end
extend RuboCop::Cop::AutoCorrector
@@ -3605,10 +3643,11 @@
def handle_conversion_method(node); end
def ignore_receiver?(receiver); end
def ignored_class?(name); end
def ignored_classes; end
def on_send(node); end
+ def remove_parentheses(corrector, node); end
def to_method(param0 = nil); end
def to_method_symbol(param0 = nil); end
def top_receiver(node); end
extend RuboCop::Cop::AutoCorrector
extend RuboCop::Cop::IgnoredMethods::Config
@@ -3898,22 +3937,28 @@
def on_send(node); end
def struct_new(param0 = nil); end
end
class RuboCop::Cop::Lint::SuppressedException < RuboCop::Cop::Base
def comment_between_rescue_and_end?(node); end
+ def nil_body?(node); end
def on_resbody(node); end
end
class RuboCop::Cop::Lint::SymbolConversion < RuboCop::Cop::Base
def correct_hash_key(node); end
+ def correct_inconsistent_hash_keys(keys); end
def hash_key?(node); end
def in_alias?(node); end
def in_percent_literal_array?(node); end
+ def on_hash(node); end
def on_send(node); end
def on_sym(node); end
def properly_quoted?(source, value); end
+ def quote_type; end
def register_offense(node, correction:, message: nil); end
+ def requires_quotes?(sym_node); end
extend RuboCop::Cop::AutoCorrector
+ include RuboCop::Cop::ConfigurableEnforcedStyle
end
class RuboCop::Cop::Lint::Syntax < RuboCop::Cop::Base
def add_offense_from_diagnostic(diagnostic, ruby_version); end
def add_offense_from_error(error); end
def beautify_message(message); end
@@ -4543,23 +4588,39 @@
end
class RuboCop::Cop::Style::BeginBlock < RuboCop::Cop::Base
def on_preexe(node); end
end
class RuboCop::Cop::Style::BisectedAttrAccessor < RuboCop::Cop::Base
- def accessor_macroses(class_node, visibility); end
- def accessor_names(class_node, visibility); end
- def attr_reader?(send_node); end
- def attr_reader_replacement(macro, node, rest_args); end
- def attr_within_visibility_scope?(node, visibility); end
- def attr_writer?(send_node); end
- def check(macro, reader_names, writer_names); end
+ def after_class(class_node); end
+ def after_module(class_node); end
+ def after_sclass(class_node); end
+ def correct_reader(corrector, macro, node, range); end
+ def correct_writer(corrector, macro, node, range); end
+ def find_bisection(macros); end
+ def find_macros(class_def); end
def on_class(class_node); end
def on_module(class_node); end
+ def on_new_investigation; end
def on_sclass(class_node); end
- def replacement(macro, node); end
- def rest_args(args, reader_names, writer_names); end
+ def register_offense(attr); end
extend RuboCop::Cop::AutoCorrector
+ include RuboCop::Cop::RangeHelp
+end
+class RuboCop::Cop::Style::BisectedAttrAccessor::Macro
+ def all_bisected?; end
+ def attr_names; end
+ def attrs; end
+ def bisect(*names); end
+ def bisected_names; end
+ def bisection; end
+ def initialize(node); end
+ def node; end
+ def reader?; end
+ def rest; end
+ def self.macro?(node); end
+ def visibility; end
+ def writer?; end
include RuboCop::Cop::VisibilityHelp
end
class RuboCop::Cop::Style::BlockComments < RuboCop::Cop::Base
def eq_end_part(comment, expr); end
def on_new_investigation; end
@@ -4616,17 +4677,19 @@
def branch_conditions(node); end
def class_reference?(node); end
def collect_conditions(node, target, conditions); end
def condition_from_binary_op(lhs, rhs, target); end
def condition_from_equality_node(node, target); end
+ def condition_from_include_or_cover_node(node, target); end
def condition_from_match_node(node, target); end
def condition_from_send_node(node, target); end
def const_reference?(node); end
def correction_range(node); end
def deparenthesize(node); end
def find_target(node); end
def find_target_in_equality_node(node); end
+ def find_target_in_include_or_cover_node(node); end
def find_target_in_match_node(node); end
def find_target_in_send_node(node); end
def on_if(node); end
def regexp_with_named_captures?(node); end
def regexp_with_working_captures?(node); end
@@ -4927,20 +4990,23 @@
def require_for_non_public_methods?; end
include RuboCop::Cop::DefNode
include RuboCop::Cop::DocumentationComment
end
class RuboCop::Cop::Style::Documentation < RuboCop::Cop::Base
+ def allowed_constants; end
def check(node, body, type); end
def compact_namespace?(node); end
+ def constant_allowed?(node); end
def constant_declaration?(node); end
def constant_definition?(param0 = nil); end
def constant_visibility_declaration?(param0 = nil); end
def macro_only?(body); end
def namespace?(node); end
def nodoc(node); end
def nodoc?(comment, require_all: nil); end
def nodoc_comment?(node, require_all: nil); end
+ def nodoc_self_or_outer_module?(node); end
def on_class(node); end
def on_module(node); end
def outer_module(param0); end
include RuboCop::Cop::DocumentationComment
end
@@ -5268,12 +5334,15 @@
def allowed_splat_argument?; end
def args_to_hash(args); end
def hash_from_array?(param0 = nil); end
def multi_argument(node); end
def on_send(node); end
+ def register_offense_for_hash(node, hash_argument); end
+ def register_offense_for_zip_method(node, zip_method); end
def requires_parens?(node); end
def single_argument(node); end
+ def use_zip_method_without_argument?(first_argument); end
extend RuboCop::Cop::AutoCorrector
end
class RuboCop::Cop::Style::HashEachMethods < RuboCop::Cop::Base
def check_argument(variable); end
def correct_args(node, corrector); end
@@ -5302,15 +5371,15 @@
def hash_like_case?(param0 = nil); end
def min_branches_count; end
def nodes_of_same_type?(nodes); end
def on_case(node); end
end
-class RuboCop::Cop::Style::HashSyntax < RuboCop::Cop::Cop
+class RuboCop::Cop::Style::HashSyntax < RuboCop::Cop::Base
def acceptable_19_syntax_symbol?(sym_name); end
def alternative_style; end
def argument_without_space?(node); end
- def autocorrect(node); end
+ def autocorrect(corrector, node); end
def autocorrect_hash_rockets(corrector, pair_node); end
def autocorrect_no_mixed_keys(corrector, pair_node); end
def autocorrect_ruby19(corrector, pair_node); end
def check(pairs, delim, msg); end
def force_hash_rockets?(pairs); end
@@ -5320,10 +5389,11 @@
def range_for_autocorrect_ruby19(pair_node); end
def ruby19_check(pairs); end
def ruby19_no_mixed_keys_check(pairs); end
def sym_indices?(pairs); end
def word_symbol_pair?(pair); end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::HashTransformKeys < RuboCop::Cop::Base
def extract_captures(match); end
@@ -5369,26 +5439,30 @@
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::IfUnlessModifier < RuboCop::Cop::Base
def another_statement_on_same_line?(node); end
def autocorrect(corrector, node); end
+ def extract_heredoc_from(last_argument); end
def ignored_patterns; end
def line_length_enabled_at_line?(line); end
def named_capture_in_condition?(node); end
def non_eligible_node?(node); end
def non_simple_if_unless?(node); end
def on_if(node); end
+ def remove_heredoc(corrector, heredoc); end
def self.autocorrect_incompatible_with; end
- def to_normal_form(node); end
+ def to_normal_form(node, indentation); end
+ def to_normal_form_with_heredoc(node, indentation, heredoc); end
def too_long_due_to_modifier?(node); end
def too_long_line_based_on_allow_uri?(line); end
def too_long_line_based_on_config?(range, line); end
def too_long_line_based_on_ignore_cop_directives?(range, line); end
def too_long_single_line?(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::IgnoredPattern
include RuboCop::Cop::LineLengthHelp
+ include RuboCop::Cop::RangeHelp
include RuboCop::Cop::StatementModifier
end
class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < RuboCop::Cop::Base
def on_if(node); end
extend RuboCop::Cop::AutoCorrector
@@ -5551,10 +5625,11 @@
end
module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
def allowed_camel_case_method_call?(node); end
def allowed_chained_call_with_parentheses?(node); end
def allowed_multiline_call_with_parentheses?(node); end
+ def allowed_string_interpolation_method_call?(node); end
def ambigious_literal?(node); end
def assigned_before?(node, target); end
def auto_correct(corrector, node); end
def call_as_argument_or_chain?(node); end
def call_in_literals?(node); end
@@ -5564,18 +5639,20 @@
def call_with_ambiguous_arguments?(node); end
def call_with_braced_block?(node); end
def hash_literal?(node); end
def hash_literal_in_arguments?(node); end
def inside_endless_method_def?(node); end
+ def inside_string_interpolation?(node); end
def legitimate_call_with_parentheses?(node); end
def logical_operator?(node); end
def offense_range(node); end
def omit_parentheses(node); end
def parentheses_at_the_end_of_multiline_call?(node); end
def regexp_slash_literal?(node); end
def splat?(node); end
def super_call_without_arguments?(node); end
+ def syntax_like_method_call?(node); end
def ternary_if?(node); end
def unary_literal?(node); end
end
module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
def eligible_for_parentheses_omission?(node); end
@@ -5631,19 +5708,21 @@
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::SoleNestedConditional < RuboCop::Cop::Base
def allow_modifier?; end
def arguments_range(node); end
+ def assigned_variables(condition); end
def autocorrect(corrector, node, if_branch); end
def correct_for_basic_condition_style(corrector, node, if_branch, and_operator); end
def correct_for_comment(corrector, node, if_branch); end
def correct_for_guard_condition_style(corrector, node, if_branch, and_operator); end
def correct_outer_condition(corrector, condition); end
def offending_branch?(branch); end
def on_if(node); end
def replacement_condition(and_operator, condition); end
def requrie_parentheses?(condition); end
+ def use_variable_assignment_in_condition?(condition, if_branch); end
def wrap_condition?(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::StaticClass < RuboCop::Cop::Base
@@ -5760,10 +5839,11 @@
def autocorrect(corrector, node); end
def closing_line(node); end
def correction_exceeds_max_line_length?(node); end
def definition_width(node); end
def indentation_width(node); end
+ def last_line_source_of_arguments(arguments); end
def max_line_length; end
def on_def(node); end
def on_defs(node); end
def opening_line(node); end
extend RuboCop::Cop::AutoCorrector
@@ -5841,15 +5921,17 @@
def correct_negated_condition(corrector, node); end
def corrected_ancestor?(node); end
def double_negation?(param0 = nil); end
def if_else?(node); end
def negated_condition?(node); end
+ def node_with_comments(node); end
def on_if(node); end
def on_new_investigation; end
def self.autocorrect_incompatible_with; end
def swap_branches(corrector, node); end
extend RuboCop::Cop::AutoCorrector
+ include RuboCop::Cop::CommentsHelp
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::NegatedUnless < RuboCop::Cop::Base
def correct_style?(node); end
def message(node); end
@@ -6216,19 +6298,24 @@
def redundant_argument?(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::RedundantBegin < RuboCop::Cop::Base
+ def any_ancestor_assignment_node?(node); end
def contain_rescue_or_ensure?(node); end
def empty_begin?(node); end
def on_block(node); end
def on_def(node); end
def on_defs(node); end
def on_kwbegin(node); end
def register_offense(node); end
+ def replace_begin_with_statement(corrector, offense_range, node); end
+ def restore_removed_comments(corrector, offense_range, node, first_child); end
+ def valid_begin_assignment?(node); end
def valid_context_using_only_begin?(node); end
extend RuboCop::Cop::AutoCorrector
+ include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::RedundantCapitalW < RuboCop::Cop::Base
def on_array(node); end
def on_percent_literal(node); end
def requires_interpolation?(node); end
@@ -6299,11 +6386,10 @@
def allowed_array_or_hash_element?(node); end
def allowed_expression?(node); end
def allowed_method_call?(node); end
def allowed_multiple_expression?(node); end
def arg_in_call_with_block?(param0 = nil); end
- def array_element?(node); end
def call_chain_starts_with_int?(begin_node, send_node); end
def check(begin_node); end
def check_send(begin_node, node); end
def check_unary(begin_node, node); end
def disallowed_literal?(begin_node, node); end
@@ -6311,11 +6397,11 @@
def first_arg_begins_with_hash_literal?(node); end
def first_argument?(node); end
def first_send_argument?(param0 = nil); end
def first_super_argument?(param0 = nil); end
def first_yield_argument?(param0 = nil); end
- def hash_element?(node); end
+ def hash_or_array_element?(node); end
def ignore_syntax?(node); end
def interpolation?(param0 = nil); end
def keyword_ancestor?(node); end
def keyword_with_redundant_parentheses?(node); end
def like_method_argument_parentheses?(node); end
@@ -6454,17 +6540,19 @@
def slash_literal?(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Style::RescueModifier < RuboCop::Cop::Cop
- def autocorrect(node); end
- def corrected_block(node, parenthesized); end
+class RuboCop::Cop::Style::RescueModifier < RuboCop::Cop::Base
+ def correct_rescue_block(corrector, node, parenthesized); end
def indentation_and_offset(node, parenthesized); end
def on_resbody(node); end
def parenthesized?(node); end
+ def self.autocorrect_incompatible_with; end
+ extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
+ include RuboCop::Cop::RangeHelp
include RuboCop::Cop::RescueNode
end
class RuboCop::Cop::Style::RescueStandardError < RuboCop::Cop::Base
def offense_for_exlicit_enforced_style(node); end
def offense_for_implicit_enforced_style(node, error); end
@@ -6600,10 +6688,11 @@
def autocorrect(corrector, node); end
def correct_to_endless(corrector, node); end
def correct_to_endless?(body_node); end
def correct_to_multiline(corrector, node); end
def each_part(body); end
+ def method_body_source(method_body); end
def move_comment(node, corrector); end
def on_def(node); end
def on_defs(node); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::Alignment
@@ -6646,10 +6735,15 @@
def stderr_puts?(param0 = nil); end
def stderr_puts_range(send); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::RangeHelp
end
+class RuboCop::Cop::Style::StringChars < RuboCop::Cop::Base
+ def on_send(node); end
+ extend RuboCop::Cop::AutoCorrector
+ include RuboCop::Cop::RangeHelp
+end
class RuboCop::Cop::Style::StringConcatenation < RuboCop::Cop::Base
def collect_parts(node, parts); end
def corrected_ancestor?(node); end
def find_topmost_plus_node(node); end
def handle_quotes(parts); end
@@ -6660,10 +6754,11 @@
def replacement(parts); end
def single_quoted?(str_node); end
def string_concatenation?(param0 = nil); end
def uncorrectable?(part); end
extend RuboCop::Cop::AutoCorrector
+ include RuboCop::Cop::RangeHelp
include RuboCop::Cop::Util
end
class RuboCop::Cop::Style::StringHashKeys < RuboCop::Cop::Base
def on_pair(node); end
def receive_environments_method?(param0 = nil); end
@@ -6708,10 +6803,11 @@
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::StructInheritance < RuboCop::Cop::Base
def correct_parent(parent, corrector); end
def on_class(node); end
+ def range_for_empty_class_body(class_node, struct_new); end
def struct_constructor?(param0 = nil); end
extend RuboCop::Cop::AutoCorrector
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::SwapValues < RuboCop::Cop::Base
@@ -7358,10 +7454,11 @@
class RuboCop::ConfigLoaderResolver
def base_configs(path, inherit_from, file); end
def determine_inherit_mode(hash, key); end
def disabled?(hash, department); end
def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end
+ def fix_include_paths(base_config_path, hash, path, key, value); end
def gem_config_path(gem_name, relative_config_path); end
def handle_disabled_by_default(config, new_default_configuration); end
def inherited_file(path, inherit_from, file); end
def merge(base_hash, derived_hash, **opts); end
def merge_hashes?(base_hash, derived_hash, key); end
@@ -7564,36 +7661,43 @@
def target_files_in_dir(base_dir = nil); end
def to_inspect?(file, hidden_files, base_dir_config); end
def wanted_dir_patterns(base_dir, exclude_pattern, flags); end
end
class RuboCop::DirectiveComment
+ def all_cop_names; end
+ def all_cops?; end
def comment; end
+ def cop_names; end
def cops; end
+ def disabled?; end
+ def enabled?; end
+ def enabled_all?; end
def initialize(comment); end
+ def line_number; end
def match?(cop_names); end
+ def match_captures; end
+ def mode; end
+ def parsed_cop_names; end
def range; end
+ def self.before_comment(line); end
+ def single_line?; end
end
class RuboCop::CommentConfig
- def all_cop_names; end
def analyze; end
- def analyze_cop(analysis, disabled, line, single_line); end
- def analyze_disabled(analysis, line); end
- def analyze_rest(analysis, line); end
- def analyze_single_line(analysis, line, disabled); end
+ def analyze_cop(analysis, directive); end
+ def analyze_disabled(analysis, directive); end
+ def analyze_rest(analysis, directive); end
+ def analyze_single_line(analysis, directive); end
def comment_only_line?(line_number); end
def cop_disabled_line_ranges; end
def cop_enabled_at_line?(cop, line_number); end
def cop_line_ranges(analysis); end
- def directive_on_comment_line?(comment); end
- def directive_parts(comment); end
def each_directive; end
- def each_mentioned_cop; end
- def enable_all?(comment); end
def extra_enabled_comments; end
def extra_enabled_comments_with_names(extras:, names:); end
- def handle_enable_all(names, extras, comment); end
- def handle_switch(cop_names, names, disabled, extras, comment); end
+ def handle_enable_all(directive, names, extras); end
+ def handle_switch(directive, names, extras); end
def initialize(processed_source); end
def non_comment_token_line_numbers; end
def processed_source; end
def qualified_cop_name(cop_name); end
end
@@ -7831,10 +7935,11 @@
def parse(command_line_args); end
def require_feature(file); end
end
class RuboCop::OptionsValidator
def boolean_or_empty_cache?; end
+ def disable_parallel_when_invalid_combo; end
def display_only_fail_level_offenses_with_autocorrect?; end
def except_syntax?; end
def incompatible_options; end
def initialize(options); end
def only_includes_redundant_disable?; end
@@ -7846,10 +7951,9 @@
def validate_compatibility; end
def validate_cop_options; end
def validate_display_only_failed; end
def validate_exclude_limit_option; end
def validate_parallel; end
- def validate_parallel_with_combo_option; end
end
module RuboCop::OptionsHelp
end
class RuboCop::RemoteConfig
def cache_name_from_uri; end