rubocop 0.69.0 → 0.70.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ceeff27cb7a9a5422da99021b22d3d729445de0cfc8db0fcd451a7b59644564
-  data.tar.gz: 975afb9f919e4b698091be763cbe0ae668aff0a76e79eea297eaf46113156049
+  metadata.gz: f98c70ae4897b3f4c793fa73cb716986f9d63815928c278accf6879a0190e97e
+  data.tar.gz: 89111e2312bdf926aab76ca58bfb90a414ff3b5f58ba48257e5d1949763d4776
 SHA512:
-  metadata.gz: 502807f9a65b63922679174a7e32e7232d1191ea30b06199811f2c7485cdd47b02548a576f88e6bbadee9ed5e2a525eec570674d6b69fdfe5bfa2843edad465f
-  data.tar.gz: fdd08613fb4d3292b99f2b9764df4b91981b5c31300c879cfdd80203f2965b8994187dff36f79e0c16c38665f9b76bf93ad57f1b0df834a42ffe9aa057f82070
+  metadata.gz: 83462908a6383ab72503c4af338d395a118e435d8f4f73e7cdda54b6d8d1cc05f40a5ebdb6a3197bf9a2734046665c7c2d6616e0bb0847f198d11b410ae4b7f8
+  data.tar.gz: 39c1a0fca5a9251e3a60f9ca3958d228d79f5797de21da608f69cb133611c683913673bbdc426a537c9578bc4394607a20617d394d1abc3454878373589a0fdd

data/README.md

@@ -53,7 +53,7 @@ haven't reached version 1.0 yet). To prevent an unwanted RuboCop update you
 might want to use a conservative version lock in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 0.69.0', require: false
+gem 'rubocop', '~> 0.70.0', require: false
 ```
 
 ## Quickstart

data/config/default.yml

@@ -260,6 +260,7 @@ Layout/AlignHash:
                  Align the elements of a hash literal if they span more than
                  one line.
   Enabled: true
+  AllowMultipleStyles: true
   VersionAdded: '0.49'
   # Alignment of entries using hash rocket as separator. Valid values are:
   #
@@ -508,6 +509,13 @@ Layout/EmptyLinesAroundAccessModifier:
   StyleGuide: '#empty-lines-around-access-modifier'
   Enabled: true
   VersionAdded: '0.49'
+  EnforcedStyle: around
+  SupportedStyles:
+    - around
+    - only_before
+  Reference:
+    # A reference to `EnforcedStyle: only_before`.
+    - https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#follow-the-coding-conventions
 
 Layout/EmptyLinesAroundArguments:
   Description: "Keeps track of empty lines around method arguments."
@@ -780,6 +788,9 @@ Layout/IndentationConsistency:
   SupportedStyles:
     - normal
     - rails
+  Reference:
+    # A reference to `EnforcedStyle: rails`.
+    - https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#follow-the-coding-conventions
 
 Layout/IndentationWidth:
   Description: 'Use 2 spaces for indentation.'
@@ -1359,7 +1370,9 @@ Lint/HandleExceptions:
   Description: "Don't suppress exception."
   StyleGuide: '#dont-hide-exceptions'
   Enabled: true
+  AllowComments: false
   VersionAdded: '0.9'
+  VersionChanged: '0.70'
 
 Lint/HeredocMethodCallPosition:
   Description: >-
@@ -1462,6 +1475,8 @@ Lint/NumberConversion:
   Description: 'Checks unsafe usage of number conversion methods.'
   Enabled: false
   VersionAdded: '0.53'
+  VersionChanged: '0.70'
+  SafeAutoCorrect: false
 
 Lint/OrderedMagicComments:
   Description: 'Checks the proper ordering of magic comments and whether a magic comment is not placed before a shebang.'
@@ -3752,8 +3767,9 @@ Style/PreferredHashMethods:
   Description: 'Checks use of `has_key?` and `has_value?` Hash methods.'
   StyleGuide: '#hash-key'
   Enabled: true
+  Safe: false
   VersionAdded: '0.41'
-  VersionChanged: '0.44'
+  VersionChanged: '0.70'
   EnforcedStyle: short
   SupportedStyles:
     - short

data/lib/rubocop.rb

@@ -117,6 +117,7 @@ require_relative 'rubocop/cop/mixin/frozen_string_literal'
 require_relative 'rubocop/cop/mixin/hash_alignment'
 require_relative 'rubocop/cop/mixin/ignored_pattern'
 require_relative 'rubocop/cop/mixin/ignored_methods'
+require_relative 'rubocop/cop/mixin/ignored_method_patterns'
 require_relative 'rubocop/cop/mixin/integer_node'
 require_relative 'rubocop/cop/mixin/match_range'
 require_relative 'rubocop/cop/mixin/method_complexity'

data/lib/rubocop/ast/builder.rb

@@ -15,45 +15,45 @@ module RuboCop
     #   root_node = parser.parse(buffer)
     class Builder < Parser::Builders::Default
       NODE_MAP = {
-        and: AndNode,
-        alias: AliasNode,
-        args: ArgsNode,
-        array: ArrayNode,
-        block: BlockNode,
-        break: BreakNode,
-        case: CaseNode,
-        class: ClassNode,
-        def: DefNode,
-        defined?: DefinedNode,
-        defs: DefNode,
-        ensure: EnsureNode,
-        for: ForNode,
-        hash: HashNode,
-        if: IfNode,
-        irange: RangeNode,
-        erange: RangeNode,
-        kwsplat: KeywordSplatNode,
-        module: ModuleNode,
-        or: OrNode,
-        pair: PairNode,
-        regexp: RegexpNode,
-        resbody: ResbodyNode,
-        retry: RetryNode,
-        csend: SendNode,
-        send: SendNode,
-        str: StrNode,
-        dstr: StrNode,
-        xstr: StrNode,
-        sclass: SelfClassNode,
-        super: SuperNode,
-        zsuper: SuperNode,
-        sym: SymbolNode,
-        until: UntilNode,
+        and:        AndNode,
+        alias:      AliasNode,
+        args:       ArgsNode,
+        array:      ArrayNode,
+        block:      BlockNode,
+        break:      BreakNode,
+        case:       CaseNode,
+        class:      ClassNode,
+        def:        DefNode,
+        defined?:   DefinedNode,
+        defs:       DefNode,
+        ensure:     EnsureNode,
+        for:        ForNode,
+        hash:       HashNode,
+        if:         IfNode,
+        irange:     RangeNode,
+        erange:     RangeNode,
+        kwsplat:    KeywordSplatNode,
+        module:     ModuleNode,
+        or:         OrNode,
+        pair:       PairNode,
+        regexp:     RegexpNode,
+        resbody:    ResbodyNode,
+        retry:      RetryNode,
+        csend:      SendNode,
+        send:       SendNode,
+        str:        StrNode,
+        dstr:       StrNode,
+        xstr:       StrNode,
+        sclass:     SelfClassNode,
+        super:      SuperNode,
+        zsuper:     SuperNode,
+        sym:        SymbolNode,
+        until:      UntilNode,
         until_post: UntilNode,
-        when: WhenNode,
-        while: WhileNode,
+        when:       WhenNode,
+        while:      WhileNode,
         while_post: WhileNode,
-        yield: YieldNode
+        yield:      YieldNode
       }.freeze
 
       # Generates {Node} from the given information.

data/lib/rubocop/ast/node/mixin/method_dispatch_node.rb

@@ -9,6 +9,7 @@ module RuboCop
       include MethodIdentifierPredicates
 
       ARITHMETIC_OPERATORS = %i[+ - * / % **].freeze
+      SPECIAL_MODIFIERS = %w[private protected].freeze
 
       # The receiving node of the method dispatch.
       #
@@ -75,6 +76,15 @@ module RuboCop
         macro? && non_bare_access_modifier_declaration?
       end
 
+      # Checks whether the dispatched method is a bare `private` or `protected`
+      # access modifier that affects all methods defined after the macro.
+      #
+      # @return [Boolean] whether the dispatched method is a bare
+      #                    `private` or `protected` access modifier
+      def special_modifier?
+        bare_access_modifier? && SPECIAL_MODIFIERS.include?(source)
+      end
+
       # Checks whether the name of the dispatched method matches the argument
       # and has an implicit receiver.
       #

data/lib/rubocop/cached_data.rb

@@ -29,9 +29,9 @@ module RuboCop
           begin_pos: offense.location.begin_pos,
           end_pos: offense.location.end_pos
         },
-        message: message(offense),
+        message:  message(offense),
         cop_name: offense.cop_name,
-        status: :uncorrected
+        status:   :uncorrected
       }
     end
 

data/lib/rubocop/config.rb

@@ -543,8 +543,10 @@ module RuboCop
         styles.each do |style_name, style|
           supported_key = RuboCop::Cop::Util.to_supported_styles(style_name)
           valid = ConfigLoader.default_configuration[name][supported_key]
+
           next unless valid
           next if valid.include?(style)
+          next if validate_support_and_has_list(name, style, valid)
 
           msg = "invalid #{style_name} '#{style}' for #{name} found in " \
             "#{smart_loaded_path}\n" \
@@ -554,6 +556,12 @@ module RuboCop
       end
     end
 
+    def validate_support_and_has_list(name, formats, valid)
+      ConfigLoader.default_configuration[name]['AllowMultipleStyles'] &&
+        formats.is_a?(Array) &&
+        formats.all? { |format| valid.include?(format) }
+    end
+
     def reject_obsolete_cops_and_parameters
       messages = [
         obsolete_cops,
@@ -712,7 +720,7 @@ module RuboCop
         end
       end
 
-      cop_options.fetch('Enabled', true)
+      cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
     end
 
     def smart_loaded_path

data/lib/rubocop/config_loader.rb

@@ -120,8 +120,8 @@ module RuboCop
       # If AllCops::EnabledByDefault is true, it changes the Enabled params
       # so that only cops explicitly disabled in user configuration are
       # disabled.
-      def merge_with_default(config, config_file)
-        resolver.merge_with_default(config, config_file)
+      def merge_with_default(config, config_file, unset_nil: true)
+        resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
       end
 
       def add_inheritance_from_auto_generated_file

data/lib/rubocop/config_loader_resolver.rb

@@ -55,7 +55,7 @@ module RuboCop
     # only cops from user configuration are enabled. If
     # AllCops::EnabledByDefault is true, it changes the Enabled params so that
     # only cops explicitly disabled in user configuration are disabled.
-    def merge_with_default(config, config_file)
+    def merge_with_default(config, config_file, unset_nil:)
       default_configuration = ConfigLoader.default_configuration
 
       disabled_by_default = config.for_all_cops['DisabledByDefault']
@@ -71,7 +71,8 @@ module RuboCop
         config = handle_disabled_by_default(config, default_configuration)
       end
 
-      opts = { inherit_mode: config['inherit_mode'] || {}, unset_nil: true }
+      opts = { inherit_mode: config['inherit_mode'] || {},
+               unset_nil: unset_nil }
       Config.new(merge(default_configuration, config, opts), config_file)
     end
 

data/lib/rubocop/cop/generator.rb

@@ -7,7 +7,13 @@ module RuboCop
     # This generator will take a cop name and generate a source file
     # and spec file when given a valid qualified cop name.
     class Generator
-      SOURCE_TEMPLATE = <<~RUBY
+      # Note: RDoc 5.1.0 or lower has the following issue.
+      # https://github.com/rubocop-hq/rubocop/issues/7043
+      #
+      # The following `String#strip_indent` can be replaced with
+      # squiggly heredoc when RuboCop supports Ruby 2.5 or higher
+      # (RDoc 6.0 or higher).
+      SOURCE_TEMPLATE = <<-RUBY.strip_indent
         # frozen_string_literal: true
 
         # TODO: when finished, run `rake generate_cops_documentation` to update the docs

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

@@ -17,7 +17,9 @@ module RuboCop
       #   - always_inspect
       #   - always_ignore
       #   - ignore_implicit (without curly braces)
-      #   - ignore_explicit (with curly braces)
+      #
+      # Alternatively you can specify multiple allowed styles. That's done by
+      # passing a list of styles to EnforcedStyles.
       #
       # @example EnforcedHashRocketStyle: key (default)
       #   # bad
@@ -198,48 +200,65 @@ module RuboCop
           return if ignored_node?(node)
           return if node.pairs.empty? || node.single_line?
 
-          return unless alignment_for_hash_rockets.checkable_layout?(node) &&
-                        alignment_for_colons.checkable_layout?(node)
+          return unless alignment_for_hash_rockets
+                        .any? { |a| a.checkable_layout?(node) } &&
+                        alignment_for_colons
+                        .any? { |a| a.checkable_layout?(node) }
 
           check_pairs(node)
         end
 
         def autocorrect(node)
-          # We can't use the instance variable inside the lambda. That would
-          # just give each lambda the same reference and they would all get the
-          # last value of each. A local variable fixes the problem.
-          key_delta = column_deltas[:key] || 0
+          delta = column_deltas[alignment_for(node).first.class][node]
+          return if delta.nil?
 
-          if !node.value
-            correct_no_value(key_delta, node.source_range)
-          else
-            correct_key_value(key_delta, node.key.source_range,
-                              node.value.source_range,
-                              node.loc.operator)
-          end
+          correct_node(node, delta)
         end
 
-        private
-
+        attr_accessor :offences_by
         attr_accessor :column_deltas
 
+        private
+
         def double_splat?(node)
           node.children.last.is_a?(Symbol)
         end
 
         def check_pairs(node)
           first_pair = node.pairs.first
-          self.column_deltas = alignment_for(first_pair)
-                               .deltas_for_first_pair(first_pair, node)
-          add_offense(first_pair) unless good_alignment?
+          self.offences_by = {}
+          self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
+
+          alignment_for(first_pair).each do |alignment|
+            delta = alignment.deltas_for_first_pair(first_pair, node)
+            check_delta delta, node: first_pair, alignment: alignment
+          end
 
           node.children.each do |current|
-            self.column_deltas = alignment_for(current)
-                                 .deltas(first_pair, current)
-            add_offense(current) unless good_alignment?
+            alignment_for(current).each do |alignment|
+              delta = alignment.deltas(first_pair, current)
+              check_delta delta, node: current, alignment: alignment
+            end
+          end
+
+          add_offences
+        end
+
+        def add_offences
+          _format, offences = offences_by.min_by { |_, v| v.length }
+          (offences || []).each do |offence|
+            add_offense offence
           end
         end
 
+        def check_delta(delta, node:, alignment:)
+          offences_by[alignment.class] ||= []
+          return if good_alignment? delta
+
+          column_deltas[alignment.class][node] = delta
+          offences_by[alignment.class].push(node)
+        end
+
         def ignore_hash_argument?(node)
           case cop_config['EnforcedLastArgumentHashStyle']
           when 'always_inspect'  then false
@@ -267,16 +286,31 @@ module RuboCop
             new_alignment('EnforcedColonStyle')
         end
 
+        def correct_node(node, delta)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. A local variable fixes the problem.
+
+          if !node.value
+            correct_no_value(delta[:key] || 0, node.source_range)
+          else
+            correct_key_value(delta, node.key.source_range,
+                              node.value.source_range,
+                              node.loc.operator)
+          end
+        end
+
         def correct_no_value(key_delta, key)
           ->(corrector) { adjust(corrector, key_delta, key) }
         end
 
-        def correct_key_value(key_delta, key, value, separator)
+        def correct_key_value(delta, key, value, separator)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
           # last value of each. Some local variables fix the problem.
-          separator_delta = column_deltas[:separator] || 0
-          value_delta     = column_deltas[:value] || 0
+          separator_delta = delta[:separator] || 0
+          value_delta     = delta[:value]     || 0
+          key_delta       = delta[:key]       || 0
 
           key_column = key.column
           key_delta = -key_column if key_delta < -key_column
@@ -289,11 +323,20 @@ module RuboCop
         end
 
         def new_alignment(key)
-          case cop_config[key]
-          when 'key'       then KeyAlignment.new
-          when 'table'     then TableAlignment.new
-          when 'separator' then SeparatorAlignment.new
-          else raise "Unknown #{key}: #{cop_config[key]}"
+          formats = cop_config[key]
+          formats = [formats] if formats.is_a? String
+
+          formats.uniq.map do |format|
+            case format
+            when 'key'
+              KeyAlignment.new
+            when 'table'
+              TableAlignment.new
+            when 'separator'
+              SeparatorAlignment.new
+            else
+              raise "Unknown #{key}: #{formats}"
+            end
           end
         end
 
@@ -306,7 +349,7 @@ module RuboCop
           end
         end
 
-        def good_alignment?
+        def good_alignment?(column_deltas)
           column_deltas.values.all?(&:zero?)
         end
       end