sorbet/rbi/gems/rubocop.rbi in clean-architecture-3.0.0 vs sorbet/rbi/gems/rubocop.rbi in clean-architecture-3.0.1
- old
+ new
@@ -5,18 +5,18 @@
#
# 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-0.75.1
+# rubocop-0.80.0
+
module RuboCop
end
module RuboCop::Version
def self.version(debug = nil); end
end
class String
- def blank?; end
end
module RuboCop::PathUtil
def absolute?(path); end
def hidden_dir?(path); end
def hidden_file_in_not_hidden_dir?(pattern, path); end
@@ -56,23 +56,26 @@
def initialize(str); end
def marshal_dump; end
def marshal_load(pattern); end
def match(*args); end
def pattern; end
+ def self.descend(element, &block); end
def to_s; end
end
class RuboCop::NodePattern::Invalid < StandardError
end
class RuboCop::NodePattern::Compiler
+ def access_unify(name); end
def auto_use_temp_node?(code); end
def captures; end
def compile_any_order(capture_all = nil); end
def compile_arg(token); end
def compile_args(tokens); end
def compile_ascend; end
def compile_capture; end
def compile_captured_ellipsis; end
+ def compile_descend; end
def compile_ellipsis; end
def compile_expr(token = nil); end
def compile_funcall(method); end
def compile_guard_clause; end
def compile_intersect; end
@@ -89,10 +92,11 @@
def emit_param_list; end
def emit_retval; end
def emit_trailing_params; end
def emit_yield_capture(when_no_capture = nil); end
def fail_due_to(message); end
+ def forbid_unification(*names); end
def get_param(number); end
def initialize(str, node_var = nil); end
def insure_same_captures(enum, what); end
def match_code; end
def next_capture; end
@@ -103,10 +107,11 @@
def run(node_var); end
def self.tokens(pattern); end
def substitute_cur_node(code, cur_node, first_cur_node: nil); end
def tokens; end
def tokens_until(stop, what); end
+ def unify_in_union(enum); end
def variadic_seq_term; end
def with_child_context(code, child_index); end
def with_context(code, cur_node, use_temp_node: nil); end
def with_seq_head_context(code); end
def with_temp_node(cur_node); end
@@ -160,10 +165,12 @@
def and_type?; end
def arg_expr_type?; end
def arg_type?; end
def args_type?; end
def argument?; end
+ def array_pattern_type?; end
+ def array_pattern_with_tail_type?; end
def array_type?; end
def assignment?; end
def assignment_or_similar?(node = nil); end
def back_ref_type?; end
def basic_conditional?; end
@@ -172,13 +179,15 @@
def begin_value_used?; end
def block_pass_type?; end
def block_type?; end
def blockarg_expr_type?; end
def blockarg_type?; end
+ def boolean_type?; end
def break_type?; end
def call_type?; end
def case_if_value_used?; end
+ def case_match_type?; end
def case_type?; end
def casgn_type?; end
def cbase_type?; end
def chained?; end
def child_nodes; end
@@ -187,10 +196,11 @@
def complete!; end
def complete?; end
def complex_type?; end
def conditional?; end
def const_name; end
+ def const_pattern_type?; end
def const_type?; end
def csend_type?; end
def cvar_type?; end
def cvasgn_type?; end
def def_type?; end
@@ -215,18 +225,24 @@
def falsey_literal?; end
def first_line; end
def float_type?; end
def for_type?; end
def for_value_used?; end
+ def forward_args_type?; end
+ def forwarded_args_type?; end
def guard_clause?(node = nil); end
def gvar_type?; end
def gvasgn_type?; end
+ def hash_pattern_type?; end
def hash_type?; end
def ident_type?; end
+ def if_guard_type?; end
def if_type?; end
def iflipflop_type?; end
def immutable_literal?; end
+ def in_match_type?; end
+ def in_pattern_type?; end
def index_type?; end
def indexasgn_type?; end
def initialize(type, children = nil, properties = nil); end
def int_type?; end
def irange_type?; end
@@ -246,13 +262,18 @@
def line_count; end
def literal?; end
def lvar_type?; end
def lvasgn_type?; end
def masgn_type?; end
+ def match_alt_type?; end
+ def match_as_type?; end
def match_current_line_type?; end
+ def match_nil_pattern_type?; end
+ def match_rest_type?; end
+ def match_var_type?; end
def match_with_lvasgn_type?; end
- def meth_ref_type?; end
+ def match_with_trailing_comma_type?; end
def mlhs_type?; end
def module_type?; end
def multiline?; end
def mutable_literal?; end
def new_class_or_module_block?(node = nil); end
@@ -263,11 +284,10 @@
def not_type?; end
def nth_ref_type?; end
def numargs_type?; end
def numblock_type?; end
def numeric_type?; end
- def numparam_type?; end
def objc_kwarg_type?; end
def objc_restarg_type?; end
def objc_varargs_type?; end
def op_asgn_type?; end
def operator_keyword?; end
@@ -280,10 +300,11 @@
def parent_module_name; end
def parent_module_name_for_block(ancestor); end
def parent_module_name_for_sclass(sclass_node); end
def parent_module_name_part(node); end
def parenthesized_call?; end
+ def pin_type?; end
def postexe_type?; end
def preexe_type?; end
def proc?(node = nil); end
def procarg0_type?; end
def pure?; end
@@ -320,10 +341,11 @@
def super_type?; end
def sym_type?; end
def true_type?; end
def truthy_literal?; end
def undef_type?; end
+ def unless_guard_type?; end
def until_post_type?; end
def until_type?; end
def updated(type = nil, children = nil, properties = nil); end
def value_used?; end
def variable?; end
@@ -372,10 +394,11 @@
def append(*args, &block); end
def assoc(*args, &block); end
def at(*args, &block); end
def bsearch(*args, &block); end
def bsearch_index(*args, &block); end
+ def chain(*args, &block); end
def chunk(*args, &block); end
def chunk_while(*args, &block); end
def clear(*args, &block); end
def collect!(*args, &block); end
def collect(*args, &block); end
@@ -388,10 +411,11 @@
def cycle(*args, &block); end
def delete(*args, &block); end
def delete_at(*args, &block); end
def delete_if(*args, &block); end
def detect(*args, &block); end
+ def difference(*args, &block); end
def dig(*args, &block); end
def drop(*args, &block); end
def drop_while(*args, &block); end
def each(*args, &block); end
def each_cons(*args, &block); end
@@ -400,12 +424,15 @@
def each_slice(*args, &block); end
def each_with_index(*args, &block); end
def each_with_object(*args, &block); end
def empty?(*args, &block); end
def entries(*args, &block); end
+ def extract_options!(*args, &block); end
def fetch(*args, &block); end
def fill(*args, &block); end
+ def filter!(*args, &block); end
+ def filter(*args, &block); end
def find(*args, &block); end
def find_all(*args, &block); end
def find_index(*args, &block); end
def first(*args, &block); end
def flat_map(*args, &block); end
@@ -476,10 +503,11 @@
def take_while(*args, &block); end
def to_ary(*args, &block); end
def to_h(*args, &block); end
def to_set(*args, &block); end
def transpose(*args, &block); end
+ def union(*args, &block); end
def uniq!(*args, &block); end
def uniq(*args, &block); end
def unshift(*args, &block); end
def values_at(*args, &block); end
def zip(*args, &block); end
@@ -601,10 +629,11 @@
def multiline?; end
def opening_delimiter; end
def send_node; end
def single_line?; end
def void_context?; end
+ include RuboCop::AST::MethodIdentifierPredicates
end
class RuboCop::AST::BreakNode < RuboCop::AST::Node
def arguments; end
include RuboCop::AST::MethodDispatchNode
include RuboCop::AST::ParameterizedNode
@@ -621,10 +650,11 @@
def body; end
def identifier; end
def parent_class; end
end
class RuboCop::AST::DefNode < RuboCop::AST::Node
+ def argument_forwarding?; end
def arguments; end
def body; end
def method_name; end
def node_parts; end
def receiver; end
@@ -646,10 +676,14 @@
def do?; end
def keyword; end
def variable; end
def void_context?; end
end
+class RuboCop::AST::ForwardArgsNode < RuboCop::AST::Node
+ def to_a; end
+ include RuboCop::AST::CollectionNode
+end
class RuboCop::AST::FloatNode < RuboCop::AST::Node
include RuboCop::AST::NumericNode
end
class RuboCop::AST::HashNode < RuboCop::AST::Node
def braces?; end
@@ -726,10 +760,15 @@
class RuboCop::AST::RetryNode < RuboCop::AST::Node
def arguments; end
include RuboCop::AST::MethodDispatchNode
include RuboCop::AST::ParameterizedNode
end
+class RuboCop::AST::ReturnNode < RuboCop::AST::Node
+ def arguments; end
+ include RuboCop::AST::MethodDispatchNode
+ include RuboCop::AST::ParameterizedNode
+end
class RuboCop::AST::SelfClassNode < RuboCop::AST::Node
def body; end
def identifier; end
end
class RuboCop::AST::SendNode < RuboCop::AST::Node
@@ -785,22 +824,26 @@
def on_and_asgn(node); end
def on_arg(node); end
def on_arg_expr(node); end
def on_args(node); end
def on_array(node); end
+ def on_array_pattern(node); end
+ def on_array_pattern_with_tail(node); end
def on_back_ref(node); end
def on_begin(node); end
def on_block(node); end
def on_block_pass(node); end
def on_blockarg(node); end
def on_break(node); end
def on_case(node); end
+ def on_case_match(node); end
def on_casgn(node); end
def on_cbase(node); end
def on_class(node); end
def on_complex(node); end
def on_const(node); end
+ def on_const_pattern(node); end
def on_csend(node); end
def on_cvar(node); end
def on_cvasgn(node); end
def on_def(node); end
def on_defined?(node); end
@@ -811,15 +854,21 @@
def on_ensure(node); end
def on_erange(node); end
def on_false(node); end
def on_float(node); end
def on_for(node); end
+ def on_forward_args(node); end
+ def on_forwarded_args(node); end
def on_gvar(node); end
def on_gvasgn(node); end
def on_hash(node); end
+ def on_hash_pattern(node); end
def on_if(node); end
+ def on_if_guard(node); end
def on_iflipflop(node); end
+ def on_in_match(node); end
+ def on_in_pattern(node); end
def on_int(node); end
def on_irange(node); end
def on_ivar(node); end
def on_ivasgn(node); end
def on_kwarg(node); end
@@ -829,23 +878,31 @@
def on_kwsplat(node); end
def on_lambda(node); end
def on_lvar(node); end
def on_lvasgn(node); end
def on_masgn(node); end
+ def on_match_alt(node); end
+ def on_match_as(node); end
def on_match_current_line(node); end
+ def on_match_nil_pattern(node); end
+ def on_match_rest(node); end
+ def on_match_var(node); end
def on_match_with_lvasgn(node); end
+ def on_match_with_trailing_comma(node); end
def on_mlhs(node); end
def on_module(node); end
def on_next(node); end
def on_nil(node); end
def on_not(node); end
def on_nth_ref(node); end
+ def on_numblock(node); end
def on_op_asgn(node); end
def on_optarg(node); end
def on_or(node); end
def on_or_asgn(node); end
def on_pair(node); end
+ def on_pin(node); end
def on_postexe(node); end
def on_preexe(node); end
def on_rational(node); end
def on_redo(node); end
def on_regexp(node); end
@@ -863,10 +920,11 @@
def on_str(node); end
def on_super(node); end
def on_sym(node); end
def on_true(node); end
def on_undef(node); end
+ def on_unless_guard(node); end
def on_until(node); end
def on_until_post(node); end
def on_when(node); end
def on_while(node); end
def on_while_post(node); end
@@ -930,10 +988,11 @@
def ==(other); end
def column; end
def column_length; end
def column_range; end
def cop_name; end
+ def correctable?; end
def corrected?; end
def corrected_with_todo?; end
def disabled?; end
def eql?(other); end
def first_line; end
@@ -986,10 +1045,11 @@
def disable_offense_before_and_after(range_by_lines); end
def disable_uncorrectable?; end
def max_line_length; end
def range_by_lines(range); end
def range_of_first_line(range); end
+ def safe_autocorrect?; end
def support_autocorrect?; end
end
class RuboCop::Cop::Badge
def ==(other); end
def cop_name; end
@@ -1051,12 +1111,15 @@
def default_severity; end
def disable_uncorrectable(node); end
def duplicate_location?(location); end
def enabled_line?(line_number); end
def excluded_file?(file); end
+ def external_dependency_checksum; end
def file_name_matches_any?(file, parameter, default_result); end
def find_location(node, loc); end
+ def find_message(node, message); end
+ def find_severity(_node, severity); end
def initialize(config = nil, options = nil); end
def join_force?(_force_class); end
def message(_node = nil); end
def name; end
def offenses; end
@@ -1108,22 +1171,26 @@
def on_and_asgn(node); end
def on_arg(node); end
def on_arg_expr(node); end
def on_args(node); end
def on_array(node); end
+ def on_array_pattern(node); end
+ def on_array_pattern_with_tail(node); end
def on_back_ref(node); end
def on_begin(node); end
def on_block(node); end
def on_block_pass(node); end
def on_blockarg(node); end
def on_break(node); end
def on_case(node); end
+ def on_case_match(node); end
def on_casgn(node); end
def on_cbase(node); end
def on_class(node); end
def on_complex(node); end
def on_const(node); end
+ def on_const_pattern(node); end
def on_csend(node); end
def on_cvar(node); end
def on_cvasgn(node); end
def on_def(node); end
def on_defined?(node); end
@@ -1134,15 +1201,21 @@
def on_ensure(node); end
def on_erange(node); end
def on_false(node); end
def on_float(node); end
def on_for(node); end
+ def on_forward_args(node); end
+ def on_forwarded_args(node); end
def on_gvar(node); end
def on_gvasgn(node); end
def on_hash(node); end
+ def on_hash_pattern(node); end
def on_if(node); end
+ def on_if_guard(node); end
def on_iflipflop(node); end
+ def on_in_match(node); end
+ def on_in_pattern(node); end
def on_int(node); end
def on_irange(node); end
def on_ivar(node); end
def on_ivasgn(node); end
def on_kwarg(node); end
@@ -1152,23 +1225,31 @@
def on_kwsplat(node); end
def on_lambda(node); end
def on_lvar(node); end
def on_lvasgn(node); end
def on_masgn(node); end
+ def on_match_alt(node); end
+ def on_match_as(node); end
def on_match_current_line(node); end
+ def on_match_nil_pattern(node); end
+ def on_match_rest(node); end
+ def on_match_var(node); end
def on_match_with_lvasgn(node); end
+ def on_match_with_trailing_comma(node); end
def on_mlhs(node); end
def on_module(node); end
def on_next(node); end
def on_nil(node); end
def on_not(node); end
def on_nth_ref(node); end
+ def on_numblock(node); end
def on_op_asgn(node); end
def on_optarg(node); end
def on_or(node); end
def on_or_asgn(node); end
def on_pair(node); end
+ def on_pin(node); end
def on_postexe(node); end
def on_preexe(node); end
def on_rational(node); end
def on_redo(node); end
def on_regexp(node); end
@@ -1186,10 +1267,11 @@
def on_str(node); end
def on_super(node); end
def on_sym(node); end
def on_true(node); end
def on_undef(node); end
+ def on_unless_guard(node); end
def on_until(node); end
def on_until_post(node); end
def on_when(node); end
def on_while(node); end
def on_while_post(node); end
@@ -1198,10 +1280,12 @@
def on_zsuper(node); end
def prepare(processed_source); end
def remove_irrelevant_cops(filename); end
def reset_callbacks; end
def reset_errors; end
+ def support_target_rails_version?(cop); end
+ def support_target_ruby_version?(cop); end
def trigger_responding_cops(callback, node); end
def with_cop_error_handling(cop, node = nil); end
include RuboCop::AST::Traversal
end
class RuboCop::Cop::Corrector
@@ -1314,10 +1398,11 @@
def process_zero_arity_super(node); end
def regexp_captured_names(node); end
def scanned_node?(node); end
def scanned_nodes; end
def skip_children!; end
+ def twisted_nodes(node); end
def variable_table; end
end
class RuboCop::Cop::VariableForce::VariableReference < Struct
def assignment?; end
def name; end
@@ -1606,10 +1691,11 @@
def detected_style=(style); end
def no_acceptable_style!; end
def no_acceptable_style?; end
def opposite_style_detected; end
def style; end
+ def style_configured?; end
def style_detected(detected); end
def style_parameter_name; end
def supported_styles; end
def unexpected_style_detected(unexpected); end
def unrecognized_style_detected; end
@@ -1715,45 +1801,95 @@
def last_by_line(nodes); end
def method_uses_parens?(node, limit); end
end
module RuboCop::Cop::FrozenStringLiteral
def frozen_string_literal_comment_exists?; end
+ def frozen_string_literal_specified?; end
def frozen_string_literals_enabled?; end
def leading_comment_lines; end
def self.frozen_string_literal_comment_exists?; end
end
-module RuboCop::Cop::HashAlignment
+module RuboCop::Cop::HashAlignmentStyles
end
-class RuboCop::Cop::HashAlignment::KeyAlignment
+class RuboCop::Cop::HashAlignmentStyles::KeyAlignment
def checkable_layout?(_node); end
def deltas(first_pair, current_pair); end
def deltas_for_first_pair(first_pair, _node); end
def separator_delta(pair); end
def value_delta(pair); end
end
-module RuboCop::Cop::HashAlignment::ValueAlignment
+module RuboCop::Cop::HashAlignmentStyles::ValueAlignment
def checkable_layout?(node); end
def deltas(first_pair, current_pair); end
def separator_delta(first_pair, current_pair, key_delta); end
end
-class RuboCop::Cop::HashAlignment::TableAlignment
+class RuboCop::Cop::HashAlignmentStyles::TableAlignment
def deltas_for_first_pair(first_pair, node); end
def hash_rocket_delta(first_pair, current_pair); end
def initialize; end
def key_delta(first_pair, current_pair); end
def max_key_width; end
def max_key_width=(arg0); end
def value_delta(first_pair, current_pair); end
- include RuboCop::Cop::HashAlignment::ValueAlignment
+ include RuboCop::Cop::HashAlignmentStyles::ValueAlignment
end
-class RuboCop::Cop::HashAlignment::SeparatorAlignment
+class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment
def deltas_for_first_pair(*_nodes); end
def hash_rocket_delta(first_pair, current_pair); end
def key_delta(first_pair, current_pair); end
def value_delta(first_pair, current_pair); end
- include RuboCop::Cop::HashAlignment::ValueAlignment
+ include RuboCop::Cop::HashAlignmentStyles::ValueAlignment
end
+module RuboCop::Cop::HashTransformMethod
+ def autocorrect(node); end
+ def execute_correction(corrector, node, correction); end
+ def extract_captures(_match); end
+ def handle_possible_offense(node, match, match_desc); end
+ def new_method_name; end
+ def on_bad_each_with_object(_node); end
+ def on_bad_hash_brackets_map(_node); end
+ def on_bad_map_to_h(_node); end
+ def on_block(node); end
+ def on_csend(node); end
+ def on_send(node); end
+ def prepare_correction(node); end
+end
+class RuboCop::Cop::HashTransformMethod::Captures < Struct
+ def noop_transformation?; end
+ def self.[](*arg0); end
+ def self.inspect; end
+ def self.members; end
+ def self.new(*arg0); end
+ def transformation_uses_both_args?; end
+ def transformed_argname; end
+ def transformed_argname=(_); end
+ def transforming_body_expr; end
+ def transforming_body_expr=(_); end
+ def unchanged_body_expr; end
+ def unchanged_body_expr=(_); end
+end
+class RuboCop::Cop::HashTransformMethod::Autocorrection < Struct
+ def block_node; end
+ def block_node=(_); end
+ def leading; end
+ def leading=(_); end
+ def match; end
+ def match=(_); end
+ def self.[](*arg0); end
+ def self.from_each_with_object(node, match); end
+ def self.from_hash_brackets_map(node, match); end
+ def self.from_map_to_h(node, match); end
+ def self.inspect; end
+ def self.members; end
+ def self.new(*arg0); end
+ def set_new_arg_name(transformed_argname, corrector); end
+ def set_new_body_expression(transforming_body_expr, corrector); end
+ def set_new_method_name(new_method_name, corrector); end
+ def strip_prefix_and_suffix(node, corrector); end
+ def trailing; end
+ def trailing=(_); end
+end
module RuboCop::Cop::IgnoredPattern
def ignored_line?(line); end
def ignored_patterns; end
def matches_ignored_pattern?(line); end
end
@@ -1769,10 +1905,24 @@
def on_dsym(node); end
def on_node_with_interpolations(node); end
def on_regexp(node); end
def on_xstr(node); end
end
+module RuboCop::Cop::LineLengthHelp
+ def allow_uri?; end
+ def allowed_uri_position?(line, uri_range); end
+ def directive_on_source_line?(line_index); end
+ def find_excessive_uri_range(line); end
+ def ignore_cop_directives?; end
+ def indentation_difference(line); end
+ def line_length(line); end
+ def line_length_without_directive(line); end
+ def match_uris(string); end
+ def tab_indentation_width; end
+ def uri_regexp; end
+ def valid_uri?(uri_ish_string); end
+end
module RuboCop::Cop::MatchRange
def each_match_range(range, regex); end
def match_range(range, match); end
include RuboCop::Cop::RangeHelp
end
@@ -1864,13 +2014,13 @@
def on_heredoc(_node); end
def on_str(node); end
def on_xstr(node); end
end
module RuboCop::Cop::NilMethods
+ def allowed_methods; end
def nil_methods; end
def other_stdlib_methods; end
- def whitelist; end
end
module RuboCop::Cop::OnNormalIfUnless
def on_if(node); end
end
module RuboCop::Cop::OrderedGemNode
@@ -1934,10 +2084,14 @@
def initialize(type, config, preferred_delimiters); end
def preferred_delimiters; end
def preferred_delimiters_config; end
def type; end
end
+module RuboCop::Cop::RationalLiteral
+ def rational_literal?(node = nil); end
+ extend RuboCop::NodePattern::Macros
+end
module RuboCop::Cop::RescueNode
def investigate(processed_source); end
def rescue_modifier?(node); end
end
module RuboCop::Cop::SafeAssignment
@@ -1945,15 +2099,10 @@
def safe_assignment?(node = nil); end
def safe_assignment_allowed?; end
def setter_method?(node = nil); end
extend RuboCop::NodePattern::Macros
end
-module RuboCop::Cop::SafeMode
- def rails?; end
- def rails_safe_mode?; end
- def safe_mode?; end
-end
module RuboCop::Cop::SpaceAfterPunctuation
def allowed_type?(token); end
def each_missing_space(tokens); end
def investigate(processed_source); end
def offset; end
@@ -2025,26 +2174,26 @@
end
module RuboCop::Cop::TrailingComma
def allowed_multiline_argument?(node); end
def any_heredoc?(items); end
def autocorrect_range(item); end
- def avoid_autocorrect?(_nodes); end
def avoid_comma(kind, comma_begin_pos, extra_info); end
def brackets?(node); end
def check(node, items, kind, begin_pos, end_pos); end
def check_comma(node, kind, comma_pos); end
def check_literal(node, kind); end
+ def comma_offset(items, range); end
def elements(node); end
def extra_avoid_comma_info; end
def heredoc?(node); end
def heredoc_send?(node); end
def inside_comment?(range, comma_offset); end
def method_name_and_arguments_on_same_line?(node); end
def multiline?(node); end
def no_elements_on_same_line?(node); end
def on_same_line?(range1, range2); end
- def put_comma(node, items, kind); end
+ def put_comma(items, kind); end
def should_have_comma?(style, node); end
def style_parameter_name; end
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
@@ -2086,11 +2235,11 @@
def annotated?; end
def arity; end
def begin_pos; end
def end_pos; end
def flags; end
- def initialize(string, **opts); end
+ def initialize(match); end
def max_digit_dollar_num; end
def name; end
def percent?; end
def precision; end
def style; end
@@ -2102,10 +2251,12 @@
end
class RuboCop::Cop::Migration::DepartmentName < RuboCop::Cop::Cop
def autocorrect(range); end
def check_cop_name(name, comment, offset); end
def investigate(processed_source); end
+ def qualified_legacy_cop_name(cop_name); end
+ def valid_content_token?(content_token); end
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::AlignmentCorrector
def self.align_end(processed_source, node, align_to); end
def self.alignment_column(align_to); end
@@ -2270,15 +2421,15 @@
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Bundler::GemComment < RuboCop::Cop::Cop
def commented?(node); end
def gem_declaration?(node = nil); end
+ 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 whitelisted_gem?(node); end
include RuboCop::Cop::DefNode
end
class RuboCop::Cop::Bundler::InsecureProtocolSource < RuboCop::Cop::Cop
def autocorrect(node); end
def insecure_protocol_source?(node = nil); end
@@ -2340,61 +2491,31 @@
def unexpected_indent_offset; end
include RuboCop::Cop::Alignment
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::AlignArguments < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::ArgumentAlignment < RuboCop::Cop::Cop
def autocorrect(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
include RuboCop::Cop::Alignment
end
-class RuboCop::Cop::Layout::AlignArray < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::ArrayAlignment < RuboCop::Cop::Cop
def autocorrect(node); end
def on_array(node); end
include RuboCop::Cop::Alignment
end
-class RuboCop::Cop::Layout::AlignHash < RuboCop::Cop::Cop
- def add_offences; end
- def adjust(corrector, delta, range); end
- def alignment_for(pair); end
- def alignment_for_colons; end
- def alignment_for_hash_rockets; end
+class RuboCop::Cop::Layout::AssignmentIndentation < RuboCop::Cop::Cop
def autocorrect(node); end
- def check_delta(delta, node:, alignment:); end
- def check_pairs(node); end
- def column_deltas; end
- def column_deltas=(arg0); end
- def correct_key_value(delta, key, value, separator); end
- def correct_no_value(key_delta, key); end
- def correct_node(node, delta); end
- def double_splat?(node); end
- def good_alignment?(column_deltas); end
- def ignore_hash_argument?(node); end
- def new_alignment(key); end
- def offences_by; end
- def offences_by=(arg0); end
- def on_hash(node); end
- def on_send(node); end
- def on_super(node); end
- def on_yield(node); end
- include RuboCop::Cop::HashAlignment
- include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Layout::AlignParameters < RuboCop::Cop::Cop
- def autocorrect(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
+ def check_assignment(node, rhs); end
+ def leftmost_multiple_assignment(node); end
include RuboCop::Cop::Alignment
+ include RuboCop::Cop::CheckAssignment
end
class RuboCop::Cop::Layout::BlockAlignment < RuboCop::Cop::Cop
def add_space_before(loc, delta); end
def alt_start_msg(start_loc, source_line_column); end
def autocorrect(node); end
@@ -2504,11 +2625,11 @@
def investigate(processed_source); end
def less_indented?(line); end
def line_after_comment(comment); end
def message(column, correct_comment_indentation); end
def own_line_comment?(comment); end
- def should_correct?(comment, column, line_no); end
+ def should_correct?(preceding_comment, reference_comment); end
def two_alternatives?(line); end
include RuboCop::Cop::Alignment
end
class RuboCop::Cop::Layout::ConditionPosition < RuboCop::Cop::Cop
def check(node); end
@@ -2556,11 +2677,11 @@
def allow_border_comment?; end
def allow_margin_comment?; end
def autocorrect(node); end
def comment_text(comment); end
def concat_consecutive_comments(comments); end
- def current_token(node); end
+ def current_token(comment); end
def empty_comment_only?(comment_text); end
def investigate(processed_source); end
def previous_token(node); end
include RuboCop::Cop::RangeHelp
end
@@ -2710,10 +2831,11 @@
include RuboCop::Cop::EndKeywordAlignment
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Layout::EndOfLine < RuboCop::Cop::Cop
def investigate(processed_source); end
+ def last_line(processed_source); end
def offense_message(line); end
def unimportant_missing_cr?(index, last_line, line); end
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
@@ -2738,16 +2860,62 @@
def ignored_ranges(ast); end
def investigate(processed_source); end
include RuboCop::Cop::PrecedingFollowingAlignment
include RuboCop::Cop::RangeHelp
end
+class RuboCop::Cop::Layout::FirstArgumentIndentation < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def base_indentation(node); end
+ def base_range(send_node, arg_node); end
+ def column_of(range); end
+ def comment_lines; end
+ def eligible_method_call?(node = nil); end
+ def message(arg_node); end
+ def on_csend(node); end
+ def on_send(node); end
+ def previous_code_line(line_number); end
+ def special_inner_call_indentation?(node); end
+ 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
+ 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 on_array(node); end
+ def on_csend(node); end
+ def on_send(node); end
+ include RuboCop::Cop::Alignment
+ include RuboCop::Cop::ConfigurableEnforcedStyle
+ include RuboCop::Cop::MultilineElementIndentation
+end
class RuboCop::Cop::Layout::FirstArrayElementLineBreak < RuboCop::Cop::Cop
def assignment_on_same_line?(node); end
def autocorrect(node); end
def on_array(node); end
include RuboCop::Cop::FirstElementLineBreak
end
+class RuboCop::Cop::Layout::FirstHashElementIndentation < RuboCop::Cop::Cop
+ def autocorrect(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 on_csend(node); end
+ def on_hash(node); end
+ def on_send(node); end
+ def separator_style?(first_pair); end
+ include RuboCop::Cop::Alignment
+ include RuboCop::Cop::ConfigurableEnforcedStyle
+ include RuboCop::Cop::MultilineElementIndentation
+end
class RuboCop::Cop::Layout::FirstHashElementLineBreak < RuboCop::Cop::Cop
def autocorrect(node); end
def on_hash(node); end
include RuboCop::Cop::FirstElementLineBreak
end
@@ -2762,10 +2930,50 @@
def autocorrect(node); end
def on_def(node); end
def on_defs(node); end
include RuboCop::Cop::FirstElementLineBreak
end
+class RuboCop::Cop::Layout::FirstParameterIndentation < RuboCop::Cop::Cop
+ def autocorrect(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
+ include RuboCop::Cop::Alignment
+ include RuboCop::Cop::ConfigurableEnforcedStyle
+ include RuboCop::Cop::MultilineElementIndentation
+end
+class RuboCop::Cop::Layout::HashAlignment < RuboCop::Cop::Cop
+ def add_offences; end
+ def adjust(corrector, delta, range); end
+ def alignment_for(pair); end
+ def alignment_for_colons; end
+ def alignment_for_hash_rockets; end
+ def autocorrect(node); end
+ def check_delta(delta, node:, alignment:); end
+ def check_pairs(node); end
+ def column_deltas; end
+ def column_deltas=(arg0); end
+ def correct_key_value(delta, key, value, separator); end
+ def correct_no_value(key_delta, key); end
+ def correct_node(node, delta); end
+ def double_splat?(node); end
+ def good_alignment?(column_deltas); end
+ def ignore_hash_argument?(node); end
+ def new_alignment(key); end
+ def offences_by; end
+ def offences_by=(arg0); end
+ def on_hash(node); end
+ def on_send(node); end
+ def on_super(node); end
+ def on_yield(node); end
+ def reset!; end
+ include RuboCop::Cop::HashAlignmentStyles
+ include RuboCop::Cop::RangeHelp
+end
class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < RuboCop::Cop::Cop
def add_correct_closing_paren(node, corrector); end
def add_correct_external_trailing_comma(node, corrector); end
def autocorrect(node); end
def external_trailing_comma?(node); end
@@ -2789,16 +2997,37 @@
def send_missing_closing_parens?(parent, child, heredoc); end
def single_line_send_with_heredoc_receiver?(node); end
def space?(pos); end
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::IndentAssignment < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::HeredocIndentation < RuboCop::Cop::Cop
+ def adjust_minus(corrector, node); end
+ def adjust_squiggly(corrector, node); end
def autocorrect(node); end
- def check_assignment(node, rhs); end
- def leftmost_multiple_assignment(node); end
- include RuboCop::Cop::Alignment
- include RuboCop::Cop::CheckAssignment
+ def base_indent_level(node); end
+ def check_style!; end
+ def correct_by_library(node); end
+ def correct_by_squiggly(node); end
+ def heredoc_body(node); end
+ def heredoc_end(node); end
+ def heredoc_indent_type(node); end
+ def indent_level(str); end
+ def indentation_width; end
+ def indented_body(node); end
+ def indented_end(node); end
+ def library_message(indentation_width, method); end
+ def line_too_long?(node); end
+ def longest_line(lines); end
+ def max_line_length; end
+ def message(node); end
+ def on_heredoc(node); end
+ def ruby23_message(indentation_width, current_indent_type); end
+ def ruby23_type_message(indentation_width, current_indent_type); end
+ def ruby23_width_message(indentation_width); end
+ def unlimited_heredoc_length?; end
+ include RuboCop::Cop::ConfigurableEnforcedStyle
+ include RuboCop::Cop::Heredoc
end
class RuboCop::Cop::Layout::IndentationConsistency < RuboCop::Cop::Cop
def autocorrect(node); end
def bare_access_modifier?(node); end
def base_column_for_normal_style(node); end
@@ -2855,117 +3084,72 @@
include RuboCop::Cop::CheckAssignment
include RuboCop::Cop::EndKeywordAlignment
include RuboCop::Cop::IgnoredPattern
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::IndentFirstArgument < RuboCop::Cop::Cop
- def autocorrect(node); end
- def base_indentation(node); end
- def base_range(send_node, arg_node); end
- def column_of(range); end
- def eligible_method_call?(node = nil); end
- def message(arg_node); end
- def on_csend(node); end
- def on_send(node); end
- def previous_code_line(line_number); end
- def special_inner_call_indentation?(node); end
- include RuboCop::Cop::Alignment
- include RuboCop::Cop::ConfigurableEnforcedStyle
- include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Layout::IndentFirstArrayElement < RuboCop::Cop::Cop
- def autocorrect(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 on_array(node); end
- def on_csend(node); end
- def on_send(node); end
- include RuboCop::Cop::Alignment
- include RuboCop::Cop::ConfigurableEnforcedStyle
- include RuboCop::Cop::MultilineElementIndentation
-end
-class RuboCop::Cop::Layout::IndentFirstHashElement < RuboCop::Cop::Cop
- def autocorrect(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 on_csend(node); end
- def on_hash(node); end
- def on_send(node); end
- def separator_style?(first_pair); end
- include RuboCop::Cop::Alignment
- include RuboCop::Cop::ConfigurableEnforcedStyle
- include RuboCop::Cop::MultilineElementIndentation
-end
-class RuboCop::Cop::Layout::IndentFirstParameter < RuboCop::Cop::Cop
- def autocorrect(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
- include RuboCop::Cop::Alignment
- include RuboCop::Cop::ConfigurableEnforcedStyle
- include RuboCop::Cop::MultilineElementIndentation
-end
-class RuboCop::Cop::Layout::IndentHeredoc < RuboCop::Cop::Cop
- def adjust_minus(corrector, node); end
- def adjust_squiggly(corrector, node); end
- def autocorrect(node); end
- def base_indent_level(node); end
- def check_style!; end
- def correct_by_library(node); end
- def correct_by_squiggly(node); end
- def heredoc_body(node); end
- def heredoc_end(node); end
- def heredoc_indent_type(node); end
- def indent_level(str); end
- def indentation_width; end
- def indented_body(node); end
- def indented_end(node); end
- def library_message(indentation_width, method); end
- def line_too_long?(node); end
- def longest_line(lines); end
- def max_line_length; end
- def message(node); end
- def on_heredoc(node); end
- def ruby23_message(indentation_width, current_indent_type); end
- def ruby23_type_message(indentation_width, current_indent_type); end
- def ruby23_width_message(indentation_width); end
- def unlimited_heredoc_length?; end
- include RuboCop::Cop::ConfigurableEnforcedStyle
- include RuboCop::Cop::Heredoc
-end
class RuboCop::Cop::Layout::InitialIndentation < RuboCop::Cop::Cop
def autocorrect(range); end
def first_token; end
def investigate(_processed_source); end
def space_before(token); end
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::LeadingBlankLines < RuboCop::Cop::Cop
- def autocorrect(node); end
- def investigate(processed_source); end
-end
class RuboCop::Cop::Layout::LeadingCommentSpace < RuboCop::Cop::Cop
def allow_doxygen_comment?; end
+ def allow_gemfile_ruby_comment?; end
def allowed_on_first_line?(comment); end
def autocorrect(comment); end
def doxygen_comment_style?(comment); end
+ def gemfile?; end
+ def gemfile_ruby_comment?(comment); end
def investigate(processed_source); end
def rackup_config_file?; end
def rackup_options?(comment); end
+ def ruby_comment_in_gemfile?(comment); end
def shebang?(comment); end
include RuboCop::Cop::RangeHelp
end
+class RuboCop::Cop::Layout::LeadingEmptyLines < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def investigate(processed_source); end
+end
+class RuboCop::Cop::Layout::LineLength < RuboCop::Cop::Cop
+ def allow_heredoc?; end
+ def allowed_heredoc; end
+ def autocorrect(range); end
+ def breakable_block_range(block_node); end
+ def breakable_range_after_semicolon(semicolon_token); end
+ def breakable_range_by_line_index; end
+ def check_directive_line(line, line_index); end
+ def check_for_breakable_block(block_node); end
+ def check_for_breakable_node(node); end
+ def check_for_breakable_semicolons(processed_source); end
+ def check_line(line, line_index); end
+ def check_uri_line(line, line_index); end
+ def excess_range(uri_range, line, line_index); end
+ def extract_heredocs(ast); end
+ def heredocs; end
+ def highlight_start(line); end
+ def ignored_line?(line, line_index); end
+ def investigate(processed_source); end
+ def investigate_post_walk(processed_source); end
+ def line_in_heredoc?(line_number); end
+ def line_in_permitted_heredoc?(line_number); end
+ def max; end
+ def on_array(node); end
+ def on_block(node); end
+ def on_hash(node); end
+ def on_potential_breakable_node(node); end
+ def on_send(node); end
+ def register_offense(loc, line, line_index); end
+ def shebang?(line, line_index); end
+ include RuboCop::Cop::CheckLineBreakable
+ include RuboCop::Cop::ConfigurableMax
+ include RuboCop::Cop::IgnoredPattern
+ include RuboCop::Cop::LineLengthHelp
+ include RuboCop::Cop::RangeHelp
+end
class RuboCop::Cop::Layout::MultilineArrayBraceLayout < RuboCop::Cop::Cop
def autocorrect(node); end
def on_array(node); end
include RuboCop::Cop::MultilineLiteralBraceLayout
end
@@ -2989,19 +3173,19 @@
def add_offense_for_expression(node, expr, msg); end
def args_on_beginning_line?(node); end
def autocorrect(node); end
def autocorrect_arguments(corrector, node); end
def autocorrect_body(corrector, node, block_body); end
- def block_arg_string(args); end
+ def block_arg_string(node, args); end
+ def include_trailing_comma?(args); end
def line_break_necessary_in_args?(node); end
def on_block(node); end
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Layout::MultilineHashBraceLayout < RuboCop::Cop::Cop
def autocorrect(node); end
def on_hash(node); end
- def self.autocorrect_incompatible_with; end
include RuboCop::Cop::MultilineLiteralBraceLayout
end
class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks < RuboCop::Cop::Cop
def autocorrect(node); end
def on_hash(node); end
@@ -3063,10 +3247,20 @@
def validate_config; end
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
+ 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
+ include RuboCop::Cop::Alignment
+end
class RuboCop::Cop::Layout::RescueEnsureAlignment < RuboCop::Cop::Cop
def access_modifier?(node); end
def access_modifier_node(node); end
def alignment_node(node); end
def alignment_source(node, starting_loc); end
@@ -3145,17 +3339,19 @@
include RuboCop::Cop::SurroundingSpace
end
class RuboCop::Cop::Layout::SpaceAroundKeyword < RuboCop::Cop::Cop
def accept_left_parenthesis?(range); end
def accept_left_square_bracket?(range); end
+ def accept_namespace_operator?(range); end
def accepted_opening_delimiter?(range, char); end
def autocorrect(range); end
def check(node, locations, begin_keyword = nil); end
def check_begin(node, range, begin_keyword); end
def check_end(node, range, begin_keyword); end
def check_keyword(node, range); end
def do?(node); end
+ def namespace_operator?(range, pos); end
def offense(range, msg); end
def on_and(node); end
def on_block(node); end
def on_break(node); end
def on_case(node); end
@@ -3212,17 +3408,22 @@
def on_send(node); end
def on_special_asgn(node); end
def operator_with_regular_syntax?(send_node); end
def regular_operator?(send_node); end
def self.autocorrect_incompatible_with; end
+ def should_not_have_surrounding_space?(operator); end
+ def space_around_exponent_operator?; end
include RuboCop::Cop::PrecedingFollowingAlignment
include RuboCop::Cop::RangeHelp
+ include RuboCop::Cop::RationalLiteral
end
class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < RuboCop::Cop::Cop
def autocorrect(range); end
+ def block_delimiters_style; end
def check_empty(left_brace, space_plus_brace, used_style); end
def check_non_empty(left_brace, space_plus_brace, used_style); end
+ def conflict_with_block_delimiters?(node); end
def empty_braces?(loc); end
def on_block(node); end
def self.autocorrect_incompatible_with; end
def space_detected(left_brace, space_plus_brace); end
def space_missing(left_brace); end
@@ -3240,10 +3441,11 @@
def investigate(processed_source); end
end
class RuboCop::Cop::Layout::SpaceBeforeFirstArg < RuboCop::Cop::Cop
def autocorrect(range); end
def expect_params_after_method_name?(node); end
+ def no_space_between_method_name_and_first_argument?(node); end
def on_csend(node); end
def on_send(node); end
def regular_method_call_with_arguments?(node); end
include RuboCop::Cop::PrecedingFollowingAlignment
include RuboCop::Cop::RangeHelp
@@ -3256,10 +3458,11 @@
class RuboCop::Cop::Layout::SpaceInLambdaLiteral < RuboCop::Cop::Cop
def arrow_lambda_with_args?(node); end
def autocorrect(lambda_node); end
def on_send(node); end
def range_of_offense(node); end
+ def space_after_arrow(lambda_node); end
def space_after_arrow?(lambda_node); end
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral < RuboCop::Cop::Cop
@@ -3271,10 +3474,11 @@
include RuboCop::Cop::PercentLiteral
end
class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < RuboCop::Cop::Cop
def array_brackets(node); end
def autocorrect(node); end
+ def compact(corrector, bracket, side); end
def compact_corrections(corrector, node, left, right); end
def compact_offense(node, token, side: nil); end
def compact_offenses(node, left, right, start_ok, end_ok); end
def empty_config; end
def end_has_own_line?(token); end
@@ -3336,10 +3540,11 @@
def can_be_ignored?(token1, token2); end
def each_extraneous_space(tokens); end
def each_missing_space(tokens); end
def investigate(processed_source); end
def parens?(token1, token2); end
+ def same_line?(token1, token2); end
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
include RuboCop::Cop::SurroundingSpace
end
class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters < RuboCop::Cop::Cop
@@ -3385,11 +3590,11 @@
def investigate(processed_source); end
def string_literal_ranges(ast); end
include RuboCop::Cop::Alignment
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Layout::TrailingBlankLines < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::TrailingEmptyLines < RuboCop::Cop::Cop
def autocorrect(range); end
def ends_in_end?(processed_source); end
def investigate(processed_source); end
def message(wanted_blank_lines, blank_lines); end
def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end); end
@@ -3479,10 +3684,14 @@
end
class RuboCop::Cop::Lint::DuplicateCaseCondition < RuboCop::Cop::Cop
def on_case(case_node); end
def repeated_condition?(previous, condition); end
end
+class RuboCop::Cop::Lint::DuplicateHashKey < RuboCop::Cop::Cop
+ def on_hash(node); end
+ include RuboCop::Cop::Duplication
+end
class RuboCop::Cop::Lint::DuplicateMethods < RuboCop::Cop::Cop
def alias_method?(node = nil); end
def attr?(node = nil); end
def check_const_receiver(node, name, const_name); end
def check_self_receiver(node, name); end
@@ -3501,14 +3710,10 @@
def possible_dsl?(node); end
def qualified_name(enclosing, namespace, mod_name); end
def source_location(node); end
def sym_name(node = nil); end
end
-class RuboCop::Cop::Lint::DuplicatedKey < RuboCop::Cop::Cop
- def on_hash(node); end
- include RuboCop::Cop::Duplication
-end
class RuboCop::Cop::Lint::EachWithObjectArgument < RuboCop::Cop::Cop
def each_with_object?(node = nil); end
def on_csend(node); end
def on_send(node); end
end
@@ -3575,14 +3780,10 @@
def on_send(node); end
def percent?(node); end
def splat_args?(node); end
def sprintf?(node); end
end
-class RuboCop::Cop::Lint::HandleExceptions < RuboCop::Cop::Cop
- def comment_lines?(node); end
- def on_resbody(node); end
-end
class RuboCop::Cop::Lint::HeredocMethodCallPosition < RuboCop::Cop::Cop
def all_on_same_line?(nodes); end
def autocorrect(node); end
def call_after_heredoc_range(heredoc); end
def call_end_pos(node); end
@@ -3672,11 +3873,11 @@
class RuboCop::Cop::Lint::MissingCopEnableDirective < RuboCop::Cop::Cop
def investigate(processed_source); end
def message(max_range:, cop:); end
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Lint::MultipleCompare < RuboCop::Cop::Cop
+class RuboCop::Cop::Lint::MultipleComparison < RuboCop::Cop::Cop
def autocorrect(node); end
def multiple_compare?(node = nil); end
def on_send(node); end
end
class RuboCop::Cop::Lint::NestedMethodDefinition < RuboCop::Cop::Cop
@@ -3697,10 +3898,19 @@
class RuboCop::Cop::Lint::NextWithoutAccumulator < RuboCop::Cop::Cop
def on_block(node); end
def on_body_of_reduce(node = nil); end
def parent_block_node(node); end
end
+class RuboCop::Cop::Lint::NonDeterministicRequireOrder < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def loop_variable(node = nil); end
+ def on_block(node); end
+ def unsorted_dir_block?(node = nil); end
+ def unsorted_dir_each?(node = nil); end
+ def unsorted_dir_loop?(node); end
+ def var_is_required?(node0, param1); end
+end
class RuboCop::Cop::Lint::NonLocalExitFromIterator < RuboCop::Cop::Cop
def chained_send?(node = nil); end
def define_method?(node = nil); end
def on_return(return_node); end
def return_value?(return_node); end
@@ -3746,10 +3956,74 @@
class RuboCop::Cop::Lint::RandOne < RuboCop::Cop::Cop
def message(node); end
def on_send(node); end
def rand_one?(node = nil); end
end
+class RuboCop::Cop::Lint::RedundantCopDisableDirective < RuboCop::Cop::Cop
+ def add_offense_for_entire_comment(comment, cops); end
+ def add_offense_for_some_cops(comment, cops); end
+ def add_offenses(redundant_cops); end
+ def all_cop_names; end
+ def all_disabled?(comment); end
+ def autocorrect(args); end
+ def check(offenses, cop_disabled_line_ranges, comments); end
+ def collect_variable_like_names(scope); end
+ def comment_range_with_surrounding_space(range); end
+ def cop_range(comment, cop); end
+ def describe(cop); end
+ def directive_count(comment); end
+ def directive_range_in_list(range, ranges); end
+ def each_already_disabled(line_ranges, disabled_ranges, comments); end
+ def each_line_range(line_ranges, disabled_ranges, offenses, comments, cop); end
+ def each_redundant_disable(cop_disabled_line_ranges, offenses, comments, &block); end
+ def ends_its_line?(range); end
+ def find_redundant(comment, offenses, cop, line_range, next_line_range); end
+ def ignore_offense?(disabled_ranges, line_range); end
+ def matching_range(haystack, needle); end
+ def trailing_range?(ranges, range); end
+ include RuboCop::Cop::RangeHelp
+ include RuboCop::NameSimilarity
+end
+class RuboCop::Cop::Lint::RedundantCopEnableDirective < RuboCop::Cop::Cop
+ def all_or_name(name); end
+ def autocorrect(comment_and_name); end
+ def comment_start(comment); end
+ def cop_name_indention(comment, name); end
+ def investigate(processed_source); end
+ def range_of_offense(comment, name); end
+ def range_to_remove(begin_pos, end_pos, comma_pos, comment); end
+ def range_with_comma(comment, name); end
+ include RuboCop::Cop::RangeHelp
+ include RuboCop::Cop::SurroundingSpace
+end
+class RuboCop::Cop::Lint::RedundantRequireStatement < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def on_send(node); end
+ def unnecessary_require_statement?(node = nil); end
+ include RuboCop::Cop::RangeHelp
+end
+class RuboCop::Cop::Lint::RedundantSplatExpansion < RuboCop::Cop::Cop
+ def array_new?(node = nil); end
+ def array_new_inside_array_literal?(array_new_node); end
+ def array_splat?(node); end
+ def autocorrect(node); end
+ def literal_expansion(node = nil); end
+ def method_argument?(node); end
+ def on_splat(node); end
+ def part_of_an_array?(node); end
+ def redundant_brackets?(node); end
+ def redundant_splat_expansion(node); end
+ def remove_brackets(array); end
+ def replacement_range_and_content(node); end
+end
+class RuboCop::Cop::Lint::RedundantStringCoercion < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def message(node); end
+ def on_interpolation(begin_node); end
+ def to_s_without_args?(node = nil); end
+ include RuboCop::Cop::Interpolation
+end
class RuboCop::Cop::Lint::RedundantWithIndex < RuboCop::Cop::Cop
def autocorrect(node); end
def message(node); end
def on_block(node); end
def redundant_with_index?(node = nil); end
@@ -3856,16 +4130,13 @@
end
class RuboCop::Cop::Lint::ShadowingOuterLocalVariable < RuboCop::Cop::Cop
def before_declaring_variable(variable, variable_table); end
def join_force?(force_class); end
end
-class RuboCop::Cop::Lint::StringConversionInInterpolation < RuboCop::Cop::Cop
- def autocorrect(node); end
- def message(node); end
- def on_interpolation(begin_node); end
- def to_s_without_args?(node = nil); end
- include RuboCop::Cop::Interpolation
+class RuboCop::Cop::Lint::SuppressedException < RuboCop::Cop::Cop
+ def comment_lines?(node); end
+ def on_resbody(node); end
end
class RuboCop::Cop::Lint::Syntax < RuboCop::Cop::Cop
def add_offense_from_diagnostic(diagnostic, ruby_version); end
def add_offense_from_error(error); end
def beautify_message(message); end
@@ -3900,67 +4171,10 @@
class RuboCop::Cop::Lint::UnifiedInteger < RuboCop::Cop::Cop
def autocorrect(node); end
def fixnum_or_bignum_const(node = nil); end
def on_const(node); end
end
-class RuboCop::Cop::Lint::UnneededCopDisableDirective < RuboCop::Cop::Cop
- def add_offense_for_entire_comment(comment, cops); end
- def add_offense_for_some_cops(comment, cops); end
- def add_offenses(unneeded_cops); end
- def all_cop_names; end
- def all_disabled?(comment); end
- def autocorrect(args); end
- def check(offenses, cop_disabled_line_ranges, comments); end
- def collect_variable_like_names(scope); end
- def comment_range_with_surrounding_space(range); end
- def cop_range(comment, cop); end
- def describe(cop); end
- def directive_count(comment); end
- def directive_range_in_list(range, ranges); end
- def each_already_disabled(line_ranges, disabled_ranges, comments); end
- def each_line_range(line_ranges, disabled_ranges, offenses, comments, cop); end
- def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments, &block); end
- def ends_its_line?(range); end
- def find_unneeded(comment, offenses, cop, line_range, next_line_range); end
- def ignore_offense?(disabled_ranges, line_range); end
- def matching_range(haystack, needle); end
- def trailing_range?(ranges, range); end
- include RuboCop::Cop::RangeHelp
- include RuboCop::NameSimilarity
-end
-class RuboCop::Cop::Lint::UnneededCopEnableDirective < RuboCop::Cop::Cop
- def all_or_name(name); end
- def autocorrect(comment_and_name); end
- def comment_start(comment); end
- def cop_name_indention(comment, name); end
- def investigate(processed_source); end
- def range_of_offense(comment, name); end
- def range_to_remove(begin_pos, end_pos, comma_pos, comment); end
- def range_with_comma(comment, name); end
- include RuboCop::Cop::RangeHelp
- include RuboCop::Cop::SurroundingSpace
-end
-class RuboCop::Cop::Lint::UnneededRequireStatement < RuboCop::Cop::Cop
- def autocorrect(node); end
- def on_send(node); end
- def unnecessary_require_statement?(node = nil); end
- include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Lint::UnneededSplatExpansion < RuboCop::Cop::Cop
- def array_new?(node = nil); end
- def array_new_inside_array_literal?(array_new_node); end
- def array_splat?(node); end
- def autocorrect(node); end
- def literal_expansion(node = nil); end
- def method_argument?(node); end
- def on_splat(node); end
- def part_of_an_array?(node); end
- def remove_brackets(array); end
- def replacement_range_and_content(node); end
- def unneeded_brackets?(node); end
- def unneeded_splat_expansion(node); end
-end
class RuboCop::Cop::Lint::UnreachableCode < RuboCop::Cop::Cop
def check_case(node); end
def check_if(node); end
def flow_command?(node = nil); end
def flow_expression?(node); end
@@ -4083,14 +4297,17 @@
include RuboCop::Cop::MethodComplexity
end
module RuboCop::Cop::Metrics::Utils
end
class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
+ def branch?(node); end
def calculate; end
+ def condition?(node); end
+ def else_branch?(node); end
def evaluate_branch_nodes(node); end
+ def evaluate_condition_node(node); end
def initialize(node); end
- def node_has_else_branch?(node); end
def self.calculate(node); end
end
class RuboCop::Cop::Metrics::AbcSize < RuboCop::Cop::Cop
def complexity(node); end
include RuboCop::Cop::MethodComplexity
@@ -4115,53 +4332,10 @@
def message(length, max_length); end
def on_casgn(node); end
def on_class(node); end
include RuboCop::Cop::ClassishLength
end
-class RuboCop::Cop::Metrics::LineLength < RuboCop::Cop::Cop
- def allow_heredoc?; end
- def allow_uri?; end
- def allowed_heredoc; end
- def allowed_uri_position?(line, uri_range); end
- def autocorrect(range); end
- def breakable_nodes_by_line_index; end
- def breakable_range(line, line_index); end
- def breakable_semicolon_range(line, line_index); end
- def check_directive_line(line, line_index); end
- def check_for_breakable_node(node); end
- def check_line(line, line_index); end
- def check_uri_line(line, line_index); end
- def directive_on_source_line?(line_index); end
- def excess_range(uri_range, line, line_index); end
- def extract_heredocs(ast); end
- def find_excessive_uri_range(line); end
- def heredocs; end
- def highlight_start(line); end
- def ignore_cop_directives?; end
- def ignored_line?(line, line_index); end
- def indentation_difference(line); end
- def investigate_post_walk(processed_source); end
- def line_in_heredoc?(line_number); end
- def line_in_permitted_heredoc?(line_number); end
- def line_length(line); end
- def line_length_without_directive(line); end
- def match_uris(string); end
- def max; end
- def on_array(node); end
- def on_hash(node); end
- def on_potential_breakable_node(node); end
- def on_send(node); end
- def register_offense(loc, line, line_index); end
- def shebang?(line, line_index); end
- def tab_indentation_width; end
- def uri_regexp; end
- def valid_uri?(uri_ish_string); end
- include RuboCop::Cop::CheckLineBreakable
- include RuboCop::Cop::ConfigurableMax
- include RuboCop::Cop::IgnoredPattern
- include RuboCop::Cop::RangeHelp
-end
class RuboCop::Cop::Metrics::MethodLength < RuboCop::Cop::Cop
def cop_label; end
def on_block(node); end
def on_def(node); end
def on_defs(node); end
@@ -4200,10 +4374,14 @@
def first_non_ascii_chars(string); end
def first_offense_range(identifier); end
def investigate(processed_source); end
include RuboCop::Cop::RangeHelp
end
+class RuboCop::Cop::Naming::BlockParameterName < RuboCop::Cop::Cop
+ def on_block(node); end
+ include RuboCop::Cop::UncommunicativeName
+end
class RuboCop::Cop::Naming::ClassAndModuleCamelCase < RuboCop::Cop::Cop
def on_class(node); end
def on_module(node); end
end
class RuboCop::Cop::Naming::ConstantName < RuboCop::Cop::Cop
@@ -4215,19 +4393,21 @@
def literal_receiver?(node = nil); end
def on_casgn(node); end
end
class RuboCop::Cop::Naming::FileName < RuboCop::Cop::Cop
def allowed_acronyms; end
+ def bad_filename_allowed?; end
def expect_matching_definition?; end
def filename_good?(basename); end
def find_class_or_module(node, namespace); end
def for_bad_filename(file_path); end
def ignore_executable_scripts?; end
def investigate(processed_source); end
def match?(expected); end
def match_acronym?(expected, name); end
def match_namespace(node, namespace, expected); end
+ def matching_definition?(file_path); end
def no_definition_message(basename, file_path); end
def other_message(basename); end
def partial_matcher!(expected); end
def regex; end
def to_module_name(basename); end
@@ -4241,11 +4421,11 @@
def on_heredoc(node); end
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::Heredoc
end
class RuboCop::Cop::Naming::HeredocDelimiterNaming < RuboCop::Cop::Cop
- def blacklisted_delimiters; end
+ def forbidden_delimiters; end
def meaningful_delimiters?(node); end
def on_heredoc(node); end
include RuboCop::Cop::Heredoc
end
class RuboCop::Cop::Naming::MemoizedInstanceVariableName < RuboCop::Cop::Cop
@@ -4265,45 +4445,41 @@
def on_def(node); end
def on_defs(node); end
include RuboCop::Cop::ConfigurableNaming
include RuboCop::Cop::IgnoredPattern
end
+class RuboCop::Cop::Naming::MethodParameterName < RuboCop::Cop::Cop
+ def on_def(node); end
+ def on_defs(node); end
+ include RuboCop::Cop::UncommunicativeName
+end
class RuboCop::Cop::Naming::BinaryOperatorParameterName < RuboCop::Cop::Cop
def on_def(node); end
def op_method?(name); end
def op_method_candidate?(node = nil); end
end
class RuboCop::Cop::Naming::PredicateName < RuboCop::Cop::Cop
def allowed_method_name?(method_name, prefix); end
+ def allowed_methods; end
def dynamic_method_define(node = nil); end
def expected_name(method_name, prefix); end
+ def forbidden_prefixes; end
def message(method_name, new_name); end
def method_definition_macros(macro_name); end
def on_def(node); end
def on_defs(node); end
def on_send(node); end
def predicate_prefixes; end
- def predicate_whitelist; end
- def prefix_blacklist; end
end
class RuboCop::Cop::Naming::RescuedExceptionsVariableName < RuboCop::Cop::Cop
def autocorrect(node); end
def message(node); end
def offense_range(resbody); end
def on_resbody(node); end
def preferred_name(variable_name); end
def variable_name(node); end
end
-class RuboCop::Cop::Naming::UncommunicativeBlockParamName < RuboCop::Cop::Cop
- def on_block(node); end
- include RuboCop::Cop::UncommunicativeName
-end
-class RuboCop::Cop::Naming::UncommunicativeMethodParamName < RuboCop::Cop::Cop
- def on_def(node); end
- def on_defs(node); end
- include RuboCop::Cop::UncommunicativeName
-end
class RuboCop::Cop::Naming::VariableName < RuboCop::Cop::Cop
def message(style); end
def on_arg(node); end
def on_blockarg(node); end
def on_cvasgn(node); end
@@ -4385,10 +4561,11 @@
def only_allowed_non_ascii_chars?(string); end
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::Attr < RuboCop::Cop::Cop
def autocorrect(node); end
+ def class_eval?(node = nil); end
def message(node); end
def on_send(node); end
def replacement_method(node); end
include RuboCop::Cop::RangeHelp
end
@@ -4419,10 +4596,13 @@
class RuboCop::Cop::Style::BlockDelimiters < RuboCop::Cop::Cop
def array_or_range?(node); end
def autocorrect(node); end
def braces_for_chaining_message(node); end
def braces_for_chaining_style?(node); end
+ def braces_required_message(node); end
+ def braces_required_method?(method_name); end
+ def braces_required_methods; end
def braces_style?(node); end
def conditional?(node); end
def correction_would_break_code?(node); end
def functional_block?(node); end
def functional_method?(method_name); end
@@ -4439,38 +4619,17 @@
def replace_do_end_with_braces(loc); end
def return_value_of_scope?(node); end
def return_value_used?(node); end
def semantic_block_style?(node); end
def semantic_message(node); end
+ def special_method?(method_name); end
+ def special_method_proper_block_style?(node); end
def whitespace_after?(range, length = nil); end
def whitespace_before?(range); end
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::IgnoredMethods
end
-class RuboCop::Cop::Style::BracesAroundHashParameters < RuboCop::Cop::Cop
- def add_arg_offense(arg, type); end
- def add_braces(corrector, node); end
- def autocorrect(send_node); end
- def braces_needed_for_semantics?(arg); end
- def check(arg, args); end
- def check_braces(arg); end
- def check_context_dependent(arg, args); end
- def check_no_braces(arg); end
- def extra_left_space?(hash_node); end
- def extra_right_space?(hash_node); end
- def extra_space(hash_node); end
- def left_brace_and_space(loc_begin, space); end
- def left_whole_line_range(loc_begin); end
- def on_csend(node); end
- def on_send(node); end
- def remove_braces_with_range(corrector, left_range, right_range); end
- def remove_braces_with_whitespace(corrector, node, space); end
- def right_brace_and_space(loc_end, space); end
- def right_whole_line_range(loc_end); end
- include RuboCop::Cop::ConfigurableEnforcedStyle
- include RuboCop::Cop::RangeHelp
-end
class RuboCop::Cop::Style::CaseEquality < RuboCop::Cop::Cop
def case_equality?(node = nil); end
def on_send(node); end
end
class RuboCop::Cop::Style::CharacterLiteral < RuboCop::Cop::Cop
@@ -4557,11 +4716,11 @@
def preferred_delimiter; end
def preferred_delimiters_config; end
include RuboCop::Cop::ConfigurableEnforcedStyle
end
class RuboCop::Cop::Style::CommentAnnotation < RuboCop::Cop::Cop
- def annotation_range(comment, margin, length); end
+ def annotation_range(comment, margin, first_word, colon, space); end
def autocorrect(comment); end
def concat_length(*args); end
def correct_annotation?(first_word, colon, space, note); end
def first_comment_line?(comments, index); end
def inline_comment?(comment); end
@@ -4674,10 +4833,11 @@
def insert_notice_before(processed_source); end
def investigate(processed_source); end
def notice; end
def notice_found?(processed_source); end
def shebang_token?(processed_source, token_index); end
+ def verify_autocorrect_notice!; end
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::DateTime < RuboCop::Cop::Cop
def date_time?(node = nil); end
def disallow_coercion?; end
@@ -4901,19 +5061,23 @@
def unannotated_format?(node, detected_style); end
include RuboCop::Cop::ConfigurableEnforcedStyle
end
class RuboCop::Cop::Style::FrozenStringLiteralComment < RuboCop::Cop::Cop
def autocorrect(node); end
- def check_for_comment(processed_source); end
- def check_for_no_comment(processed_source); end
+ def disabled_offense(processed_source); end
+ def enable_comment(corrector); end
+ def ensure_comment(processed_source); end
+ def ensure_enabled_comment(processed_source); end
+ def ensure_no_comment(processed_source); end
def following_comment; end
def frozen_string_literal_comment(processed_source); end
def insert_comment(corrector); end
def investigate(processed_source); end
def last_special_comment(processed_source); end
def line_range(line); end
- def offense(processed_source); end
+ def missing_offense(processed_source); end
+ def missing_true_offense(processed_source); end
def preceding_comment; end
def remove_comment(corrector, node); end
def unnecessary_comment_offense(processed_source); end
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::FrozenStringLiteral
@@ -4937,10 +5101,23 @@
def register_offense(node, scope_exiting_keyword, conditional_keyword); end
def too_long_for_single_line?(node, example); end
include RuboCop::Cop::MinBodyLength
include RuboCop::Cop::StatementModifier
end
+class RuboCop::Cop::Style::HashEachMethods < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def check_argument(variable); end
+ def correct_args(node, corrector); end
+ def correct_implicit(node, corrector, method_name); end
+ def correct_key_value_each(node, corrector); end
+ def kv_each(node = nil); end
+ def kv_range(outer_node); end
+ def on_block(node); end
+ def register_kv_offense(node); end
+ def used?(arg); end
+ include RuboCop::Cop::Lint::UnusedArgument
+end
class RuboCop::Cop::Style::HashSyntax < RuboCop::Cop::Cop
def acceptable_19_syntax_symbol?(sym_name); end
def alternative_style; end
def argument_without_space?(node); end
def autocorrect(node); end
@@ -4957,10 +5134,28 @@
def sym_indices?(pairs); end
def word_symbol_pair?(pair); end
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
+class RuboCop::Cop::Style::HashTransformKeys < RuboCop::Cop::Cop
+ def extract_captures(match); end
+ def new_method_name; end
+ def on_bad_each_with_object(node = nil); end
+ def on_bad_hash_brackets_map(node = nil); end
+ def on_bad_map_to_h(node = nil); end
+ extend RuboCop::Cop::TargetRubyVersion
+ include RuboCop::Cop::HashTransformMethod
+end
+class RuboCop::Cop::Style::HashTransformValues < RuboCop::Cop::Cop
+ def extract_captures(match); end
+ def new_method_name; end
+ def on_bad_each_with_object(node = nil); end
+ def on_bad_hash_brackets_map(node = nil); end
+ def on_bad_map_to_h(node = nil); end
+ extend RuboCop::Cop::TargetRubyVersion
+ include RuboCop::Cop::HashTransformMethod
+end
class RuboCop::Cop::Style::IdenticalConditionalBranches < RuboCop::Cop::Cop
def check_branches(branches); end
def check_expressions(expressions); end
def expand_elses(branch); end
def head(node); end
@@ -4976,17 +5171,24 @@
end
class RuboCop::Cop::Style::IfUnlessModifier < RuboCop::Cop::Cop
def autocorrect(node); end
def eligible_node?(node); end
def first_line_comment(node); end
+ def ignored_patterns; end
+ def line_length_enabled_at_line?(line); end
def named_capture_in_condition?(node); end
def non_eligible_if?(node); end
def on_if(node); end
def parenthesize?(node); end
def to_modifier_form(node); end
def to_normal_form(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
+ include RuboCop::Cop::IgnoredPattern
+ include RuboCop::Cop::LineLengthHelp
include RuboCop::Cop::StatementModifier
end
class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < RuboCop::Cop::Cop
def on_if(node); end
include RuboCop::Cop::StatementModifier
@@ -5019,10 +5221,11 @@
end
class RuboCop::Cop::Style::InverseMethods < RuboCop::Cop::Cop
def autocorrect(node); end
def camel_case_constant?(node); end
def correct_inverse_block(node); end
+ def correct_inverse_method(node); end
def correct_inverse_selector(block, corrector); end
def dot_range(loc); end
def end_parentheses(node, method_call); end
def inverse_block?(node = nil); end
def inverse_blocks; end
@@ -5039,17 +5242,17 @@
end
class RuboCop::Cop::Style::InlineComment < RuboCop::Cop::Cop
def investigate(processed_source); end
end
class RuboCop::Cop::Style::IpAddresses < RuboCop::Cop::Cop
+ def allowed_addresses; end
def correct_style_detected; end
def could_be_ip?(str); end
def offense?(node); end
def opposite_style_detected; end
def starts_with_hex_or_colon?(str); end
def too_long?(str); end
- def whitelist; end
include RuboCop::Cop::StringHelp
end
class RuboCop::Cop::Style::Lambda < RuboCop::Cop::Cop
def arguments_with_whitespace(node); end
def autocorrect(node); end
@@ -5078,10 +5281,11 @@
def check_token_set(index); end
def eligible_next_successor?(next_successor); end
def eligible_operator?(operator); end
def eligible_predecessor?(predecessor); end
def eligible_successor?(successor); end
+ def eligible_token_set?(predecessor, operator, successor); end
def investigate(processed_source); end
def self.autocorrect_incompatible_with; end
def standard_string_literal?(token); end
def token_after_last_string(successor, base_index); end
include RuboCop::Cop::RangeHelp
@@ -5094,34 +5298,34 @@
def same_name_assignment?(node); end
def variable_in_mass_assignment?(variable_name, node); end
include RuboCop::Cop::IgnoredMethods
end
class RuboCop::Cop::Style::MethodCallWithArgsParentheses < RuboCop::Cop::Cop
- def add_offense_for_omit_parentheses(node); end
- def add_offense_for_require_parentheses(node); end
+ def args_begin(node); end
+ def args_end(node); end
+ def args_parenthesized?(node); end
+ def autocorrect(_node); end
+ def initialize(*arg0); end
+ include RuboCop::Cop::ConfigurableEnforcedStyle
+ include RuboCop::Cop::IgnoredMethods
+ include RuboCop::Cop::IgnoredPattern
+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 ambigious_literal?(node); end
- def args_begin(node); end
- def args_end(node); end
- def args_parenthesized?(node); end
def assigned_before?(node, target); end
def autocorrect(node); end
- def autocorrect_for_omit_parentheses(node); end
- def autocorrect_for_require_parentheses(node); end
def call_as_argument_or_chain?(node); end
def call_in_literals?(node); end
def call_in_logical_operators?(node); end
def call_in_optional_arguments?(node); end
def call_with_ambiguous_arguments?(node); end
def call_with_braced_block?(node); end
- def eligible_for_parentheses_omission?(node); end
def hash_literal?(node); end
def hash_literal_in_arguments?(node); end
- def ignored_macro?(node); end
- def included_macros_list; end
def legitimate_call_with_parentheses?(node); end
def logical_operator?(node); end
def message(_node = nil); end
def on_csend(node); end
def on_send(node); end
@@ -5131,23 +5335,33 @@
def regexp_slash_literal?(node); end
def splat?(node); end
def super_call_without_arguments?(node); end
def ternary_if?(node); end
def unary_literal?(node); end
- include RuboCop::Cop::ConfigurableEnforcedStyle
- include RuboCop::Cop::IgnoredMethods
- include RuboCop::Cop::IgnoredPattern
end
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
+ def autocorrect(node); end
+ def eligible_for_parentheses_omission?(node); end
+ def ignored_macro?(node); end
+ def included_macros_list; end
+ def message(_node = nil); end
+ def on_csend(node); end
+ def on_send(node); end
+ def on_super(node); end
+ def on_yield(node); end
+end
class RuboCop::Cop::Style::MethodCalledOnDoEndBlock < RuboCop::Cop::Cop
def on_block(node); end
def on_csend(node); end
def on_send(node); end
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::MethodDefParentheses < RuboCop::Cop::Cop
def arguments_without_parentheses?(node); end
def autocorrect(node); end
+ def correct_arguments(arg_node, corrector); end
+ def correct_definition(def_node, corrector); end
def missing_parentheses(node); end
def on_def(node); end
def on_defs(node); end
def require_parentheses?(args); end
def unwanted_parentheses(args); end
@@ -5264,10 +5478,11 @@
end
class RuboCop::Cop::Style::MultilineTernaryOperator < RuboCop::Cop::Cop
def on_if(node); end
end
class RuboCop::Cop::Style::MultilineWhenThen < RuboCop::Cop::Cop
+ def accept_node_type?(node); end
def autocorrect(node); end
def on_when(node); end
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::MultipleComparison < RuboCop::Cop::Cop
@@ -5327,26 +5542,26 @@
def add_parentheses_to_method_arguments(send_node); end
def autocorrect(node); end
def check(node); end
def left_hand_operand(node, operator); end
def modifier?(node); end
- def new_expression(outer_node, inner_node); end
+ def new_expression(inner_node); end
def on_if(node); end
def on_until(node); end
def on_while(node); end
def replacement_operator(keyword); end
def requires_parens?(node); end
def right_hand_operand(node, left_hand_keyword); end
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::NestedParenthesizedCalls < RuboCop::Cop::Cop
+ def allowed?(send_node); end
+ def allowed_methods; end
def allowed_omission?(send_node); end
def autocorrect(nested); end
def on_csend(node); end
def on_send(node); end
- def whitelisted?(send_node); end
- def whitelisted_methods; end
include RuboCop::Cop::RangeHelp
end
class RuboCop::Cop::Style::NestedTernaryOperator < RuboCop::Cop::Cop
def on_if(node); end
end
@@ -5482,15 +5697,15 @@
def take_variable_and_default_from_unless(node); end
def ternary_assignment?(node = nil); end
def unless_assignment?(node = nil); end
end
class RuboCop::Cop::Style::OptionHash < RuboCop::Cop::Cop
+ def allowlist; end
def on_args(node); end
def option_hash(node = nil); end
def super_used?(node); end
def suspicious_name?(arg_name); end
- def whitelist; end
end
class RuboCop::Cop::Style::OptionalArguments < RuboCop::Cop::Cop
def argument_positions(arguments); end
def each_misplaced_optional_arg(arguments); end
def on_def(node); end
@@ -5558,10 +5773,11 @@
include RuboCop::Cop::Parentheses
include RuboCop::Cop::SafeAssignment
end
class RuboCop::Cop::Style::PercentLiteralDelimiters < RuboCop::Cop::Cop
def autocorrect(node); end
+ def contains_delimiter?(node, delimiters); end
def contains_preferred_delimiter?(node, type); end
def include_same_character_as_used_for_delimiter?(node, type); end
def matchpairs(begin_delimiter); end
def message(node); end
def on_array(node); end
@@ -5636,10 +5852,28 @@
def check(node); end
def on_block(node); end
def on_def(node); end
def on_defs(node); end
end
+class RuboCop::Cop::Style::RedundantCapitalW < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def on_array(node); end
+ def on_percent_literal(node); end
+ def requires_interpolation?(node); end
+ include RuboCop::Cop::PercentLiteral
+end
+class RuboCop::Cop::Style::RedundantCondition < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def else_source(else_branch); end
+ def make_ternary_form(node); end
+ def message(node); end
+ def offense?(node); end
+ def on_if(node); end
+ def range_of_offense(node); end
+ def use_if_branch?(else_branch); end
+ include RuboCop::Cop::RangeHelp
+end
class RuboCop::Cop::Style::RedundantConditional < RuboCop::Cop::Cop
def autocorrect(node); end
def configured_indentation_width; end
def indented_else_node(expression, node); end
def invert_expression?(node); end
@@ -5663,10 +5897,25 @@
def on_send(node); end
def operation_produces_immutable_object?(node = nil); end
def strip_parenthesis(node); end
include RuboCop::Cop::FrozenStringLiteral
end
+class RuboCop::Cop::Style::RedundantInterpolation < RuboCop::Cop::Cop
+ def autocorrect(node); end
+ def autocorrect_other(embedded_node, node); end
+ def autocorrect_single_variable_interpolation(embedded_node, node); end
+ def autocorrect_variable_interpolation(embedded_node, node); end
+ def embedded_in_percent_array?(node); end
+ def implicit_concatenation?(node); end
+ def interpolation?(node); end
+ def on_dstr(node); end
+ def self.autocorrect_incompatible_with; end
+ def single_interpolation?(node); end
+ def single_variable_interpolation?(node); end
+ def variable_interpolation?(node); end
+ include RuboCop::Cop::PercentLiteral
+end
class RuboCop::Cop::Style::RedundantParentheses < RuboCop::Cop::Cop
def allowed_ancestor?(node); end
def allowed_array_or_hash_element?(node); end
def allowed_expression?(node); end
def allowed_method_call?(node); end
@@ -5700,23 +5949,38 @@
def rescue?(node = nil); end
def square_brackets?(node = nil); end
def suspect_unary?(node); end
include RuboCop::Cop::Parentheses
end
+class RuboCop::Cop::Style::RedundantPercentQ < RuboCop::Cop::Cop
+ def acceptable_capital_q?(node); end
+ def acceptable_q?(node); end
+ def allowed_percent_q?(node); end
+ def autocorrect(node); end
+ def check(node); end
+ def interpolated_quotes?(node); end
+ def message(node); end
+ def on_dstr(node); end
+ def on_str(node); end
+ def start_with_percent_q_variant?(string); end
+ def string_literal?(node); end
+end
class RuboCop::Cop::Style::RedundantReturn < RuboCop::Cop::Cop
def add_braces(corrector, node); end
def add_brackets(corrector, node); end
def allow_multiple_return_values?; end
- def arguments?(args); end
def autocorrect(node); end
def check_begin_node(node); end
def check_branch(node); end
def check_case_node(node); end
def check_ensure_node(node); end
def check_if_node(node); end
def check_rescue_node(node); end
def check_return_node(node); end
+ def correct_with_arguments(return_node, corrector); end
+ def correct_without_arguments(return_node, corrector); end
+ def hash_without_braces?(node); end
def message(node); end
def on_def(node); end
def on_defs(node); end
include RuboCop::Cop::RangeHelp
end
@@ -5741,10 +6005,23 @@
def on_or_asgn(node); end
def on_send(node); end
def regular_method_call?(node); end
def self.autocorrect_incompatible_with; end
end
+class RuboCop::Cop::Style::RedundantSort < RuboCop::Cop::Cop
+ def accessor_start(node); end
+ def arg_node(node); end
+ def arg_value(node); end
+ def autocorrect(node); end
+ def base(accessor, arg); end
+ def message(node, sorter, accessor); end
+ def on_send(node); end
+ def redundant_sort?(node = nil); end
+ def suffix(sorter); end
+ def suggestion(sorter, accessor, arg); end
+ include RuboCop::Cop::RangeHelp
+end
class RuboCop::Cop::Style::RedundantSortBy < RuboCop::Cop::Cop
def autocorrect(node); end
def on_block(node); end
def redundant_sort_by(node = nil); end
def sort_by_range(send, node); end
@@ -5815,10 +6092,11 @@
def extract_parts(node); end
def extract_parts_from_and(node); end
def extract_parts_from_if(node); end
def find_matching_receiver_invocation(method_chain, checked_variable); end
def handle_comments(corrector, node, method_call); end
+ def method_call(node); end
def method_called?(send_node); end
def modifier_if_safe_navigation_candidate(node = nil); end
def negated?(send_node); end
def not_nil_check?(node = nil); end
def on_and(node); end
@@ -6062,12 +6340,10 @@
include RuboCop::Cop::Alignment
include RuboCop::Cop::TrailingBody
end
class RuboCop::Cop::Style::TrailingCommaInArguments < RuboCop::Cop::Cop
def autocorrect(range); end
- def avoid_autocorrect?(args); end
- def braces_will_be_removed?(args); end
def on_csend(node); end
def on_send(node); end
def self.autocorrect_incompatible_with; end
include RuboCop::Cop::TrailingComma
end
@@ -6112,10 +6388,11 @@
class RuboCop::Cop::Style::TrivialAccessors < RuboCop::Cop::Cop
def accessor(kind, method_name); end
def allow_dsl_writers?; end
def allow_predicates?; end
def allowed_method?(node); end
+ def allowed_methods; end
def allowed_reader?(node); end
def allowed_writer?(method_name); end
def autocorrect(node); end
def autocorrect_class(node); end
def autocorrect_instance(node); end
@@ -6131,78 +6408,18 @@
def on_method_def(node); end
def top_level_node?(node); end
def trivial_accessor_kind(node); end
def trivial_reader?(node); end
def trivial_writer?(node); end
- def whitelist; end
end
class RuboCop::Cop::Style::UnlessElse < RuboCop::Cop::Cop
def autocorrect(node); end
def on_if(node); end
def range_between_condition_and_else(node, condition); end
def range_between_else_and_end(node); end
include RuboCop::Cop::RangeHelp
end
-class RuboCop::Cop::Style::UnneededCapitalW < RuboCop::Cop::Cop
- def autocorrect(node); end
- def on_array(node); end
- def on_percent_literal(node); end
- def requires_interpolation?(node); end
- include RuboCop::Cop::PercentLiteral
-end
-class RuboCop::Cop::Style::UnneededCondition < RuboCop::Cop::Cop
- def autocorrect(node); end
- def else_source(else_branch); end
- def make_ternary_form(node); end
- def message(node); end
- def offense?(node); end
- def on_if(node); end
- def range_of_offense(node); end
- def use_if_branch?(else_branch); end
- include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Style::UnneededInterpolation < RuboCop::Cop::Cop
- def autocorrect(node); end
- def autocorrect_other(embedded_node, node); end
- def autocorrect_single_variable_interpolation(embedded_node, node); end
- def autocorrect_variable_interpolation(embedded_node, node); end
- def embedded_in_percent_array?(node); end
- def implicit_concatenation?(node); end
- def interpolation?(node); end
- def on_dstr(node); end
- def self.autocorrect_incompatible_with; end
- def single_interpolation?(node); end
- def single_variable_interpolation?(node); end
- def variable_interpolation?(node); end
- include RuboCop::Cop::PercentLiteral
-end
-class RuboCop::Cop::Style::UnneededPercentQ < RuboCop::Cop::Cop
- def acceptable_capital_q?(node); end
- def acceptable_q?(node); end
- def allowed_percent_q?(node); end
- def autocorrect(node); end
- def check(node); end
- def interpolated_quotes?(node); end
- def message(node); end
- def on_dstr(node); end
- def on_str(node); end
- def start_with_percent_q_variant?(string); end
- def string_literal?(node); end
-end
-class RuboCop::Cop::Style::UnneededSort < RuboCop::Cop::Cop
- def accessor_start(node); end
- def arg_node(node); end
- def arg_value(node); end
- def autocorrect(node); end
- def base(accessor, arg); end
- def message(node, sorter, accessor); end
- def on_send(node); end
- def suffix(sorter); end
- def suggestion(sorter, accessor, arg); end
- def unneeded_sort?(node = nil); end
- include RuboCop::Cop::RangeHelp
-end
class RuboCop::Cop::Style::UnpackFirst < RuboCop::Cop::Cop
def autocorrect(node); end
def first_element_range(node, unpack_call); end
def on_send(node); end
def unpack_and_first_element?(node = nil); end
@@ -6250,15 +6467,18 @@
def actual_code_range(node); end
def autocorrect(node); end
def corrected_code(node); end
def enforce_yoda?; end
def equality_only?; end
+ def file_constant_equal_program_name?(node = nil); end
def message(node); end
def non_equality_operator?(node); end
def noncommutative_operator?(node); end
def on_send(node); end
+ def program_name?(name); end
def reverse_comparison(operator); end
+ def source_file_path_constant?(node); end
def valid_yoda?(node); end
def yoda_compatible_condition?(node); end
include RuboCop::Cop::ConfigurableEnforcedStyle
include RuboCop::Cop::RangeHelp
end
@@ -6310,10 +6530,11 @@
def autocorrect_all_cops(buffer, cops); end
def collate_corrections(corrector, cops); end
def cops; end
def debug?; end
def errors; end
+ def external_dependency_checksum; end
def forces; end
def forces_for(cops); end
def handle_error(error, location, cop); end
def handle_warning(error, location); end
def initialize(cop_classes, config, options = nil); end
@@ -6493,10 +6714,16 @@
def metadata_hash; end
def output_hash; end
def started(target_files); end
include RuboCop::PathUtil
end
+class RuboCop::Formatter::JUnitFormatter < RuboCop::Formatter::BaseFormatter
+ def add_failure_to(testcase, offenses, cop_name); end
+ def file_finished(file, offenses); end
+ def finished(_inspected_files); end
+ def initialize(output, options = nil); end
+end
class RuboCop::Formatter::OffenseCountFormatter < RuboCop::Formatter::BaseFormatter
def file_finished(_file, offenses); end
def finished(_inspected_files); end
def offense_counts; end
def ordered_offense_counts(offense_counts); end
@@ -6587,10 +6814,11 @@
def file_to_include?(file); end
def for_all_cops; end
def for_cop(cop); end
def for_department(department_name); end
def initialize(hash = nil, loaded_path = nil); end
+ def internal?; end
def key?(*args, &block); end
def keys(*args, &block); end
def loaded_path; end
def make_excludes_absolute; end
def map(*args, &block); end
@@ -6623,11 +6851,11 @@
def inherited_file(path, inherit_from, file); end
def merge(base_hash, derived_hash, **opts); end
def merge_with_default(config, config_file, unset_nil:); end
def remote_file?(uri); end
def resolve_inheritance(path, hash, file, debug); end
- def resolve_inheritance_from_gems(hash, gems); end
+ def resolve_inheritance_from_gems(hash); end
def resolve_requires(path, hash); end
def should_union?(base_hash, key, inherit_mode); end
def transform(config); end
def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts); end
end
@@ -6638,11 +6866,10 @@
def self.add_inheritance_from_auto_generated_file; end
def self.add_missing_namespaces(path, hash); end
def self.auto_gen_config; end
def self.auto_gen_config=(arg0); end
def self.auto_gen_config?; end
- def self.check_cop_config_value(hash, parent = nil); end
def self.check_duplication(yaml_code, absolute_path); end
def self.clear_options; end
def self.configuration_file_for(target_dir); end
def self.configuration_from_file(config_file); end
def self.debug; end
@@ -6664,10 +6891,11 @@
def self.merge_with_default(config, config_file, unset_nil: nil); end
def self.options_config; end
def self.options_config=(arg0); end
def self.read_file(absolute_path); end
def self.resolver; end
+ def self.warn_on_pending_cops(config); end
def self.write_config_file(file_name, file_string, rubocop_yml_contents); end
def self.yaml_safe_load(yaml_code, filename); end
end
class RuboCop::ConfigObsoletion
def initialize(config); end
@@ -6684,31 +6912,28 @@
def force_default_config!; end
def initialize; end
def options_config=(options_config); end
end
class RuboCop::ConfigValidator
- def base_dir_for_path_parameters(*args, &block); end
- def bundler_lock_file_path(*args, &block); end
+ def alert_about_unrecognized_cops(invalid_cop_names); end
+ def check_cop_config_value(hash, parent = nil); end
def check_target_ruby; end
- def find_file_upwards(*args, &block); end
+ def each_invalid_parameter(cop_name); end
def for_all_cops(*args, &block); end
def initialize(config); end
- def read_ruby_version_from_bundler_lock_file; end
+ def msg_not_boolean(parent, key, value); end
+ def reject_conflicting_safe_settings; end
def reject_mutually_exclusive_defaults; end
- def ruby_version_file; end
def smart_loaded_path(*args, &block); end
- def target_ruby_source; end
+ def target_ruby; end
def target_ruby_version; end
- def target_ruby_version_from_bundler_lock_file; end
- def target_ruby_version_from_version_file; end
def validate; end
def validate_enforced_styles(valid_cop_names); end
def validate_parameter_names(valid_cop_names); end
def validate_section_presence(name); end
def validate_support_and_has_list(name, formats, valid); end
def validate_syntax_cop; end
- def warn_about_unrecognized_cops(invalid_cop_names); end
extend Forwardable
end
class RuboCop::TargetFinder
def all_cops_include; end
def configured_include?(file); end
@@ -6718,10 +6943,11 @@
def find(args); end
def find_files(base_dir, flags); end
def force_exclusion?; end
def included_file?(file); end
def initialize(config_store, options = nil); end
+ def order; end
def process_explicit_path(path); end
def ruby_executable?(file); end
def ruby_extension?(file); end
def ruby_extensions; end
def ruby_file?(file); end
@@ -6771,10 +6997,11 @@
def analyze_single_line(analysis, line, disabled); 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
@@ -6862,12 +7089,13 @@
def tokens; end
def valid_syntax?; end
end
class RuboCop::ResultCache
def any_symlink?(path); end
+ def context_checksum(team, options); end
def file_checksum(file, config_store); end
- def initialize(file, options, config_store, cache_root = nil); end
+ def initialize(file, team, options, config_store, cache_root = nil); end
def load; end
def relevant_options_digest(options); end
def rubocop_checksum; end
def save(offenses); end
def self.allow_symlinks_in_cache_location?(config_store); end
@@ -6879,24 +7107,27 @@
def self.remove_oldest_files(files, dirs, cache_root, verbose); end
def self.requires_file_removal?(file_count, config_store); end
def self.source_checksum; end
def self.source_checksum=(arg0); end
def symlink_protection_triggered?(path); end
+ def team_checksum(team); end
def valid?; end
end
class RuboCop::Runner
def aborting=(arg0); end
def aborting?; end
- def add_unneeded_disables(file, offenses, source); end
- def autocorrect_unneeded_disables(file, source, cop, offenses); end
+ def add_redundant_disables(file, offenses, source); end
+ def autocorrect_redundant_disables(file, source, cop, offenses); end
+ def cached_result(file, team); end
def cached_run?; end
def check_for_infinite_loop(processed_source, offenses); end
- def check_for_unneeded_disables?(source); end
+ def check_for_redundant_disables?(source); end
def considered_failure?(offense); end
def do_inspection_loop(file, processed_source); end
def each_inspected_file(files); end
def errors; end
+ def file_finished(file, offenses); end
def file_offense_cache(file); end
def file_offenses(file); end
def file_started(file); end
def filter_cop_classes(cop_classes, config); end
def filtered_run?; end
@@ -6909,12 +7140,14 @@
def iterate_until_no_changes(source, offenses); end
def list_files(paths); end
def minimum_severity_to_fail; end
def mobilized_cop_classes(config); end
def process_file(file); end
+ def redundant_cop_disable_directive(file); end
def run(paths); end
def save_in_cache(cache, offenses); end
+ def standby_team(config); end
def style_guide_cops_only?(config); end
def warm_cache(target_files); end
def warnings; end
end
class RuboCop::Runner::InfiniteCorrectionLoop < RuntimeError
@@ -6922,39 +7155,77 @@
def offenses; end
end
class RuboCop::CLI
def act_on_options; end
def apply_default_formatter; end
- def config_lines(cop); end
def config_store; end
- def cops_of_department(cops, department); end
- def display_error_summary(errors); end
- def display_warning_summary(warnings); end
- def execute_runner(paths); end
- def execute_runners(paths); end
+ def execute_runners; end
def handle_exiting_options; end
- def init_dotfile; end
def initialize; end
+ def options; end
+ def run(args = nil); end
+ def run_command(name); end
+ def validate_options_vs_config; end
+end
+class RuboCop::CLI::Finished < RuntimeError
+end
+module RuboCop::CLI::Command
+ def self.class_for(name); end
+ def self.run(env, name); end
+end
+class RuboCop::CLI::Environment
+ def config_store; end
+ def initialize(options, config_store, paths); end
+ def options; end
+ def paths; end
+ def run(name); end
+end
+class RuboCop::CLI::Command::Base
+ def env; end
+ def initialize(env); end
+ def self.by_command_name(name); end
+ def self.command_name; end
+ def self.command_name=(arg0); end
+ def self.inherited(subclass); end
+end
+class RuboCop::CLI::Command::AutoGenerateConfig < RuboCop::CLI::Command::Base
+ def add_formatter; end
+ def execute_runner; end
def line_length_cop(config); end
def line_length_enabled?(config); end
def max_line_length(config); end
+ def maybe_run_line_length_cop; end
+ def reset_config_and_auto_gen_file; end
+ def run; end
+ def run_all_cops(line_length_contents); end
+ def run_line_length_cop; end
+ def same_max_line_length?(config1, config2); end
+ def skip_line_length_cop(reason); end
+end
+class RuboCop::CLI::Command::ExecuteRunner < RuboCop::CLI::Command::Base
+ def display_error_summary(errors); end
+ def display_warning_summary(warnings); end
+ def execute_runner(paths); end
def maybe_print_corrected_source; end
- def maybe_run_line_length_cop(paths); end
- def options; end
+ def run; end
+ include RuboCop::Formatter::TextUtil
+end
+class RuboCop::CLI::Command::InitDotfile < RuboCop::CLI::Command::Base
+ def run; end
+end
+class RuboCop::CLI::Command::ShowCops < RuboCop::CLI::Command::Base
+ def config_lines(cop); end
+ def cops_of_department(cops, department); end
+ def initialize(env); end
def print_available_cops; end
def print_cop_details(cops); end
def print_cops_of_department(registry, department, show_all); end
- def reset_config_and_auto_gen_file; end
- def run(args = nil); end
- def run_all_cops_auto_gen_config(line_length_contents, paths); end
- def run_line_length_cop_auto_gen_config(paths); end
- def same_max_line_length?(config1, config2); end
+ def run; end
def selected_cops_of_department(cops, department); end
- def validate_options_vs_config; end
- include RuboCop::Formatter::TextUtil
end
-class RuboCop::CLI::Finished < RuntimeError
+class RuboCop::CLI::Command::Version < RuboCop::CLI::Command::Base
+ def run; end
end
class RuboCop::IncorrectCopNameError < StandardError
end
class RuboCop::OptionArgumentError < StandardError
end
@@ -6981,16 +7252,17 @@
def boolean_or_empty_cache?; 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_unneeded_disable?; end
+ def only_includes_redundant_disable?; end
def self.format_message_from(name, cop_names); end
def self.validate_cop_list(names); end
def validate_auto_correct; end
def validate_auto_gen_config; end
def validate_compatibility; end
+ def validate_cop_options; end
def validate_exclude_limit_option; end
def validate_parallel; end
def validate_parallel_with_combo_option; end
end
module RuboCop::OptionsHelp
@@ -7005,9 +7277,41 @@
def handle_response(response, limit, &block); end
def inherit_from_remote(file, path); end
def initialize(url, base_dir); end
def request(uri = nil, limit = nil, &block); end
def uri; end
+end
+class RuboCop::TargetRuby
+ def initialize(config); end
+ def rubocop_version_with_support; end
+ def self.supported_versions; end
+ def source; end
+ def supported?; end
+ def version; end
+end
+class RuboCop::TargetRuby::Source
+ def initialize(config); end
+ def name; end
+ def to_s; end
+ def version; end
+end
+class RuboCop::TargetRuby::RuboCopConfig < RuboCop::TargetRuby::Source
+ def find_version; end
+ def name; end
+end
+class RuboCop::TargetRuby::RubyVersionFile < RuboCop::TargetRuby::Source
+ def find_version; end
+ def name; end
+ def ruby_version_file; end
+end
+class RuboCop::TargetRuby::BundlerLockFile < RuboCop::TargetRuby::Source
+ def bundler_lock_file_path; end
+ def find_version; end
+ def name; end
+end
+class RuboCop::TargetRuby::Default < RuboCop::TargetRuby::Source
+ def find_version; end
+ def name; end
end
module RuboCop::YAMLDuplicationChecker
def self.check(yaml_string, filename, &on_duplicated); end
def self.traverse(tree, &on_duplicated); end
end