rubocop 1.9.1 → 1.22.3

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

@@ -7,9 +7,10 @@ module RuboCop
       # replaced with a module. Classes should be used only when it makes sense to create
       # instances out of them.
       #
-      # This cop is marked as unsafe, because it is possible that this class is a parent
-      # for some other subclass, monkey-patched with instance methods or
-      # a dummy instance is instantiated from it somewhere.
+      # @safety
+      #   This cop is unsafe, because it is possible that this class is a parent
+      #   for some other subclass, monkey-patched with instance methods or
+      #   a dummy instance is instantiated from it somewhere.
       #
       # @example
       #   # bad
@@ -60,8 +61,7 @@ module RuboCop
           return false if nodes.empty?
 
           nodes.all? do |node|
-            node_visibility(node) == :public &&
-              node.defs_type? ||
+            (node_visibility(node) == :public && node.defs_type?) ||
               sclass_convertible_to_module?(node) ||
               node.equals_asgn? ||
               extend_call?(node)

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

@@ -18,10 +18,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG =
-          'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+        MSG = 'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
         RESTRICT_ON_SEND = %i[puts].freeze
 
+        # @!method stderr_puts?(node)
         def_node_matcher :stderr_puts?, <<~PATTERN
           (send
             {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
@@ -49,10 +49,7 @@ module RuboCop
         end
 
         def stderr_puts_range(send)
-          range_between(
-            send.loc.expression.begin_pos,
-            send.loc.selector.end_pos
-          )
+          range_between(send.loc.expression.begin_pos, send.loc.selector.end_pos)
         end
       end
     end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `String#split` with empty string or regexp literal argument.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is actually a string. If another class has a `split` method with
+      #   different behaviour, it would be registered as a false positive.
+      #
+      # @example
+      #   # bad
+      #   string.split(//)
+      #   string.split('')
+      #
+      #   # good
+      #   string.chars
+      #
+      class StringChars < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `chars` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[split].freeze
+        BAD_ARGUMENTS = %w[// '' ""].freeze
+
+        def on_send(node)
+          return unless node.arguments.one? && BAD_ARGUMENTS.include?(node.first_argument.source)
+
+          range = range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+
+          add_offense(range, message: format(MSG, current: range.source)) do |corrector|
+            corrector.replace(range, 'chars')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -15,25 +15,50 @@ module RuboCop
       # lines, this cop does not register an offense; instead,
       # `Style/LineEndConcatenation` will pick up the offense if enabled.
       #
-      # @example
+      # Two modes are supported:
+      # 1. `aggressive` style checks and corrects all occurrences of `+` where
+      # either the left or right side of `+` is a string literal.
+      # 2. `conservative` style on the other hand, checks and corrects only if
+      # left side (receiver of `+` method call) is a string literal.
+      # This is useful when the receiver is some expression that returns string like `Pathname`
+      # instead of a string literal.
+      #
+      # @safety
+      #   This cop is unsafe in `aggressive` mode, as it cannot be guaranteed that
+      #   the receiver is actually a string, which can result in a false positive.
+      #
+      # @example Mode: aggressive (default)
       #   # bad
       #   email_with_name = user.name + ' <' + user.email + '>'
+      #   Pathname.new('/') + 'test'
       #
       #   # good
       #   email_with_name = "#{user.name} <#{user.email}>"
       #   email_with_name = format('%s <%s>', user.name, user.email)
+      #   "#{Pathname.new('/')}test"
       #
       #   # accepted, line-end concatenation
       #   name = 'First' +
       #     'Last'
       #
+      # @example Mode: conservative
+      #   # bad
+      #   'Hello' + user.name
+      #
+      #   # good
+      #   "Hello #{user.name}"
+      #   user.name + '!!'
+      #   Pathname.new('/') + 'test'
+      #
       class StringConcatenation < Base
         include Util
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Prefer string interpolation to string concatenation.'
         RESTRICT_ON_SEND = %i[+].freeze
 
+        # @!method string_concatenation?(node)
         def_node_matcher :string_concatenation?, <<~PATTERN
           {
             (send str_type? :+ _)
@@ -50,10 +75,15 @@ module RuboCop
           return if line_end_concatenation?(node)
 
           topmost_plus_node = find_topmost_plus_node(node)
+          parts = collect_parts(topmost_plus_node)
+          return unless parts[0..-2].any? { |receiver_node| offensive_for_mode?(receiver_node) }
 
-          parts = []
-          collect_parts(topmost_plus_node, parts)
+          register_offense(topmost_plus_node, parts)
+        end
+
+        private
 
+        def register_offense(topmost_plus_node, parts)
           add_offense(topmost_plus_node) do |corrector|
             correctable_parts = parts.none? { |part| uncorrectable?(part) }
             if correctable_parts && !corrected_ancestor?(topmost_plus_node)
@@ -65,7 +95,10 @@ module RuboCop
           end
         end
 
-        private
+        def offensive_for_mode?(receiver_node)
+          mode = cop_config['Mode'].to_sym
+          mode == :aggressive || (mode == :conservative && receiver_node.str_type?)
+        end
 
         def line_end_concatenation?(node)
           # If the concatenation happens at the end of the line,
@@ -85,7 +118,7 @@ module RuboCop
           current
         end
 
-        def collect_parts(node, parts)
+        def collect_parts(node, parts = [])
           return unless node
 
           if plus_node?(node)
@@ -101,10 +134,7 @@ module RuboCop
         end
 
         def uncorrectable?(part)
-          part.multiline? ||
-            part.dstr_type? ||
-            (part.str_type? && part.heredoc?) ||
-            part.each_descendant(:block).any?
+          part.multiline? || (part.str_type? && part.heredoc?) || part.each_descendant(:block).any?
         end
 
         def corrected_ancestor?(node)
@@ -114,12 +144,12 @@ module RuboCop
         def replacement(parts)
           interpolated_parts =
             parts.map do |part|
-              if part.str_type?
-                if single_quoted?(part)
-                  part.value.gsub(/(\\|")/, '\\\\\&')
-                else
-                  part.value.inspect[1..-2]
-                end
+              case part.type
+              when :str
+                value = part.value
+                single_quoted?(part) ? value.gsub(/(\\|")/, '\\\\\&') : value.inspect[1..-2]
+              when :dstr
+                contents_range(part).source
               else
                 "\#{#{part.source}}"
               end

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for the use of strings as keys in hashes. The use of
       # symbols is preferred instead.
       #
+      # @safety
+      #   This cop is unsafe because while symbols are preferred for hash keys,
+      #   there are instances when string keys are required.
+      #
       # @example
       #   # bad
       #   { 'one' => 1, 'two' => 2, 'three' => 3 }
@@ -17,10 +21,12 @@ module RuboCop
 
         MSG = 'Prefer symbols instead of strings as hash keys.'
 
+        # @!method string_hash_key?(node)
         def_node_matcher :string_hash_key?, <<~PATTERN
           (pair (str _) _)
         PATTERN
 
+        # @!method receive_environments_method?(node)
         def_node_matcher :receive_environments_method?, <<~PATTERN
           {
             ^^(send (const {nil? cbase} :IO) :popen ...)

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

@@ -29,6 +29,7 @@ module RuboCop
       class StringLiterals < Base
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
+        include StringHelp
         extend AutoCorrector
 
         MSG_INCONSISTENT = 'Inconsistent quote style.'
@@ -86,10 +87,10 @@ module RuboCop
         def message(_node)
           if style == :single_quotes
             "Prefer single-quoted strings when you don't need string " \
-            'interpolation or special symbols.'
+              'interpolation or special symbols.'
           else
             'Prefer double-quoted strings unless you need single quotes to ' \
-            'avoid extra backslashes for escaping.'
+              'avoid extra backslashes for escaping.'
           end
         end
 
@@ -110,8 +111,7 @@ module RuboCop
           if unexpected_single_quotes?(quote)
             all_children_with_quotes = children.all? { |c| wrong_quotes?(c) }
             register_offense(node) if all_children_with_quotes
-          elsif unexpected_double_quotes?(quote) &&
-                !accept_child_double_quotes?(children)
+          elsif unexpected_double_quotes?(quote) && !accept_child_double_quotes?(children)
             register_offense(node)
           end
         end
@@ -125,9 +125,7 @@ module RuboCop
         end
 
         def accept_child_double_quotes?(nodes)
-          nodes.any? do |n|
-            n.dstr_type? || double_quotes_required?(n.source)
-          end
+          nodes.any? { |n| n.dstr_type? || double_quotes_required?(n.source) }
         end
       end
     end

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

@@ -22,6 +22,7 @@ module RuboCop
       class StringLiteralsInInterpolation < Base
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
+        include StringHelp
         extend AutoCorrector
 
         def autocorrect(corrector, node)

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

@@ -20,6 +20,7 @@ module RuboCop
         MSG = 'Use `strip` instead of `%<methods>s`.'
         RESTRICT_ON_SEND = %i[lstrip rstrip].freeze
 
+        # @!method lstrip_rstrip(node)
         def_node_matcher :lstrip_rstrip, <<~PATTERN
           {(send $(send _ $:rstrip) $:lstrip)
            (send $(send _ $:lstrip) $:rstrip)}

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

@@ -5,6 +5,10 @@ module RuboCop
     module Style
       # This cop checks for inheritance from Struct.new.
       #
+      # @safety
+      #   Auto-correction is unsafe because it will change the inheritance
+      #   tree (e.g. return value of `Module#ancestors`) of the constant.
+      #
       # @example
       #   # bad
       #   class Person < Struct.new(:first_name, :last_name)
@@ -37,6 +41,7 @@ module RuboCop
           end
         end
 
+        # @!method struct_constructor?(node)
         def_node_matcher :struct_constructor?, <<~PATTERN
           {(send (const {nil? cbase} :Struct) :new ...)
            (block (send (const {nil? cbase} :Struct) :new ...) ...)}
@@ -47,10 +52,20 @@ module RuboCop
         def correct_parent(parent, corrector)
           if parent.block_type?
             corrector.remove(range_with_surrounding_space(range: parent.loc.end, newlines: false))
+          elsif (class_node = parent.parent).body.nil?
+            corrector.remove(range_for_empty_class_body(class_node, parent))
           else
             corrector.insert_after(parent.loc.expression, ' do')
           end
         end
+
+        def range_for_empty_class_body(class_node, struct_new)
+          if class_node.single_line?
+            range_between(struct_new.source_range.end_pos, class_node.source_range.end_pos)
+          else
+            range_by_whole_lines(class_node.loc.end, include_final_newline: true)
+          end
+        end
       end
     end
   end

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

@@ -4,8 +4,10 @@ module RuboCop
   module Cop
     module Style
       # This cop enforces the use of shorthand-style swapping of 2 variables.
-      # Its autocorrection is marked as unsafe, because it can erroneously remove
-      # the temporary variable which is used later.
+      #
+      # @safety
+      #   Autocorrection is unsafe, because the temporary variable used to
+      #   swap variables will be removed, but may be referred to elsewhere.
       #
       # @example
       #   # bad
@@ -21,7 +23,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Replace this and assignments at lines %<x_line>d '\
-          'and %<y_line>d with `%<replacement>s`.'
+              'and %<y_line>d with `%<replacement>s`.'
 
         SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].to_set.freeze
 

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

@@ -35,7 +35,7 @@ module RuboCop
         extend AutoCorrector
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
-        ARRAY_MSG = 'Use `[]` for an array of symbols.'
+        ARRAY_MSG = 'Use `%<prefer>s` for an array of symbols.'
 
         class << self
           attr_accessor :largest_brackets
@@ -60,7 +60,7 @@ module RuboCop
           end
         end
 
-        def correct_bracketed(corrector, node)
+        def build_bracketed_array(node)
           syms = node.children.map do |c|
             if c.dsym_type?
               string_literal = to_string_literal(c.source)
@@ -71,7 +71,7 @@ module RuboCop
             end
           end
 
-          corrector.replace(node, "[#{syms.join(', ')}]")
+          "[#{syms.join(', ')}]"
         end
 
         def to_symbol_literal(string)

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

@@ -20,9 +20,7 @@ module RuboCop
         def on_sym(node)
           return unless /\A:["'][A-Za-z_]\w*["']\z/.match?(node.source)
 
-          add_offense(node) do |corrector|
-            corrector.replace(node, node.source.delete(%q('")))
-          end
+          add_offense(node) { |corrector| corrector.replace(node, node.source.delete(%q('"))) }
         end
       end
     end

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

@@ -5,6 +5,35 @@ module RuboCop
     module Style
       # Use symbols as procs when possible.
       #
+      # If you prefer a style that allows block for method with arguments,
+      # please set `true` to `AllowMethodsWithArguments`.
+      #
+      # @safety
+      #   This cop is unsafe because `proc`s and blocks work differently
+      #   when additional arguments are passed in. A block will silently
+      #   ignore additional arguments, but a `proc` will raise
+      #   an `ArgumentError`.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Foo
+      #     def bar
+      #       :bar
+      #     end
+      #   end
+      #
+      #   def call(options = {}, &block)
+      #     block.call(Foo.new, options)
+      #   end
+      #
+      #   call { |x| x.bar }
+      #   #=> :bar
+      #   call(&:bar)
+      #   # ArgumentError: wrong number of arguments (given 1, expected 0)
+      #   ----
+      #
       # @example
       #   # bad
       #   something.map { |s| s.upcase }
@@ -12,17 +41,32 @@ module RuboCop
       #
       #   # good
       #   something.map(&:upcase)
+      #
+      # @example AllowMethodsWithArguments: false (default)
+      #   # bad
+      #   something.do_something(foo) { |o| o.bar }
+      #
+      #   # good
+      #   something.do_something(foo, &:bar)
+      #
+      # @example AllowMethodsWithArguments: true
+      #   # good
+      #   something.do_something(foo) { |o| o.bar }
       class SymbolProc < Base
         include RangeHelp
         include IgnoredMethods
         extend AutoCorrector
 
-        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
-              'instead of a block.'
+        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
 
+        # @!method proc_node?(node)
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
+
+        # @!method symbol_proc_receiver?(node)
         def_node_matcher :symbol_proc_receiver?, '{(send ...) (super ...) zsuper}'
+
+        # @!method symbol_proc?(node)
         def_node_matcher :symbol_proc?, <<~PATTERN
           {
             (block $#symbol_proc_receiver? $(args (arg _var)) (send (lvar _var) $_))
@@ -37,11 +81,12 @@ module RuboCop
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
             # TODO: Rails-specific handling that we should probably make
-            # configurable - https://github.com/rubocop-hq/rubocop/issues/1485
+            # configurable - https://github.com/rubocop/rubocop/issues/1485
             # we should ignore lambdas & procs
             return if proc_node?(dispatch_node)
             return if %i[lambda proc].include?(dispatch_node.method_name)
             return if ignored_method?(dispatch_node.method_name)
+            return if allow_if_method_has_argument?(node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
 
             register_offense(node, method_name, dispatch_node.method_name)
@@ -61,9 +106,7 @@ module RuboCop
           range = range_between(block_start, block_end)
           message = format(MSG, method: method_name, block_method: block_method_name)
 
-          add_offense(range, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(range, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -75,8 +118,7 @@ module RuboCop
         end
 
         def autocorrect_without_args(corrector, node)
-          corrector.replace(block_range_with_space(node),
-                            "(&:#{node.body.method_name})")
+          corrector.replace(block_range_with_space(node), "(&:#{node.body.method_name})")
         end
 
         def autocorrect_with_args(corrector, node, args, method_name)
@@ -89,8 +131,7 @@ module RuboCop
         end
 
         def block_range_with_space(node)
-          block_range = range_between(begin_pos_for_replacement(node),
-                                      node.loc.end.end_pos)
+          block_range = range_between(begin_pos_for_replacement(node), node.loc.end.end_pos)
           range_with_surrounding_space(range: block_range, side: :left)
         end
 
@@ -103,6 +144,10 @@ module RuboCop
             node.loc.begin.begin_pos
           end
         end
+
+        def allow_if_method_has_argument?(node)
+          !!cop_config.fetch('AllowMethodsWithArguments', false) && !node.arguments.count.zero?
+        end
       end
     end
   end

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

@@ -64,8 +64,7 @@ module RuboCop
         NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
 
         MSG = '%<command>s parentheses for ternary conditions.'
-        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with' \
-          ' complex conditions.'
+        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with complex conditions.'
 
         def on_if(node)
           return if only_closing_parenthesis_is_last_line?(node.condition)
@@ -88,8 +87,7 @@ module RuboCop
           condition = node.condition
 
           return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) ||
-                        unsafe_autocorrect?(condition))
+                        (safe_assignment?(condition) || unsafe_autocorrect?(condition))
 
           if parenthesized?(condition)
             correct_parenthesized(corrector, condition)
@@ -127,8 +125,7 @@ module RuboCop
         # Anything that is not a variable, constant, or method/.method call
         # will be counted as a complex expression.
         def non_complex_expression?(condition)
-          NON_COMPLEX_TYPES.include?(condition.type) ||
-            non_complex_send?(condition)
+          NON_COMPLEX_TYPES.include?(condition.type) || non_complex_send?(condition)
         end
 
         def non_complex_send?(node)
@@ -191,6 +188,7 @@ module RuboCop
             (child.send_type? && child.prefix_not?)
         end
 
+        # @!method method_name(node)
         def_node_matcher :method_name, <<~PATTERN
           {($:defined? _ ...)
            (send {_ nil?} $_ _ ...)}

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Newcomers to ruby applications may write top-level methods,
+      # when ideally they should be organized in appropriate classes or modules.
+      # This cop looks for definitions of top-level methods and warns about them.
+      #
+      # However for ruby scripts it is perfectly fine to use top-level methods.
+      # Hence this cop is disabled by default.
+      #
+      # @example
+      #   # bad
+      #   def some_method
+      #   end
+      #
+      #   # bad
+      #   def self.some_method
+      #   end
+      #
+      #   # bad
+      #   define_method(:foo) { puts 1 }
+      #
+      #   # good
+      #   module Foo
+      #     def some_method
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.some_method
+      #     end
+      #   end
+      #
+      #   # good
+      #   Struct.new do
+      #     def some_method
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     define_method(:foo) { puts 1 }
+      #   end
+      class TopLevelMethodDefinition < Base
+        MSG = 'Do not define methods at the top-level.'
+
+        RESTRICT_ON_SEND = %i[define_method].freeze
+
+        def on_def(node)
+          return unless top_level_method_definition?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+        alias on_send on_def
+
+        def on_block(node)
+          return unless define_method_block?(node) && top_level_method_definition?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def top_level_method_definition?(node)
+          if node.parent&.begin_type?
+            node.parent.root?
+          else
+            node.root?
+          end
+        end
+
+        # @!method define_method_block?(node)
+        def_node_matcher :define_method_block?, <<~PATTERN
+          (block (send _ {:define_method} _) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # This cop checks for trailing code after the method definition.
       #
+      # NOTE: It always accepts endless method definitions that are basically on the same line.
+      #
       # @example
       #   # bad
       #   def some_method; do_stuff
@@ -24,16 +26,18 @@ module RuboCop
       #     b[c: x]
       #   end
       #
+      #   def endless_method = do_stuff
+      #
       class TrailingBodyOnMethodDefinition < Base
         include Alignment
         include TrailingBody
         extend AutoCorrector
 
-        MSG = "Place the first line of a multi-line method definition's " \
-              'body on its own line.'
+        MSG = "Place the first line of a multi-line method definition's body on its own line."
 
         def on_def(node)
           return unless trailing_body?(node)
+          return if node.endless?
 
           add_offense(first_part_of(node.body)) do |corrector|
             LineBreakCorrector.correct_trailing_body(