rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/lint/empty_when.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of `when` branches without a body.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   case foo
+      #   when bar then 1
+      #   when baz then # nothing
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   case foo
+      #   when bar then 1
+      #   when baz then 2
+      #   end
+      class EmptyWhen < Cop
+        MSG = 'Avoid `when` branches without a body.'.freeze
+
+        def on_case(node)
+          node.each_when do |when_node|
+            next if when_node.body
+
+            add_offense(when_node, location: when_node.source_range)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,8 +5,8 @@ module RuboCop
     module Lint
       # This cop checks whether the end keywords are aligned properly.
       #
-      # Three modes are supported through the `AlignWith` configuration
-      # parameter:
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
       #
       # If it's set to `keyword` (which is the default), the `end`
       # shall be aligned with the start of the keyword (if, class, etc.).
@@ -18,23 +17,41 @@ module RuboCop
       # If it's set to `start_of_line`, the `end` shall be aligned with the
       # start of the line where the matching keyword appears.
       #
-      # @example
-      #   @good
-      #   # keyword style
+      # @example EnforcedStyleAlignWith: keyword (default)
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   # good
+      #
       #   variable = if true
       #              end
       #
-      #   # variable style
+      # @example EnforcedStyleAlignWith: variable
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   # good
+      #
       #   variable = if true
       #   end
       #
-      #   # start_of_line style
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   # good
+      #
       #   puts(if true
       #   end)
       class EndAlignment < Cop
         include CheckAssignment
         include EndKeywordAlignment
-        include IfNode
 
         def on_class(node)
           check_other_alignment(node)
@@ -45,7 +62,7 @@ module RuboCop
         end
 
         def on_if(node)
-          check_other_alignment(node) unless ternary?(node)
+          check_other_alignment(node) unless node.ternary?
         end
 
         def on_while(node)
@@ -57,8 +74,17 @@ module RuboCop
         end
 
         def on_case(node)
-          return check_asgn_alignment(node.parent, node) if argument_case?(node)
-          check_other_alignment(node)
+          if node.argument?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.align_end(processed_source,
+                                       node,
+                                       alignment_node(node))
         end
 
         private
@@ -68,31 +94,31 @@ module RuboCop
           # assignment, we let rhs be the receiver of those method calls before
           # we check if it's an if/unless/while/until.
           return unless (rhs = first_part_of_call_chain(rhs))
-          return unless [:if, :while, :until, :case].include?(rhs.type)
-          return if ternary?(rhs)
+          return unless CONDITIONAL_NODES.include?(rhs.type)
+          return if rhs.if_type? && rhs.ternary?
 
           check_asgn_alignment(node, rhs)
         end
 
         def check_asgn_alignment(outer_node, inner_node)
-          expr = outer_node.source_range
-
           align_with = {
             keyword: inner_node.loc.keyword,
-            start_of_line: start_line_range(outer_node)
+            start_of_line: start_line_range(outer_node),
+            variable: asgn_variable_align_with(outer_node, inner_node)
           }
 
-          align_with[:variable] =
-            if !line_break_before_keyword?(expr, inner_node)
-              Parser::Source::Range.new(expr.source_buffer,
-                                        expr.begin_pos,
-                                        inner_node.loc.keyword.end_pos)
-            else
-              inner_node.loc.keyword
-            end
-
           check_end_kw_alignment(inner_node, align_with)
-          ignore_node(inner_node) # Don't check again.
+          ignore_node(inner_node)
+        end
+
+        def asgn_variable_align_with(outer_node, inner_node)
+          expr = outer_node.source_range
+
+          if !line_break_before_keyword?(expr, inner_node)
+            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
+          else
+            inner_node.loc.keyword
+          end
         end
 
         def check_other_alignment(node)
@@ -104,15 +130,11 @@ module RuboCop
           check_end_kw_alignment(node, align_with)
         end
 
-        def autocorrect(node)
-          align(node, alignment_node(node))
-        end
-
         def alignment_node(node)
           if style == :keyword
             node
           elsif style == :variable
-            return node.parent if argument_case?(node)
+            return node.parent if node.case_type? && node.argument?
             # Fall back to 'keyword' style if this node is not on the RHS
             # of an assignment
             node.ancestors.find(&:assignment?) || node
@@ -121,18 +143,14 @@ module RuboCop
           end
         end
 
-        def argument_case?(node)
-          node.case_type? && node.parent && node.parent.send_type?
-        end
-
         def start_line_range(node)
           expr   = node.source_range
           buffer = expr.source_buffer
           source = buffer.source_line(expr.line)
           range  = buffer.line_range(expr.line)
-          Parser::Source::Range.new(buffer,
-                                    range.begin_pos + (source =~ /\S/),
-                                    range.begin_pos + (source =~ /\s*\z/))
+
+          range_between(range.begin_pos + (source =~ /\S/),
+                        range.begin_pos + (source =~ /\s*\z/))
         end
       end
     end

data/lib/rubocop/cop/lint/end_in_method.rb

@@ -1,16 +1,38 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for END blocks in method definitions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     END { do_something }
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     at_exit { do_something }
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # outside defs
+      #   END { do_something }
       class EndInMethod < Cop
         MSG = '`END` found in method definition. Use `at_exit` instead.'.freeze
 
         def on_postexe(node)
           inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?
-          add_offense(node, :keyword) if inside_of_method
+          add_offense(node, location: :keyword) if inside_of_method
         end
       end
     end

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -1,20 +1,40 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for *return* from an *ensure* block.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #     return
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
       class EnsureReturn < Cop
         MSG = 'Do not return from an `ensure` block.'.freeze
 
         def on_ensure(node)
-          _body, ensure_body = *node
+          ensure_body = node.body
 
           return unless ensure_body
 
           ensure_body.each_node(:return) do |return_node|
-            add_offense(return_node, :expression)
+            add_offense(return_node)
           end
         end
       end

data/lib/rubocop/cop/lint/float_out_of_range.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,21 +8,26 @@ module RuboCop
       # that big. If you need a float that big, something is wrong with you.
       #
       # @example
+      #
       #   # bad
+      #
       #   float = 3.0e400
       #
+      # @example
+      #
       #   # good
+      #
       #   float = 42.9
       class FloatOutOfRange < Cop
         MSG = 'Float out of range.'.freeze
 
         def on_float(node)
           value, = *node
-          if value.infinite?
-            add_offense(node, :expression, MSG)
-          elsif value.zero? && node.source =~ /[1-9]/
-            add_offense(node, :expression, MSG)
-          end
+
+          return unless value.infinite? ||
+                        value.zero? && node.source =~ /[1-9]/
+
+          add_offense(node)
         end
       end
     end

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,24 +9,33 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   format('A value: %s and another: %i', a_value)
       #
+      # @example
+      #
+      #   # good
+      #
+      #   format('A value: %s and another: %i', a_value, another)
       class FormatParameterMismatch < Cop
         # http://rubular.com/r/CvpbxkcTzy
         MSG = "Number of arguments (%i) to `%s` doesn't match the number of " \
               'fields (%i).'.freeze
         FIELD_REGEX =
-          /(%(([\s#+-0\*]*)(\d*)?(.\d+)?[bBdiouxXeEfgGaAcps]|%))/
+          /(%(([\s#+-0\*]*)(\d*)?(\.\d+)?[bBdiouxXeEfgGaAcps]|%))/
         NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/
         KERNEL = 'Kernel'.freeze
         SHOVEL = '<<'.freeze
         PERCENT = '%'.freeze
         PERCENT_PERCENT = '%%'.freeze
-        STRING_TYPES = [:str, :dstr].freeze
+        STRING_TYPES = %i[str dstr].freeze
         NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/
 
         def on_send(node)
-          add_offense(node, :selector) if offending_node?(node)
+          return unless offending_node?(node)
+
+          add_offense(node, location: :selector)
         end
 
         private
@@ -35,12 +43,20 @@ module RuboCop
         def offending_node?(node)
           return false unless called_on_string?(node)
           return false unless method_with_format_args?(node)
-          return false if named_mode?(node) || node_with_splat_args?(node)
+          return false if named_mode?(node) || splat_args?(node)
 
           num_of_format_args, num_of_expected_fields = count_matches(node)
 
-          num_of_format_args != :unknown &&
-            num_of_expected_fields != num_of_format_args
+          return false if num_of_format_args == :unknown
+          matched_arguments_count?(num_of_expected_fields, num_of_format_args)
+        end
+
+        def matched_arguments_count?(expected, passed)
+          if passed < 0
+            expected < passed.abs
+          else
+            expected != passed
+          end
         end
 
         def called_on_string?(node)
@@ -57,57 +73,58 @@ module RuboCop
         end
 
         def named_mode?(node)
-          receiver_node, _method_name, *args = *node
-
           relevant_node = if sprintf?(node) || format?(node)
-                            args.first
+                            node.first_argument
                           elsif percent?(node)
-                            receiver_node
+                            node.receiver
                           end
 
           !relevant_node.source.scan(NAMED_FIELD_REGEX).empty?
         end
 
-        def node_with_splat_args?(node)
+        def splat_args?(node)
           return false if percent?(node)
 
-          _receiver_node, _method_name, *args = *node
-
-          args.butfirst.any? { |arg| arg.type == :splat }
+          node.arguments.butfirst.any?(&:splat_type?)
         end
 
         def heredoc?(node)
-          _receiver, _name, args = *node
-
-          args.source[0, 2] == SHOVEL
+          node.first_argument.source[0, 2] == SHOVEL
         end
 
         def count_matches(node)
-          receiver_node, _method_name, *args = *node
-
-          if (sprintf?(node) || format?(node)) && !heredoc?(node)
-            number_of_args_for_format = (args.size - 1)
-            number_of_expected_fields = expected_fields_count(args.first)
-          elsif percent?(node) && args.first.array_type?
-            number_of_expected_fields = expected_fields_count(receiver_node)
-            number_of_args_for_format = args.first.child_nodes.size
+          if countable_format?(node)
+            count_format_matches(node)
+          elsif countable_percent?(node)
+            count_percent_matches(node)
           else
-            number_of_args_for_format = number_of_expected_fields = :unknown
+            [:unknown] * 2
           end
+        end
 
-          [number_of_args_for_format, number_of_expected_fields]
+        def countable_format?(node)
+          (sprintf?(node) || format?(node)) && !heredoc?(node)
         end
 
-        def format_method?(name, node)
-          receiver, method_name, *args = *node
+        def countable_percent?(node)
+          percent?(node) && node.first_argument.array_type?
+        end
 
-          if receiver && receiver.const_type?
-            return false unless receiver.loc.name.is?(KERNEL)
-          end
+        def count_format_matches(node)
+          [node.arguments.count - 1, expected_fields_count(node.first_argument)]
+        end
+
+        def count_percent_matches(node)
+          [node.first_argument.child_nodes.count,
+           expected_fields_count(node.receiver)]
+        end
 
-          return false unless method_name == name
+        def format_method?(name, node)
+          return false if node.const_receiver? &&
+                          !node.receiver.loc.name.is?(KERNEL)
+          return false unless node.method?(name)
 
-          args.size > 1 && args.first.str_type?
+          node.arguments.size > 1 && node.first_argument.str_type?
         end
 
         def expected_fields_count(node)
@@ -117,8 +134,13 @@ module RuboCop
           node
             .source
             .scan(FIELD_REGEX)
-            .select { |x| x.first != PERCENT_PERCENT }
-            .reduce(0) { |a, e| a + (e[2] =~ /\*/ ? 2 : 1) }
+            .reject { |x| x.first == PERCENT_PERCENT }
+            .reduce(0) { |acc, elem| acc + arguments_count(elem[2]) }
+        end
+
+        # number of arguments required for the format sequence
+        def arguments_count(format)
+          format.scan('*').count + 1
         end
 
         def format?(node)
@@ -130,24 +152,23 @@ module RuboCop
         end
 
         def percent?(node)
-          receiver_node, method_name, *arg_nodes = *node
+          receiver = node.receiver
 
-          percent = method_name == :% &&
-                    (STRING_TYPES.include?(receiver_node.type) ||
-                     arg_nodes[0].array_type?)
+          percent = node.method?(:%) &&
+                    (STRING_TYPES.include?(receiver.type) ||
+                     node.first_argument.array_type?)
 
-          if percent && STRING_TYPES.include?(receiver_node.type)
-            return false if heredoc?(node)
-          end
+          return false if percent && STRING_TYPES.include?(receiver.type) &&
+                          heredoc?(node)
 
           percent
         end
 
         def message(node)
-          _receiver, method_name, *_args = *node
           num_args_for_format, num_expected_fields = count_matches(node)
 
-          method_name = 'String#%' if PERCENT == method_name.to_s
+          method_name = node.method?(:%) ? 'String#%' : node.method_name
+
           format(MSG, num_args_for_format, method_name, num_expected_fields)
         end
       end

data/lib/rubocop/cop/lint/handle_exceptions.rb

@@ -1,17 +1,54 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for *rescue* blocks with no body.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
       class HandleExceptions < Cop
         MSG = 'Do not suppress exceptions.'.freeze
 
         def on_resbody(node)
-          _exc_list_node, _exc_var_node, body_node = *node
-
-          add_offense(node, :expression) unless body_node
+          add_offense(node) unless node.body
         end
       end
     end

data/lib/rubocop/cop/lint/implicit_string_concatenation.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,10 +7,15 @@ module RuboCop
       # which are on the same line.
       #
       # @example
-      #   @bad
+      #
+      #   # bad
+      #
       #   array = ['Item 1' 'Item 2']
       #
-      #   @good
+      # @example
+      #
+      #   # good
+      #
       #   array = ['Item 1Item 2']
       #   array = ['Item 1' + 'Item 2']
       #   array = [
@@ -35,7 +39,7 @@ module RuboCop
             elsif node.parent && node.parent.send_type?
               message << FOR_METHOD
             end
-            add_offense(node, range, message)
+            add_offense(node, location: range, message: message)
           end
         end
 
@@ -45,7 +49,7 @@ module RuboCop
           node.children.each_cons(2) do |child1, child2|
             # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
             next unless string_literal?(child1) && string_literal?(child2)
-            next unless child1.loc.last_line == child2.loc.line
+            next unless child1.last_line == child2.first_line
 
             # Make sure we don't flag a string literal which simply has
             # embedded newlines