rubocop 0.71.0 → 0.75.1

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

@@ -45,7 +45,7 @@ module RuboCop
               'Instead, use %<replacements>s depending on your specific use ' \
               'case.'
 
-        def_node_matcher :uri_escape_unescape?, <<-PATTERN
+        def_node_matcher :uri_escape_unescape?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
             ...)

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

@@ -18,13 +18,13 @@ module RuboCop
               'be used. Instead, use `%<top_level>sURI::DEFAULT_PARSER.' \
               'make_regexp%<arg>s`.'
 
-        def_node_matcher :uri_regexp_with_argument?, <<-PATTERN
+        def_node_matcher :uri_regexp_with_argument?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) :regexp
             (str $_))
         PATTERN
 
-        def_node_matcher :uri_regexp_without_argument?, <<-PATTERN
+        def_node_matcher :uri_regexp_without_argument?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) :regexp)
         PATTERN

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

@@ -113,19 +113,19 @@ module RuboCop
 
         private
 
-        def_node_matcher :static_method_definition?, <<-PATTERN
+        def_node_matcher :static_method_definition?, <<~PATTERN
           {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
         PATTERN
 
-        def_node_matcher :dynamic_method_definition?, <<-PATTERN
+        def_node_matcher :dynamic_method_definition?, <<~PATTERN
           {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
         PATTERN
 
-        def_node_matcher :class_or_instance_eval?, <<-PATTERN
+        def_node_matcher :class_or_instance_eval?, <<~PATTERN
           (block (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
-        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
+        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
           (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
@@ -202,7 +202,7 @@ module RuboCop
           cop_config.fetch('MethodCreatingMethods', []).any? do |m|
             matcher_name = "#{m}_method?".to_sym
             unless respond_to?(matcher_name)
-              self.class.def_node_matcher matcher_name, <<-PATTERN
+              self.class.def_node_matcher matcher_name, <<~PATTERN
                 {def (send nil? :#{m} ...)}
               PATTERN
             end
@@ -226,7 +226,7 @@ module RuboCop
           cop_config.fetch('ContextCreatingMethods', []).any? do |m|
             matcher_name = "#{m}_block?".to_sym
             unless respond_to?(matcher_name)
-              self.class.def_node_matcher matcher_name, <<-PATTERN
+              self.class.def_node_matcher matcher_name, <<~PATTERN
                 (block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end

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

@@ -49,7 +49,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :setter_call_to_local_variable?, <<-PATTERN
+        def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
           [(send (lvar _) ...) setter_method?]
         PATTERN
 

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

@@ -6,55 +6,36 @@ module RuboCop
       # This cop checks for operators, variables, literals, and nonmutating
       # methods used in void context.
       #
-      # @example
-      #
+      # @example CheckForMethodsWithNoSideEffects: false (default)
       #   # bad
-      #
       #   def some_method
       #     some_num * 10
       #     do_something
       #   end
       #
-      # @example
-      #
-      #   # bad
-      #
       #   def some_method(some_var)
       #     some_var
       #     do_something
       #   end
       #
-      # @example
-      #
-      #   # bad, when CheckForMethodsWithNoSideEffects is set true
-      #
+      # @example CheckForMethodsWithNoSideEffects: true
+      #   # bad
       #   def some_method(some_array)
       #     some_array.sort
       #     do_something(some_array)
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def some_method
       #     do_something
       #     some_num * 10
       #   end
       #
-      # @example
-      #
-      #   # good
-      #
       #   def some_method(some_var)
       #     do_something
       #     some_var
       #   end
       #
-      # @example
-      #
-      #   # good, when CheckForMethodsWithNoSideEffects is set true
-      #
       #   def some_method(some_array)
       #     some_array.sort!
       #     do_something(some_array)

data/lib/rubocop/cop/message_annotator.rb

@@ -9,11 +9,11 @@ module RuboCop
     #
     # @example
     #   RuboCop::Cop::MessageAnnotator.new(
-    #     config, cop_config, @options
-    #   ).annotate('message', 'Cop/CopName')
+    #     config, cop_name, cop_config, @options
+    #   ).annotate('message')
     #  #=> 'Cop/CopName: message (http://example.org/styleguide)'
     class MessageAnnotator
-      attr_reader :options, :config, :cop_config
+      attr_reader :options, :config, :cop_name, :cop_config
 
       @style_guide_urls = {}
 
@@ -29,6 +29,7 @@ module RuboCop
       #     :ExtraDetails [Boolean] Include cop details
       #     :DisplayCopNames [Boolean] Include cop name
       #
+      # @param [String] cop_name for specific cop name
       # @param [Hash] cop_config configs for specific cop, from config#for_cop
       # @option cop_config [String] :StyleGuide Extension of base styleguide URL
       # @option cop_config [String] :Reference Full reference URL
@@ -43,8 +44,9 @@ module RuboCop
       #   Include debug output
       # @option options [Boolean] :display_cop_names
       #   Include cop name
-      def initialize(config, cop_config, options)
+      def initialize(config, cop_name, cop_config, options)
         @config = config
+        @cop_name = cop_name
         @cop_config = cop_config || {}
         @options = options
       end
@@ -53,8 +55,8 @@ module RuboCop
       # based on params passed into initializer
       #
       # @return [String] annotated message
-      def annotate(message, name)
-        message = "#{name}: #{message}" if display_cop_names?
+      def annotate(message)
+        message = "#{cop_name}: #{message}" if display_cop_names?
         message += " #{details}" if extra_details? && details
         if display_style_guide?
           links = urls.join(', ')
@@ -74,7 +76,7 @@ module RuboCop
         return nil if url.nil? || url.empty?
 
         self.class.style_guide_urls[url] ||= begin
-          base_url = config.for_all_cops['StyleGuideBaseURL']
+          base_url = style_guide_base_url
           if base_url.nil? || base_url.empty?
             url
           else
@@ -83,6 +85,13 @@ module RuboCop
         end
       end
 
+      def style_guide_base_url
+        department_name = cop_name.split('/').first
+
+        config.for_department(department_name)['StyleGuideBaseURL'] ||
+          config.for_all_cops['StyleGuideBaseURL']
+      end
+
       def display_style_guide?
         (options[:display_style_guide] ||
          config.for_all_cops['DisplayStyleGuide']) &&

data/lib/rubocop/cop/metrics/class_length.rb

@@ -21,7 +21,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :class_definition?, <<-PATTERN
+        def_node_matcher :class_definition?, <<~PATTERN
           (casgn nil? _ (block (send (const nil? :Class) :new) ...))
         PATTERN
 

data/lib/rubocop/cop/metrics/line_length.rb

@@ -10,6 +10,7 @@ module RuboCop
       # The maximum length is configurable.
       # The tab size is configured in the `IndentationWidth`
       # of the `Layout/Tab` cop.
+      # It also ignores a shebang line by default.
       #
       # This cop has some autocorrection capabilities.
       # It can programmatically shorten certain long lines by
@@ -138,9 +139,14 @@ module RuboCop
 
         def ignored_line?(line, line_index)
           matches_ignored_pattern?(line) ||
+            shebang?(line, line_index) ||
             heredocs && line_in_permitted_heredoc?(line_index.succ)
         end
 
+        def shebang?(line, line_index)
+          line_index.zero? && line.start_with?('#!')
+        end
+
         def register_offense(loc, line, line_index)
           message = format(MSG, length: line_length(line), max: max)
 

data/lib/rubocop/cop/metrics/module_length.rb

@@ -21,7 +21,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :module_definition?, <<-PATTERN
+        def_node_matcher :module_definition?, <<~PATTERN
           (casgn nil? _ (block (send (const nil? :Module) :new) ...))
         PATTERN
 

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -25,7 +25,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :argument_to_lambda_or_proc?, <<-PATTERN
+        def_node_matcher :argument_to_lambda_or_proc?, <<~PATTERN
           ^lambda_or_proc?
         PATTERN
 

data/lib/rubocop/cop/migration/department_name.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Check that cop names in rubocop:disable comments are given with
+      # department name.
+      class DepartmentName < Cop
+        include RangeHelp
+
+        MSG = 'Department name is missing.'
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next if comment.text !~ /\A(# *rubocop:((dis|en)able|todo) +)(.*)/
+
+            offset = Regexp.last_match(1).length
+            Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
+              check_cop_name(name, comment, offset)
+              offset += name.length
+            end
+          end
+        end
+
+        def autocorrect(range)
+          shall_warn = false
+          qualified_cop_name = Cop.registry.qualified_cop_name(range.source,
+                                                               nil, shall_warn)
+          ->(corrector) { corrector.replace(range, qualified_cop_name) }
+        end
+
+        private
+
+        def check_cop_name(name, comment, offset)
+          return if name !~ /^[A-Z]/ || name =~ %r{/}
+
+          start = comment.location.expression.begin_pos + offset
+          range = range_between(start, start + name.length)
+          add_offense(range, location: range)
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module RuboCop
 
       def configured_indentation_width
         cop_config['IndentationWidth'] ||
-          config.for_cop('IndentationWidth')['Width']
+          config.for_cop('Layout/IndentationWidth')['Width']
       end
 
       def indentation(node)

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

@@ -25,7 +25,7 @@ module RuboCop
         processed_source[0..index].map(&:strip)
       end
 
-      def_node_matcher :non_public_modifier?, <<-PATTERN
+      def_node_matcher :non_public_modifier?, <<~PATTERN
         (send nil? {:private :protected} ({def defs} ...))
       PATTERN
     end

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

@@ -9,8 +9,6 @@ module RuboCop
 
       private
 
-      def_node_matcher :constant_definition?, '{class module casgn}'
-
       def documentation_comment?(node)
         preceding_lines = preceding_lines(node)
 

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

@@ -8,7 +8,7 @@ module RuboCop
 
       private
 
-      def_node_matcher :empty_arguments?, <<-PATTERN
+      def_node_matcher :empty_arguments?, <<~PATTERN
         (block _ $(args) _)
       PATTERN
 

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

@@ -5,12 +5,12 @@ module RuboCop
     # Common functionality for enforcing a specific superclass
     module EnforceSuperclass
       def self.included(base)
-        base.def_node_matcher :class_definition, <<-PATTERN
-        (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
+        base.def_node_matcher :class_definition, <<~PATTERN
+          (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
         PATTERN
 
-        base.def_node_matcher :class_new_definition, <<-PATTERN
-        [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
+        base.def_node_matcher :class_new_definition, <<~PATTERN
+          [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
         PATTERN
       end
 

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

@@ -12,7 +12,7 @@ module RuboCop
 
       def frozen_string_literal_comment_exists?
         leading_comment_lines.any? do |line|
-          MagicComment.parse(line).frozen_string_literal_specified?
+          MagicComment.parse(line).valid_literal_value?
         end
       end
 

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with string interpolations.
+    #
+    # @abstract Subclasses are expected to implement {#on_interpolation}.
+    module Interpolation
+      def on_dstr(node)
+        on_node_with_interpolations(node)
+      end
+
+      alias on_xstr on_dstr
+      alias on_dsym on_dstr
+      alias on_regexp on_dstr
+
+      def on_node_with_interpolations(node)
+        node.each_child_node(:begin) do |begin_node|
+          on_interpolation(begin_node)
+        end
+      end
+
+      # @!method on_interpolation(begin_node)
+      #   Inspect the `:begin` node of an interpolation
+    end
+  end
+end

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

@@ -20,7 +20,7 @@ module RuboCop
 
       private
 
-      def_node_matcher :define_method?, <<-PATTERN
+      def_node_matcher :define_method?, <<~PATTERN
         (block
          (send nil? :define_method ({sym str} $_))
          args

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

@@ -159,11 +159,11 @@ module RuboCop
           break false if a.block_type?
 
           next if a.setter_method?
+          next unless kind == :with_or_without_parentheses ||
+                      kind == :with_parentheses && parentheses?(a)
 
           a.arguments.any? do |arg|
-            within_node?(node, arg) && (kind == :with_or_without_parentheses ||
-                                        kind == :with_parentheses &&
-                                        parentheses?(node.parent))
+            within_node?(node, arg)
           end
         end
       end

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

@@ -19,6 +19,18 @@ module RuboCop
         aligned_with_adjacent_line?(range, method(:aligned_operator?))
       end
 
+      def aligned_with_preceding_assignment(token)
+        preceding_line_range = token.line.downto(1)
+
+        aligned_with_assignment(token, preceding_line_range)
+      end
+
+      def aligned_with_subsequent_assignment(token)
+        subsequent_line_range = token.line.upto(processed_source.lines.length)
+
+        aligned_with_assignment(token, subsequent_line_range)
+      end
+
       def aligned_with_adjacent_line?(range, predicate)
         # minus 2 because node.loc.line is zero-based
         pre  = (range.line - 2).downto(0)
@@ -89,6 +101,81 @@ module RuboCop
       def aligned_identical?(range, line)
         range.source == line[range.column, range.size]
       end
+
+      def aligned_with_assignment(token, line_range)
+        token_line_indent    = processed_source
+                               .line_indentation(token.line)
+        assignment_lines     = relevant_assignment_lines(line_range)
+        relevant_line_number = assignment_lines[1]
+
+        return :none unless relevant_line_number
+
+        relevant_indent = processed_source
+                          .line_indentation(relevant_line_number)
+
+        return :none if relevant_indent < token_line_indent
+
+        assignment_line = processed_source.lines[relevant_line_number - 1]
+
+        return :none unless assignment_line
+
+        aligned_assignment?(token.pos, assignment_line) ? :yes : :no
+      end
+
+      def assignment_lines
+        @assignment_lines ||= assignment_tokens.map(&:line)
+      end
+
+      def assignment_tokens
+        @assignment_tokens ||= begin
+          tokens = processed_source.tokens.select(&:equal_sign?)
+
+          # we don't want to operate on equals signs which are part of an
+          #   optarg in a method definition
+          # e.g.: def method(optarg = default_val); end
+          tokens = remove_optarg_equals(tokens, processed_source)
+
+          # Only attempt to align the first = on each line
+          Set.new(tokens.uniq(&:line))
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
+      def relevant_assignment_lines(line_range)
+        result                        = []
+        original_line_indent          = processed_source
+                                        .line_indentation(line_range.first)
+        relevant_line_indent_at_level = true
+
+        line_range.each do |line_number|
+          current_line_indent = processed_source.line_indentation(line_number)
+          blank_line          = processed_source.lines[line_number - 1].blank?
+
+          if (current_line_indent < original_line_indent && !blank_line) ||
+             (relevant_line_indent_at_level && blank_line)
+            break
+          end
+
+          result << line_number if assignment_lines.include?(line_number) &&
+                                   current_line_indent == original_line_indent
+
+          unless blank_line
+            relevant_line_indent_at_level = \
+              current_line_indent == original_line_indent
+          end
+        end
+
+        result
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
+
+      def remove_optarg_equals(asgn_tokens, processed_source)
+        optargs    = processed_source.ast.each_node(:optarg)
+        optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
+        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
+      end
     end
   end
 end