rubocop 1.11.0 → 1.15.0

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

@@ -8,9 +8,7 @@ module RuboCop
         extend NodePattern::Macros
 
         def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_argument(variable)
-          end
+          scope.variables.each_value { |variable| check_argument(variable) }
         end
 
         private

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

@@ -70,16 +70,14 @@ module RuboCop
         private
 
         def should_check?(token)
-          token.type == :tIDENTIFIER ||
-            (token.type == :tCONSTANT && cop_config['AsciiConstants'])
+          token.type == :tIDENTIFIER || (token.type == :tCONSTANT && cop_config['AsciiConstants'])
         end
 
         def first_offense_range(identifier)
           expression    = identifier.pos
           first_offense = first_non_ascii_chars(identifier.text)
 
-          start_position = expression.begin_pos +
-                           identifier.text.index(first_offense)
+          start_position = expression.begin_pos + identifier.text.index(first_offense)
           end_position   = start_position + first_offense.length
 
           range_between(start_position, end_position)

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

@@ -16,8 +16,7 @@ module RuboCop
       class BinaryOperatorParameterName < Base
         extend AutoCorrector
 
-        MSG = 'When defining the `%<opr>s` operator, ' \
-              'name its argument `other`.'
+        MSG = 'When defining the `%<opr>s` operator, name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
         EXCLUDED = %i[+@ -@ [] []= << === ` =~].freeze

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

@@ -27,22 +27,17 @@ module RuboCop
       class FileName < Base
         include RangeHelp
 
-        MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) ' \
-                         'should use snake_case.'
-        MSG_NO_DEFINITION = '%<basename>s should define a class or module ' \
-                            'called `%<namespace>s`.'
+        MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) should use snake_case.'
+        MSG_NO_DEFINITION = '%<basename>s should define a class or module called `%<namespace>s`.'
         MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
 
         SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
         def on_new_investigation
           file_path = processed_source.file_path
-          return if config.file_to_exclude?(file_path) ||
-                    config.allowed_camel_case_file?(file_path)
+          return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
 
-          for_bad_filename(file_path) do |range, msg|
-            add_offense(range, message: msg)
-          end
+          for_bad_filename(file_path) { |range, msg| add_offense(range, message: msg) }
         end
 
         private
@@ -62,8 +57,7 @@ module RuboCop
         def perform_class_and_module_naming_checks(file_path, basename)
           return unless expect_matching_definition?
 
-          if check_definition_path_hierarchy? &&
-             !matching_definition?(file_path)
+          if check_definition_path_hierarchy? && !matching_definition?(file_path)
             msg = no_definition_message(basename, file_path)
           elsif !matching_class?(basename)
             msg = no_definition_message(basename, basename)
@@ -136,8 +130,7 @@ module RuboCop
 
             const_namespace, const_name = *const
             next if name != const_name && !match_acronym?(name, const_name)
-            next unless namespace.empty? ||
-                        match_namespace(child, const_namespace, namespace)
+            next unless namespace.empty? || match_namespace(child, const_namespace, namespace)
 
             return node
           end
@@ -181,9 +174,7 @@ module RuboCop
           expected = expected.to_s
           name = name.to_s
 
-          allowed_acronyms.any? do |acronym|
-            expected.gsub(acronym.capitalize, acronym) == name
-          end
+          allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
         end
 
         def to_namespace(path)

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
 
@@ -243,8 +247,7 @@ module RuboCop
         def message(variable)
           variable_name = variable.to_s.sub('@', '')
 
-          return UNDERSCORE_REQUIRED if style == :required &&
-                                        !variable_name.start_with?('_')
+          return UNDERSCORE_REQUIRED if style == :required && !variable_name.start_with?('_')
 
           MSG
         end
@@ -256,7 +259,7 @@ module RuboCop
         end
 
         def variable_name_candidates(method_name)
-          no_underscore = method_name.sub(/\A_/, '')
+          no_underscore = method_name.delete_prefix('_')
           with_underscore = "_#{method_name}"
           case style
           when :required

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

@@ -53,8 +53,7 @@ module RuboCop
         end
 
         def on_def(node)
-          return if node.operator_method? ||
-                    matches_ignored_pattern?(node.method_name)
+          return if node.operator_method? || matches_ignored_pattern?(node.method_name)
 
           check_name(node, node.method_name, node.loc.name)
         end

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

@@ -44,8 +44,7 @@ module RuboCop
 
               add_offense(
                 node.first_argument.loc.expression,
-                message: message(method_name,
-                                 expected_name(method_name.to_s, prefix))
+                message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end
           end

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/offense.rb

@@ -7,8 +7,7 @@ module RuboCop
       include Comparable
 
       # @api private
-      COMPARISON_ATTRIBUTES = %i[line column cop_name
-                                 message severity].freeze
+      COMPARISON_ATTRIBUTES = %i[line column cop_name message severity].freeze
 
       # @api public
       #
@@ -141,9 +140,7 @@ module RuboCop
       # @return [Parser::Source::Range]
       #   the range of the code that is highlighted
       def highlighted_area
-        Parser::Source::Range.new(source_line,
-                                  column,
-                                  column + column_length)
+        Parser::Source::Range.new(source_line, column, column + column_length)
       end
 
       # @api private
@@ -220,9 +217,7 @@ module RuboCop
       alias eql? ==
 
       def hash
-        COMPARISON_ATTRIBUTES.reduce(0) do |hash, attribute|
-          hash ^ public_send(attribute).hash
-        end
+        COMPARISON_ATTRIBUTES.reduce(0) { |hash, attribute| hash ^ public_send(attribute).hash }
       end
 
       # @api public

data/lib/rubocop/cop/registry.rb

@@ -10,12 +10,7 @@ module RuboCop
 
       def initialize(name, origin, badges)
         super(
-          format(
-            MSG,
-            name: name,
-            origin: origin,
-            options: badges.to_a.join(' or ')
-          )
+          format(MSG, name: name, origin: origin, options: badges.to_a.join(' or '))
         )
       end
     end
@@ -64,6 +59,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
@@ -150,16 +150,13 @@ module RuboCop
       end
 
       def enabled(config, only = [], only_safe: false)
-        select do |cop|
-          only.include?(cop.cop_name) || enabled?(cop, config, only_safe)
-        end
+        select { |cop| only.include?(cop.cop_name) || enabled?(cop, config, only_safe) }
       end
 
       def enabled?(cop, config, only_safe)
         cfg = config.for_cop(cop)
 
-        cop_enabled = cfg.fetch('Enabled') == true ||
-                      enabled_pending_cop?(cfg, config)
+        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
 
         if only_safe
           cop_enabled && cfg.fetch('Safe', true)
@@ -179,6 +176,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

@@ -47,7 +47,7 @@ module RuboCop
       #
       #   end
       #
-      # @example AllowModifiersOnSymbols: true
+      # @example AllowModifiersOnSymbols: true (default)
       #   # good
       #   class Foo
       #
@@ -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)
@@ -88,9 +88,7 @@ module RuboCop
           return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
-            add_offense(node.loc.selector) do
-              opposite_style_detected
-            end
+            add_offense(node.loc.selector) { opposite_style_detected }
           else
             correct_style_detected
           end

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

@@ -129,9 +129,7 @@ module RuboCop
         end
 
         def group_accessors(node, accessors)
-          accessor_names = accessors.flat_map do |accessor|
-            accessor.arguments.map(&:source)
-          end
+          accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }
 
           "#{node.method_name} #{accessor_names.join(', ')}"
         end

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

@@ -27,10 +27,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG_ALIAS = 'Use `alias_method` instead of `alias`.'
-        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` ' \
-                           '%<current>s.'
-        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of ' \
-                           '`alias %<current>s`.'
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %<current>s.'
+        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of `alias %<current>s`.'
 
         RESTRICT_ON_SEND = %i[alias_method].freeze
 
@@ -52,9 +50,7 @@ module RuboCop
               autocorrect(corrector, node)
             end
           elsif node.children.none? { |arg| bareword?(arg) }
-            add_offense_for_args(node) do |corrector|
-              autocorrect(corrector, node)
-            end
+            add_offense_for_args(node) { |corrector| autocorrect(corrector, node) }
           end
         end
 
@@ -75,17 +71,14 @@ module RuboCop
         end
 
         def alias_method_possible?(node)
-          scope_type(node) != :instance_eval &&
-            node.children.none?(&:gvar_type?)
+          scope_type(node) != :instance_eval && node.children.none?(&:gvar_type?)
         end
 
         def add_offense_for_args(node, &block)
           existing_args  = node.children.map(&:source).join(' ')
           preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
-          msg            = format(MSG_SYMBOL_ARGS,
-                                  prefer: preferred_args,
-                                  current: existing_args)
+          msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
           add_offense(arg_ranges.reduce(&:join), message: msg, &block)
         end
 

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

@@ -94,7 +94,9 @@ module RuboCop
 
           return unless correctable_send?(node)
 
-          corrector.replace(whitespace_before_arg(node), '(')
+          whitespace_before_arg_range = whitespace_before_arg(node)
+          corrector.remove(whitespace_before_arg_range)
+          corrector.insert_before(whitespace_before_arg_range, '(')
           corrector.insert_after(node.last_argument, ')')
         end
 

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

@@ -107,9 +107,7 @@ module RuboCop
           begin_pos = forwarding_method.source_range.begin_pos
           end_pos = forwarding_method.source_range.end_pos
 
-          lvars.all? do |lvar|
-            lvar.source_range.begin_pos.between?(begin_pos, end_pos)
-          end
+          lvars.all? { |lvar| lvar.source_range.begin_pos.between?(begin_pos, end_pos) }
         end
 
         def register_offense_to_forwarding_method_arguments(forwarding_method)

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

@@ -35,8 +35,7 @@ module RuboCop
           expression    = comment.loc.expression
           first_offense = first_non_ascii_chars(comment.text)
 
-          start_position = expression.begin_pos +
-                           comment.text.index(first_offense)
+          start_position = expression.begin_pos + comment.text.index(first_offense)
           end_position   = start_position + first_offense.length
 
           range_between(start_position, end_position)

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

@@ -24,9 +24,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
           # check only for method definitions in class/module body
-          return if node.parent &&
-                    !node.parent.class_type? &&
-                    !class_eval?(node.parent)
+          return if node.parent && !node.parent.class_type? && !class_eval?(node.parent)
 
           message = message(node)
           add_offense(node.loc.selector, message: message) do |corrector|

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

@@ -19,9 +19,7 @@ module RuboCop
       class AutoResourceCleanup < Base
         MSG = 'Use the block version of `%<class>s.%<method>s`.'
 
-        TARGET_METHODS = {
-          File: :open
-        }.freeze
+        TARGET_METHODS = { File: :open }.freeze
 
         RESTRICT_ON_SEND = TARGET_METHODS.values.freeze
 
@@ -42,8 +40,7 @@ module RuboCop
 
         def cleanup?(node)
           parent = node.parent
-          node.block_argument? ||
-            (parent && (parent.block_type? || !parent.lvasgn_type?))
+          node.block_argument? || (parent && (parent.block_type? || !parent.lvasgn_type?))
         end
       end
     end

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