rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,136 @@
+# 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.
+      #
+      # @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 < Cop
+        include ConfigurableEnforcedStyle
+
+        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_module on_class
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, correction(node))
+          end
+        end
+
+        private
+
+        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 check(send_node)
+          if grouped_style? && sibling_accessors(send_node).size > 1
+            add_offense(send_node)
+          elsif separated_style? && send_node.arguments.size > 1
+            add_offense(send_node)
+          end
+        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|
+            sibling.macro? && sibling.method?(send_node.method_name)
+          end
+        end
+
+        def message(send_node)
+          msg = grouped_style? ? GROUPED_MSG : SEPARATED_MSG
+          format(msg, accessor: send_node.method_name)
+        end
+
+        def correction(node)
+          if grouped_style?
+            accessors = sibling_accessors(node)
+            if node == accessors.first
+              group_accessors(node, accessors)
+            else
+              ''
+            end
+          else
+            separate_accessors(node)
+          end
+        end
+
+        def group_accessors(node, accessors)
+          accessor_names = accessors.flat_map do |accessor|
+            accessor.arguments.map(&:source)
+          end
+
+          "#{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

@@ -7,38 +7,35 @@ module RuboCop
       # depending on configuration.
       # It also flags uses of `alias :symbol` rather than `alias bareword`.
       #
-      # @example
-      #
-      #   # EnforcedStyle: prefer_alias
+      # @example EnforcedStyle: prefer_alias (default)
+      #   # bad
+      #   alias_method :bar, :foo
+      #   alias :bar :foo
       #
       #   # good
       #   alias bar foo
       #
+      # @example EnforcedStyle: prefer_alias_method
       #   # bad
-      #   alias_method :bar, :foo
       #   alias :bar :foo
-      #
-      # @example
-      #
-      #   # EnforcedStyle: prefer_alias_method
+      #   alias bar foo
       #
       #   # good
       #   alias_method :bar, :foo
-      #
-      #   # bad
-      #   alias bar foo
       class Alias < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_ALIAS = 'Use `alias_method` instead of `alias`.'.freeze
-        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %s.'.freeze
-        MSG_SYMBOL_ARGS  = 'Use `alias %s` instead of `alias %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`.'
 
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)
 
-          msg = format(MSG_ALIAS_METHOD, lexical_scope_type(node))
+          msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
           add_offense(node, location: :selector, message: msg)
         end
 
@@ -52,6 +49,16 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          if node.send_type?
+            correct_alias_method_to_alias(node)
+          elsif scope_type(node) == :dynamic || style == :prefer_alias_method
+            correct_alias_to_alias_method(node)
+          else
+            correct_alias_with_symbol_args(node)
+          end
+        end
+
         private
 
         def alias_keyword_possible?(node)
@@ -63,22 +70,13 @@ module RuboCop
             node.children.none?(&:gvar_type?)
         end
 
-        def autocorrect(node)
-          if node.send_type?
-            correct_alias_method_to_alias(node)
-          elsif scope_type(node) == :dynamic || style == :prefer_alias_method
-            correct_alias_to_alias_method(node)
-          else
-            correct_alias_with_symbol_args(node)
-          end
-        end
-
         def add_offense_for_args(node)
           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, preferred_args,
-                                  existing_args)
+          msg            = format(MSG_SYMBOL_ARGS,
+                                  prefer: preferred_args,
+                                  current: existing_args)
           add_offense(node, location: arg_ranges.reduce(&:join), message: msg)
         end
 
@@ -93,7 +91,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
@@ -116,27 +114,33 @@ module RuboCop
         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)
+            replacement = "alias #{identifier(new)} #{identifier(old)}"
+            corrector.replace(send_node, replacement)
           end
         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)
+            replacement =
+              'alias_method ' \
+              ":#{identifier(node.new_identifier)}, " \
+              ":#{identifier(node.old_identifier)}"
+            corrector.replace(node, replacement)
           end
         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)
+            corrector.replace(node.new_identifier,
+                              node.new_identifier.source[1..-1])
+            corrector.replace(node.old_identifier,
+                              node.old_identifier.source[1..-1])
           end
         end
+
+        def_node_matcher :identifier, <<~PATTERN
+          (sym $_)
+        PATTERN
       end
     end
   end

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

@@ -4,36 +4,43 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for uses of `and` and `or`, and suggests using `&&` and
-      # `|| instead`. It can be configured to check only in conditions, or in
+      # `||` instead. It can be configured to check only in conditions or in
       # all contexts.
       #
-      # @example
+      # @example EnforcedStyle: always
+      #   # bad
+      #   foo.save and return
       #
-      #   # EnforcedStyle: always (default)
+      #   # bad
+      #   if foo and bar
+      #   end
       #
       #   # good
       #   foo.save && return
+      #
+      #   # good
       #   if foo && bar
+      #   end
       #
+      # @example EnforcedStyle: conditionals (default)
       #   # bad
-      #   foo.save and return
       #   if foo and bar
-      #
-      # @example
-      #
-      #   # EnforcedStyle: conditionals
+      #   end
       #
       #   # good
       #   foo.save && return
+      #
+      #   # good
       #   foo.save and return
-      #   if foo && bar
       #
-      #   # bad
-      #   if foo and bar
+      #   # good
+      #   if foo && bar
+      #   end
       class AndOr < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
         def on_and(node)
           process_logical_operator(node) if style == :always
@@ -48,24 +55,6 @@ module RuboCop
         alias on_until      on_if
         alias on_until_post on_if
 
-        private
-
-        def on_conditionals(node)
-          node.condition.each_node(*LOGICAL_OPERATOR_NODES) do |logical_node|
-            process_logical_operator(logical_node)
-          end
-        end
-
-        def process_logical_operator(node)
-          return if node.logical_operator?
-
-          add_offense(node, location: :operator)
-        end
-
-        def message(node)
-          format(MSG, node.alternate_operator, node.operator)
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             node.each_child_node do |expr|
@@ -82,6 +71,24 @@ module RuboCop
           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
+
         def correct_send(node, corrector)
           return correct_not(node, node.receiver, corrector) if node.method?(:!)
           return correct_setter(node, corrector) if node.setter_method?
@@ -90,12 +97,12 @@ module RuboCop
           return unless correctable_send?(node)
 
           corrector.replace(whitespace_before_arg(node), '(')
-          corrector.insert_after(node.last_argument.source_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:
@@ -103,11 +110,11 @@ module RuboCop
         # recurse down a level and add parens to 'obj.method arg'
         # however, 'not x' also parses as (send x :!)
         def correct_not(node, receiver, corrector)
-          if node.keyword_bang?
+          if node.prefix_bang?
             return unless receiver.send_type?
 
             correct_send(receiver, corrector)
-          elsif node.keyword_not?
+          elsif node.prefix_not?
             correct_other(node, corrector)
           else
             raise 'unrecognized unary negation operator'
@@ -117,8 +124,7 @@ 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 correctable_send?(node)
@@ -130,7 +136,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

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

@@ -3,13 +3,22 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of "*" as a substitute for *join*.
+      # This cop checks for uses of "*" as a substitute for _join_.
       #
       # Not all cases can reliably checked, due to Ruby's dynamic
       # types, so we consider only cases when the first argument is an
       # array literal or the second is a string literal.
+      #
+      # @example
+      #
+      #   # bad
+      #   %w(foo bar baz) * ","
+      #
+      #   # good
+      #   %w(foo bar baz).join(",")
+      #
       class ArrayJoin < Cop
-        MSG = 'Favor `Array#join` over `Array#*`.'.freeze
+        MSG = 'Favor `Array#join` over `Array#*`.'
 
         def_node_matcher :join_candidate?, '(send $array :* $str)'
 
@@ -21,7 +30,7 @@ module RuboCop
           array, join_arg = join_candidate?(node).map(&:source)
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "#{array}.join(#{join_arg})")
+            corrector.replace(node, "#{array}.join(#{join_arg})")
           end
         end
       end

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

@@ -1,18 +1,31 @@
 # frozen_string_literal: true
 
+# rubocop:disable Style/AsciiComments
+
 module RuboCop
   module Cop
     module Style
       # This cop checks for non-ascii (non-English) characters
-      # in comments.
+      # in comments. You could set an array of allowed non-ascii chars in
+      # AllowedChars attribute (empty by default).
+      #
+      # @example
+      #   # bad
+      #   # Translates from English to 日本語。
+      #
+      #   # good
+      #   # Translates from English to Japanese
       class AsciiComments < Cop
-        MSG = 'Use only ascii symbols in comments.'.freeze
+        include RangeHelp
+
+        MSG = 'Use only ascii symbols in comments.'
 
         def investigate(processed_source)
-          processed_source.comments.each do |comment|
-            unless comment.text.ascii_only?
-              add_offense(comment, location: first_offense_range(comment))
-            end
+          processed_source.each_comment do |comment|
+            next if comment.text.ascii_only?
+            next if only_allowed_non_ascii_chars?(comment.text)
+
+            add_offense(comment, location: first_offense_range(comment))
           end
         end
 
@@ -32,7 +45,17 @@ module RuboCop
         def first_non_ascii_chars(string)
           string.match(/[^[:ascii:]]+/).to_s
         end
+
+        def only_allowed_non_ascii_chars?(string)
+          non_ascii = string.scan(/[^[:ascii:]]/)
+          (non_ascii - allowed_non_ascii_chars).empty?
+        end
+
+        def allowed_non_ascii_chars
+          cop_config['AllowedChars'] || []
+        end
       end
     end
   end
 end
+# rubocop:enable Style/AsciiComments

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

@@ -4,26 +4,38 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for uses of Module#attr.
+      #
+      # @example
+      #   # bad - creates a single attribute accessor (deprecated in Ruby 1.9)
+      #   attr :something, true
+      #   attr :one, :two, :three # behaves as attr_reader
+      #
+      #   # good
+      #   attr_accessor :something
+      #   attr_reader :one, :two, :three
+      #
       class Attr < Cop
-        MSG = 'Do not use `attr`. Use `%s` instead.'.freeze
+        include RangeHelp
+
+        MSG = 'Do not use `attr`. Use `%<replacement>s` instead.'
 
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
+          # check only for method definitions in class/module body
+          return if node.parent &&
+                    !node.parent.class_type? &&
+                    !class_eval?(node.parent)
 
           add_offense(node, location: :selector)
         end
 
-        private
-
         def autocorrect(node)
           attr_name, setter = *node.arguments
 
           node_expr = node.source_range
           attr_expr = attr_name.source_range
 
-          if setter && (setter.true_type? || setter.false_type?)
-            remove = range_between(attr_expr.end_pos, node_expr.end_pos)
-          end
+          remove = range_between(attr_expr.end_pos, node_expr.end_pos) if setter&.boolean_type?
 
           lambda do |corrector|
             corrector.replace(node.loc.selector, replacement_method(node))
@@ -31,19 +43,25 @@ module RuboCop
           end
         end
 
+        private
+
         def message(node)
-          format(MSG, replacement_method(node))
+          format(MSG, replacement: replacement_method(node))
         end
 
         def replacement_method(node)
           setter = node.last_argument
 
-          if setter && (setter.true_type? || setter.false_type?)
+          if setter&.boolean_type?
             setter.true_type? ? 'attr_accessor' : 'attr_reader'
           else
             'attr_reader'
           end
         end
+
+        def_node_matcher :class_eval?, <<~PATTERN
+          (block (send _ {:class_eval :module_eval}) ...)
+        PATTERN
       end
     end
   end

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

@@ -14,10 +14,10 @@ module RuboCop
       #
       #   # good
       #   File.open('file') do |f|
-      #     ...
+      #     # ...
       #   end
       class AutoResourceCleanup < Cop
-        MSG = 'Use the block version of `%s.%s`.'.freeze
+        MSG = 'Use the block version of `%<class>s.%<method>s`.'
 
         TARGET_METHODS = {
           File: :open
@@ -29,13 +29,22 @@ module RuboCop
 
             next if node.receiver != target_receiver
             next if node.method_name != target_method
-            next if node.parent && node.parent.block_type?
-            next if node.block_argument?
+            next if cleanup?(node)
 
             add_offense(node,
-                        message: format(MSG, target_class, target_method))
+                        message: format(MSG,
+                                        class: target_class,
+                                        method: target_method))
           end
         end
+
+        private
+
+        def cleanup?(node)
+          parent = node.parent
+          node.block_argument? ||
+            (parent && (parent.block_type? || !parent.lvasgn_type?))
+        end
       end
     end
   end