rubocop 1.40.0 → 1.43.0

data/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -30,6 +30,8 @@ module RuboCop
         MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
+          return unless node.loc.name.source.include?('_')
+
           allowed = /#{cop_config['AllowedNames'].join('|')}/
           name = node.loc.name.source.gsub(allowed, '')
           return unless /_/.match?(name)

data/lib/rubocop/cop/naming/inclusive_language.rb

@@ -207,7 +207,10 @@ module RuboCop
         end
 
         def scan_for_words(input)
-          mask_input(input).enum_for(:scan, @flagged_terms_regex).map do
+          masked_input = mask_input(input)
+          return EMPTY_ARRAY unless masked_input.match?(@flagged_terms_regex)
+
+          masked_input.enum_for(:scan, @flagged_terms_regex).map do
             match = Regexp.last_match
             WordLocation.new(match.to_s, match.offset(0).first)
           end

data/lib/rubocop/cop/registry.rb

@@ -19,6 +19,28 @@ module RuboCop
     class Registry
       include Enumerable
 
+      def self.all
+        global.without_department(:Test).cops
+      end
+
+      def self.qualified_cop_name(name, origin)
+        global.qualified_cop_name(name, origin)
+      end
+
+      # Changes momentarily the global registry
+      # Intended for testing purposes
+      def self.with_temporary_global(temp_global = global.dup)
+        previous = @global
+        @global = temp_global
+        yield
+      ensure
+        @global = previous
+      end
+
+      def self.reset!
+        @global = new
+      end
+
       attr_reader :options
 
       def initialize(cops = [], options = {})
@@ -28,6 +50,9 @@ module RuboCop
 
         @enrollment_queue = cops
         @options = options
+
+        @enabled_cache = {}.compare_by_identity
+        @disabled_cache = {}.compare_by_identity
       end
 
       def enlist(cop)
@@ -61,7 +86,7 @@ module RuboCop
 
       # @return [Boolean] Checks if given name is department
       def department?(name)
-        departments.include? name.to_sym
+        departments.include?(name.to_sym)
       end
 
       def contains_cop_matching?(names)
@@ -150,11 +175,11 @@ module RuboCop
       end
 
       def enabled(config)
-        select { |cop| enabled?(cop, config) }
+        @enabled_cache[config] ||= select { |cop| enabled?(cop, config) }
       end
 
       def disabled(config)
-        reject { |cop| enabled?(cop, config) }
+        @disabled_cache[config] ||= reject { |cop| enabled?(cop, config) }
       end
 
       def enabled?(cop, config)
@@ -235,28 +260,6 @@ module RuboCop
         attr_reader :global
       end
 
-      def self.all
-        global.without_department(:Test).cops
-      end
-
-      def self.qualified_cop_name(name, origin)
-        global.qualified_cop_name(name, origin)
-      end
-
-      # Changes momentarily the global registry
-      # Intended for testing purposes
-      def self.with_temporary_global(temp_global = global.dup)
-        previous = @global
-        @global = temp_global
-        yield
-      ensure
-        @global = previous
-      end
-
-      def self.reset!
-        @global = new
-      end
-
       private
 
       def initialize_copy(reg)

data/lib/rubocop/cop/security/compound_hash.rb

@@ -9,7 +9,8 @@ module RuboCop
       # Manually combining hashes is error prone and hard to follow, especially
       # when there are many values. Poor implementations may also introduce
       # performance or security concerns if they are prone to collisions.
-      # Delegating to `Array#hash` is clearer, faster, and safer.
+      # Delegating to `Array#hash` is clearer and safer, although it might be slower
+      # depending on the use case.
       #
       # @safety
       #   This cop may be unsafe if the application logic depends on the hash

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

@@ -7,6 +7,11 @@ module RuboCop
       # depending on configuration.
       # It also flags uses of `alias :symbol` rather than `alias bareword`.
       #
+      # However, it will always enforce `method_alias` when used `alias`
+      # in an instance method definition and in a singleton method definition.
+      # If used in a block, always enforce `alias_method`
+      # unless it is an `instance_eval` block.
+      #
       # @example EnforcedStyle: prefer_alias (default)
       #   # bad
       #   alias_method :bar, :foo
@@ -22,6 +27,7 @@ module RuboCop
       #
       #   # good
       #   alias_method :bar, :foo
+      #
       class Alias < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -71,7 +77,9 @@ module RuboCop
         end
 
         def alias_method_possible?(node)
-          scope_type(node) != :instance_eval && node.children.none?(&:gvar_type?)
+          scope_type(node) != :instance_eval &&
+            node.children.none?(&:gvar_type?) &&
+            node&.parent&.type != :def
         end
 
         def add_offense_for_args(node, &block)

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

@@ -32,7 +32,7 @@ module RuboCop
               eq_begin, eq_end, contents = parts(comment)
 
               corrector.remove(eq_begin)
-              unless contents.length.zero?
+              unless contents.empty?
                 corrector.replace(
                   contents,
                   contents.source.gsub(/\A/, '# ').gsub(/\n\n/, "\n#\n").gsub(/\n(?=[^#])/, "\n# ")

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `Array#push(item)` instead of `Array#concat([item])`
+      # to avoid redundant array literals.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Array` object.
+      #
+      # @example
+      #
+      #   # bad
+      #   list.concat([foo])
+      #   list.concat([bar, baz])
+      #   list.concat([qux, quux], [corge])
+      #
+      #   # good
+      #   list.push(foo)
+      #   list.push(bar, baz)
+      #   list.push(qux, quux, corge)
+      #
+      class ConcatArrayLiterals < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        MSG_FOR_PERCENT_LITERALS =
+          '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?)
+
+          offense = offense_range(node)
+          current = offense.source
+
+          if node.arguments.any?(&:percent_literal?)
+            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)
+          end
+
+          add_offense(offense, message: message) do |corrector|
+            corrector.replace(offense, prefer)
+          end
+        end
+        # rubocop:enable Metrics
+
+        private
+
+        def offense_range(node)
+          node.loc.selector.join(node.source_range.end)
+        end
+
+        def preferred_method(node)
+          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
+end

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

@@ -86,6 +86,11 @@ module RuboCop
           (send nil? {:public_constant :private_constant} ({sym str} _))
         PATTERN
 
+        # @!method include_statement?(node)
+        def_node_matcher :include_statement?, <<~PATTERN
+          (send nil? {:include :extend :prepend} const)
+        PATTERN
+
         def on_class(node)
           return unless node.body
 
@@ -103,7 +108,7 @@ module RuboCop
           return if documentation_comment?(node)
           return if constant_allowed?(node)
           return if nodoc_self_or_outer_module?(node)
-          return if macro_only?(body)
+          return if include_statement_only?(body)
 
           range = range_between(node.loc.expression.begin_pos, node.loc.name.end_pos)
           message = format(MSG, type: node.type, identifier: identifier(node))
@@ -115,9 +120,10 @@ module RuboCop
             (compact_namespace?(node) && nodoc_comment?(outer_module(node).first))
         end
 
-        def macro_only?(body)
-          (body.respond_to?(:macro?) && body.macro?) ||
-            (body.respond_to?(:children) && body.children&.all? { |child| macro_only?(child) })
+        def include_statement_only?(body)
+          return true if include_statement?(body)
+
+          body.respond_to?(:children) && body.children.all? { |node| include_statement_only?(node) }
         end
 
         def namespace?(node)
@@ -176,7 +182,7 @@ module RuboCop
         end
 
         def qualify_const(node)
-          return if node.nil? || node.cbase_type?
+          return if node.nil? || node.cbase_type? || node.self_type? || node.send_type?
 
           [qualify_const(node.namespace), node.short_name].compact
         end

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

@@ -187,35 +187,43 @@ module RuboCop
           if_branch = node.if_branch
           else_branch = node.else_branch
 
-          if if_branch&.send_type? && if_branch.last_argument&.heredoc?
+          if if_branch&.send_type? && heredoc?(if_branch.last_argument)
             autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
-          elsif else_branch&.send_type? && else_branch.last_argument&.heredoc?
+          elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)
             autocorrect_heredoc_argument(corrector, node, else_branch, if_branch, guard)
           else
             corrector.remove(node.loc.end)
             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
 
+        def heredoc?(argument)
+          argument.respond_to?(:heredoc?) && argument.heredoc?
+        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/if_with_semicolon.rb

@@ -21,13 +21,12 @@ module RuboCop
         MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
-          return unless node.else_branch
           return if node.parent&.if_type?
 
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          message = node.else_branch.if_type? ? MSG_IF_ELSE : MSG_TERNARY
+          message = node.else_branch&.if_type? ? MSG_IF_ELSE : MSG_TERNARY
 
           add_offense(node, message: format(message, expr: node.condition.source)) do |corrector|
             corrector.replace(node, autocorrect(node))
@@ -37,7 +36,7 @@ module RuboCop
         private
 
         def autocorrect(node)
-          return correct_elsif(node) if node.else_branch.if_type?
+          return correct_elsif(node) if node.else_branch&.if_type?
 
           then_code = node.if_branch ? node.if_branch.source : 'nil'
           else_code = node.else_branch ? node.else_branch.source : 'nil'

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

@@ -51,6 +51,8 @@ module RuboCop
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
+        RESTRICT_ON_SEND = [:!].freeze
+
         def self.autocorrect_incompatible_with
           [Style::Not, Style::SymbolProc]
         end

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

@@ -55,7 +55,10 @@ module RuboCop
         private
 
         def check_token_set(index)
-          predecessor, operator, successor = processed_source.tokens[index, 3]
+          tokens = processed_source.tokens
+          predecessor = tokens[index]
+          operator = tokens[index + 1]
+          successor = tokens[index + 2]
 
           return unless eligible_token_set?(predecessor, operator, successor)
 

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

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -102,20 +102,23 @@ module RuboCop
           end
 
           def call_in_literals?(node)
-            node.parent &&
-              (node.parent.pair_type? ||
-              node.parent.array_type? ||
-              node.parent.range_type? ||
-              splat?(node.parent) ||
-              ternary_if?(node.parent))
+            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            return unless parent
+
+            parent.pair_type? ||
+              parent.array_type? ||
+              parent.range_type? ||
+              splat?(parent) ||
+              ternary_if?(parent)
           end
 
           def call_in_logical_operators?(node)
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            parent &&
-              (logical_operator?(parent) ||
+            return unless parent
+
+            logical_operator?(parent) ||
               (parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) }))
+              parent.arguments.any? { |argument| logical_operator?(argument) })
           end
 
           def call_in_optional_arguments?(node)

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

@@ -10,7 +10,9 @@ module RuboCop
       #
       # 1. Endless methods
       # 2. Argument lists containing a `forward-arg` (`...`)
-      # 3. Argument lists containing an anonymous block forwarding (`&`)
+      # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
+      # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
+      # 5. Argument lists containing an anonymous block forwarding (`&`)
       #
       # Removing the parens would be a syntax error here.
       #
@@ -130,9 +132,11 @@ module RuboCop
           # Regardless of style, parentheses are necessary for:
           # 1. Endless methods
           # 2. Argument lists containing a `forward-arg` (`...`)
-          # 3. Argument lists containing an anonymous block forwarding (`&`)
+          # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
+          # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
+          # 5. Argument lists containing an anonymous block forwarding (`&`)
           # Removing the parens would be a syntax error here.
-          node.endless? || node.arguments.any?(&:forward_arg_type?) || anonymous_block_arg?(node)
+          node.endless? || anonymous_arguments?(node)
         end
 
         def require_parentheses?(args)
@@ -162,7 +166,10 @@ module RuboCop
           end
         end
 
-        def anonymous_block_arg?(node)
+        def anonymous_arguments?(node)
+          return true if node.arguments.any? do |arg|
+            arg.forward_arg_type? || arg.restarg_type? || arg.kwrestarg_type?
+          end
           return false unless (last_argument = node.arguments.last)
 
           last_argument.blockarg_type? && last_argument.name.nil?