rubocop 0.78.0 → 1.13.0

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

@@ -6,23 +6,27 @@ module RuboCop
     module UncommunicativeName
       CASE_MSG = 'Only use lowercase characters for %<name_type>s.'
       NUM_MSG = 'Do not end %<name_type>s with a number.'
-      LENGTH_MSG = '%<name_type>s must be at least %<min>s ' \
-                   'characters long.'
-      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a ' \
-                      '%<name_type>s.'
+      LENGTH_MSG = '%<name_type>s must be at least %<min>s characters long.'
+      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a %<name_type>s.'
 
       def check(node, args)
         args.each do |arg|
           # Argument names might be "_" or prefixed with "_" to indicate they
           # are unused. Trim away this prefix and only analyse the basename.
-          full_name = arg.children.first.to_s
+          name_child = arg.children.first
+          next if name_child.nil?
+
+          full_name = name_child.to_s
           next if full_name == '_'
 
-          name = full_name.gsub(/\A([_]+)/, '')
-          next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
+          name = full_name.gsub(/\A(_+)/, '')
           next if allowed_names.include?(name)
 
-          range = arg_range(arg, name.size)
+          length = full_name.size
+          length += 1 if arg.restarg_type?
+          length += 2 if arg.kwrestarg_type?
+
+          range = arg_range(arg, length)
           issue_offenses(node, range, name)
         end
       end
@@ -39,37 +43,32 @@ module RuboCop
       end
 
       def case_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(CASE_MSG, name_type: name_type(node)))
+        add_offense(range, message: format(CASE_MSG, name_type: name_type(node)))
       end
 
       def uppercase?(name)
-        name =~ /[[:upper:]]/
+        /[[:upper:]]/.match?(name)
       end
 
       def name_type(node)
-        @name_type ||= begin
-          case node.type
-          when :block then 'block parameter'
-          when :def, :defs then 'method parameter'
-          end
-        end
+        @name_type ||= case node.type
+                       when :block then 'block parameter'
+                       when :def, :defs then 'method parameter'
+                       end
       end
 
       def num_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(NUM_MSG, name_type: name_type(node)))
+        add_offense(range, message: format(NUM_MSG, name_type: name_type(node)))
       end
 
       def ends_with_num?(name)
-        name[-1] =~ /\d/
+        /\d/.match?(name[-1])
       end
 
       def length_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(LENGTH_MSG,
-                                          name_type: name_type(node).capitalize,
-                                          min: min_length))
+        message = format(LENGTH_MSG, name_type: name_type(node).capitalize, min: min_length)
+
+        add_offense(range, message: message)
       end
 
       def long_enough?(name)
@@ -78,17 +77,11 @@ module RuboCop
 
       def arg_range(arg, length)
         begin_pos = arg.source_range.begin_pos
-        Parser::Source::Range.new(processed_source.buffer,
-                                  begin_pos,
-                                  begin_pos + length)
+        Parser::Source::Range.new(processed_source.buffer, begin_pos, begin_pos + length)
       end
 
       def forbidden_offense(node, range, name)
-        add_offense(
-          node,
-          location: range,
-          message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node))
-        )
+        add_offense(range, message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node)))
       end
 
       def allowed_names

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

@@ -7,14 +7,8 @@ module RuboCop
       module UnusedArgument
         extend NodePattern::Macros
 
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
         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
@@ -24,8 +18,10 @@ module RuboCop
           return if variable.referenced?
 
           message = message(variable)
-          add_offense(variable.declaration_node, location: :name,
-                                                 message: message)
+
+          add_offense(variable.declaration_node.loc.name, message: message) do |corrector|
+            autocorrect(corrector, variable.declaration_node)
+          end
         end
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining node visibility.
+    module VisibilityHelp
+      extend NodePattern::Macros
+
+      VISIBILITY_SCOPES = %i[private protected public].freeze
+
+      private
+
+      def node_visibility(node)
+        scope = find_visibility_start(node)
+        scope&.method_name || :public
+      end
+
+      def find_visibility_start(node)
+        node.left_siblings.reverse.find { |sibling| visibility_block?(sibling) }
+      end
+
+      # Navigate to find the last protected method
+      def find_visibility_end(node)
+        possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
+        right = node.right_siblings
+        right.find do |child_node|
+          possible_visibilities.include?(node_visibility(child_node))
+        end || right.last
+      end
+
+      # @!method visibility_block?(node)
+      def_node_matcher :visibility_block?, <<~PATTERN
+        (send nil? { :private :protected :public })
+      PATTERN
+    end
+  end
+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,14 +27,24 @@ module RuboCop
       #   # good
       #   def attribute
       #   end
-      class AccessorMethodName < Cop
+      #
+      #   # 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_`.'
 
         def on_def(node)
           return unless bad_reader_name?(node) || bad_writer_name?(node)
 
-          add_offense(node, location: :name)
+          message = message(node)
+
+          add_offense(node.loc.name, message: message)
         end
         alias on_defs on_def
 

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

@@ -5,7 +5,9 @@
 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
@@ -36,27 +38,46 @@ module RuboCop
       #   # good
       #   params[:width_gteq]
       #
-      class AsciiIdentifiers < Cop
+      # @example AsciiConstants: true (default)
+      #   # bad
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
+      # @example AsciiConstants: false
+      #   # good
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
+      class AsciiIdentifiers < Base
         include RangeHelp
 
-        MSG = 'Use only ascii symbols in identifiers.'
+        IDENTIFIER_MSG = 'Use only ascii symbols in identifiers.'
+        CONSTANT_MSG   = 'Use only ascii symbols in constants.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.each_token do |token|
-            next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
+            next if !should_check?(token) || token.text.ascii_only?
 
-            add_offense(token, location: first_offense_range(token))
+            message = token.type == :tIDENTIFIER ? IDENTIFIER_MSG : CONSTANT_MSG
+            add_offense(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)
 
-          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

@@ -13,29 +13,39 @@ module RuboCop
       #
       #   # good
       #   def +(other); end
-      class BinaryOperatorParameterName < Cop
-        MSG = 'When defining the `%<opr>s` operator, ' \
-              'name its argument `other`.'
+      class BinaryOperatorParameterName < Base
+        extend AutoCorrector
+
+        MSG = 'When defining the `%<opr>s` operator, name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
-        BLACKLISTED = %i[+@ -@ [] []= << === `].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === ` =~].freeze
 
+        # @!method op_method_candidate?(node)
         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|
-            add_offense(arg, message: format(MSG, opr: name))
+            add_offense(arg, message: format(MSG, opr: name)) do |corrector|
+              corrector.replace(arg, 'other')
+              node.each_descendant(:lvar, :lvasgn) do |lvar|
+                lvar_location = lvar.loc.name
+                next unless lvar_location.source == arg.source
+
+                corrector.replace(lvar_location, 'other')
+              end
+            end
           end
         end
 
         private
 
         def op_method?(name)
-          return false if BLACKLISTED.include?(name)
+          return false if EXCLUDED.include?(name)
 
-          name !~ /\A\w/ || OP_LIKE_METHODS.include?(name)
+          !/\A[[:word:]]/.match?(name) || OP_LIKE_METHODS.include?(name)
         end
       end
     end

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

@@ -35,7 +35,7 @@ module RuboCop
       #   foo { |speed, distance| speed * distance }
       #
       #   baz { |age, height, gender| do_stuff(age, height, gender) }
-      class BlockParameterName < Cop
+      class BlockParameterName < Base
         include UncommunicativeName
 
         def on_block(node)

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

@@ -6,6 +6,12 @@ module RuboCop
       # 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
@@ -18,13 +24,17 @@ module RuboCop
       #   end
       #   module MyModule
       #   end
-      class ClassAndModuleCamelCase < Cop
+      #   class module_parent::MyModule
+      #   end
+      class ClassAndModuleCamelCase < Base
         MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
-          return unless 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)
+          add_offense(node.loc.name)
         end
         alias on_module on_class
       end

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

@@ -17,12 +17,13 @@ module RuboCop
       #
       #   # good
       #   INCH_IN_CM = 2.54
-      class ConstantName < Cop
+      class ConstantName < Base
         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
 
+        # @!method class_or_struct_return_method?(node)
         def_node_matcher :class_or_struct_return_method?, <<~PATTERN
           (send
             (const _ {:Class :Struct}) :new
@@ -45,8 +46,9 @@ module RuboCop
           # SomeClass = Class.new(...)
           # SomeClass = Struct.new(...)
           return if allowed_assignment?(value)
+          return if SNAKE_CASE.match?(const_name)
 
-          add_offense(node, location: :name) if const_name !~ SNAKE_CASE
+          add_offense(node.loc.name)
         end
 
         private
@@ -63,6 +65,7 @@ module RuboCop
             (node.receiver.nil? || !literal_receiver?(node))
         end
 
+        # @!method literal_receiver?(node)
         def_node_matcher :literal_receiver?, <<~PATTERN
           {(send literal? ...)
            (send (begin literal?) ...)}

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

@@ -24,50 +24,55 @@ module RuboCop
       #   lib/layout_manager.rb
       #
       #   anything/using_snake_case.rake
-      class FileName < Cop
+      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 = /^[\da-z_.?!]+$/.freeze
+        SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
-        def investigate(processed_source)
+        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(nil, location: range, message: msg)
-          end
+          for_bad_filename(file_path) { |range, msg| add_offense(range, message: msg) }
         end
 
         private
 
         def for_bad_filename(file_path)
           basename = File.basename(file_path)
-          msg = if filename_good?(basename)
-                  return if matching_definition?(file_path)
 
-                  no_definition_message(basename, file_path)
-                else
-                  return if bad_filename_allowed?
+          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
 
-                  other_message(basename)
-                end
+        def perform_class_and_module_naming_checks(file_path, basename)
+          return unless expect_matching_definition?
 
-          yield source_range(processed_source.buffer, 1, 0), msg
+          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)
-          return true unless expect_matching_definition?
-
           find_class_or_module(processed_source.ast, to_namespace(file_path))
         end
 
+        def matching_class?(file_name)
+          find_class_or_module(processed_source.ast, to_namespace(file_name))
+        end
+
         def bad_filename_allowed?
           ignore_executable_scripts? && processed_source.start_with?('#!')
         end
@@ -94,6 +99,10 @@ module RuboCop
           cop_config['ExpectMatchingDefinition']
         end
 
+        def check_definition_path_hierarchy?
+          cop_config['CheckDefinitionPathHierarchy']
+        end
+
         def regex
           cop_config['Regex']
         end
@@ -104,14 +113,13 @@ module RuboCop
 
         def filename_good?(basename)
           basename = basename.sub(/^\./, '')
-          basename = basename.sub(/\.[^\.]+$/, '')
+          basename = basename.sub(/\.[^.]+$/, '')
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx
           basename = basename.sub('+', '_')
-          basename =~ (regex || SNAKE_CASE)
+          basename.match?(regex || SNAKE_CASE)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def find_class_or_module(node, namespace)
           return nil unless node
 
@@ -122,15 +130,13 @@ 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
 
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def match_namespace(node, namespace, expected)
           match_partial = partial_matcher!(expected)
@@ -153,9 +159,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
@@ -170,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)