rubocop 0.80.0 → 1.42.0

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for modifier cops.
     module StatementModifier
+      include LineLengthHelp
+
       private
 
       def single_line_as_modifier?(node)
@@ -15,16 +17,17 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        node.nonempty_line_count > 3 ||
-          !node.modifier_form? &&
-            processed_source.commented?(node.loc.end)
+        node.modifier_form? ||
+          node.nonempty_line_count > 3 ||
+          processed_source.line_with_comment?(node.loc.last_line) ||
+          (first_line_comment(node) && code_after(node))
       end
 
       def non_eligible_body?(body)
         body.nil? ||
           body.empty_source? ||
           body.begin_type? ||
-          processed_source.commented?(body.source_range)
+          processed_source.contains_comment?(body.source_range)
       end
 
       def non_eligible_condition?(condition)
@@ -34,21 +37,60 @@ module RuboCop
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        modifier_length = length_in_modifier_form(node, node.condition,
-                                                  node.body.source_length)
+        length_in_modifier_form(node) <= max_line_length
+      end
+
+      def length_in_modifier_form(node)
+        keyword_element = node.loc.keyword
+        code_before = keyword_element.source_line[0...keyword_element.column]
+        expression = to_modifier_form(node)
+        line_length("#{code_before}#{expression}#{code_after(node)}")
+      end
 
-        modifier_length <= max_line_length
+      def to_modifier_form(node)
+        body = if_body_source(node.body)
+        expression = [body, node.keyword, node.condition.source].compact.join(' ')
+        parenthesized = parenthesize?(node) ? "(#{expression})" : expression
+        [parenthesized, first_line_comment(node)].compact.join(' ')
       end
 
-      def length_in_modifier_form(node, cond, body_length)
-        keyword = node.loc.keyword
+      def if_body_source(if_body)
+        if if_body.call_type? &&
+           if_body.last_argument&.hash_type? && if_body.last_argument.pairs.last&.value_omission?
+          "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
+        else
+          if_body.source
+        end
+      end
+
+      def method_source(if_body)
+        range_between(if_body.loc.expression.begin_pos, if_body.loc.selector.end_pos).source
+      end
 
-        indentation = keyword.column * indentation_multiplier
-        kw_length = keyword.size
-        cond_length = cond.source_range.size
-        space = 1
+      def first_line_comment(node)
+        comment = processed_source.find_comment { |c| same_line?(c, node) }
+        return unless comment
 
-        indentation + body_length + space + kw_length + space + cond_length
+        comment_source = comment.loc.expression.source
+        comment_source unless comment_disables_cop?(comment_source)
+      end
+
+      def code_after(node)
+        end_element = node.loc.end
+        code = end_element.source_line[end_element.last_column..]
+        code unless code.empty?
+      end
+
+      def parenthesize?(node)
+        # Parenthesize corrected expression if changing to modifier-if form
+        # would change the meaning of the parent expression
+        # (due to the low operator precedence of modifier-if)
+        parent = node.parent
+        return false if parent.nil?
+        return true if parent.assignment? || parent.operator_keyword?
+        return true if %i[array pair].include?(parent.type)
+
+        node.parent.send_type?
       end
 
       def max_line_length
@@ -57,14 +99,9 @@ module RuboCop
         config.for_cop('Layout/LineLength')['Max']
       end
 
-      def indentation_multiplier
-        return 1 if config.for_cop('Layout/Tab')['Enabled']
-
-        default_configuration = RuboCop::ConfigLoader.default_configuration
-        config.for_cop('Layout/Tab')['IndentationWidth'] ||
-          config.for_cop('Layout/IndentationWidth')['Width'] ||
-          default_configuration.for_cop('Layout/Tab')['IndentationWidth'] ||
-          default_configuration.for_cop('Layout/IndentationWidth')['Width']
+      def comment_disables_cop?(comment)
+        regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+        Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
       end
     end
   end

data/lib/rubocop/cop/mixin/string_help.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     # Classes that include this module just implement functions to determine
-    # what is an offense and how to do auto-correction. They get help with
+    # what is an offense and how to do autocorrection. They get help with
     # adding offenses for the faulty string nodes, and with filtering out
     # nodes.
     module StringHelp
@@ -14,7 +14,10 @@ module RuboCop
         return if part_of_ignored_node?(node)
 
         if offense?(node)
-          add_offense(node) { opposite_style_detected }
+          add_offense(node) do |corrector|
+            opposite_style_detected
+            autocorrect(corrector, node) if respond_to?(:autocorrect, true)
+          end
         else
           correct_style_detected
         end

data/lib/rubocop/cop/mixin/string_literals_help.rb

@@ -4,18 +4,16 @@ module RuboCop
   module Cop
     # Common functionality for cops checking single/double quotes.
     module StringLiteralsHelp
-      include StringHelp
-
       private
 
-      def wrong_quotes?(node)
-        src = node.source
+      def wrong_quotes?(src_or_node)
+        src = src_or_node.is_a?(RuboCop::AST::Node) ? src_or_node.source : src_or_node
         return false if src.start_with?('%', '?')
 
         if style == :single_quotes
           !double_quotes_required?(src)
         else
-          src !~ /" | \\[^'] | \#(@|\{)/x
+          !/" | \\[^'\\] | \#[@{$]/x.match?(src)
         end
       end
     end

data/lib/rubocop/cop/mixin/surrounding_space.rb

@@ -13,46 +13,26 @@ module RuboCop
 
       private
 
-      def side_space_range(range:, side:)
-        buffer = @processed_source.buffer
+      def side_space_range(range:, side:, include_newlines: false)
+        buffer = processed_source.buffer
         src = buffer.source
 
         begin_pos = range.begin_pos
         end_pos = range.end_pos
         if side == :left
           end_pos = begin_pos
-          begin_pos = reposition(src, begin_pos, -1)
+          begin_pos = reposition(src, begin_pos, -1, include_newlines: include_newlines)
         end
         if side == :right
           begin_pos = end_pos
-          end_pos = reposition(src, end_pos, 1)
+          end_pos = reposition(src, end_pos, 1, include_newlines: include_newlines)
         end
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      def index_of_first_token(node)
-        range = node.source_range
-        token_table[range.line][range.column]
-      end
-
-      def index_of_last_token(node)
-        range = node.source_range
-        table_row = token_table[range.last_line]
-        (0...range.last_column).reverse_each do |c|
-          ix = table_row[c]
-          return ix if ix
-        end
-      end
-
-      def token_table
-        @token_table ||= begin
-          table = {}
-          @processed_source.tokens.each_with_index do |t, ix|
-            table[t.line] ||= {}
-            table[t.line][t.column] = ix
-          end
-          table
-        end
+      def on_new_investigation
+        @token_table = nil
+        super
       end
 
       def no_space_offenses(node, # rubocop:disable Metrics/ParameterLists
@@ -64,7 +44,8 @@ module RuboCop
         if extra_space?(left_token, :left) && !start_ok
           space_offense(node, left_token, :right, message, NO_SPACE_COMMAND)
         end
-        return if !extra_space?(right_token, :right) || end_ok
+        return if (!extra_space?(right_token, :right) || end_ok) ||
+                  (autocorrect_with_disable_uncorrectable? && !start_ok)
 
         space_offense(node, right_token, :left, message, NO_SPACE_COMMAND)
       end
@@ -78,7 +59,8 @@ module RuboCop
         unless extra_space?(left_token, :left) || start_ok
           space_offense(node, left_token, :none, message, SPACE_COMMAND)
         end
-        return if extra_space?(right_token, :right) || end_ok
+        return if (extra_space?(right_token, :right) || end_ok) ||
+                  (autocorrect_with_disable_uncorrectable? && !start_ok)
 
         space_offense(node, right_token, :none, message, SPACE_COMMAND)
       end
@@ -87,22 +69,26 @@ module RuboCop
         return false unless token
 
         if side == :left
-          String(token.space_after?) =~ SINGLE_SPACE_REGEXP
+          SINGLE_SPACE_REGEXP.match?(String(token.space_after?))
         else
-          String(token.space_before?) =~ SINGLE_SPACE_REGEXP
+          SINGLE_SPACE_REGEXP.match?(String(token.space_before?))
         end
       end
 
-      def reposition(src, pos, step)
+      def reposition(src, pos, step, include_newlines: false)
         offset = step == -1 ? -1 : 0
-        pos += step while src[pos + offset] =~ SINGLE_SPACE_REGEXP
+        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset]) ||
+                          (include_newlines && src[pos + offset] == "\n")
         pos.negative? ? 0 : pos
       end
 
       def space_offense(node, token, side, message, command)
         range = side_space_range(range: token.pos, side: side)
-        add_offense(node, location: range,
-                          message: format(message, command: command))
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node) unless ignored_node?(node)
+
+          ignore_node(node)
+        end
       end
 
       def empty_offenses(node, left, right, message)
@@ -116,8 +102,9 @@ module RuboCop
       end
 
       def empty_offense(node, range, message, command)
-        add_offense(node, location: range,
-                          message: format(message, command: command))
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node)
+        end
       end
 
       def empty_brackets?(left_bracket_token, right_bracket_token)
@@ -131,14 +118,15 @@ module RuboCop
       end
 
       def offending_empty_no_space?(config, left_token, right_token)
-        config == 'no_space' && !no_space_between?(left_token, right_token)
+        config == 'no_space' && !no_character_between?(left_token, right_token)
       end
 
       def space_between?(left_bracket_token, right_bracket_token)
-        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos
+        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos &&
+          processed_source.buffer.source[left_bracket_token.end_pos] == ' '
       end
 
-      def no_space_between?(left_bracket_token, right_bracket_token)
+      def no_character_between?(left_bracket_token, right_bracket_token)
         left_bracket_token.end_pos == right_bracket_token.begin_pos
       end
     end

data/lib/rubocop/cop/mixin/symbol_help.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Classes that include this module just implement functions for working
+    # with symbol nodes.
+    module SymbolHelp
+      def hash_key?(node)
+        node.parent&.pair_type? && node == node.parent.child_nodes.first
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/target_ruby_version.rb

@@ -4,12 +4,16 @@ module RuboCop
   module Cop
     # Common functionality for checking target ruby version.
     module TargetRubyVersion
+      def required_minimum_ruby_version
+        @minimum_target_ruby_version
+      end
+
       def minimum_target_ruby_version(version)
         @minimum_target_ruby_version = version
       end
 
       def support_target_ruby_version?(version)
-        @minimum_target_ruby_version <= version
+        required_minimum_ruby_version <= version
       end
     end
   end

data/lib/rubocop/cop/mixin/trailing_body.rb

@@ -6,12 +6,11 @@ module RuboCop
     module TrailingBody
       def trailing_body?(node)
         body = node.to_a.reverse[0]
-        body && node.multiline? &&
-          body_on_first_line?(node, body)
+        body && node.multiline? && body_on_first_line?(node, body)
       end
 
       def body_on_first_line?(node, body)
-        node.source_range.first_line == body.source_range.first_line
+        same_line?(node, body)
       end
 
       def first_part_of(body)

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -31,7 +31,7 @@ module RuboCop
         # If there is any heredoc in items, then match the comma succeeding
         # any whitespace (except newlines), otherwise allow for newlines
         comma_regex = any_heredoc?(items) ? /\A[^\S\n]*,/ : /\A\s*,/
-        range.source =~ comma_regex && range.source.index(',')
+        comma_regex.match?(range.source) && range.source.index(',')
       end
 
       def check_comma(node, kind, comma_pos)
@@ -74,10 +74,8 @@ module RuboCop
       end
 
       def inside_comment?(range, comma_offset)
-        processed_source.comments.any? do |comment|
-          comment_offset = comment.loc.expression.begin_pos - range.begin_pos
-          comment_offset >= 0 && comment_offset < comma_offset
-        end
+        comment = processed_source.comment_at_line(range.line)
+        comment && comment.loc.expression.begin_pos < range.begin_pos + comma_offset
       end
 
       # Returns true if the node has round/square/curly brackets.
@@ -97,8 +95,7 @@ module RuboCop
 
         line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
 
-        line == node.last_argument.last_line &&
-          node.last_line == node.last_argument.last_line
+        line == node.last_argument.last_line && node.last_line == node.last_argument.last_line
       end
 
       # A single argument with the closing bracket on the same line as the end
@@ -135,14 +132,16 @@ module RuboCop
 
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
-        article = kind =~ /array/ ? 'an' : 'a'
+        article = /array/.match?(kind) ? 'an' : 'a'
         msg = format(
           MSG,
           command: 'Avoid',
           unit: format(kind, article: article) + extra_info.to_s
         )
 
-        add_offense(range, location: range, message: msg)
+        add_offense(range, message: msg) do |corrector|
+          PunctuationCorrector.swap_comma(corrector, range)
+        end
       end
 
       def put_comma(items, kind)
@@ -150,19 +149,17 @@ module RuboCop
         return if last_item.block_pass_type?
 
         range = autocorrect_range(last_item)
-        msg = format(
-          MSG,
-          command: 'Put a',
-          unit: format(kind, article: 'a multiline')
-        )
+        msg = format(MSG, command: 'Put a', unit: format(kind, article: 'a multiline'))
 
-        add_offense(range, location: range, message: msg)
+        add_offense(range, message: msg) do |corrector|
+          PunctuationCorrector.swap_comma(corrector, range)
+        end
       end
 
       def autocorrect_range(item)
         expr = item.source_range
         ix = expr.source.rindex("\n") || 0
-        ix += expr.source[ix..-1] =~ /\S/
+        ix += expr.source[ix..] =~ /\S/
 
         range_between(expr.begin_pos + ix, expr.end_pos)
       end
@@ -184,9 +181,7 @@ module RuboCop
         #       ...
         #     SOURCE
         #   })
-        if node.pair_type? || node.hash_type?
-          return heredoc?(node.children.last)
-        end
+        return heredoc?(node.children.last) if node.pair_type? || node.hash_type?
 
         false
       end

data/lib/rubocop/cop/mixin/uncommunicative_name.rb

@@ -6,23 +6,27 @@ module RuboCop
     module UncommunicativeName
       CASE_MSG = 'Only use lowercase characters for %<name_type>s.'
       NUM_MSG = 'Do not end %<name_type>s with a number.'
-      LENGTH_MSG = '%<name_type>s must be at least %<min>s ' \
-                   'characters long.'
-      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a ' \
-                      '%<name_type>s.'
+      LENGTH_MSG = '%<name_type>s must be at least %<min>s characters long.'
+      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a %<name_type>s.'
 
       def check(node, args)
         args.each do |arg|
           # Argument names might be "_" or prefixed with "_" to indicate they
           # are unused. Trim away this prefix and only analyse the basename.
-          full_name = arg.children.first.to_s
+          name_child = arg.children.first
+          next if name_child.nil?
+
+          full_name = name_child.to_s
           next if full_name == '_'
 
-          name = full_name.gsub(/\A([_]+)/, '')
-          next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
+          name = full_name.gsub(/\A(_+)/, '')
           next if allowed_names.include?(name)
 
-          range = arg_range(arg, name.size)
+          length = full_name.size
+          length += 1 if arg.restarg_type?
+          length += 2 if arg.kwrestarg_type?
+
+          range = arg_range(arg, length)
           issue_offenses(node, range, name)
         end
       end
@@ -39,37 +43,32 @@ module RuboCop
       end
 
       def case_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(CASE_MSG, name_type: name_type(node)))
+        add_offense(range, message: format(CASE_MSG, name_type: name_type(node)))
       end
 
       def uppercase?(name)
-        name =~ /[[:upper:]]/
+        /[[:upper:]]/.match?(name)
       end
 
       def name_type(node)
-        @name_type ||= begin
-          case node.type
-          when :block then 'block parameter'
-          when :def, :defs then 'method parameter'
-          end
-        end
+        @name_type ||= case node.type
+                       when :block then 'block parameter'
+                       when :def, :defs then 'method parameter'
+                       end
       end
 
       def num_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(NUM_MSG, name_type: name_type(node)))
+        add_offense(range, message: format(NUM_MSG, name_type: name_type(node)))
       end
 
       def ends_with_num?(name)
-        name[-1] =~ /\d/
+        /\d/.match?(name[-1])
       end
 
       def length_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(LENGTH_MSG,
-                                          name_type: name_type(node).capitalize,
-                                          min: min_length))
+        message = format(LENGTH_MSG, name_type: name_type(node).capitalize, min: min_length)
+
+        add_offense(range, message: message)
       end
 
       def long_enough?(name)
@@ -78,17 +77,11 @@ module RuboCop
 
       def arg_range(arg, length)
         begin_pos = arg.source_range.begin_pos
-        Parser::Source::Range.new(processed_source.buffer,
-                                  begin_pos,
-                                  begin_pos + length)
+        Parser::Source::Range.new(processed_source.buffer, begin_pos, begin_pos + length)
       end
 
       def forbidden_offense(node, range, name)
-        add_offense(
-          node,
-          location: range,
-          message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node))
-        )
+        add_offense(range, message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node)))
       end
 
       def allowed_names

data/lib/rubocop/cop/mixin/unused_argument.rb

@@ -7,14 +7,8 @@ module RuboCop
       module UnusedArgument
         extend NodePattern::Macros
 
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
         def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_argument(variable)
-          end
+          scope.variables.each_value { |variable| check_argument(variable) }
         end
 
         private
@@ -24,8 +18,10 @@ module RuboCop
           return if variable.referenced?
 
           message = message(variable)
-          add_offense(variable.declaration_node, location: :name,
-                                                 message: message)
+
+          add_offense(variable.declaration_node.loc.name, message: message) do |corrector|
+            autocorrect(corrector, variable.declaration_node)
+          end
         end
       end
     end

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    # Help methods for determining node visibility.
+    module VisibilityHelp
+      extend NodePattern::Macros
+
+      VISIBILITY_SCOPES = ::Set[:private, :protected, :public].freeze
+
+      private
+
+      def node_visibility(node)
+        node_visibility_from_visibility_inline(node) ||
+          node_visibility_from_visibility_block(node) ||
+          :public
+      end
+
+      def node_visibility_from_visibility_inline(node)
+        return unless node.def_type?
+
+        node_visibility_from_visibility_inline_on_def(node) ||
+          node_visibility_from_visibility_inline_on_method_name(node)
+      end
+
+      def node_visibility_from_visibility_inline_on_def(node)
+        parent = node.parent
+        parent.method_name if visibility_inline_on_def?(parent)
+      end
+
+      def node_visibility_from_visibility_inline_on_method_name(node)
+        node.right_siblings.reverse.find do |sibling|
+          visibility_inline_on_method_name?(sibling, method_name: node.method_name)
+        end&.method_name
+      end
+
+      def node_visibility_from_visibility_block(node)
+        find_visibility_start(node)&.method_name
+      end
+
+      def find_visibility_start(node)
+        node.left_siblings.reverse.find { |sibling| visibility_block?(sibling) }
+      end
+
+      # Navigate to find the last protected method
+      def find_visibility_end(node)
+        possible_visibilities = VISIBILITY_SCOPES - ::Set[node_visibility(node)]
+        right = node.right_siblings
+        right.find do |child_node|
+          possible_visibilities.include?(node_visibility(child_node))
+        end || right.last
+      end
+
+      # @!method visibility_block?(node)
+      def_node_matcher :visibility_block?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES)
+      PATTERN
+
+      # @!method visibility_inline_on_def?(node)
+      def_node_matcher :visibility_inline_on_def?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES def)
+      PATTERN
+
+      # @!method visibility_inline_on_method_name?(node, method_name:)
+      def_node_matcher :visibility_inline_on_method_name?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES (sym %method_name))
+      PATTERN
+    end
+  end
+end