rubocop 0.72.0 → 0.73.0

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

@@ -40,7 +40,7 @@ module RuboCop
         MSG = '`%<assignment>s` method calls already given on line '\
               '%<line_of_first_occurrence>d of the gemspec.'
 
-        def_node_search :gem_specification, <<-PATTERN
+        def_node_search :gem_specification, <<~PATTERN
           (block
             (send
               (const
@@ -49,7 +49,7 @@ module RuboCop
               (arg $_)) ...)
         PATTERN
 
-        def_node_search :assignment_method_declarations, <<-PATTERN
+        def_node_search :assignment_method_declarations, <<~PATTERN
           (send
             (lvar #match_block_variable_name?) #assignment_method? ...)
         PATTERN

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

@@ -97,7 +97,7 @@ module RuboCop
           node.method_name
         end
 
-        def_node_search :dependency_declarations, <<-PATTERN
+        def_node_search :dependency_declarations, <<~PATTERN
           (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} ...)
         PATTERN
       end

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

@@ -41,7 +41,7 @@ module RuboCop
               '(%<target_ruby_version>s, which may be specified in ' \
               '.rubocop.yml) should be equal.'
 
-        def_node_search :required_ruby_version, <<-PATTERN
+        def_node_search :required_ruby_version, <<~PATTERN
           (send _ :required_ruby_version= ${(str _) (array (str _))})
         PATTERN
 

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

@@ -30,7 +30,7 @@ module RuboCop
 
         def_node_matcher :ruby_version?, '(const nil? :RUBY_VERSION)'
 
-        def_node_search :gem_specification?, <<-PATTERN
+        def_node_search :gem_specification?, <<~PATTERN
           (block
             (send
               (const

data/lib/rubocop/cop/generator.rb

@@ -63,7 +63,7 @@ module RuboCop
                 # For example
                 MSG = 'Use `#good_method` instead of `#bad_method`.'.freeze
 
-                def_node_matcher :bad_method?, <<-PATTERN
+                def_node_matcher :bad_method?, <<~PATTERN
                   (send nil? :bad_method ...)
                 PATTERN
 

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

@@ -19,11 +19,11 @@ module RuboCop
         MSG = 'Use the methods provided with the node extensions instead ' \
               'of manually destructuring nodes.'
 
-        def_node_matcher :node_variable?, <<-PATTERN
+        def_node_matcher :node_variable?, <<~PATTERN
           {(lvar [#node_suffix? _]) (send nil? [#node_suffix? _])}
         PATTERN
 
-        def_node_matcher :node_destructuring?, <<-PATTERN
+        def_node_matcher :node_destructuring?, <<~PATTERN
           {(masgn (mlhs ...) {(send #node_variable? :children) (array (splat #node_variable?))})}
         PATTERN
 

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

@@ -16,7 +16,7 @@ module RuboCop
       class NodeTypePredicate < Cop
         MSG = 'Use `#%<type>s_type?` to check node type.'
 
-        def_node_matcher :node_type_check, <<-PATTERN
+        def_node_matcher :node_type_check, <<~PATTERN
           (send (send $_ :type) :== (sym $_))
         PATTERN
 

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

@@ -33,11 +33,11 @@ module RuboCop
 
         private
 
-        def_node_matcher :node_type_check, <<-PATTERN
+        def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
-        def_node_matcher :offending_location_argument, <<-PATTERN
+        def_node_matcher :offending_location_argument, <<~PATTERN
           (pair (sym :location) $(send (send $_node :loc) $_keyword))
         PATTERN
 

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

@@ -21,7 +21,7 @@ module RuboCop
 
         MSG = 'Redundant location argument to `#add_offense`.'
 
-        def_node_matcher :redundant_location_argument, <<-PATTERN
+        def_node_matcher :redundant_location_argument, <<~PATTERN
           (send nil? :add_offense _
             (hash <$(pair (sym :location) (sym :expression)) ...>)
           )

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

@@ -24,11 +24,11 @@ module RuboCop
 
         MSG = 'Redundant message argument to `#add_offense`.'
 
-        def_node_matcher :node_type_check, <<-PATTERN
+        def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
-        def_node_matcher :redundant_message_argument, <<-PATTERN
+        def_node_matcher :redundant_message_argument, <<~PATTERN
           (pair
             (sym :message)
             ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})

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

@@ -16,11 +16,11 @@ module RuboCop
       class UselessMessageAssertion < Cop
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'
 
-        def_node_search :described_class_msg, <<-PATTERN
+        def_node_search :described_class_msg, <<~PATTERN
           (const (send nil? :described_class) :MSG)
         PATTERN
 
-        def_node_matcher :rspec_expectation_on_msg?, <<-PATTERN
+        def_node_matcher :rspec_expectation_on_msg?, <<~PATTERN
           (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN
 

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

@@ -67,7 +67,7 @@ module RuboCop
 
         MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
 
-        def_node_matcher :block_end_align_target?, <<-PATTERN
+        def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
            splat
            and

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

@@ -142,7 +142,7 @@ module RuboCop
         MSG = '`%<category>s` is supposed to appear before ' \
               '`%<previous>s`.'
 
-        def_node_matcher :visibility_block?, <<-PATTERN
+        def_node_matcher :visibility_block?, <<~PATTERN
           (send nil? { :private :protected :public })
         PATTERN
 

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

@@ -204,7 +204,7 @@ module RuboCop
           node.source_range.begin_pos > parent.source_range.begin_pos
         end
 
-        def_node_matcher :eligible_method_call?, <<-PATTERN
+        def_node_matcher :eligible_method_call?, <<~PATTERN
           (send _ !:[]= ...)
         PATTERN
 

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

@@ -37,7 +37,7 @@ module RuboCop
       #   # good
       #   # When EnforcedStyle is powerpack, bad code is auto-corrected to
       #   # the following code.
-      #   <<~RUBY
+      #   <<-RUBY.strip_indent
       #     something
       #   RUBY
       #
@@ -206,7 +206,8 @@ module RuboCop
           body = heredoc_body(node)
           body_indent_level = indent_level(body)
           correct_indent_level = base_indent_level(node) + indentation_width
-          body.gsub(/^\s{#{body_indent_level}}/, ' ' * correct_indent_level)
+          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/,
+                    ' ' * correct_indent_level)
         end
 
         def indented_end(node)

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

@@ -52,7 +52,7 @@ module RuboCop
         MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
               'spaces for%<name>s indentation.'
 
-        def_node_matcher :access_modifier?, <<-PATTERN
+        def_node_matcher :access_modifier?, <<~PATTERN
           [(send ...) access_modifier?]
         PATTERN
 

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

@@ -16,6 +16,25 @@ module RuboCop
       #
       #   # good
       #   # Some comment
+      #
+      # @example AllowDoxygenCommentStyle: false (default)
+      #
+      #   # bad
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
+      # @example AllowDoxygenCommentStyle: true
+      #
+      #   # good
+      #
+      #   #**
+      #   # Some comment
+      #   # Another line of comment
+      #   #*
+      #
       class LeadingCommentSpace < Cop
         include RangeHelp
 
@@ -25,6 +44,7 @@ module RuboCop
           processed_source.each_comment do |comment|
             next unless comment.text =~ /\A#+[^#\s=:+-]/
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
+            next if allow_doxygen_comment? && doxygen_comment_style?(comment)
 
             add_offense(comment)
           end
@@ -54,6 +74,14 @@ module RuboCop
         def rackup_config_file?
           File.basename(processed_source.file_path).eql?('config.ru')
         end
+
+        def allow_doxygen_comment?
+          cop_config['AllowDoxygenCommentStyle']
+        end
+
+        def doxygen_comment_style?(comment)
+          comment.text.start_with?('#*')
+        end
       end
     end
   end

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

@@ -30,6 +30,8 @@ module RuboCop
         ANCESTOR_TYPES = %i[kwbegin def defs class module].freeze
         RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + %i[block]).freeze
         ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
+        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method
+                                          private_class_method].freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -99,8 +101,12 @@ module RuboCop
             case node.type
             when :block, :kwbegin
               node.loc.begin
-            when :def, :defs, :class, :module
+            when :def, :defs, :class, :module,
+                 :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
               node.loc.name
+            when :masgn
+              mlhs_node, = *node
+              mlhs_node.loc.expression
             else
               # It is a wrapper with access modifier.
               node.child_nodes.first.loc.name
@@ -150,9 +156,7 @@ module RuboCop
             ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS.include?(node.type)
 
           access_modifier_node = node.ancestors.first
-          return nil unless
-            access_modifier_node.respond_to?(:access_modifier?) &&
-            access_modifier_node.access_modifier?
+          return nil unless access_modifier?(access_modifier_node)
 
           access_modifier_node
         end
@@ -169,6 +173,16 @@ module RuboCop
 
           range_between(begin_pos - current_column, begin_pos)
         end
+
+        def access_modifier?(node)
+          return true if node.respond_to?(:access_modifier?) &&
+                         node.access_modifier?
+
+          return true if node.respond_to?(:method_name) &&
+                         ALTERNATIVE_ACCESS_MODIFIERS.include?(node.method_name)
+
+          false
+        end
       end
     end
   end

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

@@ -130,7 +130,8 @@ module RuboCop
           args_delimiter = node.arguments.loc.begin # Can be ( | or nil.
 
           check_left_brace(inner, node.loc.begin, args_delimiter)
-          check_right_brace(inner, node.loc.end, node.single_line?)
+          check_right_brace(inner, node.loc.begin, node.loc.end,
+                            node.single_line?)
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
@@ -141,15 +142,26 @@ module RuboCop
           end
         end
 
-        def check_right_brace(inner, right_brace, single_line)
+        def check_right_brace(inner, left_brace, right_brace, single_line)
           if single_line && inner =~ /\S$/
             no_space(right_brace.begin_pos, right_brace.end_pos,
                      'Space missing inside }.')
           else
+            return if multiline_block?(left_brace, right_brace) &&
+                      aligned_braces?(left_brace, right_brace)
+
             space_inside_right_brace(right_brace)
           end
         end
 
+        def multiline_block?(left_brace, right_brace)
+          left_brace.first_line != right_brace.first_line
+        end
+
+        def aligned_braces?(left_brace, right_brace)
+          left_brace.first_line == right_brace.last_column
+        end
+
         def no_space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
             if left_brace.end_pos == args_delimiter.begin_pos &&

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

@@ -30,16 +30,13 @@ module RuboCop
           str_ranges = string_literal_ranges(processed_source.ast)
 
           processed_source.lines.each.with_index(1) do |line, lineno|
-            match = line.match(/^([^\t]*)\t+/)
+            match = line.match(/\t+/)
             next unless match
 
-            prefix = match.captures[0]
-            col = prefix.length
-            next if in_string_literal?(str_ranges, lineno, col)
-
             range = source_range(processed_source.buffer,
                                  lineno,
-                                 col...match.end(0))
+                                 match.begin(0)...match.end(0))
+            next if in_string_literal?(str_ranges, range)
 
             add_offense(range, location: range)
           end
@@ -54,16 +51,9 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def in_string_literal?(ranges, line, col)
-          ranges.any? do |range|
-            (range.line == line && range.column <= col) ||
-              (range.line < line && line < range.last_line) ||
-              (range.line != line && range.last_line == line &&
-               range.last_column >= col)
-          end
+        def in_string_literal?(ranges, tabs_range)
+          ranges.any? { |range| range.contains?(tabs_range) }
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def string_literal_ranges(ast)
           # which lines start inside a string literal?
@@ -72,13 +62,11 @@ module RuboCop
           ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
             loc = str.location
 
-            range = if str.heredoc?
-                      loc.heredoc_body
-                    else
-                      loc.expression
-                    end
-
-            ranges << range
+            if str.heredoc?
+              ranges << loc.heredoc_body
+            elsif loc.respond_to?(:begin) && loc.begin
+              ranges << loc.expression
+            end
           end
         end
       end

data/lib/rubocop/cop/lint/big_decimal_new.rb

@@ -18,7 +18,7 @@ module RuboCop
         MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
               'Use `%<double_colon>sBigDecimal()` instead.'
 
-        def_node_matcher :big_decimal_new, <<-PATTERN
+        def_node_matcher :big_decimal_new, <<~PATTERN
           (send
             (const ${nil? cbase} :BigDecimal) :new ...)
         PATTERN

data/lib/rubocop/cop/lint/debugger.rb

@@ -35,14 +35,14 @@ module RuboCop
       class Debugger < Cop
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        def_node_matcher :kernel?, <<-PATTERN
+        def_node_matcher :kernel?, <<~PATTERN
           {
             (const nil? :Kernel)
             (const (cbase) :Kernel)
           }
         PATTERN
 
-        def_node_matcher :debugger_call?, <<-PATTERN
+        def_node_matcher :debugger_call?, <<~PATTERN
           {(send {nil? #kernel?} {:debugger :byebug} ...)
            (send (send {#kernel? nil?} :binding)
              {:pry :remote_pry :pry_remote} ...)
@@ -52,7 +52,7 @@ module RuboCop
                       :save_screenshot} ...)}
         PATTERN
 
-        def_node_matcher :binding_irb_call?, <<-PATTERN
+        def_node_matcher :binding_irb_call?, <<~PATTERN
           (send (send {#kernel? nil?} :binding) :irb ...)
         PATTERN
 

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -79,7 +79,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :method_alias?, <<-PATTERN
+        def_node_matcher :method_alias?, <<~PATTERN
           (alias (sym $_name) sym)
         PATTERN
 
@@ -91,11 +91,11 @@ module RuboCop
           found_instance_method(node, name)
         end
 
-        def_node_matcher :alias_method?, <<-PATTERN
+        def_node_matcher :alias_method?, <<~PATTERN
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
-        def_node_matcher :attr?, <<-PATTERN
+        def_node_matcher :attr?, <<~PATTERN
           (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
         PATTERN