rubocop 0.52.1 → 0.53.0

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

@@ -37,10 +37,12 @@ module RuboCop
       #   params[:width_gteq]
       #
       class AsciiIdentifiers < Cop
+        include RangeHelp
+
         MSG = 'Use only ascii symbols in identifiers.'.freeze
 
         def investigate(processed_source)
-          processed_source.tokens.each do |token|
+          processed_source.each_token do |token|
             next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
             add_offense(token, location: first_offense_range(token))
           end

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

@@ -20,6 +20,8 @@ module RuboCop
       #
       #   anything/using_snake_case.rake
       class FileName < Cop
+        include RangeHelp
+
         MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) ' \
                          'should use snake_case.'.freeze
         MSG_NO_DEFINITION = '%<basename>s should define a class or module ' \
@@ -29,7 +31,7 @@ module RuboCop
         SNAKE_CASE = /^[\da-z_.?!]+$/
 
         def investigate(processed_source)
-          file_path = processed_source.buffer.name
+          file_path = processed_source.file_path
           return if config.file_to_include?(file_path)
 
           for_bad_filename(file_path) do |range, msg|
@@ -48,17 +50,14 @@ module RuboCop
 
                   no_definition_message(basename, file_path)
                 else
-                  return if ignore_executable_scripts? && shebang?(first_line)
+                  return if ignore_executable_scripts? &&
+                            processed_source.start_with?('#!')
                   other_message(basename)
                 end
 
           yield source_range(processed_source.buffer, 1, 0), msg
         end
 
-        def first_line
-          processed_source.lines.first
-        end
-
         def no_definition_message(basename, file_path)
           format(MSG_NO_DEFINITION,
                  basename: basename,
@@ -73,10 +72,6 @@ module RuboCop
           end
         end
 
-        def shebang?(line)
-          line && line.start_with?('#!')
-        end
-
         def ignore_executable_scripts?
           cop_config['IgnoreExecutableScripts']
         end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks for memoized methods whose instance variable name
+      # does not match the method name.
+      #
+      # @example
+      #   # bad
+      #   # Method foo is memoized using an instance variable that is
+      #   # not `@foo`. This can cause confusion and bugs.
+      #   def foo
+      #     @something ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     @foo ||= begin
+      #       calculate_expensive_thing
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     helper_variable = something_we_need_to_calculate_foo
+      #     @foo ||= calculate_expensive_thing(helper_variable)
+      #   end
+      #
+      class MemoizedInstanceVariableName < Cop
+        MSG = 'Memoized variable `%<var>s` does not match ' \
+          'method name `%<method>s`. Use `@%<method>s` instead.'.freeze
+
+        def self.node_pattern
+          memo_assign = '(or_asgn $(ivasgn _) _)'
+          memoized_at_end_of_method = "(begin ... #{memo_assign})"
+          instance_method =
+            "(def $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
+          class_method =
+            "(defs self $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
+          "{#{instance_method} #{class_method}}"
+        end
+
+        private_class_method :node_pattern
+        def_node_matcher :memoized?, node_pattern
+
+        def on_def(node)
+          (method_name, ivar_assign) = memoized?(node)
+          return if matches?(method_name, ivar_assign)
+          msg = format(
+            MSG,
+            var: ivar_assign.children.first.to_s,
+            method: method_name
+          )
+          add_offense(node, location: ivar_assign.source_range, message: msg)
+        end
+        alias on_defs on_def
+
+        private
+
+        def matches?(method_name, ivar_assign)
+          return true if ivar_assign.nil? || method_name == :initialize
+          method_name = method_name.to_s.sub('?', '')
+          variable = ivar_assign.children.first
+          variable_name = variable.to_s.sub('@', '')
+          variable_name == method_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks block parameter names for how descriptive they
+      # are. It is highly configurable.
+      #
+      # The `MinNameLength` config option takes an integer. It represents
+      # the minimum amount of characters the name must be. Its default is 1.
+      # The `AllowNamesEndingInNumbers` config option takes a boolean. When
+      # set to false, this cop will register offenses for names ending with
+      # numbers. Its default is false. The `AllowedNames` config option
+      # takes an array of whitelisted names that will never register an
+      # offense. The `ForbiddenNames` config option takes an array of
+      # blacklisted names that will always register an offense.
+      #
+      # @example
+      #   # bad
+      #   bar do |varOne, varTwo|
+      #     varOne + varTwo
+      #   end
+      #
+      #   # With `AllowNamesEndingInNumbers` set to false
+      #   foo { |num1, num2| num1 * num2 }
+      #
+      #   # With `MinParamNameLength` set to number greater than 1
+      #   baz { |a, b, c| do_stuff(a, b, c) }
+      #
+      #   # good
+      #   bar do |thud, fred|
+      #     thud + fred
+      #   end
+      #
+      #   foo { |speed, distance| speed * distance }
+      #
+      #   baz { |age, height, gender| do_stuff(age, height, gender) }
+      class UncommunicativeBlockParamName < Cop
+        include UncommunicativeName
+
+        def on_block(node)
+          return unless node.arguments?
+          check(node, node.arguments)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks method parameter names for how descriptive they
+      # are. It is highly configurable.
+      #
+      # The `MinNameLength` config option takes an integer. It represents
+      # the minimum amount of characters the name must be. Its default is 3.
+      # The `AllowNamesEndingInNumbers` config option takes a boolean. When
+      # set to false, this cop will register offenses for names ending with
+      # numbers. Its default is false. The `AllowedNames` config option
+      # takes an array of whitelisted names that will never register an
+      # offense. The `ForbiddenNames` config option takes an array of
+      # blacklisted names that will always register an offense.
+      #
+      # @example
+      #   # bad
+      #   def bar(varOne, varTwo)
+      #     varOne + varTwo
+      #   end
+      #
+      #   # With `AllowNamesEndingInNumbers` set to false
+      #   def foo(num1, num2)
+      #     num1 * num2
+      #   end
+      #
+      #   # With `MinArgNameLength` set to number greater than 1
+      #   def baz(a, b, c)
+      #     do_stuff(a, b, c)
+      #   end
+      #
+      #   # good
+      #   def bar(thud, fred)
+      #     thud + fred
+      #   end
+      #
+      #   def foo(speed, distance)
+      #     speed * distance
+      #   end
+      #
+      #   def baz(age_a, height_b, gender_c)
+      #     do_stuff(age_a, height_b, gender_c)
+      #   end
+      class UncommunicativeMethodParamName < Cop
+        include UncommunicativeName
+
+        def on_def(node)
+          return unless node.arguments?
+          check(node, node.arguments)
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

data/lib/rubocop/cop/offense.rb

@@ -99,8 +99,9 @@ module RuboCop
       # @api private
       # This is just for debugging purpose.
       def to_s
-        format('%s:%3d:%3d: %s',
-               severity.code, line, real_column, message)
+        format('%<severity>s:%3<line>d:%3<column>d: %<message>s',
+               severity: severity.code, line: line,
+               column: real_column, message: message)
       end
 
       # @api private

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -52,6 +52,7 @@ module RuboCop
       #   end
       class CaseWhenSplat < Cop
         include Alignment
+        include RangeHelp
 
         MSG = 'Place `when` conditions with a splat ' \
               'at the end of the `when` branches.'.freeze

data/lib/rubocop/cop/performance/casecmp.rb

@@ -35,6 +35,13 @@ module RuboCop
             $(send _ ${:downcase :upcase}))
         PATTERN
 
+        def_node_matcher :downcase_downcase, <<-PATTERN
+          (send
+            $(send _ ${:downcase :upcase})
+            ${:== :eql? :!=}
+            $(send _ ${:downcase :upcase}))
+        PATTERN
+
         def on_send(node)
           return if part_of_ignored_node?(node)
 
@@ -46,17 +53,19 @@ module RuboCop
         end
 
         def autocorrect(node)
-          downcase_eq(node) do
+          if downcase_downcase(node)
+            receiver, method, rhs = *node
+            arg, = *rhs
+          elsif downcase_eq(node)
             receiver, method, arg = *node
-            variable, = *receiver
-            return correction(node, receiver, method, arg, variable)
-          end
-
-          eq_downcase(node) do
+          elsif eq_downcase(node)
             arg, method, receiver = *node
-            variable, = *receiver
-            return correction(node, receiver, method, arg, variable)
+          else
+            return
           end
+
+          variable, = *receiver
+          correction(node, receiver, method, arg, variable)
         end
 
         private

data/lib/rubocop/cop/performance/compare_with_block.rb

@@ -24,6 +24,8 @@ module RuboCop
       #   array.min_by(&:foo)
       #   array.sort_by { |a| a[:foo] }
       class CompareWithBlock < Cop
+        include RangeHelp
+
         MSG = 'Use `%<compare_method>s_by%<instead>s` instead of ' \
               '`%<compare_method>s { |%<var_a>s, %<var_b>s| %<str_a>s ' \
               '<=> %<str_b>s }`.'.freeze

data/lib/rubocop/cop/performance/count.rb

@@ -39,6 +39,7 @@ module RuboCop
       #   Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }
       class Count < Cop
         include SafeMode
+        include RangeHelp
 
         MSG = 'Use `count` instead of `%<selector>s...%<counter>s`.'.freeze
 

data/lib/rubocop/cop/performance/fixed_size.rb

@@ -4,6 +4,47 @@ module RuboCop
   module Cop
     module Performance
       # Do not compute the size of statically sized objects.
+      #
+      # @example
+      #   # String methods
+      #   # bad
+      #   'foo'.size
+      #   %q[bar].count
+      #   %(qux).length
+      #
+      #   # Symbol methods
+      #   # bad
+      #   :fred.size
+      #   :'baz'.length
+      #
+      #   # Array methods
+      #   # bad
+      #   [1, 2, thud].count
+      #   %W(1, 2, bar).size
+      #
+      #   # Hash methods
+      #   # bad
+      #   { a: corge, b: grault }.length
+      #
+      #   # good
+      #   foo.size
+      #   bar.count
+      #   qux.length
+      #
+      #   # good
+      #   :"#{fred}".size
+      #   CONST = :baz.length
+      #
+      #   # good
+      #   [1, 2, *thud].count
+      #   garply = [1, 2, 3]
+      #   garly.size
+      #
+      #   # good
+      #   { a: corge, **grault }.length
+      #   waldo = { a: corge, b: grault }
+      #   waldo.size
+      #
       class FixedSize < Cop
         MSG = 'Do not compute the size of statically sized objects.'.freeze
 

data/lib/rubocop/cop/performance/flat_map.rb

@@ -15,6 +15,8 @@ module RuboCop
       #   [1, 2, 3, 4].map { |e| [e, e] }.flatten
       #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten
       class FlatMap < Cop
+        include RangeHelp
+
         MSG = 'Use `flat_map` instead of `%<method>s...%<flatten>s`.'.freeze
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
                                   'and `flatten` can be used to flatten ' \

data/lib/rubocop/cop/performance/lstrip_rstrip.rb

@@ -14,6 +14,8 @@ module RuboCop
       #   # good
       #   'abc'.strip
       class LstripRstrip < Cop
+        include RangeHelp
+
         MSG = 'Use `strip` instead of `%<methods>s`.'.freeze
 
         def_node_matcher :lstrip_rstrip, <<-PATTERN

data/lib/rubocop/cop/performance/redundant_merge.rb

@@ -118,7 +118,7 @@ module RuboCop
         end
 
         def max_key_value_pairs
-          cop_config['MaxKeyValuePairs'].to_i
+          Integer(cop_config['MaxKeyValuePairs'])
         end
 
         # A utility class for checking the use of values within an

data/lib/rubocop/cop/performance/redundant_sort_by.rb

@@ -16,6 +16,8 @@ module RuboCop
       #   # good
       #   array.sort
       class RedundantSortBy < Cop
+        include RangeHelp
+
         MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'.freeze
 
         def_node_matcher :redundant_sort_by, <<-PATTERN

data/lib/rubocop/cop/performance/regexp_match.rb

@@ -154,6 +154,10 @@ module RuboCop
         def last_match_used?(match_node)
           scope_root = scope_root(match_node)
           body = scope_root ? scope_body(scope_root) : match_node.ancestors.last
+
+          return true if match_node.parent.if_type? &&
+                         match_node.parent.modifier_form?
+
           match_node_pos = match_node.loc.expression.begin_pos
 
           next_match_pos = next_match_pos(body, match_node_pos, scope_root)

data/lib/rubocop/cop/performance/reverse_each.rb

@@ -13,6 +13,8 @@ module RuboCop
       #   # good
       #   [].reverse_each
       class ReverseEach < Cop
+        include RangeHelp
+
         MSG = 'Use `reverse_each` instead of `reverse.each`.'.freeze
         UNDERSCORE = '_'.freeze
 

data/lib/rubocop/cop/performance/string_replacement.rb

@@ -19,6 +19,8 @@ module RuboCop
       #   'abc'.tr('b', 'd')
       #   'a b c'.delete(' ')
       class StringReplacement < Cop
+        include RangeHelp
+
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
         DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/
         DELETE = 'delete'.freeze