rubocop 0.51.0 → 0.87.0

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

@@ -7,7 +7,7 @@ module RuboCop
       # each branch of a conditional statement.
       #
       # @example
-      #   @bad
+      #   # bad
       #   if condition
       #     do_x
       #     do_z
@@ -16,7 +16,7 @@ module RuboCop
       #     do_z
       #   end
       #
-      #   @good
+      #   # good
       #   if condition
       #     do_x
       #   else
@@ -24,7 +24,7 @@ module RuboCop
       #   end
       #   do_z
       #
-      #   @bad
+      #   # bad
       #   if condition
       #     do_z
       #     do_x
@@ -33,7 +33,7 @@ module RuboCop
       #     do_y
       #   end
       #
-      #   @good
+      #   # good
       #   do_z
       #   if condition
       #     do_x
@@ -41,7 +41,7 @@ module RuboCop
       #     do_y
       #   end
       #
-      #   @bad
+      #   # bad
       #   case foo
       #   when 1
       #     do_x
@@ -51,7 +51,7 @@ module RuboCop
       #     do_x
       #   end
       #
-      #   @good
+      #   # good
       #   case foo
       #   when 1
       #     do_x
@@ -63,17 +63,12 @@ module RuboCop
       #     do_z
       #   end
       class IdenticalConditionalBranches < Cop
-        MSG = 'Move `%s` out of the conditional.'.freeze
+        MSG = 'Move `%<source>s` out of the conditional.'
 
         def on_if(node)
           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_branches(branches)
         end
 
@@ -81,19 +76,20 @@ module RuboCop
           return unless node.else? && node.else_branch
 
           branches = node.when_branches.map(&:body).push(node.else_branch)
-
-          return if branches.any?(&:nil?)
-
           check_branches(branches)
         end
 
         private
 
-        def check_branches(branches)
-          tails = branches.compact.map { |branch| tail(branch) }
-          check_expressions(tails)
-          heads = branches.compact.map { |branch| head(branch) }
-          check_expressions(heads)
+        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity
+          # 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?)
+
+          tails = branches.map { |branch| tail(branch) }
+          check_expressions(tails) if tails.none?(&:nil?)
+          heads = branches.map { |branch| head(branch) }
+          check_expressions(heads) if tails.none?(&:nil?)
         end
 
         def check_expressions(expressions)
@@ -105,7 +101,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, node.source)
+          format(MSG, source: node.source)
         end
 
         # `elsif` branches show up in the if node as nested `else` branches. We

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

@@ -8,7 +8,18 @@ module RuboCop
       # This helps to keep the nesting level from getting too deep.
       #
       # @example
-      #   @good
+      #   # bad
+      #   if condition_a
+      #     action_a
+      #   else
+      #     if condition_b
+      #       action_b
+      #     else
+      #       action_c
+      #     end
+      #   end
+      #
+      #   # good
       #   if condition_a
       #     action_a
       #   elsif condition_b
@@ -17,28 +28,59 @@ module RuboCop
       #     action_c
       #   end
       #
-      #   @bad
+      # @example AllowIfModifier: false (default)
+      #   # bad
       #   if condition_a
       #     action_a
       #   else
-      #     if condition_b
-      #       action_b
-      #     else
-      #       action_c
-      #     end
+      #     action_b if condition_b
+      #   end
+      #
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   end
+      #
+      # @example AllowIfModifier: true
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   else
+      #     action_b if condition_b
       #   end
+      #
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   end
+      #
       class IfInsideElse < Cop
-        MSG = 'Convert `if` nested inside `else` to `elsif`.'.freeze
+        MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
-        def on_if(node)
+        def on_if(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if node.ternary? || node.unless?
 
           else_branch = node.else_branch
 
-          return unless else_branch && else_branch.if_type? && else_branch.if?
+          return unless else_branch&.if_type? && else_branch&.if?
+          return if allow_if_modifier_in_else_branch?(else_branch)
 
           add_offense(else_branch, location: :keyword)
         end
+
+        private
+
+        def allow_if_modifier_in_else_branch?(else_branch)
+          allow_if_modifier? && else_branch&.modifier_form?
+        end
+
+        def allow_if_modifier?
+          cop_config['AllowIfModifier']
+        end
       end
     end
   end

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

@@ -3,32 +3,126 @@
 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.
+      # Checks for `if` and `unless` statements that would fit on one line if
+      # written as modifier `if`/`unless`. The cop also checks for modifier
+      # `if`/`unless` lines that exceed the maximum line length.
+      #
+      # The maximum line length is configured in the `Layout/LineLength`
+      # cop. The tab size is configured in the `IndentationWidth` of the
+      # `Layout/IndentationStyle` cop.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #     do_stuff(bar)
+      #   end
+      #
+      #   unless qux.empty?
+      #     Foo.do_something
+      #   end
+      #
+      #   do_something_in_a_method_with_a_long_name(arg) if long_condition
+      #
+      #   # good
+      #   do_stuff(bar) if condition
+      #   Foo.do_something unless qux.empty?
+      #
+      #   if long_condition
+      #     do_something_in_a_method_with_a_long_name(arg)
+      #   end
       class IfUnlessModifier < Cop
         include StatementModifier
+        include LineLengthHelp
+        include IgnoredPattern
 
-        MSG = 'Favor modifier `%s` usage when having a single-line body. ' \
-              'Another good alternative is the usage of control flow ' \
-              '`&&`/`||`.'.freeze
+        MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
+                           'single-line body. Another good alternative is ' \
+                           'the usage of control flow `&&`/`||`.'
+        MSG_USE_NORMAL =
+          'Modifier form of `%<keyword>s` makes the line too long.'
 
         ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
                               gvasgn ivasgn masgn].freeze
 
         def on_if(node)
-          return unless eligible_node?(node)
+          msg = if eligible_node?(node)
+                  MSG_USE_MODIFIER unless named_capture_in_condition?(node)
+                elsif too_long_due_to_modifier?(node)
+                  MSG_USE_NORMAL
+                end
+          return unless msg
+
+          add_offense(node,
+                      location: :keyword,
+                      message: format(msg, keyword: node.keyword))
+        end
 
-          add_offense(node, location: :keyword,
-                            message: format(MSG, node.keyword))
+        def autocorrect(node)
+          replacement = if node.modifier_form?
+                          to_normal_form(node)
+                        else
+                          to_modifier_form(node)
+                        end
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
         private
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, to_modifier_form(node))
+        def too_long_due_to_modifier?(node)
+          node.modifier_form? && too_long_single_line?(node) &&
+            !another_statement_on_same_line?(node)
+        end
+
+        def ignored_patterns
+          config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
+        end
+
+        def too_long_single_line?(node)
+          return false unless max_line_length
+
+          range = node.source_range
+          return false unless range.first_line == range.last_line
+          return false unless line_length_enabled_at_line?(range.first_line)
+
+          line = range.source_line
+          return false if line_length(line) <= max_line_length
+
+          too_long_line_based_on_config?(range, line)
+        end
+
+        def too_long_line_based_on_config?(range, line)
+          return false if matches_ignored_pattern?(line)
+
+          too_long = too_long_line_based_on_ignore_cop_directives?(range, line)
+          return too_long unless too_long == :undetermined
+
+          too_long_line_based_on_allow_uri?(line)
+        end
+
+        def too_long_line_based_on_ignore_cop_directives?(range, line)
+          if ignore_cop_directives? && directive_on_source_line?(range.line - 1)
+            return line_length_without_directive(line) > max_line_length
+          end
+
+          :undetermined
+        end
+
+        def too_long_line_based_on_allow_uri?(line)
+          if allow_uri?
+            uri_range = find_excessive_uri_range(line)
+            return false if uri_range && allowed_uri_position?(line, uri_range)
           end
+
+          true
+        end
+
+        def line_length_enabled_at_line?(line)
+          processed_source.comment_config
+                          .cop_enabled_at_line?('Layout/LineLength', line)
+        end
+
+        def named_capture_in_condition?(node)
+          node.condition.match_with_lvasgn_type?
         end
 
         def eligible_node?(node)
@@ -40,6 +134,21 @@ module RuboCop
           node.ternary? || node.modifier_form? || node.elsif? || node.else?
         end
 
+        def another_statement_on_same_line?(node)
+          line_no = node.source_range.last_line
+
+          # traverse the AST upwards until we find a 'begin' node
+          # we want to look at the following child and see if it is on the
+          #   same line as this 'if' node
+          while node && !node.begin_type?
+            index = node.sibling_index
+            node  = node.parent
+          end
+
+          node && (sibling = node.children[index + 1]) &&
+            sibling.source_range.first_line == line_no
+        end
+
         def parenthesize?(node)
           # Parenthesize corrected expression if changing to modifier-if form
           # would change the meaning of the parent expression
@@ -47,17 +156,7 @@ module RuboCop
           return false if node.parent.nil?
           return true if ASSIGNMENT_TYPES.include?(node.parent.type)
 
-          if node.parent.send_type?
-            _receiver, _name, *args = *node.parent
-            return !method_uses_parens?(node.parent, args.first)
-          end
-
-          false
-        end
-
-        def method_uses_parens?(node, limit)
-          source = node.source_range.source_line[0...limit.loc.column]
-          source =~ /\s*\(\s*$/
+          node.parent.send_type? && !node.parent.parenthesized?
         end
 
         def to_modifier_form(node)
@@ -69,9 +168,18 @@ module RuboCop
           parenthesize?(node) ? "(#{expression})" : expression
         end
 
+        def to_normal_form(node)
+          indentation = ' ' * node.source_range.column
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}end
+          RUBY
+        end
+
         def first_line_comment(node)
           comment =
-            processed_source.comments.find { |c| c.loc.line == node.loc.line }
+            processed_source.find_comment { |c| c.loc.line == node.loc.line }
 
           comment ? comment.loc.expression.source : nil
         end

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

@@ -25,13 +25,25 @@ module RuboCop
       class IfUnlessModifierOfIfUnless < Cop
         include StatementModifier
 
-        MSG = 'Avoid modifier `%s` after another conditional.'.freeze
+        MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
 
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?
 
           add_offense(node, location: :keyword,
-                            message: format(MSG, node.keyword))
+                            message: format(MSG, keyword: node.keyword))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            keyword = node.if? ? 'if' : 'unless'
+
+            corrector.replace(node, <<~RUBY.chop)
+              #{keyword} #{node.condition.source}
+              #{node.if_branch.source}
+              end
+            RUBY
+          end
         end
       end
     end

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

@@ -4,16 +4,42 @@ 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
 
-        MSG = 'Do not use if x; Use the ternary operator instead.'.freeze
+        MSG = 'Do not use if x; Use the ternary operator instead.'
 
         def on_normal_if_unless(node)
+          return unless node.else_branch
+
           beginning = node.loc.begin
-          return unless beginning && beginning.is?(';')
+          return unless beginning&.is?(';')
+
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, correct_to_ternary(node))
+          end
+        end
+
+        private
+
+        def correct_to_ternary(node)
+          else_code = node.else_branch ? node.else_branch.source : 'nil'
+
+          "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
+        end
       end
     end
   end

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

@@ -9,21 +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 `%s` with an explicit exception class and message, ' \
-              'rather than just a message.'.freeze
+        MSG = 'Use `%<method>s` with an explicit exception class and message,' \
+              ' rather than just a message.'
 
         def_node_matcher :implicit_runtime_error_raise_or_fail,
                          '(send nil? ${:raise :fail} {str dstr})'
 
         def on_send(node)
           implicit_runtime_error_raise_or_fail(node) do |method|
-            add_offense(node, message: format(MSG, method))
+            add_offense(node, message: format(MSG, method: method))
           end
         end
       end

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

@@ -16,27 +16,30 @@ module RuboCop
       #     work
       #   end
       class InfiniteLoop < Cop
-        LEADING_SPACE = /\A(\s*)/
+        LEADING_SPACE = /\A(\s*)/.freeze
 
-        MSG = 'Use `Kernel#loop` for infinite loops.'.freeze
+        MSG = 'Use `Kernel#loop` for infinite loops.'
 
-        def on_while(node)
-          return unless node.condition.truthy_literal?
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
 
-          add_offense(node, location: :keyword)
+        def after_leaving_scope(scope, _variable_table)
+          @variables ||= []
+          @variables.concat(scope.variables.values)
         end
 
-        def on_until(node)
-          return unless node.condition.falsey_literal?
+        def on_while(node)
+          while_or_until(node) if node.condition.truthy_literal?
+        end
 
-          add_offense(node, location: :keyword)
+        def on_until(node)
+          while_or_until(node) if node.condition.falsey_literal?
         end
 
         alias on_while_post on_while
         alias on_until_post on_until
 
-        private
-
         def autocorrect(node)
           if node.while_post_type? || node.until_post_type?
             replace_begin_end_with_modifier(node)
@@ -47,6 +50,39 @@ module RuboCop
           end
         end
 
+        private
+
+        def while_or_until(node)
+          range = node.source_range
+          # Not every `while true` and `until false` can be turned into a
+          # `loop do` without further modification. The reason is that a
+          # variable that's introduced inside a while/until loop is in scope
+          # outside of that loop too, but a variable that's assigned for the
+          # first time inside a block cannot be accessed after the block. In
+          # those more complicated cases we don't report an offense.
+          return if @variables.any? do |var|
+            assigned_inside_loop?(var, range) &&
+            !assigned_before_loop?(var, range) &&
+            referenced_after_loop?(var, range)
+          end
+
+          add_offense(node, location: :keyword)
+        end
+
+        def assigned_inside_loop?(var, range)
+          var.assignments.any? { |a| range.contains?(a.node.source_range) }
+        end
+
+        def assigned_before_loop?(var, range)
+          b = range.begin_pos
+          var.assignments.any? { |a| a.node.source_range.end_pos < b }
+        end
+
+        def referenced_after_loop?(var, range)
+          e = range.end_pos
+          var.references.any? { |r| r.node.source_range.begin_pos > e }
+        end
+
         def replace_begin_end_with_modifier(node)
           lambda do |corrector|
             corrector.replace(node.body.loc.begin, 'loop do')
@@ -61,12 +97,13 @@ module RuboCop
         end
 
         def modifier_replacement(node)
+          body = node.body
           if node.single_line?
-            'loop { ' + node.body.source + ' }'
+            'loop { ' + body.source + ' }'
           else
-            indentation = node.body.loc.expression.source_line[LEADING_SPACE]
+            indentation = body.source_range.source_line[LEADING_SPACE]
 
-            ['loop do', node.body.source.gsub(/^/, configured_indent),
+            ['loop do', body.source.gsub(/^/, configured_indent),
              'end'].join("\n#{indentation}")
           end
         end
@@ -83,7 +120,7 @@ module RuboCop
         end
 
         def configured_indent
-          ' ' * config.for_cop('IndentationWidth')['Width']
+          ' ' * config.for_cop('Layout/IndentationWidth')['Width']
         end
       end
     end

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

@@ -18,11 +18,13 @@ module RuboCop
       #     f.bar # Trailing inline comment
       #   end
       class InlineComment < Cop
-        MSG = 'Avoid trailing inline comments.'.freeze
+        MSG = 'Avoid trailing inline comments.'
 
         def investigate(processed_source)
-          processed_source.comments.each do |comment|
-            next if comment_line?(processed_source[comment.loc.line - 1])
+          processed_source.each_comment do |comment|
+            next if comment_line?(processed_source[comment.loc.line - 1]) ||
+                    comment.text.match?(/\A# rubocop:(enable|disable)/)
+
             add_offense(comment)
           end
         end