rubocop 0.78.0 → 1.13.0

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of `_.each_with_object({}) {...}`,
+      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # transforming the values of a hash, and tries to use a simpler & faster
+      # call to `transform_values` instead.
+      #
+      # This can produce false positives if we are transforming an enumerable
+      # of key-value-like pairs that isn't actually a hash, e.g.:
+      # `[[k1, v1], [k2, v2], ...]`
+      #
+      # This cop should only be enabled on Ruby version 2.4 or newer
+      # (`transform_values` was added in Ruby 2.4.)
+      #
+      # @example
+      #   # bad
+      #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
+      #   Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }]
+      #   {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h
+      #   {a: 1, b: 2}.to_h { |k, v| [k, v * v] }
+      #
+      #   # good
+      #   {a: 1, b: 2}.transform_values { |v| foo(v) }
+      #   {a: 1, b: 2}.transform_values { |v| v * v }
+      class HashTransformValues < Base
+        include HashTransformMethod
+        extend AutoCorrector
+
+        # @!method on_bad_each_with_object(node)
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend} !#array_receiver? :each_with_object (hash))
+            (args
+              (mlhs
+                (arg _key)
+                (arg $_))
+              (arg _memo))
+            ({send csend} (lvar _memo) :[]= $(lvar _key) $!`_memo))
+        PATTERN
+
+        # @!method on_bad_hash_brackets_map(node)
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} !#array_receiver? {:map :collect})
+              (args
+                (arg _key)
+                (arg $_))
+              (array $(lvar _key) $_)))
+        PATTERN
+
+        # @!method on_bad_map_to_h(node)
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend} !#array_receiver? {:map :collect})
+              (args
+                (arg _key)
+                (arg $_))
+              (array $(lvar _key) $_))
+            :to_h)
+        PATTERN
+
+        # @!method on_bad_to_h(node)
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            ({send csend} !#array_receiver? :to_h)
+            (args
+              (arg _key)
+              (arg $_))
+            (array $(lvar _key) $_))
+        PATTERN
+
+        private
+
+        def extract_captures(match)
+          val_argname, key_body_expr, val_body_expr = *match
+          Captures.new(val_argname, val_body_expr, key_body_expr)
+        end
+
+        def new_method_name
+          'transform_values'
+        end
+      end
+    end
+  end
+end

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

@@ -3,8 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for identical lines at the beginning or end of
-      # each branch of a conditional statement.
+      # This cop checks for identical expressions at the beginning or end of
+      # each branch of a conditional expression. Such expressions should normally
+      # be placed outside the conditional expression - before or after it.
+      #
+      # NOTE: The cop is poorly named and some people might think that it actually
+      # checks for duplicated conditional branches. The name will probably be changed
+      # in a future major RuboCop release.
       #
       # @example
       #   # bad
@@ -62,7 +67,7 @@ module RuboCop
       #     do_x
       #     do_z
       #   end
-      class IdenticalConditionalBranches < Cop
+      class IdenticalConditionalBranches < Base
         MSG = 'Move `%<source>s` out of the conditional.'
 
         def on_if(node)
@@ -81,7 +86,7 @@ module RuboCop
 
         private
 
-        def check_branches(branches)
+        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           # 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?)
@@ -95,9 +100,7 @@ module RuboCop
         def check_expressions(expressions)
           return unless expressions.size > 1 && expressions.uniq.one?
 
-          expressions.each do |expression|
-            add_offense(expression)
-          end
+          expressions.each { |expression| add_offense(expression) }
         end
 
         def message(node)

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

@@ -58,7 +58,10 @@ module RuboCop
       #     action_b
       #   end
       #
-      class IfInsideElse < Cop
+      class IfInsideElse < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
         def on_if(node)
@@ -69,11 +72,56 @@ module RuboCop
           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)
+          add_offense(else_branch.loc.keyword) do |corrector|
+            autocorrect(corrector, else_branch)
+          end
         end
 
         private
 
+        def autocorrect(corrector, node)
+          if node.modifier_form?
+            correct_to_elsif_from_modifier_form(corrector, node)
+          else
+            correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
+          end
+          corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
+          return unless (if_branch = node.if_branch)
+
+          range = range_by_whole_lines(if_branch.source_range, include_final_newline: true)
+          corrector.remove(range)
+        end
+
+        def correct_to_elsif_from_modifier_form(corrector, node)
+          corrector.replace(node.parent.loc.else, <<~RUBY.chop)
+            elsif #{node.condition.source}
+            #{indent(node.if_branch)}#{node.if_branch.source}
+            end
+          RUBY
+        end
+
+        def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
+          corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
+          if_condition_range = if_condition_range(node, condition)
+          if (if_branch = node.if_branch)
+            corrector.replace(if_condition_range, if_branch.source)
+          else
+            corrector.remove(range_by_whole_lines(if_condition_range, include_final_newline: true))
+          end
+          corrector.remove(condition)
+        end
+
+        def find_end_range(node)
+          end_range = node.loc.end
+          return end_range if end_range
+
+          find_end_range(node.parent)
+        end
+
+        def if_condition_range(node, condition)
+          range_between(node.loc.keyword.begin_pos, condition.source_range.end_pos)
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -9,7 +9,7 @@ module RuboCop
       #
       # The maximum line length is configured in the `Layout/LineLength`
       # cop. The tab size is configured in the `IndentationWidth` of the
-      # `Layout/Tab` cop.
+      # `Layout/IndentationStyle` cop.
       #
       # @example
       #   # bad
@@ -21,52 +21,72 @@ module RuboCop
       #     Foo.do_something
       #   end
       #
-      #   do_something_in_a_method_with_a_long_name(arg) if long_condition
+      #   do_something_with_a_long_name(arg) if long_condition_that_prevents_code_fit_on_single_line
       #
       #   # 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)
+      #   if long_condition_that_prevents_code_fit_on_single_line
+      #     do_something_with_a_long_name(arg)
       #   end
-      class IfUnlessModifier < Cop
+      #
+      #   if short_condition # a long comment that makes it too long if it were just a single line
+      #     do_something
+      #   end
+      class IfUnlessModifier < Base
         include StatementModifier
         include LineLengthHelp
         include IgnoredPattern
+        include RangeHelp
+        extend AutoCorrector
 
         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.'
+        MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
 
-        ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
-                              gvasgn ivasgn masgn].freeze
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
 
         def on_if(node)
-          msg = if eligible_node?(node)
-                  MSG_USE_MODIFIER unless named_capture_in_condition?(node)
-                elsif node.modifier_form? && too_long_single_line?(node)
+          msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
+                  MSG_USE_MODIFIER
+                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))
+          add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           replacement = if node.modifier_form?
-                          to_normal_form(node)
+                          indentation = ' ' * node.source_range.column
+                          last_argument = node.if_branch.last_argument
+
+                          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
+                            heredoc = extract_heredoc_from(last_argument)
+                            remove_heredoc(corrector, heredoc)
+                            to_normal_form_with_heredoc(node, indentation, heredoc)
+                          else
+                            to_normal_form(node, indentation)
+                          end
                         else
                           to_modifier_form(node)
                         end
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
+          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'] || []
@@ -112,56 +132,66 @@ module RuboCop
         end
 
         def line_length_enabled_at_line?(line)
-          processed_source.comment_config
-                          .cop_enabled_at_line?('Layout/LineLength', 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)
+        def non_eligible_node?(node)
+          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? || super
         end
 
-        def non_eligible_if?(node)
-          node.ternary? || node.modifier_form? || node.elsif? || node.else?
+        def non_simple_if_unless?(node)
+          node.ternary? || node.elsif? || node.else?
         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)
+        def another_statement_on_same_line?(node)
+          line_no = node.source_range.last_line
 
-          node.parent.send_type? && !node.parent.parenthesized?
-        end
+          # 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
 
-        def to_modifier_form(node)
-          expression = [node.body.source,
-                        node.keyword,
-                        node.condition.source,
-                        first_line_comment(node)].compact.join(' ')
+          node && (sibling = node.children[index + 1]) && sibling.source_range.first_line == line_no
+        end
 
-          parenthesize?(node) ? "(#{expression})" : expression
+        def to_normal_form(node, indentation)
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}end
+          RUBY
         end
 
-        def to_normal_form(node)
-          indentation = ' ' * node.source_range.column
+        def to_normal_form_with_heredoc(node, indentation, heredoc)
+          heredoc_body, heredoc_end = heredoc
+
           <<~RUBY.chomp
             #{node.keyword} #{node.condition.source}
             #{indentation}  #{node.body.source}
+            #{indentation}  #{heredoc_body.source.chomp}
+            #{indentation}  #{heredoc_end.source.chomp}
             #{indentation}end
           RUBY
         end
 
-        def first_line_comment(node)
-          comment =
-            processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        def extract_heredoc_from(last_argument)
+          heredoc_body = last_argument.loc.heredoc_body
+          heredoc_end = last_argument.loc.heredoc_end
 
-          comment ? comment.loc.expression.source : nil
+          [heredoc_body, heredoc_end]
+        end
+
+        def remove_heredoc(corrector, heredoc)
+          heredoc.each do |range|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
         end
       end
     end

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

@@ -22,16 +22,24 @@ module RuboCop
       #  if running?
       #    tired? ? 'stop' : 'go faster'
       #  end
-      class IfUnlessModifierOfIfUnless < Cop
+      class IfUnlessModifierOfIfUnless < Base
         include StatementModifier
+        extend AutoCorrector
 
         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))
+          add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) 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_boolean_literal_branches.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant `if` with boolean literal branches.
+      # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
+      # The conditions to be checked are comparison methods, predicate methods, and double negative.
+      # However, auto-correction is unsafe because there is no guarantee that all predicate methods
+      # will return boolean value. Those methods can be allowed with `AllowedMethods` config.
+      #
+      # @example
+      #   # bad
+      #   if foo == bar
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # bad
+      #   foo == bar ? true : false
+      #
+      #   # good
+      #   foo == bar
+      #
+      # @example AllowedMethods: ['nonzero?']
+      #   # good
+      #   num.nonzero? ? true : false
+      #
+      class IfWithBooleanLiteralBranches < Base
+        include AllowedMethods
+        extend AutoCorrector
+
+        MSG = 'Remove redundant %<keyword>s with boolean literal branches.'
+        MSG_FOR_ELSIF = 'Use `else` instead of redundant `elsif` with boolean literal branches.'
+
+        # @!method if_with_boolean_literal_branches?(node)
+        def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
+          (if #return_boolean_value? {(true) (false) | (false) (true)})
+        PATTERN
+        # @!method double_negative?(node)
+        def_node_matcher :double_negative?, '(send (send _ :!) :!)'
+
+        def on_if(node)
+          return unless if_with_boolean_literal_branches?(node)
+
+          condition = node.condition
+          range, keyword = offense_range_with_keyword(node, condition)
+
+          add_offense(range, message: message(node, keyword)) do |corrector|
+            replacement = replacement_condition(node, condition)
+
+            if node.elsif?
+              corrector.insert_before(node, "else\n")
+              corrector.replace(node, "#{indent(node.if_branch)}#{replacement}")
+            else
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def offense_range_with_keyword(node, condition)
+          if node.ternary?
+            range = condition.source_range.end.join(node.source_range.end)
+
+            [range, 'ternary operator']
+          else
+            keyword = node.loc.keyword
+
+            [keyword, "`#{keyword.source}`"]
+          end
+        end
+
+        def message(node, keyword)
+          message_template = node.elsif? ? MSG_FOR_ELSIF : MSG
+
+          format(message_template, keyword: keyword)
+        end
+
+        def return_boolean_value?(condition)
+          if condition.begin_type?
+            return_boolean_value?(condition.children.first)
+          elsif condition.or_type?
+            return_boolean_value?(condition.lhs) && return_boolean_value?(condition.rhs)
+          elsif condition.and_type?
+            return_boolean_value?(condition.rhs)
+          else
+            assume_boolean_value?(condition)
+          end
+        end
+
+        def assume_boolean_value?(condition)
+          return false unless condition.send_type?
+          return false if allowed_method?(condition.method_name)
+
+          condition.comparison_method? || condition.predicate_method? || double_negative?(condition)
+        end
+
+        def replacement_condition(node, condition)
+          bang = '!' if opposite_condition?(node)
+
+          if bang && require_parentheses?(condition)
+            "#{bang}(#{condition.source})"
+          else
+            "#{bang}#{condition.source}"
+          end
+        end
+
+        def opposite_condition?(node)
+          !node.unless? && node.if_branch.false_type? || node.unless? && node.if_branch.true_type?
+        end
+
+        def require_parentheses?(condition)
+          condition.and_type? || condition.or_type? ||
+            condition.send_type? && condition.comparison_method?
+        end
+      end
+    end
+  end
+end