rubocop 0.42.0 → 0.52.1

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

@@ -1,14 +1,13 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for identical lines at the end of each branch of a
-      # conditional statement.
+      # This cop checks for identical lines at the beginning or end of
+      # each branch of a conditional statement.
       #
       # @example
-      #   @bad
+      #   # bad
       #   if condition
       #     do_x
       #     do_z
@@ -17,50 +16,98 @@ module RuboCop
       #     do_z
       #   end
       #
-      #   @good
+      #   # good
       #   if condition
       #     do_x
       #   else
       #     do_y
       #   end
       #   do_z
+      #
+      #   # bad
+      #   if condition
+      #     do_z
+      #     do_x
+      #   else
+      #     do_z
+      #     do_y
+      #   end
+      #
+      #   # good
+      #   do_z
+      #   if condition
+      #     do_x
+      #   else
+      #     do_y
+      #   end
+      #
+      #   # bad
+      #   case foo
+      #   when 1
+      #     do_x
+      #   when 2
+      #     do_x
+      #   else
+      #     do_x
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when 1
+      #     do_x
+      #     do_y
+      #   when 2
+      #     # nothing
+      #   else
+      #     do_x
+      #     do_z
+      #   end
       class IdenticalConditionalBranches < Cop
-        include IfNode
-
-        MSG = 'Move `%s` out of the conditional.'.freeze
+        MSG = 'Move `%<source>s` out of the conditional.'.freeze
 
         def on_if(node)
-          return if elsif?(node)
-          _condition, if_branch, else_branch = *node
-          branches = expand_elses(else_branch).unshift(if_branch)
+          return if node.elsif?
+
+          branches = expand_elses(node.else_branch).unshift(node.if_branch)
 
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else`, or a branch that contains only comments.
           return if branches.any?(&:nil?)
 
-          check_node(branches)
+          check_branches(branches)
         end
 
         def on_case(node)
-          return unless node.loc.else
-          _condition, *when_branches, else_branch = *node
-          return unless else_branch # empty else
-          when_branches = expand_when_branches(when_branches)
+          return unless node.else? && node.else_branch
+
+          branches = node.when_branches.map(&:body).push(node.else_branch)
 
-          check_node(when_branches.push(else_branch))
+          return if branches.any?(&:nil?)
+
+          check_branches(branches)
         end
 
         private
 
-        def check_node(branches)
-          branches = branches.map { |branch| tail(branch) }
+        def check_branches(branches)
+          tails = branches.compact.map { |branch| tail(branch) }
+          check_expressions(tails)
+          heads = branches.compact.map { |branch| head(branch) }
+          check_expressions(heads)
+        end
 
-          return unless branches.all? { |branch| branch == branches[0] }
-          branches.each do |branch|
-            add_offense(branch, :expression, format(MSG, branch.source))
+        def check_expressions(expressions)
+          return unless expressions.size > 1 && expressions.uniq.one?
+
+          expressions.each do |expression|
+            add_offense(expression)
           end
         end
 
+        def message(node)
+          format(MSG, source: node.source)
+        end
+
         # `elsif` branches show up in the if node as nested `else` branches. We
         # need to recursively iterate over all `else` branches.
         def expand_elses(branch)
@@ -74,18 +121,12 @@ module RuboCop
           end
         end
 
-        # `when` nodes contain the entire branch including the condition.
-        # We only need the contents of the branch, not the condition.
-        def expand_when_branches(when_branches)
-          when_branches.map { |branch| branch.children[1] }
+        def tail(node)
+          node.begin_type? ? node.children.last : node
         end
 
-        def tail(node)
-          if node && node.begin_type?
-            node.children.last
-          else
-            node
-          end
+        def head(node)
+          node.begin_type? ? node.children.first : node
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,16 +8,7 @@ module RuboCop
       # This helps to keep the nesting level from getting too deep.
       #
       # @example
-      #   @good
-      #   if condition_a
-      #     action_a
-      #   elsif condition_b
-      #     action_b
-      #   else
-      #     action_c
-      #   end
-      #
-      #   @bad
+      #   # bad
       #   if condition_a
       #     action_a
       #   else
@@ -28,20 +18,26 @@ module RuboCop
       #       action_c
       #     end
       #   end
+      #
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   else
+      #     action_c
+      #   end
       class IfInsideElse < Cop
-        include IfNode
-
         MSG = 'Convert `if` nested inside `else` to `elsif`.'.freeze
 
         def on_if(node)
-          _cond, _if_branch, else_branch = *node
-          return unless else_branch
-          return unless else_branch.if_type?
-          return if ternary?(node) || ternary?(else_branch)
-          return unless else_branch.loc.keyword.is?('if')
-          return if node.loc.keyword.is?('unless')
+          return if node.ternary? || node.unless?
+
+          else_branch = node.else_branch
+
+          return unless else_branch && else_branch.if_type? && else_branch.if?
 
-          add_offense(else_branch, :keyword, MSG)
+          add_offense(else_branch, location: :keyword)
         end
       end
     end

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

@@ -1,34 +1,57 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # Checks for if and unless statements that would fit on one line
-      # if written as a modifier if/unless.
-      # The maximum line length is configurable.
+      # if written as a modifier if/unless. The maximum line length is
+      # configured in the `Metrics/LineLength` cop.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #     do_stuff(bar)
+      #   end
+      #
+      #   unless qux.empty?
+      #     Foo.do_something
+      #   end
+      #
+      #   # good
+      #   do_stuff(bar) if condition
+      #   Foo.do_something unless qux.empty?
       class IfUnlessModifier < Cop
-        include IfNode
         include StatementModifier
 
-        ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn,
-                            :gvasgn, :ivasgn, :masgn].freeze
+        MSG = 'Favor modifier `%<keyword>s` usage when having a single-line ' \
+              'body. Another good alternative is the usage of control flow ' \
+              '`&&`/`||`.'.freeze
 
-        def message(keyword)
-          "Favor modifier `#{keyword}` usage when having a single-line body." \
-          ' Another good alternative is the usage of control flow `&&`/`||`.'
-        end
+        ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
+                              gvasgn ivasgn masgn].freeze
 
         def on_if(node)
-          # discard ternary ops, if/else and modifier if/unless nodes
-          return if ternary?(node)
-          return if modifier_if?(node)
-          return if elsif?(node)
-          return if if_else?(node)
-          return if node.chained?
-          return unless fit_within_line_as_modifier_form?(node)
-          return if nested_conditional?(node)
-          add_offense(node, :keyword, message(node.loc.keyword.source))
+          return unless eligible_node?(node)
+
+          add_offense(node, location: :keyword,
+                            message: format(MSG, keyword: node.keyword))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, to_modifier_form(node))
+          end
+        end
+
+        private
+
+        def eligible_node?(node)
+          !non_eligible_if?(node) && !node.chained? &&
+            !node.nested_conditional? && single_line_as_modifier?(node)
+        end
+
+        def non_eligible_if?(node)
+          node.ternary? || node.modifier_form? || node.elsif? || node.else?
         end
 
         def parenthesize?(node)
@@ -51,27 +74,13 @@ module RuboCop
           source =~ /\s*\(\s*$/
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.source_range, oneline(node)) }
-        end
-
-        private
-
-        # returns false if the then or else children are conditionals
-        def nested_conditional?(node)
-          node.children[1, 2].any? { |child| child && child.type == :if }
-        end
-
-        def oneline(node)
-          cond, body, _else = if_node_parts(node)
-
-          expr = "#{body.source} #{node.loc.keyword.source} " + cond.source
-          if (comment_after = first_line_comment(node))
-            expr << ' ' << comment_after
-          end
-          expr = "(#{expr})" if parenthesize?(node)
+        def to_modifier_form(node)
+          expression = [node.body.source,
+                        node.keyword,
+                        node.condition.source,
+                        first_line_comment(node)].compact.join(' ')
 
-          expr
+          parenthesize?(node) ? "(#{expression})" : expression
         end
 
         def first_line_comment(node)

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

@@ -1,10 +1,9 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # Checks for if and unless statements used as modifers of other if or
+      # Checks for if and unless statements used as modifiers of other if or
       # unless statements.
       #
       # @example
@@ -26,18 +25,13 @@ module RuboCop
       class IfUnlessModifierOfIfUnless < Cop
         include StatementModifier
 
-        MESSAGE = 'Avoid modifier `%s` after another conditional.'.freeze
-
-        def message(keyword)
-          format(MESSAGE, keyword)
-        end
+        MSG = 'Avoid modifier `%<keyword>s` after another conditional.'.freeze
 
         def on_if(node)
-          return unless modifier_if?(node)
-          _cond, body, _else = if_node_parts(node)
-          if body.type == :if
-            add_offense(node, :keyword, message(node.loc.keyword.source))
-          end
+          return unless node.modifier_form? && node.body.if_type?
+
+          add_offense(node, location: :keyword,
+                            message: format(MSG, keyword: node.keyword))
         end
       end
     end

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

@@ -1,10 +1,18 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # Checks for uses of semicolon in if statements.
+      #
+      # @example
+      #
+      #   # bad
+      #   result = if some_condition; something else another_thing end
+      #
+      #   # good
+      #   result = some_condition ? something : another_thing
+      #
       class IfWithSemicolon < Cop
         include OnNormalIfUnless
 
@@ -13,7 +21,7 @@ module RuboCop
         def on_normal_if_unless(node)
           beginning = node.loc.begin
           return unless beginning && beginning.is?(';')
-          add_offense(node, :expression, MSG)
+          add_offense(node)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,20 +9,21 @@ module RuboCop
       # nature of the error.)
       #
       # @example
-      #   @bad
+      #   # bad
       #   raise 'Error message here'
       #
-      #   @good
+      #   # good
       #   raise ArgumentError, 'Error message here'
       class ImplicitRuntimeError < Cop
+        MSG = 'Use `%<method>s` with an explicit exception class and message,' \
+              ' rather than just a message.'.freeze
+
         def_node_matcher :implicit_runtime_error_raise_or_fail,
-                         '(send nil ${:raise :fail} {str dstr})'
+                         '(send nil? ${:raise :fail} {str dstr})'
 
         def on_send(node)
           implicit_runtime_error_raise_or_fail(node) do |method|
-            add_offense(node, :expression, "Use `#{method}` with an explicit " \
-                                           'exception class and message, ' \
-                                           'rather than just a message.')
+            add_offense(node, message: format(MSG, method: method))
           end
         end
       end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -17,20 +16,20 @@ module RuboCop
       #     work
       #   end
       class InfiniteLoop < Cop
+        LEADING_SPACE = /\A(\s*)/
+
         MSG = 'Use `Kernel#loop` for infinite loops.'.freeze
 
         def on_while(node)
-          condition, = *node
-          return unless condition.truthy_literal?
+          return unless node.condition.truthy_literal?
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
 
         def on_until(node)
-          condition, = *node
-          return unless condition.falsey_literal?
+          return unless node.condition.falsey_literal?
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
 
         alias on_while_post on_while
@@ -38,51 +37,53 @@ module RuboCop
 
         def autocorrect(node)
           if node.while_post_type? || node.until_post_type?
-            _, body = *node
-            return lambda do |corrector|
-              corrector.replace(body.loc.begin, 'loop do')
-              corrector.remove(body.loc.end.end.join(node.source_range.end))
-            end
-          end
-
-          if node.modifier_form?
-            range = node.source_range
-            replacement = modifier_replacement(node)
+            replace_begin_end_with_modifier(node)
+          elsif node.modifier_form?
+            replace_source(node.source_range, modifier_replacement(node))
           else
-            range = non_modifier_range(node)
-            replacement = 'loop do'
+            replace_source(non_modifier_range(node), 'loop do')
           end
-
-          ->(corrector) { corrector.replace(range, replacement) }
         end
 
         private
 
+        def replace_begin_end_with_modifier(node)
+          lambda do |corrector|
+            corrector.replace(node.body.loc.begin, 'loop do')
+            corrector.remove(node.body.loc.end.end.join(node.source_range.end))
+          end
+        end
+
+        def replace_source(range, replacement)
+          lambda do |corrector|
+            corrector.replace(range, replacement)
+          end
+        end
+
         def modifier_replacement(node)
-          _, body = *node
           if node.single_line?
-            'loop { ' + body.source + ' }'
+            'loop { ' + node.body.source + ' }'
           else
-            indentation = body.loc.expression.source_line[/\A(\s*)/]
-            "loop do\n" + indentation +
-              body.source.gsub(/^/, ' ' * configured_indentation_width) +
-              "\n#{indentation}end"
+            indentation = node.body.loc.expression.source_line[LEADING_SPACE]
+
+            ['loop do', node.body.source.gsub(/^/, configured_indent),
+             'end'].join("\n#{indentation}")
           end
         end
 
         def non_modifier_range(node)
-          condition_node, = *node
           start_range = node.loc.keyword.begin
-          end_range = if node.loc.begin
+          end_range = if node.do?
                         node.loc.begin.end
                       else
-                        condition_node.source_range.end
+                        node.condition.source_range.end
                       end
+
           start_range.join(end_range)
         end
 
-        def configured_indentation_width
-          config.for_cop('IndentationWidth')['Width']
+        def configured_indent
+          ' ' * config.for_cop('IndentationWidth')['Width']
         end
       end
     end

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

@@ -1,17 +1,29 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for inline comments.
+      # This cop checks for trailing inline comments.
+      #
+      # @example
+      #
+      #   # good
+      #   foo.each do |f|
+      #     # Standalone comment
+      #     f.bar
+      #   end
+      #
+      #   # bad
+      #   foo.each do |f|
+      #     f.bar # Trailing inline comment
+      #   end
       class InlineComment < Cop
-        MSG = 'Avoid inline comments.'.freeze
+        MSG = 'Avoid trailing inline comments.'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            next unless comment.inline?
-            add_offense(comment, :expression)
+            next if comment_line?(processed_source[comment.loc.line - 1])
+            add_offense(comment)
           end
         end
       end