rubocop 1.5.0 → 1.7.0

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

@@ -9,6 +9,12 @@ module RuboCop
       # In rare cases where only one iteration (or at most one iteration) is intended behavior,
       # the code should be refactored to use `if` conditionals.
       #
+      # NOTE: Block methods that are used with `Enumerable`s are considered to be loops.
+      #
+      # `IgnoredPatterns` can be used to match against the block receiver in order to allow
+      # code that would otherwise be registered as an offense (eg. `times` used not in an
+      # `Enumerable` context).
+      #
       # @example
       #   # bad
       #   while node
@@ -70,7 +76,16 @@ module RuboCop
       #     raise NotFoundError
       #   end
       #
+      #   # bad
+      #   2.times { raise ArgumentError }
+      #
+      # @example IgnoredPatterns: [/(exactly|at_least|at_most)\(\d+\)\.times/] (default)
+      #
+      #   # good
+      #   exactly(2).times { raise StandardError }
       class UnreachableLoop < Base
+        include IgnoredPattern
+
         MSG = 'This loop will have at most one iteration.'
 
         def on_while(node)
@@ -91,6 +106,8 @@ module RuboCop
           return false unless node.block_type?
 
           send_node = node.send_node
+          return false if matches_ignored_pattern?(send_node.source)
+
           send_node.enumerable_method? || send_node.enumerator_method? || send_node.method?(:loop)
         end
 

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -124,7 +124,7 @@ module RuboCop
           end
 
           def classlike_node?(node)
-            CLASSLIKE_TYPES.include?(node.type)
+            CLASSLIKE_TYPES.include?(node&.type)
           end
 
           def foldable_node?(node)

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

@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def qualified_legacy_cop_name(cop_name)
-          legacy_cop_names = RuboCop::ConfigObsoletion::OBSOLETE_COPS.keys
+          legacy_cop_names = RuboCop::ConfigObsoletion.legacy_cop_names
 
           legacy_cop_names.detect do |legacy_cop_name|
             legacy_cop_name.split('/')[1] == cop_name

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

@@ -14,7 +14,10 @@ module RuboCop
         return if part_of_ignored_node?(node)
 
         if offense?(node)
-          add_offense(node) { opposite_style_detected }
+          add_offense(node) do |corrector|
+            opposite_style_detected
+            autocorrect(corrector, node) if respond_to?(:autocorrect, true)
+          end
         else
           correct_style_detected
         end

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

@@ -3,7 +3,13 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that accessor methods are named properly.
+      # This cop makes sure that accessor methods are named properly. Applies
+      # to both instance and class methods.
+      #
+      # NOTE: Offenses are only registered for methods with the expected
+      # arity. Getters (`get_attribute`) must have no arguments to be
+      # registered, and setters (`set_attribute(value)`) must have exactly
+      # one.
       #
       # @example
       #   # bad
@@ -21,6 +27,14 @@ module RuboCop
       #   # good
       #   def attribute
       #   end
+      #
+      #   # accepted, incorrect arity for getter
+      #   def get_value(attr)
+      #   end
+      #
+      #   # accepted, incorrect arity for setter
+      #   def set_value
+      #   end
       class AccessorMethodName < Base
         MSG_READER = 'Do not prefix reader method names with `get_`.'
         MSG_WRITER = 'Do not prefix writer method names with `set_`.'

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

@@ -4,7 +4,9 @@ module RuboCop
   module Cop
     module Naming
       # This cop checks for memoized methods whose instance variable name
-      # does not match the method name.
+      # does not match the method name. Applies to both regular methods
+      # (defined with `def`) and dynamic methods (defined with
+      # `define_method` or `define_singleton_method`).
       #
       # This cop can be configured with the EnforcedStyleForLeadingUnderscores
       # directive. It can be configured to allow for memoized instance variables
@@ -48,6 +50,17 @@ module RuboCop
       #     @foo ||= calculate_expensive_thing(helper_variable)
       #   end
       #
+      #   # good
+      #   define_method(:foo) do
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     return @foo if defined?(@foo)
+      #     @foo = calculate_expensive_thing
+      #   end
+      #
       # @example EnforcedStyleForLeadingUnderscores: required
       #   # bad
       #   def foo
@@ -79,6 +92,17 @@ module RuboCop
       #     @_foo = calculate_expensive_thing
       #   end
       #
+      #   # good
+      #   define_method(:foo) do
+      #     @_foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     return @_foo if defined?(@_foo)
+      #     @_foo = calculate_expensive_thing
+      #   end
+      #
       # @example EnforcedStyleForLeadingUnderscores :optional
       #   # bad
       #   def foo
@@ -105,6 +129,16 @@ module RuboCop
       #     return @_foo if defined?(@_foo)
       #     @_foo = calculate_expensive_thing
       #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     @_foo ||= calculate_expensive_thing
+      #   end
       class MemoizedInstanceVariableName < Base
         include ConfigurableEnforcedStyle
 
@@ -112,17 +146,27 @@ module RuboCop
           'method name `%<method>s`. Use `@%<suggested_var>s` instead.'
         UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
           'with `_`. Use `@%<suggested_var>s` instead.'
+        DYNAMIC_DEFINE_METHODS = %i[define_method define_singleton_method].to_set.freeze
+
+        def_node_matcher :method_definition?, <<~PATTERN
+          ${
+            (block (send _ %DYNAMIC_DEFINE_METHODS ({sym str} $_)) ...)
+            (def $_ ...)
+            (defs _ $_ ...)
+          }
+        PATTERN
 
         # rubocop:disable Metrics/AbcSize
         def on_or_asgn(node)
           lhs, _value = *node
           return unless lhs.ivasgn_type?
-          return unless (method_node = node.each_ancestor(:def, :defs).first)
+
+          method_node, method_name = find_definition(node)
+          return unless method_node
 
           body = method_node.body
           return unless body == node || body.children.last == node
 
-          method_name = method_node.method_name
           return if matches?(method_name, lhs)
 
           msg = format(
@@ -147,11 +191,10 @@ module RuboCop
           arg = node.arguments.first
           return unless arg.ivar_type?
 
-          method_node = node.each_ancestor(:def, :defs).first
+          method_node, method_name = find_definition(node)
           return unless method_node
 
           var_name = arg.children.first
-          method_name = method_node.method_name
           defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
             return if matches?(method_name, ivar_assign)
 
@@ -174,6 +217,17 @@ module RuboCop
           'EnforcedStyleForLeadingUnderscores'
         end
 
+        def find_definition(node)
+          # Methods can be defined in a `def` or `defs`,
+          # or dynamically via a `block` node.
+          node.each_ancestor(:def, :defs, :block).each do |ancestor|
+            method_node, method_name = method_definition?(ancestor)
+            return [method_node, method_name] if method_node
+          end
+
+          nil
+        end
+
         def matches?(method_name, ivar_assign)
           return true if ivar_assign.nil? || method_name == :initialize
 

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

@@ -104,6 +104,8 @@ module RuboCop
         def on_arg(node)
           @node = node
           name, = *node
+          return if allowed_identifier?(name)
+
           check_name(node, name, node.loc.name)
         end
         alias on_lvasgn on_arg
@@ -139,7 +141,7 @@ module RuboCop
         end
 
         def allowed_identifier?(name)
-          allowed_identifiers.include?(name.to_s)
+          allowed_identifiers.include?(name.to_s.delete('@'))
         end
 
         def allowed_identifiers

data/lib/rubocop/cop/registry.rb

@@ -204,6 +204,12 @@ module RuboCop
         to_h[cop_name].first
       end
 
+      def freeze
+        clear_enrollment_queue
+        unqualified_cop_names # build cache
+        super
+      end
+
       @global = new
 
       class << self
@@ -228,6 +234,10 @@ module RuboCop
         @global = previous
       end
 
+      def self.reset!
+        @global = new
+      end
+
       private
 
       def initialize_copy(reg)

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

@@ -87,7 +87,9 @@ module RuboCop
           return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
-            add_offense(node.loc.selector) if opposite_style_detected
+            add_offense(node.loc.selector) do
+              opposite_style_detected
+            end
           else
             correct_style_detected
           end

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

@@ -14,8 +14,9 @@ module RuboCop
       #
       #   # good
       #   ?\C-\M-d
-      class CharacterLiteral < Cop
+      class CharacterLiteral < Base
         include StringHelp
+        extend AutoCorrector
 
         MSG = 'Do not use the character literal - ' \
               'use string literal instead.'
@@ -26,17 +27,15 @@ module RuboCop
             node.source.size.between?(2, 3)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            string = node.source[1..-1]
+        def autocorrect(corrector, node)
+          string = node.source[1..-1]
 
-            # special character like \n
-            # or ' which needs to use "" or be escaped.
-            if string.length == 2 || string == "'"
-              corrector.replace(node, %("#{string}"))
-            elsif string.length == 1 # normal character
-              corrector.replace(node, "'#{string}'")
-            end
+          # special character like \n
+          # or ' which needs to use "" or be escaped.
+          if string.length == 2 || string == "'"
+            corrector.replace(node, %("#{string}"))
+          elsif string.length == 1 # normal character
+            corrector.replace(node, "'#{string}'")
           end
         end
 

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

@@ -48,7 +48,7 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.arguments.one? && node.first_argument.block_pass_type?
+          return unless implicit_block?(node)
 
           check_method_node(node)
         end
@@ -64,9 +64,22 @@ module RuboCop
           end
         end
 
+        def implicit_block?(node)
+          return false unless node.arguments.any?
+
+          node.last_argument.block_pass_type? ||
+            node.last_argument.sym_type? && methods_accepting_symbol.include?(node.method_name.to_s)
+        end
+
         def message(node)
           format(MSG, prefer: preferred_method(node.method_name), current: node.method_name)
         end
+
+        # Some enumerable methods accept a bare symbol (ie. _not_ Symbol#to_proc) instead
+        # of a block.
+        def methods_accepting_symbol
+          Array(cop_config['MethodsAcceptingSymbol'])
+        end
       end
     end
   end

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

@@ -4,12 +4,15 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for comments put on the same line as some keywords.
-      # These keywords are: `begin`, `class`, `def`, `end`, `module`.
+      # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
       # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
       # are allowed.
       #
+      # Auto-correction removes comments from `end` keyword and keeps comments
+      # for `class`, `module`, `def` and `begin` above the keyword.
+      #
       # @example
       #   # bad
       #   if condition
@@ -34,16 +37,17 @@ module RuboCop
       #     y
       #   end
       class CommentedKeyword < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Do not place comments on the same line as the ' \
               '`%<keyword>s` keyword.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless (match = line(comment).match(/(?<keyword>\S+).*#/))
+            next unless (match = line(comment).match(/(?<keyword>\S+).*#/)) && offensive?(comment)
 
-            if offensive?(comment)
-              add_offense(comment, message: format(MSG, keyword: match[:keyword]))
-            end
+            register_offense(comment, match[:keyword])
           end
         end
 
@@ -60,6 +64,19 @@ module RuboCop
         ].freeze
         ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
 
+        def register_offense(comment, matched_keyword)
+          add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
+            range = range_with_surrounding_space(range: comment.loc.expression, newlines: false)
+            corrector.remove(range)
+
+            unless matched_keyword == 'end'
+              corrector.insert_before(
+                range.source_buffer.line_range(comment.loc.line), "#{comment.text}\n"
+              )
+            end
+          end
+        end
+
         def offensive?(comment)
           line = line(comment)
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&

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

@@ -41,6 +41,8 @@ module RuboCop
       #   a.fdiv(b)
       class FloatDivision < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
         MESSAGES = {
           left_coerce: 'Prefer using `.to_f` on the left side.',
           right_coerce: 'Prefer using `.to_f` on the right side.',
@@ -64,7 +66,20 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          add_offense(node) if offense_condition?(node)
+          return unless offense_condition?(node)
+
+          add_offense(node) do |corrector|
+            case style
+            when :left_coerce, :single_coerce
+              add_to_f_method(corrector, node.receiver)
+              remove_to_f_method(corrector, node.first_argument)
+            when :right_coerce
+              remove_to_f_method(corrector, node.receiver)
+              add_to_f_method(corrector, node.first_argument)
+            when :fdiv
+              correct_from_slash_to_fdiv(corrector, node, node.receiver, node.first_argument)
+            end
+          end
         end
 
         private
@@ -87,6 +102,34 @@ module RuboCop
         def message(_node)
           MESSAGES[style]
         end
+
+        def add_to_f_method(corrector, node)
+          corrector.insert_after(node, '.to_f') unless node.send_type? && node.method?(:to_f)
+        end
+
+        def remove_to_f_method(corrector, send_node)
+          corrector.remove(send_node.loc.dot)
+          corrector.remove(send_node.loc.selector)
+        end
+
+        def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
+          receiver_source = extract_receiver_source(receiver)
+          argument_source = extract_receiver_source(argument)
+
+          if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
+            argument_source = "(#{argument_source})"
+          end
+
+          corrector.replace(node, "#{receiver_source}.fdiv#{argument_source}")
+        end
+
+        def extract_receiver_source(node)
+          if node.send_type? && node.method?(:to_f)
+            node.receiver.source
+          else
+            node.source
+          end
+        end
       end
     end
   end