rubocop 0.51.0 → 0.52.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_`.'.freeze
+        MSG_WRITER = 'Do not prefix writer method names with `set_`.'.freeze
+
         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,9 +1,41 @@
 # frozen_string_literal: true
 
+# rubocop:disable Style/AsciiComments
+
 module RuboCop
   module Cop
     module Naming
       # This cop checks for non-ascii characters in identifier names.
+      #
+      # @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]
+      #
       class AsciiIdentifiers < Cop
         MSG = 'Use only ascii symbols in identifiers.'.freeze
 
@@ -34,3 +66,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Style/AsciiComments

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

@@ -14,23 +14,24 @@ module RuboCop
       #   # good
       #   def +(other); end
       class BinaryOperatorParameterName < Cop
-        MSG = 'When defining the `%s` operator, ' \
+        MSG = 'When defining the `%<opr>s` operator, ' \
               'name its argument `other`.'.freeze
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
         BLACKLISTED = %i[+@ -@ [] []= << `].freeze
 
         def_node_matcher :op_method_candidate?, <<-PATTERN
-          (def $_ (args $(arg [!:other !:_other])) _)
+          (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)

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

@@ -5,24 +5,28 @@ module RuboCop
     module Naming
       # This cops checks for class and module names with
       # an underscore in them.
+      #
+      # @example
+      #   # bad
+      #   class My_Class
+      #   end
+      #   module My_Module
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #   end
+      #   module MyModule
+      #   end
       class ClassAndModuleCamelCase < Cop
         MSG = 'Use CamelCase for classes and modules.'.freeze
 
         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
+          return unless node.loc.name.source =~ /_/
 
-          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,21 +8,50 @@ 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_]+$/
+        # Use POSIX character classes, so we allow accented characters rather
+        # than just standard ASCII characters
+        SNAKE_CASE = /^[[:digit:][:upper:]_]+$/
+
+        def_node_matcher :class_or_struct_return_method?, <<-PATTERN
+          (send
+            (const _ {:Class :Struct}) :new
+            ...)
+        PATTERN
 
         def on_casgn(node)
           _scope, const_name, value = *node
 
           # 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 value && %i[block const casgn].include?(value.type) ||
+                    allowed_method_call_on_rhs?(value) ||
+                    class_or_struct_return_method?(value)
 
           add_offense(node, location: :name) if const_name !~ SNAKE_CASE
         end
+
+        private
+
+        def allowed_method_call_on_rhs?(node)
+          node && node.send_type? &&
+            (node.receiver.nil? || !node.receiver.literal?)
+        end
       end
     end
   end

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

@@ -8,12 +8,23 @@ 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.
+      #
+      # @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`) ' \
+        MSG_SNAKE_CASE = 'The name of this source file (`%<basename>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
+        MSG_NO_DEFINITION = '%<basename>s should define a class or module ' \
+                            'called `%<namespace>s`.'.freeze
+        MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'.freeze
 
         SNAKE_CASE = /^[\da-z_.?!]+$/
 
@@ -50,15 +61,15 @@ module RuboCop
 
         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
 

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.'.freeze
 
         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/method_name.rb

@@ -4,29 +4,35 @@ module RuboCop
   module Cop
     module Naming
       # This cop makes sure that all methods use the configured style,
-      # snake_case or camelCase, for their names. Some special arrangements
-      # have to be made for operator methods.
+      # snake_case or camelCase, for their names.
+      #
+      # @example EnforcedStyle: snake_case (default)
+      #   # bad
+      #   def fooBar; end
+      #
+      #   # good
+      #   def foo_bar; end
+      #
+      # @example EnforcedStyle: camelCase
+      #   # bad
+      #   def foo_bar; end
+      #
+      #   # good
+      #   def fooBar; end
       class MethodName < Cop
         include ConfigurableNaming
 
-        def on_def(node)
-          name, = *node
-          check_name(node, sanitize_name(name), node.loc.name)
-        end
+        MSG = 'Use %<style>s for method names.'.freeze
 
-        def on_defs(node)
-          _object, name, = *node
-          check_name(node, sanitize_name(name), node.loc.name)
+        def on_def(node)
+          check_name(node, node.method_name, node.loc.name)
         end
+        alias on_defs on_def
 
         private
 
         def message(style)
-          format('Use %s for method names.', style)
-        end
-
-        def sanitize_name(name)
-          name.to_s.delete('@').to_sym
+          format(MSG, style: style)
         end
       end
     end

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

@@ -7,16 +7,20 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   def is_even?(value) ...
+      #   def is_even?(value)
+      #   end
       #
       #   # good
       #   def even?(value)
+      #   end
       #
       #   # bad
-      #   def has_value? ...
+      #   def has_value?
+      #   end
       #
       #   # good
-      #   def value? ...
+      #   def value?
+      #   end
       class PredicateName < Cop
         def_node_matcher :dynamic_method_define, <<-PATTERN
           (send nil? #method_definition_macros

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

@@ -5,15 +5,30 @@ module RuboCop
     module Naming
       # This cop makes sure that all variables use the configured style,
       # snake_case or camelCase, for their names.
+      #
+      # @example EnforcedStyle: snake_case (default)
+      #   # bad
+      #   fooBar = 1
+      #
+      #   # good
+      #   foo_bar = 1
+      #
+      # @example EnforcedStyle: camelCase
+      #   # bad
+      #   foo_bar = 1
+      #
+      #   # good
+      #   fooBar = 1
       class VariableName < Cop
         include ConfigurableNaming
 
+        MSG = 'Use %<style>s for variable names.'.freeze
+
         def on_lvasgn(node)
           name, = *node
           return unless name
           check_name(node, name, node.loc.name)
         end
-
         alias on_ivasgn    on_lvasgn
         alias on_cvasgn    on_lvasgn
         alias on_arg       on_lvasgn
@@ -27,7 +42,7 @@ module RuboCop
         private
 
         def message(style)
-          format('Use %s for variable names.', style)
+          format(MSG, style: style)
         end
       end
     end

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

@@ -7,9 +7,7 @@ module RuboCop
       # configured style, snake_case, normalcase or non_integer,
       # for their numbering.
       #
-      # @example
-      #   "EnforcedStyle => 'snake_case'"
-      #
+      # @example EnforcedStyle: snake_case
       #   # bad
       #
       #   variable1 = 1
@@ -18,9 +16,7 @@ module RuboCop
       #
       #   variable_1 = 1
       #
-      # @example
-      #   "EnforcedStyle => 'normalcase'"
-      #
+      # @example EnforcedStyle: normalcase (default)
       #   # bad
       #
       #   variable_1 = 1
@@ -29,48 +25,35 @@ module RuboCop
       #
       #   variable1 = 1
       #
-      # @example
-      #   "EnforcedStyle => 'non_integer'"
-      #
-      #   #bad
+      # @example EnforcedStyle: non_integer
+      #   # bad
       #
       #   variable1 = 1
       #
       #   variable_1 = 1
       #
-      #   #good
+      #   # good
       #
       #   variableone = 1
       #
       #   variable_one = 1
-      #
       class VariableNumber < Cop
         include ConfigurableNumbering
 
-        def on_lvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_ivasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_cvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
+        MSG = 'Use %<style>s for variable numbers.'.freeze
 
         def on_arg(node)
           name, = *node
           check_name(node, name, node.loc.name)
         end
+        alias on_lvasgn on_arg
+        alias on_ivasgn on_arg
+        alias on_cvasgn on_arg
 
         private
 
         def message(style)
-          format('Use %s for variable numbers.', style)
+          format(MSG, style: style)
         end
       end
     end