rubocop 0.49.1 → 0.52.0

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

@@ -5,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
 
@@ -36,6 +46,11 @@ module RuboCop
           end
         end
 
+        def autocorrect(range)
+          return unless range
+          ->(corrector) { corrector.remove(range) }
+        end
+
         private
 
         def check_for_line_terminator_or_opener
@@ -44,25 +59,20 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.pos.column if tokens.last.type == :tSEMI
-            yield line, tokens.first.pos.column if tokens.first.type == :tSEMI
+            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 { |token| token.pos.line }
+          @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

@@ -4,6 +4,15 @@ 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
@@ -13,7 +22,7 @@ module RuboCop
         def on_send(node)
           return unless sending?(node) && node.arguments?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -4,6 +4,106 @@ 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
 
@@ -11,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 ...)}'
 
@@ -77,7 +177,8 @@ 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
@@ -85,7 +186,7 @@ module RuboCop
         def check_send(method_name, node)
           return unless node && command_or_kernel_call?(method_name, node)
 
-          add_offense(node, :selector, message(method_name))
+          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

@@ -9,25 +9,17 @@ module RuboCop
       # For instance one can configure `reduce`(`inject`) to use |a, e| as
       # parameters.
       class SingleLineBlockParams < Cop
-        MSG = 'Name `%s` block params `|%s|`.'.freeze
+        MSG = 'Name `%<method>s` block params `|%<params>s|`.'.freeze
 
         def on_block(node)
           return unless node.single_line?
 
-          send_node = node.send_node
+          return unless eligible_method?(node)
+          return unless eligible_arguments?(node)
 
-          return unless send_node.receiver
-          return unless method_names.include?(send_node.method_name)
+          return if args_match?(node.send_node.method_name, node.arguments)
 
-          return unless node.arguments?
-
-          arguments = node.arguments.to_a
-
-          # discard cases with argument destructuring
-          return true unless arguments.all?(&:arg_type?)
-          return if args_match?(send_node.method_name, arguments)
-
-          add_offense(node.arguments, :expression)
+          add_offense(node.arguments)
         end
 
         private
@@ -36,7 +28,16 @@ module RuboCop
           method_name = node.parent.send_node.method_name
           arguments   = target_args(method_name).join(', ')
 
-          format(MSG, method_name, arguments)
+          format(MSG, method: method_name, params: arguments)
+        end
+
+        def eligible_arguments?(node)
+          node.arguments? && node.arguments.to_a.all?(&:arg_type?)
+        end
+
+        def eligible_method?(node)
+          node.send_node.receiver &&
+            method_names.include?(node.send_node.method_name)
         end
 
         def methods
@@ -58,7 +59,7 @@ module RuboCop
         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

@@ -3,33 +3,35 @@
 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
 
         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
-
-          empty_body = body.nil?
-          return unless start_line == end_line && !(allow_empty? && empty_body)
+        def on_def(node)
+          return unless node.single_line?
+          return if allow_empty? && !node.body
 
-          @body = body
-          add_offense(node, :expression)
+          add_offense(node)
         end
+        alias on_defs on_def
 
         def autocorrect(node)
-          body = @body
+          body = node.body
 
           lambda do |corrector|
             each_part(body) do |part|
@@ -43,6 +45,12 @@ module RuboCop
           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

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

@@ -7,11 +7,12 @@ module RuboCop
       class SpecialGlobalVars < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_BOTH = 'Prefer `%s` from the stdlib \'English\' module ' \
-        '(don\'t forget to require it), or `%s` over `%s`.'.freeze
-        MSG_ENGLISH = 'Prefer `%s` from the stdlib \'English\' module ' \
-        '(don\'t forget to require it) 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],
@@ -47,8 +48,8 @@ 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(%i[
@@ -67,7 +68,7 @@ module RuboCop
             correct_style_detected
           else
             opposite_style_detected
-            add_offense(node, :expression)
+            add_offense(node)
           end
         end
 
@@ -77,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
 
@@ -104,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

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

@@ -6,17 +6,18 @@ module RuboCop
       # Check for parentheses around stabby lambda arguments.
       # There are two different styles. Defaults to `require_parentheses`.
       #
-      # @example
-      #   # require_parentheses - bad
+      # @example EnforcedStyle: require_parentheses (default)
+      #   # bad
       #   ->a,b,c { a + b + c }
       #
-      #   # require_parentheses - good
+      #   # good
       #   ->(a,b,c) { a + b + c}
       #
-      #   # require_no_parentheses - bad
+      # @example EnforcedStyle: require_no_parentheses
+      #   # bad
       #   ->(a,b,c) { a + b + c }
       #
-      #   # require_no_parentheses - good
+      #   # good
       #   ->a,b,c { a + b + c}
       class StabbyLambdaParentheses < Cop
         include ConfigurableEnforcedStyle
@@ -24,22 +25,12 @@ module RuboCop
         MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'.freeze
         MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
                          'with parentheses.'.freeze
-        ARROW = '->'.freeze
-
         def on_send(node)
-          return unless arrow_lambda_with_args?(node)
+          return unless stabby_lambda_with_args?(node)
+          return unless redundant_parentheses?(node) ||
+                        missing_parentheses?(node)
 
-          if style == :require_parentheses
-            if parentheses?(node)
-              correct_style_detected
-            else
-              missing_parentheses(node)
-            end
-          elsif parentheses?(node)
-            unwanted_parentheses(node)
-          else
-            correct_style_detected
-          end
+          add_offense(node.parent.arguments)
         end
 
         def autocorrect(node)
@@ -52,21 +43,21 @@ module RuboCop
 
         private
 
-        def missing_parentheses(node)
-          add_offense(node_args(node), :expression, MSG_REQUIRE) do
-            opposite_style_detected
-          end
+        def missing_parentheses?(node)
+          style == :require_parentheses && !parentheses?(node)
         end
 
-        def unwanted_parentheses(node)
-          add_offense(node_args(node), :expression, MSG_NO_REQUIRE) do
-            opposite_style_detected
-          end
+        def redundant_parentheses?(node)
+          style == :require_no_parentheses && parentheses?(node)
+        end
+
+        def message(_node)
+          style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
         end
 
         def missing_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node_args(node).source_range
+            args_loc = node.parent.arguments.source_range
 
             corrector.insert_before(args_loc, '(')
             corrector.insert_after(args_loc, ')')
@@ -75,37 +66,19 @@ module RuboCop
 
         def unwanted_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node_args(node).loc
+            args_loc = node.parent.arguments.loc
 
             corrector.replace(args_loc.begin, '')
             corrector.remove(args_loc.end)
           end
         end
 
-        def arrow_lambda_with_args?(node)
-          lambda_node?(node) && arrow_form?(node) && args?(node)
-        end
-
-        def lambda_node?(node)
-          receiver, call = *node
-          !receiver && call == :lambda
-        end
-
-        def arrow_form?(node)
-          node.loc.selector.source == ARROW
-        end
-
-        def node_args(node)
-          _call, args, _body = *node.parent
-          args
-        end
-
-        def args?(node)
-          !node_args(node).children.empty?
+        def stabby_lambda_with_args?(node)
+          node.stabby_lambda? && node.parent.arguments?
         end
 
         def parentheses?(node)
-          node_args(node).loc.begin
+          node.parent.arguments.loc.begin
         end
       end
     end