rubocop 1.41.1 → 1.45.1

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

@@ -299,8 +299,8 @@ module RuboCop
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
-          comment_range = range_between(range.end_pos, comment.loc.expression.end_pos)
-          corrector.remove(range_with_surrounding_space(comment_range, side: :right))
+          corrector.remove(range_with_surrounding_space(comment.loc.expression, side: :right))
+          remove_trailing_whitespace(corrector, range, comment)
           corrector.insert_after(range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
@@ -313,6 +313,12 @@ module RuboCop
           end_of_chain(node.parent)
         end
 
+        def remove_trailing_whitespace(corrector, range, comment)
+          range_of_trailing = range.end.join(comment.loc.expression.begin)
+
+          corrector.remove(range_of_trailing) if range_of_trailing.source.match?(/\A\s+\z/)
+        end
+
         def with_block?(node)
           node.respond_to?(:block_node) && node.block_node
         end

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

@@ -31,6 +31,7 @@ module RuboCop
       #
       # The compact style is only forced for classes/modules with one child.
       class ClassAndModuleChildren < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
@@ -59,7 +60,7 @@ module RuboCop
         end
 
         def nest_definition(corrector, node)
-          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding = indentation(node) + leading_spaces(node)
           padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
 
           replace_namespace_keyword(corrector, node)
@@ -124,10 +125,6 @@ module RuboCop
           corrector.remove(range)
         end
 
-        def configured_indentation_width
-          config.for_badge(Layout::IndentationWidth.badge).fetch('Width', 2)
-        end
-
         def unindent(corrector, node)
           return if node.body.children.last.nil?
 
@@ -141,10 +138,6 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def indent_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def check_style(node, body)
           return if node.identifier.children[0]&.cbase_type?
 
@@ -185,7 +178,7 @@ module RuboCop
         end
 
         def compact_node_name?(node)
-          /::/.match?(node.identifier.source)
+          node.identifier.source.include?('::')
         end
       end
     end

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

@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          /`/.match?(node_body(node))
+          node_body(node).include?('`')
         end
 
         def node_body(node)

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `Comparable#clamp` instead of comparison by minimum and maximum.
+      #
+      # This cop supports autocorrection for `if/elsif/else` bad style only.
+      # Because `ArgumentError` occurs if the minimum and maximum of `clamp` arguments are reversed.
+      # When these are variables, it is not possible to determine which is the minimum and maximum:
+      #
+      # [source,ruby]
+      # ----
+      # [1, [2, 3].max].min # => 1
+      # 1.clamp(3, 1)       # => min argument must be smaller than max argument (ArgumentError)
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   [[x, low].max, high].min
+      #
+      #   # bad
+      #   if x < low
+      #     low
+      #   elsif high < x
+      #     high
+      #   else
+      #     x
+      #   end
+      #
+      #   # good
+      #   x.clamp(low, high)
+      #
+      class ComparableClamp < Base
+        include Alignment
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
+
+        MSG = 'Use `%<prefer>s` instead of `if/elsif/else`.'
+        MSG_MIN_MAX = 'Use `Comparable#clamp` instead.'
+        RESTRICT_ON_SEND = %i[min max].freeze
+
+        # @!method if_elsif_else_condition?(node)
+        def_node_matcher :if_elsif_else_condition?, <<~PATTERN
+          {
+            (if (send _x :< _min) _min (if (send _max :< _x) _max _x))
+            (if (send _min :> _x) _min (if (send _max :< _x) _max _x))
+            (if (send _x :< _min) _min (if (send _x :> _max) _max _x))
+            (if (send _min :> _x) _min (if (send _x :> _max) _max _x))
+            (if (send _max :< _x) _max (if (send _x :< _min) _min _x))
+            (if (send _x :> _max) _max (if (send _x :< _min) _min _x))
+            (if (send _max :< _x) _max (if (send _min :> _x) _min _x))
+            (if (send _x :> _max) _max (if (send _min :> _x) _min _x))
+          }
+        PATTERN
+
+        # @!method array_min_max?(node)
+        def_node_matcher :array_min_max?, <<~PATTERN
+          {
+            (send
+              (array
+                (send (array _ _) :max) _) :min)
+            (send
+              (array
+                _ (send (array _ _) :max)) :min)
+            (send
+              (array
+                (send (array _ _) :min) _) :max)
+            (send
+              (array
+                _ (send (array _ _) :min)) :max)
+          }
+        PATTERN
+
+        def on_if(node)
+          return unless if_elsif_else_condition?(node)
+
+          if_body, elsif_body, else_body = *node.branches
+
+          else_body_source = else_body.source
+
+          if min_condition?(node.condition, else_body_source)
+            min = if_body.source
+            max = elsif_body.source
+          else
+            min = elsif_body.source
+            max = if_body.source
+          end
+
+          prefer = "#{else_body_source}.clamp(#{min}, #{max})"
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            autocorrect(corrector, node, prefer)
+          end
+        end
+
+        def on_send(node)
+          return unless array_min_max?(node)
+
+          add_offense(node, message: MSG_MIN_MAX)
+        end
+
+        private
+
+        def autocorrect(corrector, node, prefer)
+          if node.elsif?
+            corrector.insert_before(node, "else\n")
+            corrector.replace(node, "#{indentation(node)}#{prefer}")
+          else
+            corrector.replace(node, prefer)
+          end
+        end
+
+        def min_condition?(if_condition, else_body)
+          lhs, op, rhs = *if_condition
+
+          (lhs.source == else_body && op == :<) || (rhs.source == else_body && op == :>)
+        end
+      end
+    end
+  end
+end

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

@@ -30,6 +30,7 @@ module RuboCop
           'Use `push` with elements as arguments without array brackets instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[concat].freeze
 
+        # rubocop:disable Metrics
         def on_send(node)
           return if node.arguments.empty?
           return unless node.arguments.all?(&:array_type?)
@@ -38,7 +39,12 @@ module RuboCop
           current = offense.source
 
           if node.arguments.any?(&:percent_literal?)
-            message = format(MSG_FOR_PERCENT_LITERALS, current: current)
+            if percent_literals_includes_only_basic_literals?(node)
+              prefer = preferred_method(node)
+              message = format(MSG, prefer: prefer, current: current)
+            else
+              message = format(MSG_FOR_PERCENT_LITERALS, current: current)
+            end
           else
             prefer = preferred_method(node)
             message = format(MSG, prefer: prefer, current: current)
@@ -48,6 +54,7 @@ module RuboCop
             corrector.replace(offense, prefer)
           end
         end
+        # rubocop:enable Metrics
 
         private
 
@@ -56,10 +63,23 @@ module RuboCop
         end
 
         def preferred_method(node)
-          new_arguments = node.arguments.map { |arg| arg.children.map(&:source) }.join(', ')
+          new_arguments =
+            node.arguments.map do |arg|
+              if arg.percent_literal?
+                arg.children.map(&:value).map(&:inspect)
+              else
+                arg.children.map(&:source)
+              end
+            end.join(', ')
 
           "push(#{new_arguments})"
         end
+
+        def percent_literals_includes_only_basic_literals?(node)
+          node.arguments.select(&:percent_literal?).all? do |arg|
+            arg.children.all? { |child| child.str_type? || child.sym_type? }
+          end
+        end
       end
     end
   end

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

@@ -218,11 +218,9 @@ module RuboCop
         VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Layout/LineLength'
-        INDENTATION_WIDTH = 'Layout/IndentationWidth'
         ENABLED = 'Enabled'
         MAX = 'Max'
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
-        WIDTH = 'Width'
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
@@ -428,10 +426,6 @@ module RuboCop
           config.for_cop(LINE_LENGTH)[MAX]
         end
 
-        def indentation_width
-          config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
-        end
-
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end

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

@@ -145,7 +145,7 @@ module RuboCop
         end
 
         def compact_namespace?(node)
-          /::/.match?(node.loc.name.source)
+          node.loc.name.source.include?('::')
         end
 
         # First checks if the :nodoc: comment is associated with the

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

@@ -7,6 +7,10 @@ module RuboCop
       # It can optionally be configured to also require documentation for
       # non-public methods.
       #
+      # NOTE: This cop allows `initialize` method because `initialize` is
+      # a special method called from `new`. In some programming languages
+      # they are called constructor to distinguish it from method.
+      #
       # @example
       #
       #   # bad
@@ -103,6 +107,8 @@ module RuboCop
         PATTERN
 
         def on_def(node)
+          return if node.method?(:initialize)
+
           parent = node.parent
           module_function_node?(parent) ? check(parent) : check(node)
         end

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

@@ -196,7 +196,7 @@ module RuboCop
             return unless node.else?
 
             corrector.remove(node.loc.else)
-            corrector.remove(branch_to_remove(node, guard))
+            corrector.remove(range_of_branch_to_remove(node, guard))
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -206,20 +206,24 @@ module RuboCop
         end
 
         def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+          return unless node.else?
+
           remove_whole_lines(corrector, leave_branch.source_range)
           remove_whole_lines(corrector, node.loc.else)
           remove_whole_lines(corrector, node.loc.end)
-          remove_whole_lines(corrector, branch_to_remove(node, guard).source_range)
+          remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
           corrector.insert_after(
             heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
           )
         end
 
-        def branch_to_remove(node, guard)
-          case guard
-          when :if then node.if_branch
-          when :else then node.else_branch
-          end
+        def range_of_branch_to_remove(node, guard)
+          branch = case guard
+                   when :if then node.if_branch
+                   when :else then node.else_branch
+                   end
+
+          branch.source_range
         end
 
         def guard_clause_source(guard_clause)

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

@@ -118,11 +118,23 @@ module RuboCop
         end
 
         def allowed_receiver?(receiver)
-          receiver_name = receiver.send_type? ? receiver.method_name.to_s : receiver.source
+          receiver_name = receiver_name(receiver)
 
           allowed_receivers.include?(receiver_name)
         end
 
+        def receiver_name(receiver)
+          if receiver.send_type?
+            if receiver.receiver
+              "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
+            else
+              receiver.method_name.to_s
+            end
+          else
+            receiver.source
+          end
+        end
+
         def allowed_receivers
           cop_config.fetch('AllowedReceivers', [])
         end

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

@@ -28,7 +28,7 @@ module RuboCop
       # * always - forces use of the 3.1 syntax (e.g. {foo:})
       # * never - forces use of explicit hash literal value
       # * either - accepts both shorthand and explicit use of hash literal value
-      # * consistent - like "either", but will avoid mixing styles in a single hash
+      # * consistent - forces use of the 3.1 syntax only if all values can be omitted in the hash
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -92,16 +92,19 @@ module RuboCop
       #
       # @example EnforcedShorthandSyntax: consistent
       #
-      #   # bad
-      #   {foo: , bar: bar}
+      #   # bad - `foo` and `bar` values can be omitted
+      #   {foo: foo, bar: bar}
       #
-      #   # good
-      #   {foo:, bar:}
+      #   # bad - `bar` value can be omitted
+      #   {foo:, bar: bar}
       #
-      #   # bad
-      #   {foo: , bar: baz}
+      #   # bad - mixed syntaxes
+      #   {foo:, bar: baz}
       #
       #   # good
+      #   {foo:, bar:}
+      #
+      #   # good - can't omit `baz`
       #   {foo: foo, bar: baz}
       #
       class HashSyntax < Base
@@ -251,6 +254,7 @@ module RuboCop
           op = pair_node.loc.operator
 
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
+          key_with_hash_rocket += pair_node.key.source if pair_node.value_omission?
           corrector.replace(pair_node.key, key_with_hash_rocket)
           corrector.remove(range_with_surrounding_space(op))
         end

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

@@ -136,6 +136,7 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_branches(node, branches)
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
@@ -144,9 +145,13 @@ module RuboCop
           tails = branches.map { |branch| tail(branch) }
           check_expressions(node, tails, :after_condition) if duplicated_expressions?(node, tails)
 
+          return if last_child_of_parent?(node) &&
+                    branches.any? { |branch| single_child_branch?(branch) }
+
           heads = branches.map { |branch| head(branch) }
           check_expressions(node, heads, :before_condition) if duplicated_expressions?(node, heads)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def duplicated_expressions?(node, expressions)
           unique_expressions = expressions.uniq
@@ -180,6 +185,16 @@ module RuboCop
           end
         end
 
+        def last_child_of_parent?(node)
+          return true unless (parent = node.parent)
+
+          parent.child_nodes.last == node
+        end
+
+        def single_child_branch?(branch_node)
+          !branch_node.begin_type? || branch_node.children.size == 1
+        end
+
         def message(node)
           format(MSG, source: node.source)
         end

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

@@ -21,6 +21,7 @@ module RuboCop
       #     work
       #   end
       class InfiniteLoop < Base
+        include Alignment
         extend AutoCorrector
 
         LEADING_SPACE = /\A(\s*)/.freeze
@@ -106,7 +107,7 @@ module RuboCop
           else
             indentation = body.source_range.source_line[LEADING_SPACE]
 
-            ['loop do', body.source.gsub(/^/, configured_indent), 'end'].join("\n#{indentation}")
+            ['loop do', body.source.gsub(/^/, indentation(node)), 'end'].join("\n#{indentation}")
           end
         end
 
@@ -120,10 +121,6 @@ module RuboCop
 
           start_range.join(end_range)
         end
-
-        def configured_indent
-          ' ' * config.for_cop('Layout/IndentationWidth')['Width']
-        end
       end
     end
   end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usages of `unless` which can be replaced by `if` with inverted condition.
+      # Code without `unless` is easier to read, but that is subjective, so this cop
+      # is disabled by default.
+      #
+      # Methods that can be inverted should be defined in `InverseMethods`. Note that
+      # the relationship of inverse methods needs to be defined in both directions.
+      # For example,
+      #   InverseMethods:
+      #     :!=: :==
+      #     :even?: :odd?
+      #     :odd?: :even?
+      #
+      #  will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`).
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the method
+      #   and its inverse method are both defined on receiver, and also are
+      #   actually inverse of each other.
+      #
+      # @example
+      #   # bad (simple condition)
+      #   foo unless !bar
+      #   foo unless x != y
+      #   foo unless x >= 10
+      #   foo unless x.even?
+      #
+      #   # good
+      #   foo if bar
+      #   foo if x == y
+      #   foo if x < 10
+      #   foo if x.odd?
+      #
+      #   # bad (complex condition)
+      #   foo unless x != y || x.even?
+      #
+      #   # good
+      #   foo if x == y && x.odd?
+      #
+      #   # good (if)
+      #   foo if !condition
+      #
+      class InvertibleUnlessCondition < Base
+        extend AutoCorrector
+
+        MSG = 'Favor `if` with inverted condition over `unless`.'
+
+        def on_if(node)
+          return unless node.unless?
+
+          condition = node.condition
+          return unless invertible?(condition)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node.loc.keyword, node.inverse_keyword)
+            autocorrect(corrector, condition)
+          end
+        end
+
+        private
+
+        def invertible?(node)
+          case node.type
+          when :begin
+            invertible?(node.children.first)
+          when :send
+            return if inheritance_check?(node)
+
+            node.method?(:!) || inverse_methods.key?(node.method_name)
+          when :or, :and
+            invertible?(node.lhs) && invertible?(node.rhs)
+          else
+            false
+          end
+        end
+
+        def inheritance_check?(node)
+          argument = node.first_argument
+          node.method?(:<) &&
+            (argument.const_type? && argument.short_name.to_s.upcase != argument.short_name.to_s)
+        end
+
+        def autocorrect(corrector, node)
+          case node.type
+          when :begin
+            autocorrect(corrector, node.children.first)
+          when :send
+            autocorrect_send_node(corrector, node)
+          when :or, :and
+            corrector.replace(node.loc.operator, node.inverse_operator)
+            autocorrect(corrector, node.lhs)
+            autocorrect(corrector, node.rhs)
+          end
+        end
+
+        def autocorrect_send_node(corrector, node)
+          if node.method?(:!)
+            corrector.remove(node.loc.selector)
+          else
+            corrector.replace(node.loc.selector, inverse_methods[node.method_name])
+          end
+        end
+
+        def inverse_methods
+          @inverse_methods ||= cop_config['InverseMethods']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of `map.to_set` or `collect.to_set` that could be
+      # written with just `to_set`.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerable`.
+      #
+      # @example
+      #   # bad
+      #   something.map { |i| i * 2 }.to_set
+      #
+      #   # good
+      #   something.to_set { |i| i * 2 }
+      #
+      #   # bad
+      #   [1, 2, 3].collect { |i| i.to_s }.to_set
+      #
+      #   # good
+      #   [1, 2, 3].to_set { |i| i.to_s }
+      #
+      class MapToSet < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Pass a block to `to_set` instead of calling `%<method>s.to_set`.'
+        RESTRICT_ON_SEND = %i[to_set].freeze
+
+        # @!method map_to_set?(node)
+        def_node_matcher :map_to_set?, <<~PATTERN
+          $(send (block $(send _ {:map :collect}) ...) :to_set)
+        PATTERN
+
+        def on_send(node)
+          return unless (to_set_node, map_node = map_to_set?(node))
+
+          message = format(MSG, method: map_node.loc.selector.source)
+          add_offense(map_node.loc.selector, message: message) do |corrector|
+            # If the `to_set` call already has a block, do not autocorrect.
+            next if to_set_node.block_node
+
+            autocorrect(corrector, to_set_node, map_node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, to_set, map)
+          removal_range = range_between(to_set.loc.dot.begin_pos, to_set.loc.selector.end_pos)
+
+          corrector.remove(range_with_surrounding_space(removal_range, side: :left))
+          corrector.replace(map.loc.selector, 'to_set')
+        end
+      end
+    end
+  end
+end