rubocop 0.93.1 → 1.79.2

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

@@ -10,7 +10,7 @@ module RuboCop
       MSG = 'Space found before %<token>s.'
 
       def on_new_investigation
-        each_missing_space(processed_source.tokens) do |token, pos_before|
+        each_missing_space(processed_source.sorted_tokens) do |token, pos_before|
           add_offense(pos_before, message: format(MSG, token: kind(token))) do |corrector|
             PunctuationCorrector.remove_space(corrector, pos_before)
           end
@@ -25,15 +25,14 @@ module RuboCop
           next unless space_missing?(token1, token2)
           next if space_required_after?(token1)
 
-          pos_before_punctuation = range_between(token1.end_pos,
-                                                 token2.begin_pos)
+          pos_before_punctuation = range_between(token1.end_pos, token2.begin_pos)
 
           yield token2, pos_before_punctuation
         end
       end
 
       def space_missing?(token1, token2)
-        token1.line == token2.line && token2.begin_pos > token1.end_pos
+        same_line?(token1, token2) && token2.begin_pos > token1.end_pos
       end
 
       def space_required_after?(token)

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

@@ -19,7 +19,8 @@ module RuboCop
       def non_eligible_node?(node)
         node.modifier_form? ||
           node.nonempty_line_count > 3 ||
-          processed_source.line_with_comment?(node.loc.last_line)
+          processed_source.line_with_comment?(node.loc.last_line) ||
+          (first_line_comment(node) && code_after(node))
       end
 
       def non_eligible_body?(body)
@@ -41,29 +42,52 @@ module RuboCop
 
       def length_in_modifier_form(node)
         keyword_element = node.loc.keyword
-        end_element = node.loc.end
         code_before = keyword_element.source_line[0...keyword_element.column]
-        code_after = end_element.source_line[end_element.last_column..-1]
         expression = to_modifier_form(node)
-        line_length("#{code_before}#{expression}#{code_after}")
+        line_length("#{code_before}#{expression}#{code_after(node)}")
       end
 
       def to_modifier_form(node)
-        expression = [node.body.source,
-                      node.keyword,
-                      node.condition.source].compact.join(' ')
+        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 if_body_source(if_body)
+        if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
+          "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
+        else
+          if_body.source
+        end
+      end
+
+      def omitted_value_in_last_hash_arg?(if_body)
+        return false unless (last_argument = if_body.last_argument)
+
+        last_argument.hash_type? && last_argument.pairs.last&.value_omission?
+      end
+
+      def method_source(if_body)
+        end_range = if_body.implicit_call? ? if_body.loc.dot.end : if_body.loc.selector
+
+        if_body.source_range.begin.join(end_range).source
+      end
+
       def first_line_comment(node)
-        comment = processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        comment = processed_source.comments.find { |c| same_line?(c, node) }
         return unless comment
 
-        comment_source = comment.loc.expression.source
+        comment_source = comment.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
@@ -77,7 +101,7 @@ module RuboCop
       end
 
       def max_line_length
-        return unless config.for_cop('Layout/LineLength')['Enabled']
+        return unless config.cop_enabled?('Layout/LineLength')
 
         config.for_cop('Layout/LineLength')['Max']
       end

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

@@ -3,18 +3,21 @@
 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
       def on_str(node)
         # Constants like __FILE__ are handled as strings,
         # but don't respond to begin.
-        return unless node.loc.respond_to?(:begin) && node.loc.begin
+        return unless node.loc?(:begin)
         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
@@ -27,8 +30,10 @@ module RuboCop
       private
 
       def inside_interpolation?(node)
-        # A :begin node inside a :dstr node is an interpolation.
-        node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+        # A :begin node inside a :dstr, :dsym, or :regexp node is an interpolation.
+        node.ancestors
+            .drop_while { |a| !a.begin_type? }
+            .any? { |a| a.type?(:dstr, :dsym, :regexp) }
       end
     end
   end

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

@@ -4,20 +4,30 @@ 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
-          !/" | \\[^'] | \#(@|\{)/x.match?(src)
+          !/" | \\[^'\\] | \#[@{$]/x.match?(src)
         end
       end
+
+      def preferred_string_literal
+        enforce_double_quotes? ? '""' : "''"
+      end
+
+      def enforce_double_quotes?
+        string_literals_config['EnforcedStyle'] == 'double_quotes'
+      end
+
+      def string_literals_config
+        config.for_enabled_cop('Style/StringLiterals')
+      end
     end
   end
 end

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

@@ -13,7 +13,7 @@ module RuboCop
 
       private
 
-      def side_space_range(range:, side:)
+      def side_space_range(range:, side:, include_newlines: false)
         buffer = processed_source.buffer
         src = buffer.source
 
@@ -21,11 +21,11 @@ module RuboCop
         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
@@ -44,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
@@ -58,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
@@ -73,9 +75,10 @@ module RuboCop
         end
       end
 
-      def reposition(src, pos, step)
+      def reposition(src, pos, step, include_newlines: false)
         offset = step == -1 ? -1 : 0
-        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset])
+        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset]) ||
+                          (include_newlines && src[pos + offset] == "\n")
         pos.negative? ? 0 : pos
       end
 
@@ -104,9 +107,9 @@ module RuboCop
         end
       end
 
-      def empty_brackets?(left_bracket_token, right_bracket_token)
-        left_index = processed_source.tokens.index(left_bracket_token)
-        right_index = processed_source.tokens.index(right_bracket_token)
+      def empty_brackets?(left_bracket_token, right_bracket_token, tokens: processed_source.tokens)
+        left_index = tokens.index(left_bracket_token)
+        right_index = tokens.index(right_bracket_token)
         right_index && left_index == right_index - 1
       end
 
@@ -115,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

@@ -8,12 +8,28 @@ module RuboCop
         @minimum_target_ruby_version
       end
 
+      def required_maximum_ruby_version
+        @maximum_target_ruby_version
+      end
+
       def minimum_target_ruby_version(version)
         @minimum_target_ruby_version = version
       end
 
+      def maximum_target_ruby_version(version)
+        @maximum_target_ruby_version = version
+      end
+
       def support_target_ruby_version?(version)
-        required_minimum_ruby_version <= version
+        # By default, no minimum or maximum versions of ruby are required
+        # to run any cop. In order to do a simple numerical comparison of
+        # the requested version against any requirements, we use 0 and
+        # Infinity as the default values to indicate no minimum (0) and no
+        # maximum (Infinity).
+        min = required_minimum_ruby_version || 0
+        max = required_maximum_ruby_version || Float::INFINITY
+
+        version.between?(min, max)
       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

@@ -2,8 +2,9 @@
 
 module RuboCop
   module Cop
-    # Common methods shared by Style/TrailingCommaInArguments and
-    # Style/TrailingCommaInLiteral
+    # Common methods shared by Style/TrailingCommaInArguments,
+    # Style/TrailingCommaInArrayLiteral and Style/TrailingCommaInHashLiteral
+    # rubocop:disable Metrics/ModuleLength
     module TrailingComma
       include ConfigurableEnforcedStyle
       include RangeHelp
@@ -57,6 +58,8 @@ module RuboCop
           ', unless each item is on its own line'
         when :consistent_comma
           ', unless items are split onto multiple lines'
+        when :diff_comma
+          ', unless that item immediately precedes a newline'
         else
           ''
         end
@@ -68,6 +71,8 @@ module RuboCop
           multiline?(node) && no_elements_on_same_line?(node)
         when :consistent_comma
           multiline?(node) && !method_name_and_arguments_on_same_line?(node)
+        when :diff_comma
+          multiline?(node) && last_item_precedes_newline?(node)
         else
           false
         end
@@ -75,7 +80,7 @@ module RuboCop
 
       def inside_comment?(range, comma_offset)
         comment = processed_source.comment_at_line(range.line)
-        comment && comment.loc.expression.begin_pos < range.begin_pos + comma_offset
+        comment && comment.source_range.begin_pos < range.begin_pos + comma_offset
       end
 
       # Returns true if the node has round/square/curly brackets.
@@ -95,19 +100,18 @@ 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
       # of the argument is not considered multiline, even if the argument
       # itself might span multiple lines.
       def allowed_multiline_argument?(node)
-        elements(node).one? && !Util.begins_its_line?(node.loc.end)
+        elements(node).one? && !Util.begins_its_line?(node_end_location(node))
       end
 
       def elements(node)
-        return node.children unless %i[csend send].include?(node.type)
+        return node.children unless node.call_type?
 
         node.arguments.flat_map do |argument|
           # For each argument, if it is a multi-line hash without braces,
@@ -123,17 +127,27 @@ module RuboCop
 
       def no_elements_on_same_line?(node)
         items = elements(node).map(&:source_range)
-        items << node.loc.end
+        items << node_end_location(node)
         items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
       end
 
+      def node_end_location(node)
+        node.loc.end || node.source_range.end.adjust(begin_pos: -1)
+      end
+
       def on_same_line?(range1, range2)
         range1.last_line == range2.line
       end
 
+      def last_item_precedes_newline?(node)
+        after_last_item = node.children.last.source_range.end.join(node.loc.end.begin)
+
+        after_last_item.source.start_with?(/,?\s*(#.*)?\n/)
+      end
+
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
-        article = /array/.match?(kind) ? 'an' : 'a'
+        article = kind.include?('array') ? 'an' : 'a'
         msg = format(
           MSG,
           command: 'Avoid',
@@ -160,7 +174,7 @@ module RuboCop
       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
@@ -182,7 +196,7 @@ module RuboCop
         #       ...
         #     SOURCE
         #   })
-        return heredoc?(node.children.last) if node.pair_type? || node.hash_type?
+        return heredoc?(node.children.last) if node.type?(:pair, :hash)
 
         false
       end
@@ -206,5 +220,6 @@ module RuboCop
         false
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

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

@@ -6,10 +6,8 @@ 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|
@@ -24,7 +22,11 @@ module RuboCop
           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
@@ -49,12 +51,10 @@ module RuboCop
       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)
@@ -77,9 +77,7 @@ 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)

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

@@ -8,9 +8,7 @@ module RuboCop
         extend NodePattern::Macros
 
         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

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

@@ -1,37 +1,71 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module RuboCop
   module Cop
     # Help methods for determining node visibility.
     module VisibilityHelp
       extend NodePattern::Macros
 
-      VISIBILITY_SCOPES = %i[private protected public].freeze
+      VISIBILITY_SCOPES = ::Set[:private, :protected, :public].freeze
 
       private
 
       def node_visibility(node)
-        scope = find_visibility_start(node)
-        scope&.method_name || :public
+        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(&method(:visibility_block?))
+        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 - [node_visibility(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? { :private :protected :public })
+        (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

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -3,7 +3,13 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that accessor methods are named properly.
+      # Avoid prefixing accessor method names with `get_` or `set_`.
+      # Applies to both instance and class methods.
+      #
+      # NOTE: Method names starting with `get_` or `set_` only register an offense
+      # when the methods match the expected arity for getters and setters respectively.
+      # Getters (`get_attribute`) must have no arguments to be registered,
+      # and setters (`set_attribute(value)`) must have exactly one.
       #
       # @example
       #   # bad
@@ -21,11 +27,20 @@ module RuboCop
       #   # good
       #   def attribute
       #   end
+      #
+      #   # accepted, incorrect arity for getter
+      #   def get_value(attr)
+      #   end
+      #
+      #   # accepted, incorrect arity for setter
+      #   def set_value
+      #   end
       class AccessorMethodName < Base
         MSG_READER = 'Do not prefix reader method names with `get_`.'
         MSG_WRITER = 'Do not prefix writer method names with `set_`.'
 
         def on_def(node)
+          return unless proper_attribute_name?(node)
           return unless bad_reader_name?(node) || bad_writer_name?(node)
 
           message = message(node)
@@ -44,12 +59,18 @@ module RuboCop
           end
         end
 
+        def proper_attribute_name?(node)
+          !node.method_name.to_s.end_with?('!', '?', '=')
+        end
+
         def bad_reader_name?(node)
           node.method_name.to_s.start_with?('get_') && !node.arguments?
         end
 
         def bad_writer_name?(node)
-          node.method_name.to_s.start_with?('set_') && node.arguments.one?
+          node.method_name.to_s.start_with?('set_') &&
+            node.arguments.one? &&
+            node.first_argument.arg_type?
         end
       end
     end