rubocop 0.66.0 → 1.25.1

data/lib/rubocop/cop/style/access_modifier_declarations.rb

@@ -5,11 +5,12 @@ module RuboCop
     module Style
       # Access modifiers should be declared to apply to a group of methods
       # or inline before each method, depending on configuration.
+      # EnforcedStyle config covers only method definitions.
+      # Applications of visibility methods to symbols can be controlled
+      # using AllowModifiersOnSymbols config.
       #
       # @example EnforcedStyle: group (default)
-      #
       #   # bad
-      #
       #   class Foo
       #
       #     private def bar; end
@@ -18,7 +19,6 @@ module RuboCop
       #   end
       #
       #   # good
-      #
       #   class Foo
       #
       #     private
@@ -27,10 +27,9 @@ module RuboCop
       #     def baz; end
       #
       #   end
-      # @example EnforcedStyle: inline
       #
+      # @example EnforcedStyle: inline
       #   # bad
-      #
       #   class Foo
       #
       #     private
@@ -41,14 +40,29 @@ module RuboCop
       #   end
       #
       #   # good
-      #
       #   class Foo
       #
       #     private def bar; end
       #     private def baz; end
       #
       #   end
-      class AccessModifierDeclarations < Cop
+      #
+      # @example AllowModifiersOnSymbols: true (default)
+      #   # good
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
+      #
+      # @example AllowModifiersOnSymbols: false
+      #   # bad
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
+      class AccessModifierDeclarations < Base
         include ConfigurableEnforcedStyle
 
         GROUP_STYLE_MESSAGE = [
@@ -61,13 +75,20 @@ module RuboCop
           'inlined in method definitions.'
         ].join(' ')
 
+        RESTRICT_ON_SEND = %i[private protected public module_function].freeze
+
+        # @!method access_modifier_with_symbol?(node)
+        def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
+          (send nil? {:private :protected :public :module_function} (sym _))
+        PATTERN
+
         def on_send(node)
           return unless node.access_modifier?
+          return if node.parent&.pair_type?
+          return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
-            add_offense(node, location: :selector) do
-              opposite_style_detected
-            end
+            add_offense(node.loc.selector) { opposite_style_detected }
           else
             correct_style_detected
           end
@@ -75,6 +96,10 @@ module RuboCop
 
         private
 
+        def allow_modifiers_on_symbols?(node)
+          cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
+        end
+
         def offense?(node)
           (group_style? && access_modifier_is_inlined?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))
@@ -96,8 +121,8 @@ module RuboCop
           !access_modifier_is_inlined?(node)
         end
 
-        def message(node)
-          access_modifier = node.loc.selector.source
+        def message(range)
+          access_modifier = range.source
 
           if group_style?
             format(GROUP_STYLE_MESSAGE, access_modifier: access_modifier)

data/lib/rubocop/cop/style/accessor_grouping.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for grouping of accessors in `class` and `module` bodies.
+      # By default it enforces accessors to be placed in grouped declarations,
+      # but it can be configured to enforce separating them in multiple declarations.
+      #
+      # NOTE: `Sorbet` is not compatible with "grouped" style. Consider "separated" style
+      # or disabling this cop.
+      #
+      # @example EnforcedStyle: grouped (default)
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar, :baz
+      #   end
+      #
+      # @example EnforcedStyle: separated
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar, :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :baz
+      #   end
+      #
+      class AccessorGrouping < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        include VisibilityHelp
+        extend AutoCorrector
+
+        GROUPED_MSG = 'Group together all `%<accessor>s` attributes.'
+        SEPARATED_MSG = 'Use one attribute per `%<accessor>s`.'
+
+        ACCESSOR_METHODS = %i[attr_reader attr_writer attr_accessor attr].freeze
+
+        def on_class(node)
+          class_send_elements(node).each do |macro|
+            next unless accessor?(macro)
+
+            check(macro)
+          end
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+
+        private
+
+        def check(send_node)
+          return if previous_line_comment?(send_node)
+          return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
+                        (separated_style? && send_node.arguments.size > 1)
+
+          message = message(send_node)
+          add_offense(send_node, message: message) do |corrector|
+            autocorrect(corrector, send_node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          if (preferred_accessors = preferred_accessors(node))
+            corrector.replace(node, preferred_accessors)
+          else
+            range = range_with_surrounding_space(range: node.loc.expression, side: :left)
+            corrector.remove(range)
+          end
+        end
+
+        def previous_line_comment?(node)
+          comment_line?(processed_source[node.first_line - 2])
+        end
+
+        def class_send_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def || class_def.def_type?
+            []
+          elsif class_def.send_type?
+            [class_def]
+          else
+            class_def.each_child_node(:send).to_a
+          end
+        end
+
+        def accessor?(send_node)
+          send_node.macro? && ACCESSOR_METHODS.include?(send_node.method_name)
+        end
+
+        def grouped_style?
+          style == :grouped
+        end
+
+        def separated_style?
+          style == :separated
+        end
+
+        def sibling_accessors(send_node)
+          send_node.parent.each_child_node(:send).select do |sibling|
+            accessor?(sibling) &&
+              sibling.method?(send_node.method_name) &&
+              node_visibility(sibling) == node_visibility(send_node) &&
+              !previous_line_comment?(sibling)
+          end
+        end
+
+        def message(send_node)
+          msg = grouped_style? ? GROUPED_MSG : SEPARATED_MSG
+          format(msg, accessor: send_node.method_name)
+        end
+
+        def preferred_accessors(node)
+          if grouped_style?
+            accessors = sibling_accessors(node)
+            group_accessors(node, accessors) if node == accessors.first
+          else
+            separate_accessors(node)
+          end
+        end
+
+        def group_accessors(node, accessors)
+          accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }
+
+          "#{node.method_name} #{accessor_names.join(', ')}"
+        end
+
+        def separate_accessors(node)
+          node.arguments.map do |arg|
+            if arg == node.arguments.first
+              "#{node.method_name} #{arg.source}"
+            else
+              indent = ' ' * node.loc.column
+              "#{indent}#{node.method_name} #{arg.source}"
+            end
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/alias.rb

@@ -22,62 +22,64 @@ module RuboCop
       #
       #   # good
       #   alias_method :bar, :foo
-      class Alias < Cop
+      class Alias < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        MSG_ALIAS = 'Use `alias_method` instead of `alias`.'.freeze
-        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` ' \
-                           '%<current>s.'.freeze
-        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of ' \
-                           '`alias %<current>s`.'.freeze
+        MSG_ALIAS = 'Use `alias_method` instead of `alias`.'
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %<current>s.'
+        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of `alias %<current>s`.'
+
+        RESTRICT_ON_SEND = %i[alias_method].freeze
 
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)
 
           msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
-          add_offense(node, location: :selector, message: msg)
+          add_offense(node.loc.selector, message: msg) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def on_alias(node)
           return unless alias_method_possible?(node)
 
           if scope_type(node) == :dynamic || style == :prefer_alias_method
-            add_offense(node, location: :keyword, message: MSG_ALIAS)
+            add_offense(node.loc.keyword, message: MSG_ALIAS) do |corrector|
+              autocorrect(corrector, node)
+            end
           elsif node.children.none? { |arg| bareword?(arg) }
-            add_offense_for_args(node)
+            add_offense_for_args(node) { |corrector| autocorrect(corrector, node) }
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           if node.send_type?
-            correct_alias_method_to_alias(node)
+            correct_alias_method_to_alias(corrector, node)
           elsif scope_type(node) == :dynamic || style == :prefer_alias_method
-            correct_alias_to_alias_method(node)
+            correct_alias_to_alias_method(corrector, node)
           else
-            correct_alias_with_symbol_args(node)
+            correct_alias_with_symbol_args(corrector, node)
           end
         end
 
-        private
-
         def alias_keyword_possible?(node)
           scope_type(node) != :dynamic && node.arguments.all?(&:sym_type?)
         end
 
         def alias_method_possible?(node)
-          scope_type(node) != :instance_eval &&
-            node.children.none?(&:gvar_type?)
+          scope_type(node) != :instance_eval && node.children.none?(&:gvar_type?)
         end
 
-        def add_offense_for_args(node)
+        def add_offense_for_args(node, &block)
           existing_args  = node.children.map(&:source).join(' ')
           preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
-          msg            = format(MSG_SYMBOL_ARGS,
-                                  prefer: preferred_args,
-                                  current: existing_args)
-          add_offense(node, location: arg_ranges.reduce(&:join), message: msg)
+          msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
+          add_offense(arg_ranges.reduce(&:join), message: msg, &block)
         end
 
         # In this expression, will `self` be the same as the innermost enclosing
@@ -91,7 +93,7 @@ module RuboCop
             when :def, :defs
               return :dynamic
             when :block
-              return :instance_eval if parent.method_name == :instance_eval
+              return :instance_eval if parent.method?(:instance_eval)
 
               return :dynamic
             end
@@ -101,40 +103,45 @@ module RuboCop
         end
 
         def lexical_scope_type(node)
-          node.each_ancestor(:class, :module) do |ancestor|
-            return ancestor.class_type? ? 'in a class body' : 'in a module body'
+          ancestor = node.each_ancestor(:class, :module).first
+          if ancestor.nil?
+            'at the top level'
+          elsif ancestor.class_type?
+            'in a class body'
+          else
+            'in a module body'
           end
-          'at the top level'
         end
 
         def bareword?(sym_node)
           !sym_node.source.start_with?(':')
         end
 
-        def correct_alias_method_to_alias(send_node)
-          lambda do |corrector|
-            new, old = *send_node.arguments
-            replacement = "alias #{new.children.first} #{old.children.first}"
-            corrector.replace(send_node.source_range, replacement)
-          end
+        def correct_alias_method_to_alias(corrector, send_node)
+          new, old = *send_node.arguments
+          replacement = "alias #{identifier(new)} #{identifier(old)}"
+
+          corrector.replace(send_node, replacement)
         end
 
-        def correct_alias_to_alias_method(node)
-          lambda do |corrector|
-            new, old = *node
-            replacement = "alias_method :#{new.children.first}, " \
-                          ":#{old.children.first}"
-            corrector.replace(node.source_range, replacement)
-          end
+        def correct_alias_to_alias_method(corrector, node)
+          replacement =
+            'alias_method ' \
+            ":#{identifier(node.new_identifier)}, " \
+            ":#{identifier(node.old_identifier)}"
+
+          corrector.replace(node, replacement)
         end
 
-        def correct_alias_with_symbol_args(node)
-          lambda do |corrector|
-            new, old = *node
-            corrector.replace(new.source_range, new.children.first.to_s)
-            corrector.replace(old.source_range, old.children.first.to_s)
-          end
+        def correct_alias_with_symbol_args(corrector, node)
+          corrector.replace(node.new_identifier, node.new_identifier.source[1..-1])
+          corrector.replace(node.old_identifier, node.old_identifier.source[1..-1])
         end
+
+        # @!method identifier(node)
+        def_node_matcher :identifier, <<~PATTERN
+          (sym $_)
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/style/and_or.rb

@@ -7,7 +7,12 @@ module RuboCop
       # `||` instead. It can be configured to check only in conditions or in
       # all contexts.
       #
-      # @example EnforcedStyle: always (default)
+      # @safety
+      #   Auto-correction is unsafe because there is a different operator precedence
+      #   between logical operators (`&&` and `||`) and semantic operators (`and` and `or`),
+      #   and that might change the behaviour.
+      #
+      # @example EnforcedStyle: always
       #   # bad
       #   foo.save and return
       #
@@ -22,7 +27,7 @@ module RuboCop
       #   if foo && bar
       #   end
       #
-      # @example EnforcedStyle: conditionals
+      # @example EnforcedStyle: conditionals (default)
       #   # bad
       #   if foo and bar
       #   end
@@ -36,11 +41,12 @@ module RuboCop
       #   # good
       #   if foo && bar
       #   end
-      class AndOr < Cop
+      class AndOr < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
         def on_and(node)
           process_logical_operator(node) if style == :always
@@ -55,36 +61,33 @@ module RuboCop
         alias on_until      on_if
         alias on_until_post on_if
 
-        def autocorrect(node)
-          lambda do |corrector|
+        private
+
+        def process_logical_operator(node)
+          return if node.logical_operator?
+
+          message = message(node)
+          add_offense(node.loc.operator, message: message) do |corrector|
             node.each_child_node do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
-              elsif expr.return_type?
-                correct_other(expr, corrector)
-              elsif expr.assignment?
+              elsif expr.return_type? || expr.assignment?
                 correct_other(expr, corrector)
               end
             end
 
             corrector.replace(node.loc.operator, node.alternate_operator)
+
+            keep_operator_precedence(corrector, node)
           end
         end
 
-        private
-
         def on_conditionals(node)
           node.condition.each_node(*AST::Node::OPERATOR_KEYWORDS) do |operator|
             process_logical_operator(operator)
           end
         end
 
-        def process_logical_operator(node)
-          return if node.logical_operator?
-
-          add_offense(node, location: :operator)
-        end
-
         def message(node)
           format(MSG, prefer: node.alternate_operator, current: node.operator)
         end
@@ -96,13 +99,15 @@ module RuboCop
 
           return unless correctable_send?(node)
 
-          corrector.replace(whitespace_before_arg(node), '(')
-          corrector.insert_after(node.last_argument.source_range, ')')
+          whitespace_before_arg_range = whitespace_before_arg(node)
+          corrector.remove(whitespace_before_arg_range)
+          corrector.insert_before(whitespace_before_arg_range, '(')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         def correct_setter(node, corrector)
-          corrector.insert_before(node.receiver.source_range, '(')
-          corrector.insert_after(node.last_argument.source_range, ')')
+          corrector.insert_before(node.receiver, '(')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         # ! is a special case:
@@ -124,8 +129,15 @@ module RuboCop
         def correct_other(node, corrector)
           return if node.source_range.begin.is?('(')
 
-          corrector.insert_before(node.source_range, '(')
-          corrector.insert_after(node.source_range, ')')
+          corrector.wrap(node, '(', ')')
+        end
+
+        def keep_operator_precedence(corrector, node)
+          if node.or_type? && node.parent&.and_type?
+            corrector.wrap(node, '(', ')')
+          elsif node.and_type? && node.rhs.or_type?
+            corrector.wrap(node.rhs, '(', ')')
+          end
         end
 
         def correctable_send?(node)
@@ -137,7 +149,7 @@ module RuboCop
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).
-          end_paren += 1 unless node.source =~ /\?\S/
+          end_paren += 1 unless /\?\S/.match?(node.source)
           range_between(begin_paren, end_paren)
         end
       end