rubocop 1.39.0 → 1.44.1

data/lib/rubocop/cop/gemspec/development_dependencies.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Enforce that development dependencies for a gem are specified in
+      # `Gemfile`, rather than in the `gemspec` using
+      # `add_development_dependency`. Alternatively, using `EnforcedStyle:
+      # gemspec`, enforce that all dependencies are specified in `gemspec`,
+      # rather than in `Gemfile`.
+      #
+      # @example EnforcedStyle: Gemfile (default)
+      #   # Specify runtime dependencies in your gemspec,
+      #   # but all other dependencies in your Gemfile.
+      #
+      #   # bad
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # gems.rb
+      #   gem "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # example.gemspec
+      #   s.add_development_dependency "bar"
+      #
+      # @example EnforcedStyle: gems.rb
+      #   # Specify runtime dependencies in your gemspec,
+      #   # but all other dependencies in your Gemfile.
+      #   #
+      #   # Identical to `EnforcedStyle: Gemfile`, but with a different error message.
+      #   # Rely on Bundler/GemFilename to enforce the use of `Gemfile` vs `gems.rb`.
+      #
+      #   # bad
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # gems.rb
+      #   gem "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # example.gemspec
+      #   s.add_development_dependency "bar"
+      #
+      # @example EnforcedStyle: gemspec
+      #   # Specify all dependencies in your gemspec.
+      #
+      #   # bad
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # Gemfile
+      #   gem "bar"
+      #
+      class DevelopmentDependencies < Base
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Specify development dependencies in %<preferred>s.'
+        RESTRICT_ON_SEND = %i[add_development_dependency gem].freeze
+
+        # @!method add_development_dependency?(node)
+        def_node_matcher :add_development_dependency?, <<~PATTERN
+          (send _ :add_development_dependency (str #forbidden_gem? ...))
+        PATTERN
+
+        # @!method gem?(node)
+        def_node_matcher :gem?, <<~PATTERN
+          (send _ :gem (str #forbidden_gem? ...))
+        PATTERN
+
+        def on_send(node)
+          case style
+          when :Gemfile, :'gems.rb'
+            add_offense(node) if add_development_dependency?(node)
+          when :gemspec
+            add_offense(node) if gem?(node)
+          end
+        end
+
+        private
+
+        def forbidden_gem?(gem_name)
+          !cop_config['AllowedGems'].include?(gem_name)
+        end
+
+        def message(_range)
+          format(MSG, preferred: style)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/cop_description.rb

@@ -28,8 +28,9 @@ module RuboCop
           /^\s+# This cop (?<special>#{SPECIAL_WORDS.join('|')})?\s*(?<word>.+?) .*/.freeze
         REPLACEMENT_REGEX = /^\s+# This cop (#{SPECIAL_WORDS.join('|')})?\s*(.+?) /.freeze
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_class(node)
-          return unless (module_node = node.parent)
+          return unless (module_node = node.parent) && node.parent_class
 
           description_beginning = first_comment_line(module_node)
           return unless description_beginning
@@ -48,6 +49,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 

data/lib/rubocop/cop/internal_affairs/lambda_or_proc.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.lambda_or_proc?` instead of `node.lambda? || node.proc?`.
+      #
+      # @example
+      #   # bad
+      #   node.lambda? || node.proc?
+      #   node.proc? || node.lambda?
+      #
+      #   # good
+      #   node.lambda_or_proc?
+      #
+      class LambdaOrProc < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+
+        # @!method lambda_or_proc(node)
+        def_node_matcher :lambda_or_proc, <<~PATTERN
+          {
+            (or $(send _node :lambda?) $(send _node :proc?))
+            (or $(send _node :proc?) $(send _node :lambda?))
+            (or
+              (or _ $(send _node :lambda?)) $(send _node :proc?))
+            (or
+              (or _ $(send _node :proc?)) $(send _node :lambda?))
+          }
+        PATTERN
+
+        def on_or(node)
+          return unless (lhs, rhs = lambda_or_proc(node))
+
+          offense = lhs.receiver.source_range.join(rhs.source_range.end)
+          prefer = "#{lhs.receiver.source}.lambda_or_proc?"
+
+          add_offense(offense, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(offense, prefer)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_let_rubocop_config_new.rb

@@ -31,9 +31,17 @@ module RuboCop
             (send nil? :let
               (sym :config))
             (args)
-            (send
-              (const
-                (const nil? :RuboCop) :Config) :new))
+            {
+              (send
+                (const
+                  (const nil? :RuboCop) :Config) :new)
+              (send
+                (const
+                  (const nil? :RuboCop) :Config) :new
+                    (hash (pair (send (send (send nil? :described_class) :badge) :to_s)
+                      (send nil? :cop_config))))
+            }
+          )
         PATTERN
 
         def on_block(node)

data/lib/rubocop/cop/internal_affairs.rb

@@ -6,6 +6,7 @@ require_relative 'internal_affairs/empty_line_between_expect_offense_and_correct
 require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
+require_relative 'internal_affairs/lambda_or_proc'
 require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_end_with'
 require_relative 'internal_affairs/method_name_equal'

data/lib/rubocop/cop/layout/block_end_newline.rb

@@ -46,7 +46,7 @@ module RuboCop
         def register_offense(node)
           add_offense(node.loc.end, message: message(node)) do |corrector|
             offense_range = offense_range(node)
-            replacement = "\n#{offense_range.source.strip}"
+            replacement = replacement(node)
 
             if (heredoc = last_heredoc_argument(node.body))
               corrector.remove(offense_range)
@@ -79,6 +79,12 @@ module RuboCop
           )
         end
 
+        def replacement(node)
+          end_with_method_chain = node.loc.end.join(end_of_method_chain(node).loc.expression.end)
+
+          "\n#{end_with_method_chain.source.strip}"
+        end
+
         def end_of_method_chain(node)
           return node unless node.parent&.call_type?
 

data/lib/rubocop/cop/layout/class_structure.rb

@@ -132,25 +132,19 @@ module RuboCop
       #     end
       #   end
       #
-      # @see https://rubystyle.guide#consistent-classes
       class ClassStructure < Base
         include VisibilityHelp
         extend AutoCorrector
 
         HUMANIZED_NODE_TYPE = {
           casgn: :constants,
-          defs: :class_methods,
+          defs: :public_class_methods,
           def: :public_methods,
           sclass: :class_singleton
         }.freeze
 
         MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
 
-        # @!method dynamic_constant?(node)
-        def_node_matcher :dynamic_constant?, <<~PATTERN
-          (casgn nil? _ (send ...))
-        PATTERN
-
         # Validates code style on class declaration.
         # Add offense when find a node out of expected order.
         def on_class(class_node)
@@ -222,7 +216,7 @@ module RuboCop
         def walk_over_nested_class_definition(class_node)
           class_elements(class_node).each do |node|
             classification = classify(node)
-            next if ignore?(classification)
+            next if ignore?(node, classification)
 
             yield node, classification
           end
@@ -240,17 +234,20 @@ module RuboCop
           end
         end
 
-        def ignore?(classification)
+        def ignore?(node, classification)
           classification.nil? ||
             classification.to_s.end_with?('=') ||
-            expected_order.index(classification).nil?
+            expected_order.index(classification).nil? ||
+            private_constant?(node)
         end
 
         def ignore_for_autocorrect?(node, sibling)
           classification = classify(node)
           sibling_class = classify(sibling)
 
-          ignore?(sibling_class) || classification == sibling_class || dynamic_constant?(node)
+          ignore?(sibling, sibling_class) ||
+            classification == sibling_class ||
+            dynamic_constant?(node)
         end
 
         def humanize_node(node)
@@ -262,6 +259,30 @@ module RuboCop
           HUMANIZED_NODE_TYPE[node.type] || node.type
         end
 
+        def dynamic_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+
+          expression = node.expression
+          expression.send_type? &&
+            !(expression.method?(:freeze) && expression.receiver&.recursive_basic_literal?)
+        end
+
+        def private_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+          return false unless (parent = node.parent)
+
+          parent.each_child_node(:send) do |child_node|
+            return true if marked_as_private_constant?(child_node, node.name)
+          end
+          false
+        end
+
+        def marked_as_private_constant?(node, name)
+          return false unless node.method?(:private_constant)
+
+          node.arguments.any? { |arg| (arg.sym_type? || arg.str_type?) && arg.value == name }
+        end
+
         def source_range_with_comment(node)
           begin_pos, end_pos =
             if (node.def_type? && !node.method?(:initialize)) ||

data/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -144,7 +144,7 @@ module RuboCop
         def expected_column(left_paren, elements)
           if line_break_after_left_paren?(left_paren, elements)
             source_indent = processed_source.line_indentation(first_argument_line(elements))
-            new_indent    = source_indent - indentation_width
+            new_indent    = source_indent - configured_indentation_width
 
             new_indent.negative? ? 0 : new_indent
           elsif all_elements_aligned?(elements)
@@ -157,7 +157,7 @@ module RuboCop
         def all_elements_aligned?(elements)
           elements.flat_map do |e|
             if e.hash_type?
-              e.each_pair.map { |pair| pair.loc.column }
+              e.each_child_node.map { |child| child.loc.column }
             else
               e.loc.column
             end
@@ -184,10 +184,6 @@ module RuboCop
           end
         end
 
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def line_break_after_left_paren?(left_paren, elements)
           elements.first && elements.first.loc.line > left_paren.line
         end

data/lib/rubocop/cop/layout/comment_indentation.rb

@@ -154,7 +154,9 @@ module RuboCop
         end
 
         def less_indented?(line)
-          /^\s*(end\b|[)}\]])/.match?(line)
+          rule = config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle'] == 'outdent'
+          access_modifier = 'private|protected|public'
+          /\A\s*(end\b|[)}\]])/.match?(line) || (rule && /\A\s*(#{access_modifier})\b/.match?(line))
         end
 
         def two_alternatives?(line)

data/lib/rubocop/cop/layout/empty_lines.rb

@@ -27,6 +27,8 @@ module RuboCop
 
         def on_new_investigation
           return if processed_source.tokens.empty?
+          # Quick check if we possibly have consecutive blank lines.
+          return unless processed_source.raw_source.include?("\n\n\n")
 
           lines = Set.new
           processed_source.each_token { |token| lines << token.line }

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -119,12 +119,16 @@ module RuboCop
         def ignored_ranges(ast)
           return [] unless ast
 
-          @ignored_ranges ||= on_node(:pair, ast).map do |pair|
-            next if pair.parent.single_line?
-
-            key, value = *pair
-            key.source_range.end_pos...value.source_range.begin_pos
-          end.compact
+          @ignored_ranges ||= begin
+            ranges = []
+            on_node(:pair, ast) do |pair|
+              next if pair.parent.single_line?
+
+              key, value = *pair
+              ranges << (key.source_range.end_pos...value.source_range.begin_pos)
+            end
+            ranges
+          end
         end
 
         def force_equal_sign_alignment?

data/lib/rubocop/cop/layout/first_array_element_line_break.rb

@@ -6,17 +6,49 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line array.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #     # bad
+      #     [ :a,
+      #       :b]
+      #
+      #     # bad
+      #     [ :a, {
+      #       :b => :c
+      #     }]
+      #
+      #     # good
+      #     [:a, :b]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b]
+      #
+      #     # good
+      #     [
+      #       :a, {
+      #       :b => :c
+      #     }]
+      #
+      # @example AllowMultilineFinalElement: true
       #
       #     # bad
       #     [ :a,
       #       :b]
       #
       #     # good
+      #     [ :a, {
+      #       :b => :c
+      #     }]
+      #
+      #     # good
       #     [
       #       :a,
       #       :b]
       #
+      #     # good
+      #     [:a, :b]
       class FirstArrayElementLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector
@@ -26,7 +58,7 @@ module RuboCop
         def on_array(node)
           return if !node.loc.begin && !assignment_on_same_line?(node)
 
-          check_children_line_break(node, node.children)
+          check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
         end
 
         private
@@ -35,6 +67,10 @@ module RuboCop
           source = node.source_range.source_line[0...node.loc.column]
           /\s*=\s*$/.match?(source)
         end
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/first_hash_element_line_break.rb

@@ -6,16 +6,55 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line hash.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
       #
       #     # bad
       #     { a: 1,
       #       b: 2}
       #
+      #     # bad
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
       #     # good
       #     {
       #       a: 1,
       #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: 2}
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: {
+      #       c: 3
+      #     }}
+      #
+      #     # good
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1, b: {
+      #       c: 3
+      #     }}
       class FirstHashElementLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector
@@ -25,7 +64,15 @@ module RuboCop
         def on_hash(node)
           # node.loc.begin tells us whether the hash opens with a {
           # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
-          check_children_line_break(node, node.children) if node.loc.begin
+          return unless node.loc.begin
+
+          check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
         end
       end
     end

data/lib/rubocop/cop/layout/first_method_argument_line_break.rb

@@ -6,17 +6,70 @@ module RuboCop
       # Checks for a line break before the first argument in a
       # multi-line method call.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
       #
       #     # bad
       #     method(foo, bar,
       #       baz)
       #
+      #     # bad
+      #     method(foo, bar, {
+      #       baz: "a",
+      #       qux: "b",
+      #     })
+      #
       #     # good
       #     method(
       #       foo, bar,
       #       baz)
       #
+      #     # good
+      #     method(
+      #       foo, bar, {
+      #       baz: "a",
+      #       qux: "b",
+      #     })
+      #
+      #     # ignored
+      #     method foo, bar,
+      #       baz
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #     # bad
+      #     method(foo, bar,
+      #       baz)
+      #
+      #     # bad
+      #     method(foo,
+      #       bar,
+      #       {
+      #         baz: "a",
+      #         qux: "b",
+      #       }
+      #     )
+      #
+      #     # good
+      #     method(foo, bar, {
+      #       baz: "a",
+      #       qux: "b",
+      #     })
+      #
+      #     # good
+      #     method(
+      #       foo, bar,
+      #       baz)
+      #
+      #     # good
+      #     method(
+      #       foo,
+      #       bar,
+      #       {
+      #         baz: "a",
+      #         qux: "b",
+      #       }
+      #     )
+      #
       #     # ignored
       #     method foo, bar,
       #       baz
@@ -38,10 +91,16 @@ module RuboCop
           last_arg = args.last
           args.concat(args.pop.children) if last_arg&.hash_type? && !last_arg&.braces?
 
-          check_method_line_break(node, args)
+          check_method_line_break(node, args, ignore_last: ignore_last_element?)
         end
         alias on_csend on_send
         alias on_super on_send
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
       end
     end
   end