rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -14,8 +13,12 @@ module RuboCop
       #   # good
       #   x += 1
       class SelfAssignment < Cop
-        MSG = 'Use self-assignment shorthand `%s=`.'.freeze
-        OPS = [:+, :-, :*, :**, :/, :|, :&].freeze
+        MSG = 'Use self-assignment shorthand `%<method>s=`.'.freeze
+        OPS = %i[+ - * ** / | &].freeze
+
+        def self.autocorrect_incompatible_with
+          [Layout::SpaceAroundOperators]
+        end
 
         def on_lvasgn(node)
           check(node, :lvar)
@@ -29,15 +32,25 @@ module RuboCop
           check(node, :cvar)
         end
 
+        def autocorrect(node)
+          _var_name, rhs = *node
+
+          if rhs.send_type?
+            autocorrect_send_node(node, rhs)
+          elsif %i[and or].include?(rhs.type)
+            autocorrect_boolean_node(node, rhs)
+          end
+        end
+
         private
 
         def check(node, var_type)
           var_name, rhs = *node
           return unless rhs
 
-          if rhs.type == :send
+          if rhs.send_type?
             check_send_node(node, rhs, var_name, var_type)
-          elsif [:and, :or].include?(rhs.type)
+          elsif %i[and or].include?(rhs.type)
             check_boolean_node(node, rhs, var_name, var_type)
           end
         end
@@ -49,7 +62,7 @@ module RuboCop
           target_node = s(var_type, var_name)
           return unless receiver == target_node
 
-          add_offense(node, :expression, format(MSG, method_name))
+          add_offense(node, message: format(MSG, method: method_name))
         end
 
         def check_boolean_node(node, rhs, var_name, var_type)
@@ -59,17 +72,7 @@ module RuboCop
           return unless first_operand == target_node
 
           operator = rhs.loc.operator.source
-          add_offense(node, :expression, format(MSG, operator))
-        end
-
-        def autocorrect(node)
-          _var_name, rhs = *node
-
-          if rhs.type == :send
-            autocorrect_send_node(node, rhs)
-          elsif [:and, :or].include?(rhs.type)
-            autocorrect_boolean_node(node, rhs)
-          end
+          add_offense(node, message: format(MSG, method: operator))
         end
 
         def autocorrect_send_node(node, rhs)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,6 +5,16 @@ module RuboCop
     module Style
       # This cop checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
+      #
+      # @example
+      #   # bad
+      #   foo = 1; bar = 2;
+      #   baz = 3;
+      #
+      #   # good
+      #   foo = 1
+      #   bar = 2
+      #   baz = 3
       class Semicolon < Cop
         MSG = 'Do not use semicolons to terminate expressions.'.freeze
 
@@ -37,34 +46,33 @@ module RuboCop
           end
         end
 
+        def autocorrect(range)
+          return unless range
+          ->(corrector) { corrector.remove(range) }
+        end
+
         private
 
         def check_for_line_terminator_or_opener
-          tokens_for_lines = @processed_source.tokens.group_by do |token|
-            token.pos.line
-          end
+          each_semicolon { |line, column| convention_on(line, column, true) }
+        end
 
+        def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            if tokens.last.type == :tSEMI
-              convention_on(line, tokens.last.pos.column, true)
-            end
-
-            if tokens.first.type == :tSEMI
-              convention_on(line, tokens.first.pos.column, true)
-            end
+            yield line, tokens.last.column if tokens.last.semicolon?
+            yield line, tokens.first.column if tokens.first.semicolon?
           end
         end
 
+        def tokens_for_lines
+          @processed_source.tokens.group_by(&:line)
+        end
+
         def convention_on(line, column, autocorrect)
           range = source_range(@processed_source.buffer, line, column)
           # Don't attempt to autocorrect if semicolon is separating statements
           # on the same line
-          add_offense(autocorrect ? range : nil, range)
-        end
-
-        def autocorrect(range)
-          return unless range
-          ->(corrector) { corrector.remove(range) }
+          add_offense(autocorrect ? range : nil, location: range)
         end
       end
     end

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

@@ -1,18 +1,28 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for the use of the send method.
+      #
+      # @example
+      #   # bad
+      #   Foo.send(:bar)
+      #   quuz.send(:fred)
+      #
+      #   # good
+      #   Foo.__send__(:bar)
+      #   quuz.public_send(:fred)
       class Send < Cop
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
               '`send`.'.freeze
 
+        def_node_matcher :sending?, '(send _ :send ...)'
+
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return unless method_name == :send && !args.empty?
-          add_offense(node, :selector)
+          return unless sending?(node) && node.arguments?
+
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -1,10 +1,109 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for uses of `fail` and `raise`.
+      #
+      # @example EnforcedStyle: only_raise (default)
+      #   # The `only_raise` style enforces the sole use of `raise`.
+      #   # bad
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.fail
+      #
+      #   # good
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.raise
+      #
+      # @example EnforcedStyle: only_fail
+      #   # The `only_fail` style enforces the sole use of `fail`.
+      #   # bad
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.raise
+      #
+      #   # good
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.fail
+      #
+      # @example EnforcedStyle: semantic
+      #   # The `semantic` style enforces the use of `fail` to signal an
+      #   # exception, then will use `raise` to trigger an offense after
+      #   # it has been rescued.
+      #   # bad
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     # Error thrown
+      #   rescue Exception
+      #     fail
+      #   end
+      #
+      #   Kernel.fail
+      #   Kernel.raise
+      #
+      #   # good
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     raise 'Preferably with descriptive message'
+      #   end
+      #
+      #   explicit_receiver.fail
+      #   explicit_receiver.raise
       class SignalException < Cop
         include ConfigurableEnforcedStyle
 
@@ -12,7 +111,7 @@ module RuboCop
         RAISE_MSG = 'Use `raise` instead of `fail` to ' \
                     'rethrow exceptions.'.freeze
 
-        def_node_matcher :kernel_call?, '(send (const nil :Kernel) %1 ...)'
+        def_node_matcher :kernel_call?, '(send (const nil? :Kernel) %1 ...)'
         def_node_search :custom_fail_methods,
                         '{(def :fail ...) (defs _ :fail ...)}'
 
@@ -78,17 +177,16 @@ module RuboCop
           each_command_or_kernel_call(method_name, node) do |send_node|
             next if ignored_node?(send_node)
 
-            add_offense(send_node, :selector, message(method_name))
+            add_offense(send_node,
+                        location: :selector, message: message(method_name))
             ignore_node(send_node)
           end
         end
 
         def check_send(method_name, node)
-          return unless node
+          return unless node && command_or_kernel_call?(method_name, node)
 
-          if command_or_kernel_call?(method_name, node)
-            add_offense(node, :selector, message(method_name))
-          end
+          add_offense(node, location: :selector, message: message(method_name))
         end
 
         def command_or_kernel_call?(name, node)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,32 +9,35 @@ module RuboCop
       # For instance one can configure `reduce`(`inject`) to use |a, e| as
       # parameters.
       class SingleLineBlockParams < Cop
+        MSG = 'Name `%<method>s` block params `|%<params>s|`.'.freeze
+
         def on_block(node)
-          # we care only for single line blocks
-          return unless block_length(node).zero?
+          return unless node.single_line?
+
+          return unless eligible_method?(node)
+          return unless eligible_arguments?(node)
 
-          method_node, args_node, _body_node = *node
-          receiver, method_name, _method_args = *method_node
+          return if args_match?(node.send_node.method_name, node.arguments)
 
-          # discard other scenarios
-          return unless receiver
-          return unless method_names.include?(method_name)
+          add_offense(node.arguments)
+        end
 
-          args = *args_node
+        private
 
-          return if args.empty?
-          # discard cases with argument destructuring
-          return true unless args.all? { |n| n.type == :arg }
-          return if args_match?(method_name, args)
+        def message(node)
+          method_name = node.parent.send_node.method_name
+          arguments   = target_args(method_name).join(', ')
 
-          add_offense(args_node, :expression, message(method_name))
+          format(MSG, method: method_name, params: arguments)
         end
 
-        private
+        def eligible_arguments?(node)
+          node.arguments? && node.arguments.to_a.all?(&:arg_type?)
+        end
 
-        def message(method_name)
-          args = target_args(method_name).join(', ')
-          "Name `#{method_name}` block params `|#{args}|`."
+        def eligible_method?(node)
+          node.send_node.receiver &&
+            method_names.include?(node.send_node.method_name)
         end
 
         def methods
@@ -43,17 +45,21 @@ module RuboCop
         end
 
         def method_names
-          methods.map { |e| e.keys.first.to_sym }
+          methods.map { |method| method_name(method).to_sym }
+        end
+
+        def method_name(method)
+          method.keys.first
         end
 
         def target_args(method_name)
           method_name = method_name.to_s
-          method_hash = methods.find { |m| m.keys.first == method_name }
+          method_hash = methods.find { |m| method_name(m) == method_name }
           method_hash[method_name]
         end
 
         def args_match?(method_name, args)
-          actual_args = args.flat_map(&:to_a)
+          actual_args = args.to_a.flat_map(&:to_a)
 
           # Prepending an underscore to mark an unused parameter is allowed, so
           # we remove any leading underscores before comparing.

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

@@ -1,56 +1,70 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for single-line method definitions.
-      # It can optionally accept single-line methods with no body.
+      # This cop checks for single-line method definitions that contain a body.
+      # It will accept single-line methods with no body.
+      #
+      # @example
+      #   # bad
+      #   def some_method; body end
+      #   def link_to(url); {:name => url}; end
+      #   def @table.columns; super; end
+      #
+      #   # good
+      #   def no_op; end
+      #   def self.resource_class=(klass); end
+      #   def @table.columns; end
+      #
       class SingleLineMethods < Cop
-        include AutocorrectAlignment
-        include OnMethodDef
+        include Alignment
 
         MSG = 'Avoid single-line method definitions.'.freeze
 
-        def allow_empty?
-          cop_config['AllowIfMethodIsEmpty']
-        end
-
-        private
-
-        def on_method_def(node, _method_name, _args, body)
-          start_line = node.loc.keyword.line
-          end_line = node.loc.end.line
+        def on_def(node)
+          return unless node.single_line?
+          return if allow_empty? && !node.body
 
-          empty_body = body.nil?
-          return unless start_line == end_line && !(allow_empty? && empty_body)
-
-          @body = body
-          add_offense(node, :expression)
+          add_offense(node)
         end
+        alias on_defs on_def
 
         def autocorrect(node)
-          body = @body
-          eol_comment = processed_source.comments.find do |c|
-            c.loc.line == node.source_range.line
-          end
+          body = node.body
+
           lambda do |corrector|
-            if body
-              if body.type == :begin
-                body.children.each do |part|
-                  break_line_before(part.source_range, node, corrector, 1)
-                end
-              else
-                break_line_before(body.source_range, node, corrector, 1)
-              end
+            each_part(body) do |part|
+              break_line_before(part, node, corrector, 1)
             end
 
             break_line_before(node.loc.end, node, corrector, 0)
 
+            eol_comment = end_of_line_comment(node.source_range.line)
             move_comment(eol_comment, node, corrector) if eol_comment
           end
         end
 
+        private
+
+        def allow_empty?
+          cop_config['AllowIfMethodIsEmpty']
+        end
+
+        def end_of_line_comment(line)
+          processed_source.comments.find { |c| c.loc.line == line }
+        end
+
+        def each_part(body)
+          return unless body
+
+          if body.begin_type?
+            body.each_child_node { |part| yield part.source_range }
+          else
+            yield body.source_range
+          end
+        end
+
         def break_line_before(range, node, corrector, indent_steps)
           corrector.insert_before(
             range,

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,11 +7,12 @@ module RuboCop
       class SpecialGlobalVars < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_BOTH = 'Prefer `%s` from the stdlib \'English\' module, ' \
-        'or `%s` over `%s`.'.freeze
-        MSG_ENGLISH = 'Prefer `%s` from the stdlib \'English\' module ' \
-        'over `%s`.'.freeze
-        MSG_REGULAR = 'Prefer `%s` over `%s`.'.freeze
+        MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+        'module (don\'t forget to require it), or `%<regular>s` over ' \
+        '`%<global>s`.'.freeze
+        MSG_ENGLISH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
+        'module (don\'t forget to require it) over `%<global>s`.'.freeze
+        MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'.freeze
 
         ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
           :$: => [:$LOAD_PATH],
@@ -20,19 +20,19 @@ module RuboCop
           :$0 => [:$PROGRAM_NAME],
           :$! => [:$ERROR_INFO],
           :$@ => [:$ERROR_POSITION],
-          :$; => [:$FIELD_SEPARATOR, :$FS],
-          :$, => [:$OUTPUT_FIELD_SEPARATOR, :$OFS],
-          :$/ => [:$INPUT_RECORD_SEPARATOR, :$RS],
-          :$\ => [:$OUTPUT_RECORD_SEPARATOR, :$ORS],
-          :$. => [:$INPUT_LINE_NUMBER, :$NR],
+          :$; => %i[$FIELD_SEPARATOR $FS],
+          :$, => %i[$OUTPUT_FIELD_SEPARATOR $OFS],
+          :$/ => %i[$INPUT_RECORD_SEPARATOR $RS],
+          :$\ => %i[$OUTPUT_RECORD_SEPARATOR $ORS],
+          :$. => %i[$INPUT_LINE_NUMBER $NR],
           :$_ => [:$LAST_READ_LINE],
           :$> => [:$DEFAULT_OUTPUT],
           :$< => [:$DEFAULT_INPUT],
-          :$$ => [:$PROCESS_ID, :$PID],
+          :$$ => %i[$PROCESS_ID $PID],
           :$? => [:$CHILD_STATUS],
           :$~ => [:$LAST_MATCH_INFO],
           :$= => [:$IGNORECASE],
-          :$* => [:$ARGV, :ARGV],
+          :$* => %i[$ARGV ARGV],
           :$& => [:$MATCH],
           :$` => [:$PREMATCH],
           :$' => [:$POSTMATCH],
@@ -48,15 +48,15 @@ module RuboCop
         PERL_VARS.merge!(
           Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
         )
-        ENGLISH_VARS.each { |_, v| v.freeze }.freeze
-        PERL_VARS.each { |_, v| v.freeze }.freeze
+        ENGLISH_VARS.each_value(&:freeze).freeze
+        PERL_VARS.each_value(&:freeze).freeze
 
         # Anything *not* in this set is provided by the English library.
-        NON_ENGLISH_VARS = Set.new([
-                                     :$LOAD_PATH,
-                                     :$LOADED_FEATURES,
-                                     :$PROGRAM_NAME,
-                                     :ARGV
+        NON_ENGLISH_VARS = Set.new(%i[
+                                     $LOAD_PATH
+                                     $LOADED_FEATURES
+                                     $PROGRAM_NAME
+                                     ARGV
                                    ]).freeze
 
         def on_gvar(node)
@@ -68,7 +68,7 @@ module RuboCop
             correct_style_detected
           else
             opposite_style_detected
-            add_offense(node, :expression)
+            add_offense(node)
           end
         end
 
@@ -78,7 +78,9 @@ module RuboCop
           if style == :use_english_names
             format_english_message(global_var)
           else
-            format(MSG_REGULAR, preferred_names(global_var).first, global_var)
+            format(MSG_REGULAR,
+                   prefer: preferred_names(global_var).first,
+                   global: global_var)
           end
         end
 
@@ -105,14 +107,16 @@ module RuboCop
           format_message(english, regular, global_var)
         end
 
-        def format_message(english, regular, global_var)
+        def format_message(english, regular, global)
           if !regular.empty? && !english.empty?
-            format(MSG_BOTH, format_list(english), format_list(regular),
-                   global_var)
+            format(MSG_BOTH,
+                   prefer: format_list(english),
+                   regular: format_list(regular),
+                   global: global)
           elsif !regular.empty?
-            format(MSG_REGULAR, format_list(regular), global_var)
+            format(MSG_REGULAR, prefer: format_list(regular), global: global)
           elsif !english.empty?
-            format(MSG_ENGLISH, format_list(english), global_var)
+            format(MSG_ENGLISH, prefer: format_list(english), global: global)
           else
             raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
           end
@@ -127,7 +131,7 @@ module RuboCop
           parent_type = node.parent && node.parent.type
           preferred_name = preferred_names(global_var).first
 
-          unless [:dstr, :xstr, :regexp].include?(parent_type)
+          unless %i[dstr xstr regexp].include?(parent_type)
             return preferred_name.to_s
           end