rubocop 0.87.1

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for identical lines at the beginning or end of
+      # each branch of a conditional statement.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #     do_x
+      #     do_z
+      #   else
+      #     do_y
+      #     do_z
+      #   end
+      #
+      #   # 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
+        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)
+          check_branches(branches)
+        end
+
+        def on_case(node)
+          return unless node.else? && node.else_branch
+
+          branches = node.when_branches.map(&:body).push(node.else_branch)
+          check_branches(branches)
+        end
+
+        private
+
+        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)
+          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)
+          if branch.nil?
+            [nil]
+          elsif branch.if_type?
+            _condition, elsif_branch, else_branch = *branch
+            expand_elses(else_branch).unshift(elsif_branch)
+          else
+            [branch]
+          end
+        end
+
+        def tail(node)
+          node.begin_type? ? node.children.last : node
+        end
+
+        def head(node)
+          node.begin_type? ? node.children.first : node
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # If the `else` branch of a conditional consists solely of an `if` node,
+      # it can be combined with the `else` to become an `elsif`.
+      # This helps to keep the nesting level from getting too deep.
+      #
+      # @example
+      #   # 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
+      #     action_b
+      #   else
+      #     action_c
+      #   end
+      #
+      # @example AllowIfModifier: false (default)
+      #   # bad
+      #   if condition_a
+      #     action_a
+      #   else
+      #     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`.'
+
+        def on_if(node) # rubocop:todo Metrics/CyclomaticComplexity
+          return if node.ternary? || node.unless?
+
+          else_branch = node.else_branch
+
+          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
+end

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

@@ -0,0 +1,189 @@
+# 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 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_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)
+          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
+
+        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 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)
+          !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 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
+          # (due to the low operator precedence of modifier-if)
+          return false if node.parent.nil?
+          return true if ASSIGNMENT_TYPES.include?(node.parent.type)
+
+          node.parent.send_type? && !node.parent.parenthesized?
+        end
+
+        def to_modifier_form(node)
+          expression = [node.body.source,
+                        node.keyword,
+                        node.condition.source,
+                        first_line_comment(node)].compact.join(' ')
+
+          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.find_comment { |c| c.loc.line == node.loc.line }
+
+          comment ? comment.loc.expression.source : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for if and unless statements used as modifiers of other if or
+      # unless statements.
+      #
+      # @example
+      #
+      #  # bad
+      #  tired? ? 'stop' : 'go faster' if running?
+      #
+      #  # bad
+      #  if tired?
+      #    "please stop"
+      #  else
+      #    "keep going"
+      #  end if running?
+      #
+      #  # good
+      #  if running?
+      #    tired? ? 'stop' : 'go faster'
+      #  end
+      class IfUnlessModifierOfIfUnless < Cop
+        include StatementModifier
+
+        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, 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
+  end
+end