rubocop 0.51.0 → 0.87.0

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

@@ -7,31 +7,41 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   def set_attribute(value) ...
+      #   def set_attribute(value)
+      #   end
       #
       #   # good
       #   def attribute=(value)
+      #   end
       #
       #   # bad
-      #   def get_attribute ...
+      #   def get_attribute
+      #   end
       #
       #   # good
-      #   def attribute ...
+      #   def attribute
+      #   end
       class AccessorMethodName < Cop
+        MSG_READER = 'Do not prefix reader method names with `get_`.'
+        MSG_WRITER = 'Do not prefix writer method names with `set_`.'
+
         def on_def(node)
-          msg =
-            if bad_reader_name?(node)
-              'Do not prefix reader method names with `get_`.'
-            elsif bad_writer_name?(node)
-              'Do not prefix writer method names with `set_`.'
-            end
+          return unless bad_reader_name?(node) || bad_writer_name?(node)
 
-          add_offense(node, location: :name, message: msg) if msg
+          add_offense(node, location: :name)
         end
         alias on_defs on_def
 
         private
 
+        def message(node)
+          if bad_reader_name?(node)
+            MSG_READER
+          elsif bad_writer_name?(node)
+            MSG_WRITER
+          end
+        end
+
         def bad_reader_name?(node)
           node.method_name.to_s.start_with?('get_') && !node.arguments?
         end

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

@@ -1,21 +1,79 @@
 # frozen_string_literal: true
 
+# rubocop:disable Style/AsciiComments
+
 module RuboCop
   module Cop
     module Naming
-      # This cop checks for non-ascii characters in identifier names.
+      # This cop checks for non-ascii characters in identifier and constant names.
+      # Identifiers are always checked and whether constants are checked
+      # can be controlled using AsciiConstants config.
+      #
+      # @example
+      #   # bad
+      #   def καλημερα # Greek alphabet (non-ascii)
+      #   end
+      #
+      #   # bad
+      #   def こんにちはと言う # Japanese character (non-ascii)
+      #   end
+      #
+      #   # bad
+      #   def hello_🍣 # Emoji (non-ascii)
+      #   end
+      #
+      #   # good
+      #   def say_hello
+      #   end
+      #
+      #   # bad
+      #   신장 = 10 # Hangul character (non-ascii)
+      #
+      #   # good
+      #   height = 10
+      #
+      #   # bad
+      #   params[:عرض_gteq] # Arabic character (non-ascii)
+      #
+      #   # good
+      #   params[:width_gteq]
+      #
+      # @example AsciiConstants: true (default)
+      #   # bad
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
+      # @example AsciiConstants: false
+      #   # good
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
       class AsciiIdentifiers < Cop
-        MSG = 'Use only ascii symbols in identifiers.'.freeze
+        include RangeHelp
+
+        IDENTIFIER_MSG = 'Use only ascii symbols in identifiers.'
+        CONSTANT_MSG   = 'Use only ascii symbols in constants.'
 
         def investigate(processed_source)
-          processed_source.tokens.each do |token|
-            next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
-            add_offense(token, location: first_offense_range(token))
+          processed_source.each_token do |token|
+            next if !should_check?(token) || token.text.ascii_only?
+
+            message = token.type == :tIDENTIFIER ? IDENTIFIER_MSG : CONSTANT_MSG
+            add_offense(token, location: first_offense_range(token), message: message)
           end
         end
 
         private
 
+        def should_check?(token)
+          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)
@@ -34,3 +92,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Style/AsciiComments

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

@@ -14,26 +14,28 @@ module RuboCop
       #   # good
       #   def +(other); end
       class BinaryOperatorParameterName < Cop
-        MSG = 'When defining the `%s` operator, ' \
-              'name its argument `other`.'.freeze
+        MSG = 'When defining the `%<opr>s` operator, ' \
+              'name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
-        BLACKLISTED = %i[+@ -@ [] []= << `].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === `].freeze
 
-        def_node_matcher :op_method_candidate?, <<-PATTERN
-          (def $_ (args $(arg [!:other !:_other])) _)
+        def_node_matcher :op_method_candidate?, <<~PATTERN
+          (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
         PATTERN
 
         def on_def(node)
           op_method_candidate?(node) do |name, arg|
-            return unless op_method?(name)
-            add_offense(arg, message: format(MSG, name))
+            add_offense(arg, message: format(MSG, opr: name))
           end
         end
 
+        private
+
         def op_method?(name)
-          return false if BLACKLISTED.include?(name)
-          name !~ /\A\w/ || OP_LIKE_METHODS.include?(name)
+          return false if EXCLUDED.include?(name)
+
+          !/\A\w/.match?(name) || OP_LIKE_METHODS.include?(name)
         end
       end
     end

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

@@ -0,0 +1,49 @@
+# 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 permitted names that will never register an
+      # offense. The `ForbiddenNames` config option takes an array of
+      # restricted 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 BlockParameterName < 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/class_and_module_camel_case.rb

@@ -3,26 +3,40 @@
 module RuboCop
   module Cop
     module Naming
-      # This cops checks for class and module names with
+      # This cop checks for class and module names with
       # an underscore in them.
+      #
+      # `AllowedNames` config takes an array of permitted names.
+      # Its default value is `['module_parent']`.
+      # These names can be full class/module names or part of the name.
+      # eg. Adding `my_class` to the `AllowedNames` config will allow names like
+      # `my_class`, `my_class::User`, `App::my_class`, `App::my_class::User`, etc.
+      #
+      # @example
+      #   # bad
+      #   class My_Class
+      #   end
+      #   module My_Module
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #   end
+      #   module MyModule
+      #   end
+      #   class module_parent::MyModule
+      #   end
       class ClassAndModuleCamelCase < Cop
-        MSG = 'Use CamelCase for classes and modules.'.freeze
+        MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
-          check_name(node)
-        end
-
-        def on_module(node)
-          check_name(node)
-        end
-
-        private
-
-        def check_name(node)
-          name = node.loc.name.source
+          allowed = /#{cop_config['AllowedNames'].join('|')}/
+          name = node.loc.name.source.gsub(allowed, '')
+          return unless /_/.match?(name)
 
-          add_offense(node, location: :name) if name =~ /_/
+          add_offense(node, location: :name)
         end
+        alias on_module on_class
       end
     end
   end

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

@@ -8,20 +8,73 @@ module RuboCop
       #
       # To avoid false positives, it ignores cases in which we cannot know
       # for certain the type of value that would be assigned to a constant.
+      #
+      # @example
+      #   # bad
+      #   InchInCm = 2.54
+      #   INCHinCM = 2.54
+      #   Inch_In_Cm = 2.54
+      #
+      #   # good
+      #   INCH_IN_CM = 2.54
       class ConstantName < Cop
-        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'.freeze
-        SNAKE_CASE = /^[\dA-Z_]+$/
+        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'
+        # Use POSIX character classes, so we allow accented characters rather
+        # than just standard ASCII characters
+        SNAKE_CASE = /^[[:digit:][:upper:]_]+$/.freeze
+
+        def_node_matcher :class_or_struct_return_method?, <<~PATTERN
+          (send
+            (const _ {:Class :Struct}) :new
+            ...)
+        PATTERN
 
         def on_casgn(node)
-          _scope, const_name, value = *node
+          if node.parent&.or_asgn_type?
+            lhs, value = *node.parent
+            _scope, const_name = *lhs
+          else
+            _scope, const_name, value = *node
+          end
 
           # We cannot know the result of method calls like
           # NewClass = something_that_returns_a_class
-          # It's also ok to assign a class constant another class constant
+          # It's also ok to assign a class constant another class constant,
+          # `Class.new(...)` or `Struct.new(...)`
           # SomeClass = SomeOtherClass
-          return if value && %i[send block const].include?(value.type)
+          # SomeClass = Class.new(...)
+          # SomeClass = Struct.new(...)
+          return if allowed_assignment?(value)
+          return if SNAKE_CASE.match?(const_name)
+
+          add_offense(node, location: :name)
+        end
+
+        private
+
+        def allowed_assignment?(value)
+          value && %i[block const casgn].include?(value.type) ||
+            allowed_method_call_on_rhs?(value) ||
+            class_or_struct_return_method?(value) ||
+            allowed_conditional_expression_on_rhs?(value)
+        end
+
+        def allowed_method_call_on_rhs?(node)
+          node&.send_type? &&
+            (node.receiver.nil? || !literal_receiver?(node))
+        end
+
+        def_node_matcher :literal_receiver?, <<~PATTERN
+          {(send literal? ...)
+           (send (begin literal?) ...)}
+        PATTERN
+
+        def allowed_conditional_expression_on_rhs?(node)
+          node&.if_type? && contains_contant?(node)
+        end
 
-          add_offense(node, location: :name) if const_name !~ SNAKE_CASE
+        def contains_contant?(node)
+          node.branches.any?(&:const_type?)
         end
       end
     end

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

@@ -8,18 +8,37 @@ module RuboCop
       # This cop makes sure that Ruby source files have snake_case
       # names. Ruby scripts (i.e. source files with a shebang in the
       # first line) are ignored.
+      #
+      # The cop also ignores `.gemspec` files, because Bundler
+      # recommends using dashes to separate namespaces in nested gems
+      # (i.e. `bundler-console` becomes `Bundler::Console`). As such, the
+      # gemspec is supposed to be named `bundler-console.gemspec`.
+      #
+      # @example
+      #   # bad
+      #   lib/layoutManager.rb
+      #
+      #   anything/usingCamelCase
+      #
+      #   # good
+      #   lib/layout_manager.rb
+      #
+      #   anything/using_snake_case.rake
       class FileName < Cop
-        MSG_SNAKE_CASE = 'The name of this source file (`%s`) ' \
-                         'should use snake_case.'.freeze
-        MSG_NO_DEFINITION = '%s should define a class or module ' \
-                            'called `%s`.'.freeze
-        MSG_REGEX = '`%s` should match `%s`.'.freeze
+        include RangeHelp
 
-        SNAKE_CASE = /^[\da-z_.?!]+$/
+        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 = /^[\da-z_.?!]+$/.freeze
 
         def investigate(processed_source)
-          file_path = processed_source.buffer.name
-          return if config.file_to_include?(file_path)
+          file_path = processed_source.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(nil, location: range, message: msg)
@@ -30,42 +49,54 @@ module RuboCop
 
         def for_bad_filename(file_path)
           basename = File.basename(file_path)
-          msg = if filename_good?(basename)
-                  return unless expect_matching_definition?
-                  return if find_class_or_module(processed_source.ast,
-                                                 to_namespace(file_path))
 
-                  no_definition_message(basename, file_path)
-                else
-                  return if ignore_executable_scripts? && shebang?(first_line)
-                  other_message(basename)
-                end
+          if filename_good?(basename)
+            msg = perform_class_and_module_naming_checks(file_path, basename)
+          else
+            msg = other_message(basename) unless bad_filename_allowed?
+          end
+
+          yield source_range(processed_source.buffer, 1, 0), msg if msg
+        end
+
+        def perform_class_and_module_naming_checks(file_path, basename)
+          return unless expect_matching_definition?
+
+          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)
+          end
+          msg
+        end
+
+        def matching_definition?(file_path)
+          find_class_or_module(processed_source.ast, to_namespace(file_path))
+        end
 
-          yield source_range(processed_source.buffer, 1, 0), msg
+        def matching_class?(file_name)
+          find_class_or_module(processed_source.ast, to_namespace(file_name))
         end
 
-        def first_line
-          processed_source.lines.first
+        def bad_filename_allowed?
+          ignore_executable_scripts? && processed_source.start_with?('#!')
         end
 
         def no_definition_message(basename, file_path)
           format(MSG_NO_DEFINITION,
-                 basename,
-                 to_namespace(file_path).join('::'))
+                 basename: basename,
+                 namespace: to_namespace(file_path).join('::'))
         end
 
         def other_message(basename)
           if regex
-            format(MSG_REGEX, basename, regex)
+            format(MSG_REGEX, basename: basename, regex: regex)
           else
-            format(MSG_SNAKE_CASE, basename)
+            format(MSG_SNAKE_CASE, basename: basename)
           end
         end
 
-        def shebang?(line)
-          line && line.start_with?('#!')
-        end
-
         def ignore_executable_scripts?
           cop_config['IgnoreExecutableScripts']
         end
@@ -74,6 +105,10 @@ module RuboCop
           cop_config['ExpectMatchingDefinition']
         end
 
+        def check_definition_path_hierarchy?
+          cop_config['CheckDefinitionPathHierarchy']
+        end
+
         def regex
           cop_config['Regex']
         end
@@ -83,11 +118,14 @@ module RuboCop
         end
 
         def filename_good?(basename)
-          basename = basename.sub(/\.[^\.]+$/, '')
-          basename =~ (regex || SNAKE_CASE)
+          basename = basename.sub(/^\./, '')
+          basename = basename.sub(/\.[^.]+$/, '')
+          # special handling for Action Pack Variants file names like
+          # some_file.xlsx+mobile.axlsx
+          basename = basename.sub('+', '_')
+          basename.match?(regex || SNAKE_CASE)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def find_class_or_module(node, namespace)
           return nil unless node
 
@@ -106,7 +144,6 @@ module RuboCop
 
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def match_namespace(node, namespace, expected)
           match_partial = partial_matcher!(expected)
@@ -115,6 +152,7 @@ module RuboCop
 
           node.each_ancestor(:class, :module, :sclass, :casgn) do |ancestor|
             return false if ancestor.sclass_type?
+
             match_partial.call(ancestor.defined_module)
           end
 
@@ -128,9 +166,7 @@ module RuboCop
 
               namespace, name = *namespace
 
-              if name == expected.last || match_acronym?(expected.last, name)
-                expected.pop
-              end
+              expected.pop if name == expected.last || match_acronym?(expected.last, name)
             end
 
             false
@@ -155,7 +191,7 @@ module RuboCop
           # To convert a pathname to a Ruby namespace, we need a starting point
           # But RC can be run from any working directory, and can check any path
           # We can't assume that the working directory, or any other, is the
-          # "starting point" to build a namespace
+          # "starting point" to build a namespace.
           start = %w[lib spec test src]
           start_index = nil
 

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

@@ -6,38 +6,32 @@ module RuboCop
       # This cop checks that your heredocs are using the configured case.
       # By default it is configured to enforce uppercase heredocs.
       #
-      # @example
-      #
-      #   # EnforcedStyle: uppercase (default)
+      # @example EnforcedStyle: uppercase (default)
+      #   # bad
+      #   <<-sql
+      #     SELECT * FROM foo
+      #   sql
       #
       #   # good
       #   <<-SQL
       #     SELECT * FROM foo
       #   SQL
       #
+      # @example EnforcedStyle: lowercase
       #   # bad
-      #   <<-sql
+      #   <<-SQL
       #     SELECT * FROM foo
-      #   sql
-      #
-      # @example
-      #
-      #   # EnforcedStyle: lowercase
+      #   SQL
       #
       #   # good
       #   <<-sql
       #     SELECT * FROM foo
       #   sql
-      #
-      #   # bad
-      #   <<-SQL
-      #     SELECT * FROM foo
-      #   SQL
       class HeredocDelimiterCase < Cop
         include Heredoc
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use %s heredoc delimiters.'.freeze
+        MSG = 'Use %<style>s heredoc delimiters.'
 
         def on_heredoc(node)
           return if correct_case_delimiters?(node)
@@ -48,7 +42,7 @@ module RuboCop
         private
 
         def message(_node)
-          format(MSG, style)
+          format(MSG, style: style)
         end
 
         def correct_case_delimiters?(node)

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

@@ -5,7 +5,7 @@ module RuboCop
     module Naming
       # This cop checks that your heredocs are using meaningful delimiters.
       # By default it disallows `END` and `EO*`, and can be configured through
-      # blacklisting additional delimiters.
+      # forbidden listing additional delimiters.
       #
       # @example
       #
@@ -26,7 +26,7 @@ module RuboCop
       class HeredocDelimiterNaming < Cop
         include Heredoc
 
-        MSG = 'Use meaningful heredoc delimiters.'.freeze
+        MSG = 'Use meaningful heredoc delimiters.'
 
         def on_heredoc(node)
           return if meaningful_delimiters?(node)
@@ -37,21 +37,17 @@ module RuboCop
         private
 
         def meaningful_delimiters?(node)
-          delimiters = delimiters(node)
+          delimiters = delimiter_string(node)
 
-          return false unless delimiters =~ /\w/
+          return false unless /\w/.match?(delimiters)
 
-          blacklisted_delimiters.none? do |blacklisted_delimiter|
-            delimiters =~ Regexp.new(blacklisted_delimiter)
+          forbidden_delimiters.none? do |forbidden_delimiter|
+            Regexp.new(forbidden_delimiter).match?(delimiters)
           end
         end
 
-        def delimiters(node)
-          node.source.match(OPENING_DELIMITER).captures.first
-        end
-
-        def blacklisted_delimiters
-          cop_config['Blacklist'] || []
+        def forbidden_delimiters
+          cop_config['ForbiddenDelimiters'] || []
         end
       end
     end