rubocop 0.50.0 → 0.51.0

data/lib/rubocop/cop/mixin/heredoc.rb

@@ -2,7 +2,7 @@
 
 # Common functionality for working with heredoc strings.
 module Heredoc
-  OPENING_DELIMITER = /<<[~-]?'?(\w+)'?\b/
+  OPENING_DELIMITER = /<<[~-]?['"`]?([^'"`]+)['"`]?/
 
   def on_str(node)
     return unless heredoc?(node)

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -12,10 +12,9 @@ module RuboCop
 
         return unless complexity > max
 
-        add_offense(node, :keyword, format(self.class::MSG,
-                                           node.method_name,
-                                           complexity,
-                                           max)) do
+        msg = format(self.class::MSG, node.method_name, complexity, max)
+
+        add_offense(node, location: :keyword, message: msg) do
           self.max = complexity.ceil
         end
       end

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -72,7 +72,7 @@ module RuboCop
       end
 
       def incorrect_style_detected(range, node, lhs, rhs)
-        add_offense(range, range, message(node, lhs, rhs)) do
+        add_offense(range, location: range, message: message(node, lhs, rhs)) do
           if supported_styles.size > 2 ||
              offending_range(node, lhs, rhs, alternative_style)
             unrecognized_style_detected

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -64,24 +64,30 @@ module RuboCop
       def check_new_line(node)
         return unless closing_brace_on_same_line?(node)
 
-        add_offense(node, :end, self.class::ALWAYS_NEW_LINE_MESSAGE)
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_NEW_LINE_MESSAGE)
       end
 
       def check_same_line(node)
         return if closing_brace_on_same_line?(node)
 
-        add_offense(node, :end, self.class::ALWAYS_SAME_LINE_MESSAGE)
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_SAME_LINE_MESSAGE)
       end
 
       def check_symmetrical(node)
         if opening_brace_on_same_line?(node)
           return if closing_brace_on_same_line?(node)
 
-          add_offense(node, :end, self.class::SAME_LINE_MESSAGE)
+          add_offense(node, location: :end,
+                            message: self.class::SAME_LINE_MESSAGE)
         else
           return unless closing_brace_on_same_line?(node)
 
-          add_offense(node, :end, self.class::NEW_LINE_MESSAGE)
+          add_offense(node, location: :end,
+                            message: self.class::NEW_LINE_MESSAGE)
         end
       end
 

data/lib/rubocop/cop/mixin/ordered_gem_node.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Bundler/OrderedGems and
+    # Gemspec/OrderedDependencies.
+    module OrderedGemNode
+      private
+
+      def case_insensitive_out_of_order?(string_a, string_b)
+        string_a.downcase < string_b.downcase
+      end
+
+      def consecutive_lines(previous, current)
+        first_line = get_source_range(current).first_line
+        previous.source_range.last_line == first_line - 1
+      end
+
+      def register_offense(previous, current)
+        message = format(self.class::MSG, gem_name(current), gem_name(previous))
+        add_offense(current, message: message)
+      end
+
+      def gem_name(declaration_node)
+        declaration_node.first_argument.str_content
+      end
+
+      def autocorrect(node)
+        previous = previous_declaration(node)
+
+        current_range = declaration_with_comment(node)
+        previous_range = declaration_with_comment(previous)
+
+        lambda do |corrector|
+          swap_range(corrector, current_range, previous_range)
+        end
+      end
+
+      def declaration_with_comment(node)
+        buffer = processed_source.buffer
+        begin_pos = get_source_range(node).begin_pos
+        end_line = buffer.line_for_position(node.loc.expression.end_pos)
+        end_pos = buffer.line_range(end_line).end_pos
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def swap_range(corrector, range1, range2)
+        src1 = range1.source
+        src2 = range2.source
+        corrector.replace(range1, src2)
+        corrector.replace(range2, src1)
+      end
+
+      def get_source_range(node)
+        unless cop_config['TreatCommentsAsGroupSeparators']
+          first_comment = processed_source.ast_with_comments[node].first
+          return first_comment.loc.expression unless first_comment.nil?
+        end
+        node.source_range
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/parser_diagnostic.rb

@@ -26,7 +26,10 @@ module RuboCop
                       d.message.capitalize
                     end
 
-          add_offense(nil, d.location, message, d.level)
+          add_offense(nil,
+                      location: d.location,
+                      message: message,
+                      severity: d.level)
         end
       end
     end

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -9,7 +9,8 @@ module RuboCop
 
       def investigate(processed_source)
         each_missing_space(processed_source.tokens) do |token|
-          add_offense(token, token.pos, format(MSG, kind(token)))
+          add_offense(token, location: token.pos,
+                             message: format(MSG, kind(token)))
         end
       end
 

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -9,7 +9,8 @@ module RuboCop
 
       def investigate(processed_source)
         each_missing_space(processed_source.tokens) do |token, pos_before|
-          add_offense(pos_before, pos_before, format(MSG, kind(token)))
+          add_offense(pos_before, location: pos_before,
+                                  message: format(MSG, kind(token)))
         end
       end
 

data/lib/rubocop/cop/mixin/space_inside.rb

@@ -11,7 +11,7 @@ module RuboCop
       def investigate(processed_source)
         @processed_source = processed_source
         each_extraneous_space(processed_source.tokens) do |kind, range|
-          add_offense(range, range, format(MSG, kind))
+          add_offense(range, location: range, message: format(MSG, kind))
         end
       end
 

data/lib/rubocop/cop/mixin/string_literals_help.rb

@@ -12,7 +12,7 @@ module RuboCop
         if style == :single_quotes
           !double_quotes_required?(src)
         else
-          src !~ /" | \\ | \#(@|\{)/x
+          src !~ /" | \\[^'] | \#(@|\{)/x
         end
       end
 

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -116,9 +116,9 @@ module RuboCop
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
         article = kind =~ /array/ ? 'an' : 'a'
-        add_offense(range, range,
-                    format(MSG, 'Avoid', format(kind, article)) +
-                    "#{extra_info}.")
+        msg = format(MSG, 'Avoid', format(kind, article)) + "#{extra_info}."
+
+        add_offense(range, location: range, message: msg)
       end
 
       def put_comma(node, items, kind)
@@ -128,9 +128,9 @@ module RuboCop
         return if last_item.block_pass_type?
 
         range = autocorrect_range(last_item)
+        msg = format(MSG, 'Put a', format(kind, 'a multiline') + '.')
 
-        add_offense(range, range,
-                    format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
+        add_offense(range, location: range, message: msg)
       end
 
       def autocorrect_range(item)

data/lib/rubocop/cop/mixin/unused_argument.rb

@@ -5,6 +5,10 @@ module RuboCop
     module Lint
       # Common functionality for cops handling unused arguments.
       module UnusedArgument
+        extend NodePattern::Macros
+
+        def_node_search :uses_var?, '(lvar %)'
+
         def join_force?(force_class)
           force_class == VariableForce
         end
@@ -17,10 +21,11 @@ module RuboCop
 
         def check_argument(variable)
           return if variable.should_be_unused?
-          return if variable.referenced?
+          return if variable_used?(variable)
 
           message = message(variable)
-          add_offense(variable.declaration_node, :name, message)
+          add_offense(variable.declaration_node, location: :name,
+                                                 message: message)
         end
 
         def autocorrect(node)
@@ -36,6 +41,42 @@ module RuboCop
             ->(corrector) { corrector.insert_before(node.loc.name, '_') }
           end
         end
+
+        private
+
+        def variable_used?(variable)
+          return false unless variable.referenced?
+
+          assignment_without_usage =
+            find_assignment_without_variable_usage(variable)
+
+          # If variable is either not assigned or assigned with usages,
+          # then it's really used
+          return true unless assignment_without_usage
+
+          assignment_without_usage_pos =
+            assignment_without_usage.node.source_range.begin_pos
+
+          reference_positions =
+            variable.references.map { |var| var.node.source_range.begin_pos }
+
+          # Was variable referenced before it was reassigned?
+          reference_positions.any? { |pos| pos <= assignment_without_usage_pos }
+        end
+
+        # Find the first variable assignment, which doesn't reference the
+        # variable at the rhs.
+        def find_assignment_without_variable_usage(variable)
+          variable.assignments.find do |assignment|
+            # It's impossible to decide whether a branch is executed, so
+            # this case is ignored
+            next if assignment.branch
+
+            assignment_node = assignment.meta_assignment_node || assignment.node
+
+            !uses_var?(assignment_node, assignment.variable.name)
+          end
+        end
       end
     end
   end

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

@@ -19,13 +19,14 @@ module RuboCop
       #   def attribute ...
       class AccessorMethodName < Cop
         def on_def(node)
-          if bad_reader_name?(node)
-            add_offense(node, :name,
-                        'Do not prefix reader method names with `get_`.')
-          elsif bad_writer_name?(node)
-            add_offense(node, :name,
-                        'Do not prefix writer method names with `set_`.')
-          end
+          msg =
+            if bad_reader_name?(node)
+              'Do not prefix reader method names with `get_`.'
+            elsif bad_writer_name?(node)
+              'Do not prefix writer method names with `set_`.'
+            end
+
+          add_offense(node, location: :name, message: msg) if msg
         end
         alias on_defs on_def
 

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

@@ -10,7 +10,7 @@ module RuboCop
         def investigate(processed_source)
           processed_source.tokens.each do |token|
             next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
-            add_offense(token, first_offense_range(token))
+            add_offense(token, location: first_offense_range(token))
           end
         end
 

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

@@ -27,7 +27,7 @@ module RuboCop
         def on_def(node)
           op_method_candidate?(node) do |name, arg|
             return unless op_method?(name)
-            add_offense(arg, :expression, format(MSG, name))
+            add_offense(arg, message: format(MSG, name))
           end
         end
 

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

@@ -21,7 +21,7 @@ module RuboCop
         def check_name(node)
           name = node.loc.name.source
 
-          add_offense(node, :name) if name =~ /_/
+          add_offense(node, location: :name) if name =~ /_/
         end
       end
     end

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

@@ -21,7 +21,7 @@ module RuboCop
           # SomeClass = SomeOtherClass
           return if value && %i[send block const].include?(value.type)
 
-          add_offense(node, :name) if const_name !~ SNAKE_CASE
+          add_offense(node, location: :name) if const_name !~ SNAKE_CASE
         end
       end
     end

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

@@ -22,7 +22,7 @@ module RuboCop
           return if config.file_to_include?(file_path)
 
           for_bad_filename(file_path) do |range, msg|
-            add_offense(nil, range, msg)
+            add_offense(nil, location: range, message: msg)
           end
         end
 

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

@@ -42,7 +42,7 @@ module RuboCop
         def on_heredoc(node)
           return if correct_case_delimiters?(node)
 
-          add_offense(node, :heredoc_end)
+          add_offense(node, location: :heredoc_end)
         end
 
         private

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

@@ -27,12 +27,11 @@ module RuboCop
         include Heredoc
 
         MSG = 'Use meaningful heredoc delimiters.'.freeze
-        OPENING_DELIMITER = /<<[~-]?'?(\w+)'?\b/
 
         def on_heredoc(node)
           return if meaningful_delimiters?(node)
 
-          add_offense(node, :heredoc_end)
+          add_offense(node, location: :heredoc_end)
         end
 
         private
@@ -40,6 +39,8 @@ module RuboCop
         def meaningful_delimiters?(node)
           delimiters = delimiters(node)
 
+          return false unless delimiters =~ /\w/
+
           blacklisted_delimiters.none? do |blacklisted_delimiter|
             delimiters =~ Regexp.new(blacklisted_delimiter)
           end

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

@@ -18,16 +18,37 @@ module RuboCop
       #   # good
       #   def value? ...
       class PredicateName < Cop
+        def_node_matcher :dynamic_method_define, <<-PATTERN
+          (send nil? #method_definition_macros
+            (sym $_)
+            ...)
+        PATTERN
+
+        def on_send(node)
+          dynamic_method_define(node) do |method_name|
+            predicate_prefixes.each do |prefix|
+              next if allowed_method_name?(method_name.to_s, prefix)
+
+              add_offense(
+                node,
+                location: node.first_argument.loc.expression,
+                message: message(method_name,
+                                 expected_name(method_name.to_s, prefix))
+              )
+            end
+          end
+        end
+
         def on_def(node)
           predicate_prefixes.each do |prefix|
             method_name = node.method_name.to_s
-            next unless method_name.start_with?(prefix)
-            next if method_name == expected_name(method_name, prefix)
-            next if predicate_whitelist.include?(method_name)
+
+            next if allowed_method_name?(method_name, prefix)
+
             add_offense(
               node,
-              :name,
-              message(method_name, expected_name(method_name, prefix))
+              location: :name,
+              message: message(method_name, expected_name(method_name, prefix))
             )
           end
         end
@@ -35,6 +56,12 @@ module RuboCop
 
         private
 
+        def allowed_method_name?(method_name, prefix)
+          !method_name.start_with?(prefix) ||
+            method_name == expected_name(method_name, prefix) ||
+            predicate_whitelist.include?(method_name)
+        end
+
         def expected_name(method_name, prefix)
           new_name = if prefix_blacklist.include?(prefix)
                        method_name.sub(prefix, '')
@@ -60,6 +87,10 @@ module RuboCop
         def predicate_whitelist
           cop_config['NameWhitelist']
         end
+
+        def method_definition_macros(macro_name)
+          cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
+        end
       end
     end
   end