rubocop 1.11.0 → 1.12.0

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

@@ -16,7 +16,7 @@ module RuboCop
 
         return false unless comment
 
-        comment.text.match?(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        !!DirectiveComment.new(comment).match_captures
       end
 
       def allow_uri?
@@ -24,9 +24,7 @@ module RuboCop
       end
 
       def allowed_uri_position?(line, uri_range)
-        uri_range.begin < max_line_length &&
-          (uri_range.end == line_length(line) ||
-           uri_range.end == line_length(line) - 1)
+        uri_range.begin < max_line_length && uri_range.end == line_length(line)
       end
 
       def line_length(line)
@@ -40,6 +38,14 @@ module RuboCop
         begin_position, end_position = last_uri_match.offset(0).map do |pos|
           pos + indentation_difference(line)
         end
+
+        # Extend the end position until the start of the next word, if any.
+        # This allows for URIs that are wrapped in quotes or parens to be handled properly
+        # while not allowing additional words to be added after the URL.
+        if (match = line[end_position..line_length(line)]&.match(/^\S+(?=\s|$)/))
+          end_position += match.offset(0).last
+        end
+
         return nil if begin_position < max_line_length &&
                       end_position < max_line_length
 
@@ -79,8 +85,7 @@ module RuboCop
       end
 
       def line_length_without_directive(line)
-        before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-        before_comment.rstrip.length
+        DirectiveComment.before_comment(line).rstrip.length
       end
     end
   end

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

@@ -77,7 +77,9 @@ module RuboCop
       def incorrect_style_detected(styles, first, left_parenthesis)
         msg = message(base_description(left_parenthesis))
 
-        add_offense(first, message: msg) do
+        add_offense(first, message: msg) do |corrector|
+          autocorrect(corrector, first)
+
           ambiguous_style_detected(*styles)
         end
       end

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

@@ -91,9 +91,10 @@ module RuboCop
       end
 
       def incorrect_style_detected(range, node, lhs, rhs)
-        add_offense(range, location: range, message: message(node, lhs, rhs)) do
-          if supported_styles.size > 2 ||
-             offending_range(node, lhs, rhs, alternative_style)
+        add_offense(range, message: message(node, lhs, rhs)) do |corrector|
+          autocorrect(corrector, range)
+
+          if supported_styles.size > 2 || offending_range(node, lhs, rhs, alternative_style)
             unrecognized_style_detected
           else
             opposite_style_detected

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

@@ -15,7 +15,7 @@ module RuboCop
       end
 
       def delimiters
-        preferred_delimiters[type].split('')
+        preferred_delimiters[type].chars
       end
 
       private

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

@@ -53,12 +53,10 @@ module RuboCop
       end
 
       def name_type(node)
-        @name_type ||= begin
-          case node.type
-          when :block then 'block parameter'
-          when :def, :defs then 'method parameter'
-          end
-        end
+        @name_type ||= case node.type
+                       when :block then 'block parameter'
+                       when :def, :defs then 'method parameter'
+                       end
       end
 
       def num_offense(node, range)

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

@@ -139,6 +139,10 @@ module RuboCop
       #   define_method(:foo) do
       #     @_foo ||= calculate_expensive_thing
       #   end
+      #
+      # This cop relies on the pattern `@instance_var ||= ...`,
+      # but this is sometimes used for other purposes than memoization
+      # so this cop is considered unsafe.
       class MemoizedInstanceVariableName < Base
         include ConfigurableEnforcedStyle
 

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

@@ -9,6 +9,11 @@ module RuboCop
       # The `PreferredName` config option takes a `String`. It represents
       # the required name of the variable. Its default is `e`.
       #
+      # NOTE: This cop does not consider nested rescues because it cannot
+      # guarantee that the variable from the outer rescue is not used within
+      # the inner rescue (in which case, changing the inner variable would
+      # shadow the outer variable).
+      #
       # @example PreferredName: e (default)
       #   # bad
       #   begin
@@ -62,6 +67,11 @@ module RuboCop
           offending_name = variable_name(node)
           return unless offending_name
 
+          # Handle nested rescues by only requiring the outer one to use the
+          # configured variable name, so that nested rescues don't use the same
+          # variable.
+          return if node.each_ancestor(:resbody).any?
+
           preferred_name = preferred_name(offending_name)
           return if preferred_name.to_sym == offending_name
 

data/lib/rubocop/cop/registry.rb

@@ -64,6 +64,11 @@ module RuboCop
         with(without_department.values.flatten)
       end
 
+      # @return [Boolean] Checks if given name is department
+      def department?(name)
+        departments.include? name.to_sym
+      end
+
       def contains_cop_matching?(names)
         cops.any? { |cop| cop.match?(names) }
       end
@@ -179,6 +184,10 @@ module RuboCop
         cops.map(&:cop_name)
       end
 
+      def names_for_department(department)
+        cops.select { |cop| cop.department == department.to_sym }.map(&:cop_name)
+      end
+
       def ==(other)
         cops == other.cops
       end

data/lib/rubocop/cop/style/access_modifier_declarations.rb

@@ -79,7 +79,7 @@ module RuboCop
 
         # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
-          (send nil? {:private :protected :public} (sym _))
+          (send nil? {:private :protected :public :module_function} (sym _))
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/style/bisected_attr_accessor.rb

@@ -19,47 +19,61 @@ module RuboCop
       #   end
       #
       class BisectedAttrAccessor < Base
-        include VisibilityHelp
+        require_relative 'bisected_attr_accessor/macro'
+
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Combine both accessors into `attr_accessor %<name>s`.'
 
+        def on_new_investigation
+          @macros_to_rewrite = {}
+        end
+
         def on_class(class_node)
-          VISIBILITY_SCOPES.each do |visibility|
-            reader_names, writer_names = accessor_names(class_node, visibility)
-            next unless reader_names && writer_names
+          @macros_to_rewrite[class_node] = Set.new
+
+          find_macros(class_node.body).each do |_visibility, macros|
+            bisected = find_bisection(macros)
+            next unless bisected.any?
 
-            accessor_macroses(class_node, visibility).each do |macro|
-              check(macro, reader_names, writer_names)
+            macros.each do |macro|
+              attrs = macro.bisect(*bisected)
+              next if attrs.none?
+
+              @macros_to_rewrite[class_node] << macro
+              attrs.each { |attr| register_offense(attr) }
             end
           end
         end
         alias on_sclass on_class
         alias on_module on_class
 
-        private
-
-        def accessor_names(class_node, visibility)
-          reader_names = nil
-          writer_names = nil
-
-          accessor_macroses(class_node, visibility).each do |macro|
-            names = macro.arguments.map(&:source)
-
-            names.each do |name|
-              if attr_reader?(macro)
-                (reader_names ||= Set.new).add(name)
+        # Each offending macro is captured and registered in `on_class` but correction
+        # happens in `after_class` because a macro might have multiple attributes
+        # rewritten from it
+        def after_class(class_node)
+          @macros_to_rewrite[class_node].each do |macro|
+            node = macro.node
+            range = range_by_whole_lines(node.loc.expression, include_final_newline: true)
+
+            correct(range) do |corrector|
+              if macro.writer?
+                correct_writer(corrector, macro, node, range)
               else
-                (writer_names ||= Set.new).add(name)
+                correct_reader(corrector, macro, node, range)
               end
             end
           end
-
-          [reader_names, writer_names]
         end
+        alias after_sclass after_class
+        alias after_module after_class
 
-        def accessor_macroses(class_node, visibility)
-          class_def = class_node.body
+        private
+
+        def find_macros(class_def)
+          # Find all the macros (`attr_reader`, `attr_writer`, etc.) in the class body
+          # and turn them into `Macro` objects so that they can be processed.
           return [] if !class_def || class_def.def_type?
 
           send_nodes =
@@ -69,66 +83,40 @@ module RuboCop
               class_def.each_child_node(:send)
             end
 
-          send_nodes.select { |node| attr_within_visibility_scope?(node, visibility) }
+          send_nodes.each_with_object([]) do |node, macros|
+            macros << Macro.new(node) if Macro.macro?(node)
+          end.group_by(&:visibility)
         end
 
-        def attr_within_visibility_scope?(node, visibility)
-          node.macro? &&
-            (attr_reader?(node) || attr_writer?(node)) &&
-            node_visibility(node) == visibility
+        def find_bisection(macros)
+          # Find which attributes are defined in both readers and writers so that they
+          # can be replaced with accessors.
+          readers, writers = macros.partition(&:reader?)
+          readers.flat_map(&:attr_names) & writers.flat_map(&:attr_names)
         end
 
-        def attr_reader?(send_node)
-          send_node.method?(:attr_reader) || send_node.method?(:attr)
+        def register_offense(attr)
+          add_offense(attr, message: format(MSG, name: attr.source))
         end
 
-        def attr_writer?(send_node)
-          send_node.method?(:attr_writer)
-        end
+        def correct_reader(corrector, macro, node, range)
+          attr_accessor = "attr_accessor #{macro.bisected_names.join(', ')}\n"
 
-        def check(macro, reader_names, writer_names)
-          macro.arguments.each do |arg_node|
-            name = arg_node.source
-
-            next unless (attr_reader?(macro) && writer_names.include?(name)) ||
-                        (attr_writer?(macro) && reader_names.include?(name))
-
-            add_offense(arg_node, message: format(MSG, name: name)) do |corrector|
-              macro = arg_node.parent
-
-              corrector.replace(macro, replacement(macro, arg_node))
-            end
-          end
-        end
-
-        def replacement(macro, node)
-          class_node = macro.each_ancestor(:class, :sclass, :module).first
-          reader_names, writer_names = accessor_names(class_node, node_visibility(macro))
-
-          rest_args = rest_args(macro.arguments, reader_names, writer_names)
-
-          if attr_reader?(macro)
-            attr_reader_replacement(macro, node, rest_args)
-          elsif rest_args.empty?
-            ''
+          if macro.all_bisected?
+            corrector.replace(range, "#{indent(node)}#{attr_accessor}")
           else
-            "#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
-          end
-        end
-
-        def rest_args(args, reader_names, writer_names)
-          args.reject do |arg|
-            name = arg.source
-            reader_names.include?(name) && writer_names.include?(name)
+            correction = "#{indent(node)}attr_reader #{macro.rest.join(', ')}"
+            corrector.insert_before(node, attr_accessor)
+            corrector.replace(node, correction)
           end
         end
 
-        def attr_reader_replacement(macro, node, rest_args)
-          if rest_args.empty?
-            "attr_accessor #{node.source}"
+        def correct_writer(corrector, macro, node, range)
+          if macro.all_bisected?
+            corrector.remove(range)
           else
-            "attr_accessor #{node.source}\n"\
-            "#{indent(macro)}#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
+            correction = "attr_writer #{macro.rest.join(', ')}"
+            corrector.replace(node, correction)
           end
         end
       end

data/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class BisectedAttrAccessor
+        # Representation of an `attr_reader`, `attr_writer` or `attr` macro
+        # for use by `Style/BisectedAttrAccessor`.
+        # @api private
+        class Macro
+          include VisibilityHelp
+
+          attr_reader :node, :attrs, :bisection
+
+          def self.macro?(node)
+            node.method?(:attr_reader) || node.method?(:attr_writer) || node.method?(:attr)
+          end
+
+          def initialize(node)
+            @node = node
+            @attrs = node.arguments.map do |attr|
+              [attr.source, attr]
+            end.to_h
+            @bisection = []
+          end
+
+          def bisect(*names)
+            @bisection = attrs.slice(*names).values
+          end
+
+          def attr_names
+            @attr_names ||= attrs.keys
+          end
+
+          def bisected_names
+            bisection.map(&:source)
+          end
+
+          def visibility
+            @visibility ||= node_visibility(node)
+          end
+
+          def reader?
+            node.method?(:attr_reader) || node.method?(:attr)
+          end
+
+          def writer?
+            node.method?(:attr_writer)
+          end
+
+          def all_bisected?
+            rest.none?
+          end
+
+          def rest
+            @rest ||= attr_names - bisected_names
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/case_like_if.rb

@@ -105,8 +105,7 @@ module RuboCop
           when :===
             node.arguments.first
           when :include?, :cover?
-            receiver = deparenthesize(node.receiver)
-            node.arguments.first if receiver.range_type?
+            find_target_in_include_or_cover_node(node)
           when :match, :match?, :=~
             find_target_in_match_node(node)
           end
@@ -124,6 +123,12 @@ module RuboCop
           end
         end
 
+        def find_target_in_include_or_cover_node(node)
+          return unless (receiver = node.receiver)
+
+          node.first_argument if deparenthesize(receiver).range_type?
+        end
+
         def find_target_in_match_node(node)
           argument = node.arguments.first
           receiver = node.receiver
@@ -167,8 +172,7 @@ module RuboCop
             lhs, _method, rhs = *node
             lhs if rhs == target
           when :include?, :cover?
-            receiver = deparenthesize(node.receiver)
-            receiver if receiver.range_type? && node.arguments.first == target
+            condition_from_include_or_cover_node(node, target)
           end
         end
         # rubocop:enable Metrics/CyclomaticComplexity
@@ -184,6 +188,13 @@ module RuboCop
           condition_from_binary_op(lhs, rhs, target)
         end
 
+        def condition_from_include_or_cover_node(node, target)
+          return unless (receiver = node.receiver)
+
+          receiver = deparenthesize(receiver)
+          receiver if receiver.range_type? && node.first_argument == target
+        end
+
         def condition_from_binary_op(lhs, rhs, target)
           lhs = deparenthesize(lhs)
           rhs = deparenthesize(rhs)