rubocop 1.10.0 → 1.14.0

data/lib/rubocop/cop/lint/missing_super.rb

@@ -53,8 +53,7 @@ module RuboCop
                                          singleton_method_added singleton_method_removed
                                          singleton_method_undefined].freeze
 
-        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS +
-                     METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
+        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS + METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
         def on_def(node)
           return unless offender?(node)

data/lib/rubocop/cop/lint/mixed_regexp_capture_types.rb

@@ -21,8 +21,7 @@ module RuboCop
       #   /(FOO)(BAR)/
       #
       class MixedRegexpCaptureTypes < Base
-        MSG = 'Do not mix named captures and numbered captures ' \
-              'in a Regexp literal.'
+        MSG = 'Do not mix named captures and numbered captures in a Regexp literal.'
 
         def on_regexp(node)
           return if node.interpolation?

data/lib/rubocop/cop/lint/multiple_comparison.rb

@@ -25,6 +25,7 @@ module RuboCop
         SET_OPERATION_OPERATORS = %i[& | ^].freeze
         RESTRICT_ON_SEND = COMPARISON_METHODS
 
+        # @!method multiple_compare?(node)
         def_node_matcher :multiple_compare?, <<~PATTERN
           (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
         PATTERN

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -55,8 +55,7 @@ module RuboCop
       #     end
       #   end
       class NestedMethodDefinition < Base
-        MSG = 'Method definitions must not be nested. ' \
-              'Use `lambda` instead.'
+        MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
           subject, = *node
@@ -81,14 +80,17 @@ module RuboCop
             class_or_module_or_struct_new_call?(child)
         end
 
+        # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
+        # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
+        # @!method class_or_module_or_struct_new_call?(node)
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
           (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN

data/lib/rubocop/cop/lint/nested_percent_literal.rb

@@ -39,9 +39,7 @@ module RuboCop
         # if found within a percent literal expression, will cause a
         # NestedPercentLiteral violation to be emitted.
         PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
-        REGEXES = PERCENT_LITERAL_TYPES.map do |percent_literal|
-          /\A#{percent_literal}\W/
-        end.freeze
+        REGEXES = PERCENT_LITERAL_TYPES.map { |percent_literal| /\A#{percent_literal}\W/ }.freeze
 
         def on_array(node)
           process(node, *PERCENT_LITERAL_TYPES)

data/lib/rubocop/cop/lint/next_without_accumulator.rb

@@ -25,6 +25,7 @@ module RuboCop
       class NextWithoutAccumulator < Base
         MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
+        # @!method on_body_of_reduce(node)
         def_node_matcher :on_body_of_reduce, <<~PATTERN
           (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
         PATTERN

data/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -66,9 +66,7 @@ module RuboCop
           loop_variable(node.arguments) do |var_name|
             return unless var_is_required?(node.body, var_name)
 
-            add_offense(node.send_node) do |corrector|
-              correct_block(corrector, node.send_node)
-            end
+            add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
           end
         end
 
@@ -129,32 +127,39 @@ module RuboCop
           unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
         end
 
+        # @!method unsorted_dir_block?(node)
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
 
+        # @!method unsorted_dir_each?(node)
         def_node_matcher :unsorted_dir_each?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
         PATTERN
 
+        # @!method method_require?(node)
         def_node_matcher :method_require?, <<~PATTERN
           (block-pass (send nil? :method (sym :require)))
         PATTERN
 
+        # @!method unsorted_dir_glob_pass?(node)
         def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...
             (block-pass (send nil? :method (sym :require))))
         PATTERN
 
+        # @!method unsorted_dir_each_pass?(node)
         def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
             (block-pass (send nil? :method (sym :require))))
         PATTERN
 
+        # @!method loop_variable(node)
         def_node_matcher :loop_variable, <<~PATTERN
           (args (arg $_))
         PATTERN
 
+        # @!method var_is_required?(node, name)
         def_node_search :var_is_required?, <<~PATTERN
           (send nil? :require (lvar %1))
         PATTERN

data/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb

@@ -73,7 +73,10 @@ module RuboCop
           !return_node.children.empty?
         end
 
+        # @!method chained_send?(node)
         def_node_matcher :chained_send?, '(send !nil? ...)'
+
+        # @!method define_method?(node)
         def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -58,14 +58,16 @@ module RuboCop
         }.freeze
         MSG = 'Replace unsafe number conversion with number '\
               'class parsing, instead of using '\
-              '%<current>s, use stricter '\
-              '%<corrected_method>s.'
+              '`%<current>s`, use stricter '\
+              '`%<corrected_method>s`.'
         METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
 
+        # @!method to_method(node)
         def_node_matcher :to_method, <<~PATTERN
           (send $_ ${#{METHODS}})
         PATTERN
 
+        # @!method to_method_symbol(node)
         def_node_matcher :to_method_symbol, <<~PATTERN
           {(send _ $_ ${(sym ${#{METHODS}})} ...)
            (send _ $_ ${(block_pass (sym ${#{METHODS}}))} ...)}
@@ -95,7 +97,7 @@ module RuboCop
 
         def handle_as_symbol(node)
           to_method_symbol(node) do |receiver, sym_node, to_method|
-            next if receiver.nil?
+            next if receiver.nil? || !node.arguments.one?
 
             message = format(
               MSG,
@@ -103,14 +105,15 @@ module RuboCop
               corrected_method: correct_sym_method(to_method)
             )
             add_offense(node, message: message) do |corrector|
+              remove_parentheses(corrector, node) if node.parenthesized?
+
               corrector.replace(sym_node, correct_sym_method(to_method))
             end
           end
         end
 
         def correct_method(node, receiver)
-          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
-                 number_object: receiver.source)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name], number_object: receiver.source)
         end
 
         def correct_sym_method(to_method)
@@ -118,6 +121,11 @@ module RuboCop
           "{ |i| #{body} }"
         end
 
+        def remove_parentheses(corrector, node)
+          corrector.replace(node.loc.begin, ' ')
+          corrector.remove(node.loc.end)
+        end
+
         def ignore_receiver?(receiver)
           if receiver.send_type? && ignored_method?(receiver.method_name)
             true

data/lib/rubocop/cop/lint/ordered_magic_comments.rb

@@ -31,8 +31,7 @@ module RuboCop
         include FrozenStringLiteral
         extend AutoCorrector
 
-        MSG = 'The encoding magic comment should precede all other ' \
-              'magic comments.'
+        MSG = 'The encoding magic comment should precede all other magic comments.'
 
         def on_new_investigation
           return if processed_source.buffer.source.empty?

data/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb

@@ -48,9 +48,7 @@ module RuboCop
         def on_when(node)
           regexp_conditions = node.conditions.select(&:regexp_type?)
 
-          @valid_ref = regexp_conditions.map do |condition|
-            check_regexp(condition)
-          end.compact.max
+          @valid_ref = regexp_conditions.map { |condition| check_regexp(condition) }.compact.max
         end
 
         def on_nth_ref(node)

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -29,9 +29,7 @@ module RuboCop
 
           range = space_range(node.first_argument.source_range, space_length)
 
-          add_offense(range) do |corrector|
-            corrector.remove(range)
-          end
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
         alias on_csend on_send
 

data/lib/rubocop/cop/lint/percent_symbol_array.rb

@@ -34,9 +34,7 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_colons_or_commas?(node)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         private

data/lib/rubocop/cop/lint/raise_exception.rb

@@ -33,18 +33,19 @@ module RuboCop
         MSG = 'Use `StandardError` over `Exception`.'
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method exception?(node)
         def_node_matcher :exception?, <<~PATTERN
           (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )
         PATTERN
 
+        # @!method exception_new_with_message?(node)
         def_node_matcher :exception_new_with_message?, <<~PATTERN
           (send nil? {:raise :fail}
             (send $(const ${cbase nil?} :Exception) :new ... ))
         PATTERN
 
         def on_send(node)
-          exception?(node, &check(node)) ||
-            exception_new_with_message?(node, &check(node))
+          exception?(node, &check(node)) || exception_new_with_message?(node, &check(node))
         end
 
         private

data/lib/rubocop/cop/lint/rand_one.rb

@@ -21,10 +21,10 @@ module RuboCop
       #
       #   0 # just use 0 instead
       class RandOne < Base
-        MSG = '`%<method>s` always returns `0`. ' \
-              'Perhaps you meant `rand(2)` or `rand`?'
+        MSG = '`%<method>s` always returns `0`. Perhaps you meant `rand(2)` or `rand`?'
         RESTRICT_ON_SEND = %i[rand].freeze
 
+        # @!method rand_one?(node)
         def_node_matcher :rand_one?, <<~PATTERN
           (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN

data/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb

@@ -69,9 +69,7 @@ module RuboCop
             # Eat the entire comment, the preceding space, and the preceding
             # newline if there is one.
             original_begin = range.begin_pos
-            range = range_with_surrounding_space(range: range,
-                                                 side: :left,
-                                                 newlines: true)
+            range = range_with_surrounding_space(range: range, side: :left, newlines: true)
 
             range_with_surrounding_space(range: range,
                                          side: :right,
@@ -93,9 +91,7 @@ module RuboCop
 
           range = range_with_surrounding_comma(range, :right)
           # Eat following spaces up to EOL, but not the newline itself.
-          range_with_surrounding_space(range: range,
-                                       side: :right,
-                                       newlines: false)
+          range_with_surrounding_space(range: range, side: :right, newlines: false)
         end
 
         def each_redundant_disable(cop_disabled_line_ranges, offenses,
@@ -103,13 +99,9 @@ module RuboCop
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
-            each_already_disabled(line_ranges,
-                                  disabled_ranges) do |comment|
-              yield comment, cop
-            end
+            each_already_disabled(line_ranges, disabled_ranges) { |comment| yield comment, cop }
 
-            each_line_range(line_ranges, disabled_ranges, offenses,
-                            cop, &block)
+            each_line_range(line_ranges, disabled_ranges, offenses, cop, &block)
           end
         end
 
@@ -119,8 +111,7 @@ module RuboCop
             comment = processed_source.comment_at_line(line_range.begin)
             next if ignore_offense?(disabled_ranges, line_range)
 
-            redundant_cop = find_redundant(comment, offenses, cop, line_range,
-                                           line_ranges[ix + 1])
+            redundant_cop = find_redundant(comment, offenses, cop, line_range, line_ranges[ix + 1])
             yield comment, redundant_cop if redundant_cop
           end
         end
@@ -151,8 +142,7 @@ module RuboCop
             # comment. If the disable all comment is truly redundant, we will
             # detect that when examining the comments of another cop, and we
             # get the full line range for the disable all.
-            if (next_line_range.nil? ||
-                line_range.last != next_line_range.first) &&
+            if (next_line_range.nil? || line_range.last != next_line_range.first) &&
                offenses.none? { |o| line_range.cover?(o.line) }
               'all'
             end
@@ -174,15 +164,13 @@ module RuboCop
         end
 
         def directive_count(comment)
-          match = comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-          _, cops_string = match.captures
+          _, cops_string = DirectiveComment.new(comment).match_captures
           cops_string.split(/,\s*/).size
         end
 
         def add_offenses(redundant_cops)
           redundant_cops.each do |comment, cops|
-            if all_disabled?(comment) ||
-               directive_count(comment) == cops.size
+            if all_disabled?(comment) || directive_count(comment) == cops.size
               add_offense_for_entire_comment(comment, cops)
             else
               add_offense_for_some_cops(comment, cops)
@@ -230,8 +218,7 @@ module RuboCop
           return unless offset
 
           offset += haystack.begin_pos
-          Parser::Source::Range.new(haystack.source_buffer, offset,
-                                    offset + needle.size)
+          Parser::Source::Range.new(haystack.source_buffer, offset, offset + needle.size)
         end
 
         def trailing_range?(ranges, range)

data/lib/rubocop/cop/lint/redundant_require_statement.rb

@@ -28,6 +28,7 @@ module RuboCop
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
 
+        # @!method unnecessary_require_statement?(node)
         def_node_matcher :unnecessary_require_statement?, <<~PATTERN
           (send nil? :require
             (str {"enumerator" "rational" "complex" "thread"}))

data/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -43,6 +43,7 @@ module RuboCop
 
         NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
 
+        # @!method respond_to_nil_specific_method?(node)
         def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
           (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
         PATTERN
@@ -52,9 +53,7 @@ module RuboCop
           return if respond_to_nil_specific_method?(node)
 
           range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
-          add_offense(range) do |corrector|
-            corrector.replace(node.loc.dot, '.')
-          end
+          add_offense(range) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
 
         private

data/lib/rubocop/cop/lint/redundant_splat_expansion.rb

@@ -79,6 +79,7 @@ module RuboCop
         PERCENT_CAPITAL_I = '%I'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
+        # @!method array_new?(node)
         def_node_matcher :array_new?, <<~PATTERN
           {
             $(send (const {nil? cbase} :Array) :new ...)
@@ -86,14 +87,14 @@ module RuboCop
           }
         PATTERN
 
+        # @!method literal_expansion(node)
         def_node_matcher :literal_expansion, <<~PATTERN
           (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
         PATTERN
 
         def on_splat(node)
           redundant_splat_expansion(node) do
-            if array_splat?(node) &&
-               (method_argument?(node) || part_of_an_array?(node))
+            if array_splat?(node) && (method_argument?(node) || part_of_an_array?(node))
               return if allow_percent_literal_array_argument? &&
                         use_percent_literal_array_argument?(node)
 
@@ -101,9 +102,7 @@ module RuboCop
                 autocorrect(corrector, node)
               end
             else
-              add_offense(node) do |corrector|
-                autocorrect(corrector, node)
-              end
+              add_offense(node) { |corrector| autocorrect(corrector, node) }
             end
           end
         end
@@ -122,8 +121,7 @@ module RuboCop
               return if array_new_inside_array_literal?(expanded_item)
 
               grandparent = node.parent.parent
-              return if grandparent &&
-                        !ASSIGNMENT_TYPES.include?(grandparent.type)
+              return if grandparent && !ASSIGNMENT_TYPES.include?(grandparent.type)
             end
 
             yield

data/lib/rubocop/cop/lint/redundant_string_coercion.rb

@@ -22,9 +22,9 @@ module RuboCop
         extend AutoCorrector
 
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
-        MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
-                   'interpolation.'
+        MSG_SELF = 'Use `self` instead of `Object#to_s` in interpolation.'
 
+        # @!method to_s_without_args?(node)
         def_node_matcher :to_s_without_args?, '(send _ :to_s)'
 
         def on_interpolation(begin_node)