cheesy-gallery 0.7.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -7,7 +7,7 @@
7
7
  #
8
8
  # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/pry/all/pry.rbi
9
9
  #
10
- # pry-0.14.0
10
+ # pry-0.14.1
11
11
 
12
12
  class Pry
13
13
  def add_sticky_local(name, &block); end
@@ -7,7 +7,7 @@
7
7
  #
8
8
  # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rexml/all/rexml.rbi
9
9
  #
10
- # rexml-3.2.4
10
+ # rexml-3.2.5
11
11
 
12
12
  module REXML
13
13
  end
@@ -79,6 +79,9 @@ class REXML::Parsers::BaseParser
79
79
  def need_source_encoding_update?(xml_declaration_encoding); end
80
80
  def normalize(input, entities = nil, entity_filter = nil); end
81
81
  def parse_attributes(prefixes, curr_ns); end
82
+ def parse_id(base_error_message, accept_external_id:, accept_public_id:); end
83
+ def parse_id_invalid_details(accept_external_id:, accept_public_id:); end
84
+ def parse_name(base_error_message); end
82
85
  def peek(depth = nil); end
83
86
  def position; end
84
87
  def process_instruction; end
@@ -211,6 +214,10 @@ class REXML::AttlistDecl < REXML::Child
211
214
  def write(out, indent = nil); end
212
215
  include Enumerable
213
216
  end
217
+ class REXML::ReferenceWriter
218
+ def initialize(id_type, public_id_literal, system_literal, context = nil); end
219
+ def write(output); end
220
+ end
214
221
  class REXML::DocType < REXML::Parent
215
222
  def add(child); end
216
223
  def attribute_of(element, attribute); end
@@ -227,7 +234,6 @@ class REXML::DocType < REXML::Parent
227
234
  def notation(name); end
228
235
  def notations; end
229
236
  def public; end
230
- def strip_quotes(quoted_string); end
231
237
  def system; end
232
238
  def write(output, indent = nil, transitive = nil, ie_hack = nil); end
233
239
  include REXML::XMLTokens
@@ -341,20 +347,7 @@ class REXML::Parsers::XPathParser
341
347
  def predicate_to_string(path, &block); end
342
348
  include REXML::XMLTokens
343
349
  end
344
- class Object < BasicObject
345
- def dclone; end
346
- end
347
- class Symbol
348
- def dclone; end
349
- end
350
- class Integer < Numeric
351
- def dclone; end
352
- end
353
- class Float < Numeric
354
- def dclone; end
355
- end
356
- class Array
357
- def dclone; end
350
+ module REXML::DClonable
358
351
  end
359
352
  class REXML::XPathParser
360
353
  def []=(variable_name, value); end
@@ -470,6 +463,7 @@ class REXML::Elements
470
463
  def initialize(parent); end
471
464
  def inject(xpath = nil, initial = nil); end
472
465
  def literalize(name); end
466
+ def parent; end
473
467
  def size; end
474
468
  def to_a(xpath = nil); end
475
469
  include Enumerable
@@ -7,7 +7,7 @@
7
7
  #
8
8
  # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop/all/rubocop.rbi
9
9
  #
10
- # rubocop-1.11.0
10
+ # rubocop-1.13.0
11
11
 
12
12
  module RuboCop
13
13
  end
@@ -58,8 +58,6 @@ end
58
58
  class String
59
59
  def blank?; end
60
60
  end
61
- class Hash
62
- end
63
61
  module RuboCop::Ext::ProcessedSource
64
62
  def comment_config; end
65
63
  def disabled_line_ranges; end
@@ -285,6 +283,7 @@ class RuboCop::Cop::Registry
285
283
  def clear_enrollment_queue; end
286
284
  def contains_cop_matching?(names); end
287
285
  def cops; end
286
+ def department?(name); end
288
287
  def department_missing?(badge, name); end
289
288
  def departments; end
290
289
  def dismiss(cop); end
@@ -299,6 +298,7 @@ class RuboCop::Cop::Registry
299
298
  def initialize_copy(reg); end
300
299
  def length; end
301
300
  def names; end
301
+ def names_for_department(department); end
302
302
  def options; end
303
303
  def print_warning(name, path); end
304
304
  def qualified_cop_name(name, path, warn: nil); end
@@ -353,6 +353,7 @@ class RuboCop::Cop::Base
353
353
  def on_investigation_end; end
354
354
  def on_new_investigation; end
355
355
  def on_other_file; end
356
+ def parse(source, path = nil); end
356
357
  def processed_source; end
357
358
  def range_from_node_or_range(node_or_range); end
358
359
  def ready; end
@@ -421,7 +422,6 @@ class RuboCop::Cop::Cop < RuboCop::Cop::Base
421
422
  def offenses; end
422
423
  def on_investigation_end; end
423
424
  def on_new_investigation; end
424
- def parse(source, path = nil); end
425
425
  def self.all; end
426
426
  def self.joining_forces; end
427
427
  def self.qualified_cop_name(name, origin); end
@@ -949,6 +949,7 @@ module RuboCop::Cop::Alignment
949
949
  def end_of_line_comment(line); end
950
950
  def indentation(node); end
951
951
  def offset(node); end
952
+ def register_offense(offense_node, message_node); end
952
953
  def within?(inner, outer); end
953
954
  end
954
955
  module RuboCop::Cop::AllowedIdentifiers
@@ -1062,6 +1063,7 @@ module RuboCop::Cop::Duplication
1062
1063
  end
1063
1064
  module RuboCop::Cop::RangeHelp
1064
1065
  def column_offset_between(base_range, range); end
1066
+ def contents_range(node); end
1065
1067
  def directions(side); end
1066
1068
  def effective_column(range); end
1067
1069
  def final_pos(src, pos, increment, continuations, newlines, whitespace); end
@@ -1343,8 +1345,6 @@ module RuboCop::Cop::MultilineExpressionIndentation
1343
1345
  def part_of_assignment_rhs(node, candidate); end
1344
1346
  def part_of_block_body?(candidate, block_node); end
1345
1347
  def postfix_conditional?(node); end
1346
- def regular_method_right_hand_side(send_node); end
1347
- def right_hand_side(send_node); end
1348
1348
  def valid_method_rhs_candidate?(candidate, node); end
1349
1349
  def valid_rhs?(candidate, ancestor); end
1350
1350
  def valid_rhs_candidate?(candidate, node); end
@@ -1411,7 +1411,6 @@ module RuboCop::Cop::PercentArray
1411
1411
  end
1412
1412
  module RuboCop::Cop::PercentLiteral
1413
1413
  def begin_source(node); end
1414
- def contents_range(node); end
1415
1414
  def percent_literal?(node); end
1416
1415
  def process(node, *types); end
1417
1416
  def type(node); end
@@ -1642,7 +1641,7 @@ class RuboCop::Cop::AlignmentCorrector
1642
1641
  def self.autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end
1643
1642
  def self.block_comment_within?(expr); end
1644
1643
  def self.calculate_range(expr, line_begin_pos, column_delta); end
1645
- def self.correct(processed_source, node, column_delta); end
1644
+ def self.correct(corrector, processed_source, node, column_delta); end
1646
1645
  def self.delimited_string_literal?(node); end
1647
1646
  def self.each_line(expr); end
1648
1647
  def self.inside_string_range(node); end
@@ -1818,6 +1817,7 @@ class RuboCop::Cop::Bundler::GemComment < RuboCop::Cop::Base
1818
1817
  def precede?(node1, node2); end
1819
1818
  def preceding_comment?(node1, node2); end
1820
1819
  def preceding_lines(node); end
1820
+ def restrictive_version_specified_gem?(node); end
1821
1821
  def version_specified_gem?(node); end
1822
1822
  include RuboCop::Cop::DefNode
1823
1823
  end
@@ -1876,44 +1876,48 @@ class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage < RuboCop::Cop::Base
1876
1876
  def on_const(node); end
1877
1877
  def ruby_version?(param0 = nil); end
1878
1878
  end
1879
- class RuboCop::Cop::Layout::AccessModifierIndentation < RuboCop::Cop::Cop
1880
- def autocorrect(node); end
1879
+ class RuboCop::Cop::Layout::AccessModifierIndentation < RuboCop::Cop::Base
1880
+ def autocorrect(corrector, node); end
1881
1881
  def check_body(body, node); end
1882
1882
  def check_modifier(send_node, end_range); end
1883
1883
  def expected_indent_offset; end
1884
- def message(node); end
1884
+ def message(range); end
1885
1885
  def on_block(node); end
1886
1886
  def on_class(node); end
1887
1887
  def on_module(node); end
1888
1888
  def on_sclass(node); end
1889
1889
  def unexpected_indent_offset; end
1890
+ extend RuboCop::Cop::AutoCorrector
1890
1891
  include RuboCop::Cop::Alignment
1891
1892
  include RuboCop::Cop::ConfigurableEnforcedStyle
1892
1893
  include RuboCop::Cop::RangeHelp
1893
1894
  end
1894
- class RuboCop::Cop::Layout::ArgumentAlignment < RuboCop::Cop::Cop
1895
- def autocorrect(node); end
1895
+ class RuboCop::Cop::Layout::ArgumentAlignment < RuboCop::Cop::Base
1896
+ def autocorrect(corrector, node); end
1896
1897
  def base_column(node, args); end
1897
1898
  def fixed_indentation?; end
1898
1899
  def message(_node); end
1899
1900
  def on_csend(node); end
1900
1901
  def on_send(node); end
1901
1902
  def target_method_lineno(node); end
1903
+ extend RuboCop::Cop::AutoCorrector
1902
1904
  include RuboCop::Cop::Alignment
1903
1905
  end
1904
- class RuboCop::Cop::Layout::ArrayAlignment < RuboCop::Cop::Cop
1905
- def autocorrect(node); end
1906
+ class RuboCop::Cop::Layout::ArrayAlignment < RuboCop::Cop::Base
1907
+ def autocorrect(corrector, node); end
1906
1908
  def base_column(node, args); end
1907
1909
  def fixed_indentation?; end
1908
- def message(_node); end
1910
+ def message(_range); end
1909
1911
  def on_array(node); end
1910
1912
  def target_method_lineno(node); end
1913
+ extend RuboCop::Cop::AutoCorrector
1911
1914
  include RuboCop::Cop::Alignment
1912
1915
  end
1913
- class RuboCop::Cop::Layout::AssignmentIndentation < RuboCop::Cop::Cop
1914
- def autocorrect(node); end
1916
+ class RuboCop::Cop::Layout::AssignmentIndentation < RuboCop::Cop::Base
1917
+ def autocorrect(corrector, node); end
1915
1918
  def check_assignment(node, rhs); end
1916
1919
  def leftmost_multiple_assignment(node); end
1920
+ extend RuboCop::Cop::AutoCorrector
1917
1921
  include RuboCop::Cop::Alignment
1918
1922
  include RuboCop::Cop::CheckAssignment
1919
1923
  end
@@ -1949,11 +1953,11 @@ class RuboCop::Cop::Layout::BlockAlignment < RuboCop::Cop::Base
1949
1953
  include RuboCop::Cop::ConfigurableEnforcedStyle
1950
1954
  include RuboCop::Cop::RangeHelp
1951
1955
  end
1952
- class RuboCop::Cop::Layout::BlockEndNewline < RuboCop::Cop::Cop
1953
- def autocorrect(node); end
1956
+ class RuboCop::Cop::Layout::BlockEndNewline < RuboCop::Cop::Base
1954
1957
  def delimiter_range(node); end
1955
1958
  def message(node); end
1956
1959
  def on_block(node); end
1960
+ extend RuboCop::Cop::AutoCorrector
1957
1961
  include RuboCop::Cop::Alignment
1958
1962
  end
1959
1963
  class RuboCop::Cop::Layout::CaseIndentation < RuboCop::Cop::Base
@@ -2007,9 +2011,9 @@ class RuboCop::Cop::Layout::ClosingHeredocIndentation < RuboCop::Cop::Base
2007
2011
  extend RuboCop::Cop::AutoCorrector
2008
2012
  include RuboCop::Cop::Heredoc
2009
2013
  end
2010
- class RuboCop::Cop::Layout::ClosingParenthesisIndentation < RuboCop::Cop::Cop
2014
+ class RuboCop::Cop::Layout::ClosingParenthesisIndentation < RuboCop::Cop::Base
2011
2015
  def all_elements_aligned?(elements); end
2012
- def autocorrect(node); end
2016
+ def autocorrect(corrector, node); end
2013
2017
  def check(node, elements); end
2014
2018
  def check_for_elements(node, elements); end
2015
2019
  def check_for_no_elements(node); end
@@ -2024,21 +2028,23 @@ class RuboCop::Cop::Layout::ClosingParenthesisIndentation < RuboCop::Cop::Cop
2024
2028
  def on_def(node); end
2025
2029
  def on_defs(node); end
2026
2030
  def on_send(node); end
2031
+ extend RuboCop::Cop::AutoCorrector
2027
2032
  include RuboCop::Cop::Alignment
2028
2033
  end
2029
- class RuboCop::Cop::Layout::CommentIndentation < RuboCop::Cop::Cop
2030
- def autocorrect(comment); end
2031
- def autocorrect_one(comment); end
2032
- def autocorrect_preceding_comments(comment); end
2034
+ class RuboCop::Cop::Layout::CommentIndentation < RuboCop::Cop::Base
2035
+ def autocorrect(corrector, comment); end
2036
+ def autocorrect_one(corrector, comment); end
2037
+ def autocorrect_preceding_comments(corrector, comment); end
2033
2038
  def check(comment); end
2034
2039
  def correct_indentation(next_line); end
2035
- def investigate(processed_source); end
2036
2040
  def less_indented?(line); end
2037
2041
  def line_after_comment(comment); end
2038
2042
  def message(column, correct_comment_indentation); end
2043
+ def on_new_investigation; end
2039
2044
  def own_line_comment?(comment); end
2040
2045
  def should_correct?(preceding_comment, reference_comment); end
2041
2046
  def two_alternatives?(line); end
2047
+ extend RuboCop::Cop::AutoCorrector
2042
2048
  include RuboCop::Cop::Alignment
2043
2049
  end
2044
2050
  class RuboCop::Cop::Layout::ConditionPosition < RuboCop::Cop::Base
@@ -2072,9 +2078,9 @@ class RuboCop::Cop::Layout::DotPosition < RuboCop::Cop::Base
2072
2078
  extend RuboCop::Cop::AutoCorrector
2073
2079
  include RuboCop::Cop::ConfigurableEnforcedStyle
2074
2080
  end
2075
- class RuboCop::Cop::Layout::ElseAlignment < RuboCop::Cop::Cop
2081
+ class RuboCop::Cop::Layout::ElseAlignment < RuboCop::Cop::Base
2076
2082
  def assignment_node(node); end
2077
- def autocorrect(node); end
2083
+ def autocorrect(corrector, node); end
2078
2084
  def base_for_method_definition(node); end
2079
2085
  def base_range_of_if(node, base); end
2080
2086
  def base_range_of_rescue(node); end
@@ -2085,6 +2091,7 @@ class RuboCop::Cop::Layout::ElseAlignment < RuboCop::Cop::Cop
2085
2091
  def on_case_match(node); end
2086
2092
  def on_if(node, base = nil); end
2087
2093
  def on_rescue(node); end
2094
+ extend RuboCop::Cop::AutoCorrector
2088
2095
  include RuboCop::Cop::Alignment
2089
2096
  include RuboCop::Cop::CheckAssignment
2090
2097
  include RuboCop::Cop::EndKeywordAlignment
@@ -2112,6 +2119,8 @@ class RuboCop::Cop::Layout::EmptyLineAfterGuardClause < RuboCop::Cop::Base
2112
2119
  def last_argument_is_heredoc?(node); end
2113
2120
  def last_heredoc_argument(node); end
2114
2121
  def next_line_empty?(line); end
2122
+ def next_line_empty_or_enable_directive_comment?(line); end
2123
+ def next_line_enable_directive_comment?(line); end
2115
2124
  def next_line_rescue_or_ensure?(node); end
2116
2125
  def next_sibling_empty_or_guard_clause?(node); end
2117
2126
  def next_sibling_parent_empty_or_else?(node); end
@@ -2317,9 +2326,9 @@ class RuboCop::Cop::Layout::ExtraSpacing < RuboCop::Cop::Base
2317
2326
  include RuboCop::Cop::PrecedingFollowingAlignment
2318
2327
  include RuboCop::Cop::RangeHelp
2319
2328
  end
2320
- class RuboCop::Cop::Layout::FirstArgumentIndentation < RuboCop::Cop::Cop
2329
+ class RuboCop::Cop::Layout::FirstArgumentIndentation < RuboCop::Cop::Base
2321
2330
  def argument_alignment_config; end
2322
- def autocorrect(node); end
2331
+ def autocorrect(corrector, node); end
2323
2332
  def bare_operator?(node); end
2324
2333
  def base_indentation(node); end
2325
2334
  def base_range(send_node, arg_node); end
@@ -2333,12 +2342,13 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < RuboCop::Cop::Cop
2333
2342
  def on_send(node); end
2334
2343
  def previous_code_line(line_number); end
2335
2344
  def special_inner_call_indentation?(node); end
2345
+ extend RuboCop::Cop::AutoCorrector
2336
2346
  include RuboCop::Cop::Alignment
2337
2347
  include RuboCop::Cop::ConfigurableEnforcedStyle
2338
2348
  include RuboCop::Cop::RangeHelp
2339
2349
  end
2340
- class RuboCop::Cop::Layout::FirstArrayElementIndentation < RuboCop::Cop::Cop
2341
- def autocorrect(node); end
2350
+ class RuboCop::Cop::Layout::FirstArrayElementIndentation < RuboCop::Cop::Base
2351
+ def autocorrect(corrector, node); end
2342
2352
  def base_description(left_parenthesis); end
2343
2353
  def brace_alignment_style; end
2344
2354
  def check(array_node, left_parenthesis); end
@@ -2348,6 +2358,7 @@ class RuboCop::Cop::Layout::FirstArrayElementIndentation < RuboCop::Cop::Cop
2348
2358
  def on_array(node); end
2349
2359
  def on_csend(node); end
2350
2360
  def on_send(node); end
2361
+ extend RuboCop::Cop::AutoCorrector
2351
2362
  include RuboCop::Cop::Alignment
2352
2363
  include RuboCop::Cop::ConfigurableEnforcedStyle
2353
2364
  include RuboCop::Cop::MultilineElementIndentation
@@ -2358,18 +2369,20 @@ class RuboCop::Cop::Layout::FirstArrayElementLineBreak < RuboCop::Cop::Base
2358
2369
  extend RuboCop::Cop::AutoCorrector
2359
2370
  include RuboCop::Cop::FirstElementLineBreak
2360
2371
  end
2361
- class RuboCop::Cop::Layout::FirstHashElementIndentation < RuboCop::Cop::Cop
2362
- def autocorrect(node); end
2372
+ class RuboCop::Cop::Layout::FirstHashElementIndentation < RuboCop::Cop::Base
2373
+ def autocorrect(corrector, node); end
2363
2374
  def base_description(left_parenthesis); end
2364
2375
  def brace_alignment_style; end
2365
2376
  def check(hash_node, left_parenthesis); end
2366
2377
  def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end
2367
2378
  def check_right_brace(right_brace, left_brace, left_parenthesis); end
2368
2379
  def message(base_description); end
2380
+ def message_for_right_brace(left_parenthesis); end
2369
2381
  def on_csend(node); end
2370
2382
  def on_hash(node); end
2371
2383
  def on_send(node); end
2372
2384
  def separator_style?(first_pair); end
2385
+ extend RuboCop::Cop::AutoCorrector
2373
2386
  include RuboCop::Cop::Alignment
2374
2387
  include RuboCop::Cop::ConfigurableEnforcedStyle
2375
2388
  include RuboCop::Cop::MultilineElementIndentation
@@ -2392,14 +2405,15 @@ class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < RuboCop::Cop::Base
2392
2405
  extend RuboCop::Cop::AutoCorrector
2393
2406
  include RuboCop::Cop::FirstElementLineBreak
2394
2407
  end
2395
- class RuboCop::Cop::Layout::FirstParameterIndentation < RuboCop::Cop::Cop
2396
- def autocorrect(node); end
2408
+ class RuboCop::Cop::Layout::FirstParameterIndentation < RuboCop::Cop::Base
2409
+ def autocorrect(corrector, node); end
2397
2410
  def base_description(_); end
2398
2411
  def brace_alignment_style; end
2399
2412
  def check(def_node); end
2400
2413
  def message(base_description); end
2401
2414
  def on_def(node); end
2402
2415
  def on_defs(node); end
2416
+ extend RuboCop::Cop::AutoCorrector
2403
2417
  include RuboCop::Cop::Alignment
2404
2418
  include RuboCop::Cop::ConfigurableEnforcedStyle
2405
2419
  include RuboCop::Cop::MultilineElementIndentation
@@ -2486,8 +2500,8 @@ class RuboCop::Cop::Layout::HeredocIndentation < RuboCop::Cop::Base
2486
2500
  extend RuboCop::Cop::AutoCorrector
2487
2501
  include RuboCop::Cop::Heredoc
2488
2502
  end
2489
- class RuboCop::Cop::Layout::IndentationConsistency < RuboCop::Cop::Cop
2490
- def autocorrect(node); end
2503
+ class RuboCop::Cop::Layout::IndentationConsistency < RuboCop::Cop::Base
2504
+ def autocorrect(corrector, node); end
2491
2505
  def bare_access_modifier?(node); end
2492
2506
  def base_column_for_normal_style(node); end
2493
2507
  def check(node); end
@@ -2495,32 +2509,35 @@ class RuboCop::Cop::Layout::IndentationConsistency < RuboCop::Cop::Cop
2495
2509
  def check_normal_style(node); end
2496
2510
  def on_begin(node); end
2497
2511
  def on_kwbegin(node); end
2512
+ extend RuboCop::Cop::AutoCorrector
2498
2513
  include RuboCop::Cop::Alignment
2499
2514
  include RuboCop::Cop::ConfigurableEnforcedStyle
2500
2515
  end
2501
- class RuboCop::Cop::Layout::IndentationStyle < RuboCop::Cop::Cop
2502
- def autocorrect(range); end
2503
- def autocorrect_lambda_for_spaces(range); end
2504
- def autocorrect_lambda_for_tabs(range); end
2505
- def find_offence(line); end
2516
+ class RuboCop::Cop::Layout::IndentationStyle < RuboCop::Cop::Base
2517
+ def autocorrect(corrector, range); end
2518
+ def autocorrect_lambda_for_spaces(corrector, range); end
2519
+ def autocorrect_lambda_for_tabs(corrector, range); end
2520
+ def find_offence(line, lineno); end
2506
2521
  def in_string_literal?(ranges, tabs_range); end
2507
- def investigate(processed_source); end
2508
2522
  def message(_node); end
2523
+ def on_new_investigation; end
2509
2524
  def string_literal_ranges(ast); end
2525
+ extend RuboCop::Cop::AutoCorrector
2510
2526
  include RuboCop::Cop::Alignment
2511
2527
  include RuboCop::Cop::ConfigurableEnforcedStyle
2512
2528
  include RuboCop::Cop::RangeHelp
2513
2529
  end
2514
- class RuboCop::Cop::Layout::IndentationWidth < RuboCop::Cop::Cop
2530
+ class RuboCop::Cop::Layout::IndentationWidth < RuboCop::Cop::Base
2515
2531
  def access_modifier?(param0 = nil); end
2516
2532
  def access_modifier_indentation_style; end
2517
- def autocorrect(node); end
2533
+ def autocorrect(corrector, node); end
2518
2534
  def check_assignment(node, rhs); end
2519
2535
  def check_if(node, body, else_clause, base_loc); end
2520
2536
  def check_indentation(base_loc, body_node, style = nil); end
2521
2537
  def check_members(base, members); end
2522
2538
  def check_members_for_indented_internal_methods_style(members); end
2523
2539
  def check_members_for_normal_style(base, members); end
2540
+ def check_rescue?(rescue_node); end
2524
2541
  def configured_indentation_width; end
2525
2542
  def each_member(members); end
2526
2543
  def indentation_consistency_style; end
@@ -2552,6 +2569,7 @@ class RuboCop::Cop::Layout::IndentationWidth < RuboCop::Cop::Cop
2552
2569
  def skip_check?(base_loc, body_node); end
2553
2570
  def special_modifier?(node); end
2554
2571
  def starts_with_access_modifier?(body_node); end
2572
+ extend RuboCop::Cop::AutoCorrector
2555
2573
  include RuboCop::Cop::Alignment
2556
2574
  include RuboCop::Cop::CheckAssignment
2557
2575
  include RuboCop::Cop::EndKeywordAlignment
@@ -2683,10 +2701,10 @@ class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout < RuboCop::Cop::Base
2683
2701
  extend RuboCop::Cop::AutoCorrector
2684
2702
  include RuboCop::Cop::MultilineLiteralBraceLayout
2685
2703
  end
2686
- class RuboCop::Cop::Layout::MultilineMethodCallIndentation < RuboCop::Cop::Cop
2704
+ class RuboCop::Cop::Layout::MultilineMethodCallIndentation < RuboCop::Cop::Base
2687
2705
  def align_with_base_message(rhs); end
2688
2706
  def alignment_base(node, rhs, given_style); end
2689
- def autocorrect(node); end
2707
+ def autocorrect(corrector, node); end
2690
2708
  def base_source; end
2691
2709
  def extra_indentation(given_style, parent); end
2692
2710
  def message(node, lhs, rhs); end
@@ -2697,12 +2715,14 @@ class RuboCop::Cop::Layout::MultilineMethodCallIndentation < RuboCop::Cop::Cop
2697
2715
  def receiver_alignment_base(node); end
2698
2716
  def relative_to_receiver_message(rhs); end
2699
2717
  def relevant_node?(send_node); end
2718
+ def right_hand_side(send_node); end
2700
2719
  def semantic_alignment_base(node, rhs); end
2701
2720
  def semantic_alignment_node(node); end
2702
2721
  def should_align_with_base?; end
2703
2722
  def should_indent_relative_to_receiver?; end
2704
2723
  def syntactic_alignment_base(lhs, rhs); end
2705
2724
  def validate_config; end
2725
+ extend RuboCop::Cop::AutoCorrector
2706
2726
  include RuboCop::Cop::Alignment
2707
2727
  include RuboCop::Cop::ConfigurableEnforcedStyle
2708
2728
  include RuboCop::Cop::MultilineExpressionIndentation
@@ -2713,30 +2733,47 @@ class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout < RuboCop::Cop:
2713
2733
  extend RuboCop::Cop::AutoCorrector
2714
2734
  include RuboCop::Cop::MultilineLiteralBraceLayout
2715
2735
  end
2716
- class RuboCop::Cop::Layout::MultilineOperationIndentation < RuboCop::Cop::Cop
2717
- def autocorrect(node); end
2736
+ class RuboCop::Cop::Layout::MultilineOperationIndentation < RuboCop::Cop::Base
2737
+ def autocorrect(corrector, node); end
2718
2738
  def check_and_or(node); end
2719
2739
  def message(node, lhs, rhs); end
2720
2740
  def offending_range(node, lhs, rhs, given_style); end
2721
2741
  def on_and(node); end
2722
2742
  def on_or(node); end
2723
2743
  def relevant_node?(node); end
2744
+ def right_hand_side(send_node); end
2724
2745
  def should_align?(node, rhs, given_style); end
2725
2746
  def validate_config; end
2747
+ extend RuboCop::Cop::AutoCorrector
2726
2748
  include RuboCop::Cop::Alignment
2727
2749
  include RuboCop::Cop::ConfigurableEnforcedStyle
2728
2750
  include RuboCop::Cop::MultilineExpressionIndentation
2729
2751
  end
2730
- class RuboCop::Cop::Layout::ParameterAlignment < RuboCop::Cop::Cop
2731
- def autocorrect(node); end
2752
+ class RuboCop::Cop::Layout::ParameterAlignment < RuboCop::Cop::Base
2753
+ def autocorrect(corrector, node); end
2732
2754
  def base_column(node, args); end
2733
2755
  def fixed_indentation?; end
2734
2756
  def message(_node); end
2735
2757
  def on_def(node); end
2736
2758
  def on_defs(node); end
2737
2759
  def target_method_lineno(node); end
2760
+ extend RuboCop::Cop::AutoCorrector
2738
2761
  include RuboCop::Cop::Alignment
2739
2762
  end
2763
+ class RuboCop::Cop::Layout::RedundantLineBreak < RuboCop::Cop::Cop
2764
+ def autocorrect(node); end
2765
+ def check_assignment(node, _rhs); end
2766
+ def comment_within?(node); end
2767
+ def configured_to_not_be_inspected?(node); end
2768
+ def convertible_block?(node); end
2769
+ def max_line_length; end
2770
+ def offense?(node); end
2771
+ def on_send(node); end
2772
+ def suitable_as_single_line?(node); end
2773
+ def to_single_line(source); end
2774
+ def too_long?(node); end
2775
+ include RuboCop::Cop::CheckAssignment
2776
+ end
2740
2777
  class RuboCop::Cop::Layout::RescueEnsureAlignment < RuboCop::Cop::Base
2741
2778
  def access_modifier?(node); end
2742
2779
  def access_modifier_node(node); end
@@ -3131,6 +3168,8 @@ class RuboCop::Cop::Lint::AmbiguousBlockAssociation < RuboCop::Cop::Base
3131
3168
  def message(send_node); end
3132
3169
  def on_csend(node); end
3133
3170
  def on_send(node); end
3171
+ extend RuboCop::Cop::IgnoredMethods::Config
3172
+ include RuboCop::Cop::IgnoredMethods
3134
3173
  end
3135
3174
  class RuboCop::Cop::Lint::AmbiguousOperator < RuboCop::Cop::Base
3136
3175
  def find_offense_node_by(diagnostic); end
@@ -3221,7 +3260,7 @@ class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod
3221
3260
  include RuboCop::AST::Sexp
3222
3261
  end
3223
3262
  class RuboCop::Cop::Lint::DeprecatedConstants < RuboCop::Cop::Base
3224
- def consntant_name(node, nested_constant_name); end
3263
+ def constant_name(node, nested_constant_name); end
3225
3264
  def deprecated_constants; end
3226
3265
  def message(good, bad, deprecated_version); end
3227
3266
  def on_const(node); end
@@ -3477,7 +3516,6 @@ class RuboCop::Cop::Lint::InterpolationCheck < RuboCop::Cop::Base
3477
3516
  def autocorrect(corrector, node); end
3478
3517
  def heredoc?(node); end
3479
3518
  def on_str(node); end
3480
- def string_or_regex?(node); end
3481
3519
  extend RuboCop::Cop::AutoCorrector
3482
3520
  end
3483
3521
  class RuboCop::Cop::Lint::LambdaWithoutLiteralBlock < RuboCop::Cop::Base
@@ -3607,6 +3645,7 @@ class RuboCop::Cop::Lint::NumberConversion < RuboCop::Cop::Base
3607
3645
  def ignored_class?(name); end
3608
3646
  def ignored_classes; end
3609
3647
  def on_send(node); end
3648
+ def remove_parentheses(corrector, node); end
3610
3649
  def to_method(param0 = nil); end
3611
3650
  def to_method_symbol(param0 = nil); end
3612
3651
  def top_receiver(node); end
@@ -3900,18 +3939,24 @@ class RuboCop::Cop::Lint::StructNewOverride < RuboCop::Cop::Base
3900
3939
  end
3901
3940
  class RuboCop::Cop::Lint::SuppressedException < RuboCop::Cop::Base
3902
3941
  def comment_between_rescue_and_end?(node); end
3942
+ def nil_body?(node); end
3903
3943
  def on_resbody(node); end
3904
3944
  end
3905
3945
  class RuboCop::Cop::Lint::SymbolConversion < RuboCop::Cop::Base
3906
3946
  def correct_hash_key(node); end
3947
+ def correct_inconsistent_hash_keys(keys); end
3907
3948
  def hash_key?(node); end
3908
3949
  def in_alias?(node); end
3909
3950
  def in_percent_literal_array?(node); end
3951
+ def on_hash(node); end
3910
3952
  def on_send(node); end
3911
3953
  def on_sym(node); end
3912
3954
  def properly_quoted?(source, value); end
3955
+ def quote_type; end
3913
3956
  def register_offense(node, correction:, message: nil); end
3957
+ def requires_quotes?(sym_node); end
3914
3958
  extend RuboCop::Cop::AutoCorrector
3959
+ include RuboCop::Cop::ConfigurableEnforcedStyle
3915
3960
  end
3916
3961
  class RuboCop::Cop::Lint::Syntax < RuboCop::Cop::Base
3917
3962
  def add_offense_from_diagnostic(diagnostic, ruby_version); end
@@ -4545,19 +4590,35 @@ class RuboCop::Cop::Style::BeginBlock < RuboCop::Cop::Base
4545
4590
  def on_preexe(node); end
4546
4591
  end
4547
4592
  class RuboCop::Cop::Style::BisectedAttrAccessor < RuboCop::Cop::Base
4548
- def accessor_macroses(class_node, visibility); end
4549
- def accessor_names(class_node, visibility); end
4550
- def attr_reader?(send_node); end
4551
- def attr_reader_replacement(macro, node, rest_args); end
4552
- def attr_within_visibility_scope?(node, visibility); end
4553
- def attr_writer?(send_node); end
4554
- def check(macro, reader_names, writer_names); end
4593
+ def after_class(class_node); end
4594
+ def after_module(class_node); end
4595
+ def after_sclass(class_node); end
4596
+ def correct_reader(corrector, macro, node, range); end
4597
+ def correct_writer(corrector, macro, node, range); end
4598
+ def find_bisection(macros); end
4599
+ def find_macros(class_def); end
4555
4600
  def on_class(class_node); end
4556
4601
  def on_module(class_node); end
4602
+ def on_new_investigation; end
4557
4603
  def on_sclass(class_node); end
4558
- def replacement(macro, node); end
4559
- def rest_args(args, reader_names, writer_names); end
4604
+ def register_offense(attr); end
4560
4605
  extend RuboCop::Cop::AutoCorrector
4606
+ include RuboCop::Cop::RangeHelp
4607
+ end
4608
+ class RuboCop::Cop::Style::BisectedAttrAccessor::Macro
4609
+ def all_bisected?; end
4610
+ def attr_names; end
4611
+ def attrs; end
4612
+ def bisect(*names); end
4613
+ def bisected_names; end
4614
+ def bisection; end
4615
+ def initialize(node); end
4616
+ def node; end
4617
+ def reader?; end
4618
+ def rest; end
4619
+ def self.macro?(node); end
4620
+ def visibility; end
4621
+ def writer?; end
4561
4622
  include RuboCop::Cop::VisibilityHelp
4562
4623
  end
4563
4624
  class RuboCop::Cop::Style::BlockComments < RuboCop::Cop::Base
@@ -4618,6 +4679,7 @@ class RuboCop::Cop::Style::CaseLikeIf < RuboCop::Cop::Base
4618
4679
  def collect_conditions(node, target, conditions); end
4619
4680
  def condition_from_binary_op(lhs, rhs, target); end
4620
4681
  def condition_from_equality_node(node, target); end
4682
+ def condition_from_include_or_cover_node(node, target); end
4621
4683
  def condition_from_match_node(node, target); end
4622
4684
  def condition_from_send_node(node, target); end
4623
4685
  def const_reference?(node); end
@@ -4625,6 +4687,7 @@ class RuboCop::Cop::Style::CaseLikeIf < RuboCop::Cop::Base
4625
4687
  def deparenthesize(node); end
4626
4688
  def find_target(node); end
4627
4689
  def find_target_in_equality_node(node); end
4690
+ def find_target_in_include_or_cover_node(node); end
4628
4691
  def find_target_in_match_node(node); end
4629
4692
  def find_target_in_send_node(node); end
4630
4693
  def on_if(node); end
@@ -4929,8 +4992,10 @@ class RuboCop::Cop::Style::DocumentationMethod < RuboCop::Cop::Base
4929
4992
  include RuboCop::Cop::DocumentationComment
4930
4993
  end
4931
4994
  class RuboCop::Cop::Style::Documentation < RuboCop::Cop::Base
4995
+ def allowed_constants; end
4932
4996
  def check(node, body, type); end
4933
4997
  def compact_namespace?(node); end
4998
+ def constant_allowed?(node); end
4934
4999
  def constant_declaration?(node); end
4935
5000
  def constant_definition?(param0 = nil); end
4936
5001
  def constant_visibility_declaration?(param0 = nil); end
@@ -4939,6 +5004,7 @@ class RuboCop::Cop::Style::Documentation < RuboCop::Cop::Base
4939
5004
  def nodoc(node); end
4940
5005
  def nodoc?(comment, require_all: nil); end
4941
5006
  def nodoc_comment?(node, require_all: nil); end
5007
+ def nodoc_self_or_outer_module?(node); end
4942
5008
  def on_class(node); end
4943
5009
  def on_module(node); end
4944
5010
  def outer_module(param0); end
@@ -5270,8 +5336,11 @@ class RuboCop::Cop::Style::HashConversion < RuboCop::Cop::Base
5270
5336
  def hash_from_array?(param0 = nil); end
5271
5337
  def multi_argument(node); end
5272
5338
  def on_send(node); end
5339
+ def register_offense_for_hash(node, hash_argument); end
5340
+ def register_offense_for_zip_method(node, zip_method); end
5273
5341
  def requires_parens?(node); end
5274
5342
  def single_argument(node); end
5343
+ def use_zip_method_without_argument?(first_argument); end
5275
5344
  extend RuboCop::Cop::AutoCorrector
5276
5345
  end
5277
5346
  class RuboCop::Cop::Style::HashEachMethods < RuboCop::Cop::Base
@@ -5304,11 +5373,11 @@ class RuboCop::Cop::Style::HashLikeCase < RuboCop::Cop::Base
5304
5373
  def nodes_of_same_type?(nodes); end
5305
5374
  def on_case(node); end
5306
5375
  end
5307
- class RuboCop::Cop::Style::HashSyntax < RuboCop::Cop::Cop
5376
+ class RuboCop::Cop::Style::HashSyntax < RuboCop::Cop::Base
5308
5377
  def acceptable_19_syntax_symbol?(sym_name); end
5309
5378
  def alternative_style; end
5310
5379
  def argument_without_space?(node); end
5311
- def autocorrect(node); end
5380
+ def autocorrect(corrector, node); end
5312
5381
  def autocorrect_hash_rockets(corrector, pair_node); end
5313
5382
  def autocorrect_no_mixed_keys(corrector, pair_node); end
5314
5383
  def autocorrect_ruby19(corrector, pair_node); end
@@ -5322,6 +5391,7 @@ class RuboCop::Cop::Style::HashSyntax < RuboCop::Cop::Cop
5322
5391
  def ruby19_no_mixed_keys_check(pairs); end
5323
5392
  def sym_indices?(pairs); end
5324
5393
  def word_symbol_pair?(pair); end
5394
+ extend RuboCop::Cop::AutoCorrector
5325
5395
  include RuboCop::Cop::ConfigurableEnforcedStyle
5326
5396
  include RuboCop::Cop::RangeHelp
5327
5397
  end
@@ -5371,14 +5441,17 @@ end
5371
5441
  class RuboCop::Cop::Style::IfUnlessModifier < RuboCop::Cop::Base
5372
5442
  def another_statement_on_same_line?(node); end
5373
5443
  def autocorrect(corrector, node); end
5444
+ def extract_heredoc_from(last_argument); end
5374
5445
  def ignored_patterns; end
5375
5446
  def line_length_enabled_at_line?(line); end
5376
5447
  def named_capture_in_condition?(node); end
5377
5448
  def non_eligible_node?(node); end
5378
5449
  def non_simple_if_unless?(node); end
5379
5450
  def on_if(node); end
5451
+ def remove_heredoc(corrector, heredoc); end
5380
5452
  def self.autocorrect_incompatible_with; end
5381
- def to_normal_form(node); end
5453
+ def to_normal_form(node, indentation); end
5454
+ def to_normal_form_with_heredoc(node, indentation, heredoc); end
5382
5455
  def too_long_due_to_modifier?(node); end
5383
5456
  def too_long_line_based_on_allow_uri?(line); end
5384
5457
  def too_long_line_based_on_config?(range, line); end
@@ -5387,6 +5460,7 @@ class RuboCop::Cop::Style::IfUnlessModifier < RuboCop::Cop::Base
5387
5460
  extend RuboCop::Cop::AutoCorrector
5388
5461
  include RuboCop::Cop::IgnoredPattern
5389
5462
  include RuboCop::Cop::LineLengthHelp
5463
+ include RuboCop::Cop::RangeHelp
5390
5464
  include RuboCop::Cop::StatementModifier
5391
5465
  end
5392
5466
  class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < RuboCop::Cop::Base
@@ -5553,6 +5627,7 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
5553
5627
  def allowed_camel_case_method_call?(node); end
5554
5628
  def allowed_chained_call_with_parentheses?(node); end
5555
5629
  def allowed_multiline_call_with_parentheses?(node); end
5630
+ def allowed_string_interpolation_method_call?(node); end
5556
5631
  def ambigious_literal?(node); end
5557
5632
  def assigned_before?(node, target); end
5558
5633
  def auto_correct(corrector, node); end
@@ -5566,6 +5641,7 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
5566
5641
  def hash_literal?(node); end
5567
5642
  def hash_literal_in_arguments?(node); end
5568
5643
  def inside_endless_method_def?(node); end
5644
+ def inside_string_interpolation?(node); end
5569
5645
  def legitimate_call_with_parentheses?(node); end
5570
5646
  def logical_operator?(node); end
5571
5647
  def offense_range(node); end
@@ -5574,6 +5650,7 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
5574
5650
  def regexp_slash_literal?(node); end
5575
5651
  def splat?(node); end
5576
5652
  def super_call_without_arguments?(node); end
5653
+ def syntax_like_method_call?(node); end
5577
5654
  def ternary_if?(node); end
5578
5655
  def unary_literal?(node); end
5579
5656
  end
@@ -5633,6 +5710,7 @@ end
5633
5710
  class RuboCop::Cop::Style::SoleNestedConditional < RuboCop::Cop::Base
5634
5711
  def allow_modifier?; end
5635
5712
  def arguments_range(node); end
5713
+ def assigned_variables(condition); end
5636
5714
  def autocorrect(corrector, node, if_branch); end
5637
5715
  def correct_for_basic_condition_style(corrector, node, if_branch, and_operator); end
5638
5716
  def correct_for_comment(corrector, node, if_branch); end
@@ -5642,6 +5720,7 @@ class RuboCop::Cop::Style::SoleNestedConditional < RuboCop::Cop::Base
5642
5720
  def on_if(node); end
5643
5721
  def replacement_condition(and_operator, condition); end
5644
5722
  def requrie_parentheses?(condition); end
5723
+ def use_variable_assignment_in_condition?(condition, if_branch); end
5645
5724
  def wrap_condition?(node); end
5646
5725
  extend RuboCop::Cop::AutoCorrector
5647
5726
  include RuboCop::Cop::RangeHelp
@@ -5762,6 +5841,7 @@ class RuboCop::Cop::Style::MultilineMethodSignature < RuboCop::Cop::Base
5762
5841
  def correction_exceeds_max_line_length?(node); end
5763
5842
  def definition_width(node); end
5764
5843
  def indentation_width(node); end
5844
+ def last_line_source_of_arguments(arguments); end
5765
5845
  def max_line_length; end
5766
5846
  def on_def(node); end
5767
5847
  def on_defs(node); end
@@ -5843,11 +5923,13 @@ class RuboCop::Cop::Style::NegatedIfElseCondition < RuboCop::Cop::Base
5843
5923
  def double_negation?(param0 = nil); end
5844
5924
  def if_else?(node); end
5845
5925
  def negated_condition?(node); end
5926
+ def node_with_comments(node); end
5846
5927
  def on_if(node); end
5847
5928
  def on_new_investigation; end
5848
5929
  def self.autocorrect_incompatible_with; end
5849
5930
  def swap_branches(corrector, node); end
5850
5931
  extend RuboCop::Cop::AutoCorrector
5932
+ include RuboCop::Cop::CommentsHelp
5851
5933
  include RuboCop::Cop::RangeHelp
5852
5934
  end
5853
5935
  class RuboCop::Cop::Style::NegatedUnless < RuboCop::Cop::Base
@@ -6218,6 +6300,7 @@ class RuboCop::Cop::Style::RedundantArgument < RuboCop::Cop::Base
6218
6300
  include RuboCop::Cop::RangeHelp
6219
6301
  end
6220
6302
  class RuboCop::Cop::Style::RedundantBegin < RuboCop::Cop::Base
6303
+ def any_ancestor_assignment_node?(node); end
6221
6304
  def contain_rescue_or_ensure?(node); end
6222
6305
  def empty_begin?(node); end
6223
6306
  def on_block(node); end
@@ -6225,8 +6308,12 @@ class RuboCop::Cop::Style::RedundantBegin < RuboCop::Cop::Base
6225
6308
  def on_defs(node); end
6226
6309
  def on_kwbegin(node); end
6227
6310
  def register_offense(node); end
6311
+ def replace_begin_with_statement(corrector, offense_range, node); end
6312
+ def restore_removed_comments(corrector, offense_range, node, first_child); end
6313
+ def valid_begin_assignment?(node); end
6228
6314
  def valid_context_using_only_begin?(node); end
6229
6315
  extend RuboCop::Cop::AutoCorrector
6316
+ include RuboCop::Cop::RangeHelp
6230
6317
  end
6231
6318
  class RuboCop::Cop::Style::RedundantCapitalW < RuboCop::Cop::Base
6232
6319
  def on_array(node); end
@@ -6301,7 +6388,6 @@ class RuboCop::Cop::Style::RedundantParentheses < RuboCop::Cop::Base
6301
6388
  def allowed_method_call?(node); end
6302
6389
  def allowed_multiple_expression?(node); end
6303
6390
  def arg_in_call_with_block?(param0 = nil); end
6304
- def array_element?(node); end
6305
6391
  def call_chain_starts_with_int?(begin_node, send_node); end
6306
6392
  def check(begin_node); end
6307
6393
  def check_send(begin_node, node); end
@@ -6313,7 +6399,7 @@ class RuboCop::Cop::Style::RedundantParentheses < RuboCop::Cop::Base
6313
6399
  def first_send_argument?(param0 = nil); end
6314
6400
  def first_super_argument?(param0 = nil); end
6315
6401
  def first_yield_argument?(param0 = nil); end
6316
- def hash_element?(node); end
6402
+ def hash_or_array_element?(node); end
6317
6403
  def ignore_syntax?(node); end
6318
6404
  def interpolation?(param0 = nil); end
6319
6405
  def keyword_ancestor?(node); end
@@ -6456,13 +6542,15 @@ class RuboCop::Cop::Style::RegexpLiteral < RuboCop::Cop::Base
6456
6542
  include RuboCop::Cop::ConfigurableEnforcedStyle
6457
6543
  include RuboCop::Cop::RangeHelp
6458
6544
  end
6459
- class RuboCop::Cop::Style::RescueModifier < RuboCop::Cop::Cop
6460
- def autocorrect(node); end
6461
- def corrected_block(node, parenthesized); end
6545
+ class RuboCop::Cop::Style::RescueModifier < RuboCop::Cop::Base
6546
+ def correct_rescue_block(corrector, node, parenthesized); end
6462
6547
  def indentation_and_offset(node, parenthesized); end
6463
6548
  def on_resbody(node); end
6464
6549
  def parenthesized?(node); end
6550
+ def self.autocorrect_incompatible_with; end
6551
+ extend RuboCop::Cop::AutoCorrector
6465
6552
  include RuboCop::Cop::Alignment
6553
+ include RuboCop::Cop::RangeHelp
6466
6554
  include RuboCop::Cop::RescueNode
6467
6555
  end
6468
6556
  class RuboCop::Cop::Style::RescueStandardError < RuboCop::Cop::Base
@@ -6602,6 +6690,7 @@ class RuboCop::Cop::Style::SingleLineMethods < RuboCop::Cop::Base
6602
6690
  def correct_to_endless?(body_node); end
6603
6691
  def correct_to_multiline(corrector, node); end
6604
6692
  def each_part(body); end
6693
+ def method_body_source(method_body); end
6605
6694
  def move_comment(node, corrector); end
6606
6695
  def on_def(node); end
6607
6696
  def on_defs(node); end
@@ -6648,6 +6737,11 @@ class RuboCop::Cop::Style::StderrPuts < RuboCop::Cop::Base
6648
6737
  extend RuboCop::Cop::AutoCorrector
6649
6738
  include RuboCop::Cop::RangeHelp
6650
6739
  end
6740
+ class RuboCop::Cop::Style::StringChars < RuboCop::Cop::Base
6741
+ def on_send(node); end
6742
+ extend RuboCop::Cop::AutoCorrector
6743
+ include RuboCop::Cop::RangeHelp
6744
+ end
6651
6745
  class RuboCop::Cop::Style::StringConcatenation < RuboCop::Cop::Base
6652
6746
  def collect_parts(node, parts); end
6653
6747
  def corrected_ancestor?(node); end
@@ -6662,6 +6756,7 @@ class RuboCop::Cop::Style::StringConcatenation < RuboCop::Cop::Base
6662
6756
  def string_concatenation?(param0 = nil); end
6663
6757
  def uncorrectable?(part); end
6664
6758
  extend RuboCop::Cop::AutoCorrector
6759
+ include RuboCop::Cop::RangeHelp
6665
6760
  include RuboCop::Cop::Util
6666
6761
  end
6667
6762
  class RuboCop::Cop::Style::StringHashKeys < RuboCop::Cop::Base
@@ -6710,6 +6805,7 @@ end
6710
6805
  class RuboCop::Cop::Style::StructInheritance < RuboCop::Cop::Base
6711
6806
  def correct_parent(parent, corrector); end
6712
6807
  def on_class(node); end
6808
+ def range_for_empty_class_body(class_node, struct_new); end
6713
6809
  def struct_constructor?(param0 = nil); end
6714
6810
  extend RuboCop::Cop::AutoCorrector
6715
6811
  include RuboCop::Cop::RangeHelp
@@ -7360,6 +7456,7 @@ class RuboCop::ConfigLoaderResolver
7360
7456
  def determine_inherit_mode(hash, key); end
7361
7457
  def disabled?(hash, department); end
7362
7458
  def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end
7459
+ def fix_include_paths(base_config_path, hash, path, key, value); end
7363
7460
  def gem_config_path(gem_name, relative_config_path); end
7364
7461
  def handle_disabled_by_default(config, new_default_configuration); end
7365
7462
  def inherited_file(path, inherit_from, file); end
@@ -7566,32 +7663,39 @@ class RuboCop::TargetFinder
7566
7663
  def wanted_dir_patterns(base_dir, exclude_pattern, flags); end
7567
7664
  end
7568
7665
  class RuboCop::DirectiveComment
7666
+ def all_cop_names; end
7667
+ def all_cops?; end
7569
7668
  def comment; end
7669
+ def cop_names; end
7570
7670
  def cops; end
7671
+ def disabled?; end
7672
+ def enabled?; end
7673
+ def enabled_all?; end
7571
7674
  def initialize(comment); end
7675
+ def line_number; end
7572
7676
  def match?(cop_names); end
7677
+ def match_captures; end
7678
+ def mode; end
7679
+ def parsed_cop_names; end
7573
7680
  def range; end
7681
+ def self.before_comment(line); end
7682
+ def single_line?; end
7574
7683
  end
7575
7684
  class RuboCop::CommentConfig
7576
- def all_cop_names; end
7577
7685
  def analyze; end
7578
- def analyze_cop(analysis, disabled, line, single_line); end
7579
- def analyze_disabled(analysis, line); end
7580
- def analyze_rest(analysis, line); end
7581
- def analyze_single_line(analysis, line, disabled); end
7686
+ def analyze_cop(analysis, directive); end
7687
+ def analyze_disabled(analysis, directive); end
7688
+ def analyze_rest(analysis, directive); end
7689
+ def analyze_single_line(analysis, directive); end
7582
7690
  def comment_only_line?(line_number); end
7583
7691
  def cop_disabled_line_ranges; end
7584
7692
  def cop_enabled_at_line?(cop, line_number); end
7585
7693
  def cop_line_ranges(analysis); end
7586
- def directive_on_comment_line?(comment); end
7587
- def directive_parts(comment); end
7588
7694
  def each_directive; end
7589
- def each_mentioned_cop; end
7590
- def enable_all?(comment); end
7591
7695
  def extra_enabled_comments; end
7592
7696
  def extra_enabled_comments_with_names(extras:, names:); end
7593
- def handle_enable_all(names, extras, comment); end
7594
- def handle_switch(cop_names, names, disabled, extras, comment); end
7697
+ def handle_enable_all(directive, names, extras); end
7698
+ def handle_switch(directive, names, extras); end
7595
7699
  def initialize(processed_source); end
7596
7700
  def non_comment_token_line_numbers; end
7597
7701
  def processed_source; end
@@ -7833,6 +7937,7 @@ class RuboCop::Options
7833
7937
  end
7834
7938
  class RuboCop::OptionsValidator
7835
7939
  def boolean_or_empty_cache?; end
7940
+ def disable_parallel_when_invalid_combo; end
7836
7941
  def display_only_fail_level_offenses_with_autocorrect?; end
7837
7942
  def except_syntax?; end
7838
7943
  def incompatible_options; end
@@ -7848,7 +7953,6 @@ class RuboCop::OptionsValidator
7848
7953
  def validate_display_only_failed; end
7849
7954
  def validate_exclude_limit_option; end
7850
7955
  def validate_parallel; end
7851
- def validate_parallel_with_combo_option; end
7852
7956
  end
7853
7957
  module RuboCop::OptionsHelp
7854
7958
  end