rubocop 0.52.1 → 0.93.1

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

@@ -9,6 +9,11 @@ module RuboCop
       # 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
@@ -19,21 +24,24 @@ 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.'.freeze
+                         'should use snake_case.'
         MSG_NO_DEFINITION = '%<basename>s should define a class or module ' \
-                            'called `%<namespace>s`.'.freeze
-        MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'.freeze
+                            'called `%<namespace>s`.'
+        MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
 
-        SNAKE_CASE = /^[\da-z_.?!]+$/
+        SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
-        def investigate(processed_source)
-          file_path = processed_source.buffer.name
-          return if config.file_to_include?(file_path)
+        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)
 
           for_bad_filename(file_path) do |range, msg|
-            add_offense(nil, location: range, message: msg)
+            add_offense(range, message: msg)
           end
         end
 
@@ -41,22 +49,38 @@ 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
+          yield source_range(processed_source.buffer, 1, 0), msg if msg
         end
 
-        def first_line
-          processed_source.lines.first
+        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
+
+        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
 
         def no_definition_message(basename, file_path)
@@ -73,10 +97,6 @@ module RuboCop
           end
         end
 
-        def shebang?(line)
-          line && line.start_with?('#!')
-        end
-
         def ignore_executable_scripts?
           cop_config['IgnoreExecutableScripts']
         end
@@ -85,6 +105,10 @@ module RuboCop
           cop_config['ExpectMatchingDefinition']
         end
 
+        def check_definition_path_hierarchy?
+          cop_config['CheckDefinitionPathHierarchy']
+        end
+
         def regex
           cop_config['Regex']
         end
@@ -94,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
 
@@ -117,7 +144,6 @@ module RuboCop
 
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def match_namespace(node, namespace, expected)
           match_partial = partial_matcher!(expected)
@@ -126,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
 
@@ -139,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
@@ -166,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

@@ -27,16 +27,16 @@ module RuboCop
       #   <<-sql
       #     SELECT * FROM foo
       #   sql
-      class HeredocDelimiterCase < Cop
+      class HeredocDelimiterCase < Base
         include Heredoc
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use %<style>s heredoc delimiters.'.freeze
+        MSG = 'Use %<style>s heredoc delimiters.'
 
         def on_heredoc(node)
           return if correct_case_delimiters?(node)
 
-          add_offense(node, location: :heredoc_end)
+          add_offense(node.loc.heredoc_end)
         end
 
         private

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
       #
@@ -23,35 +23,31 @@ module RuboCop
       #   <<-EOS
       #     SELECT * FROM foo
       #   EOS
-      class HeredocDelimiterNaming < Cop
+      class HeredocDelimiterNaming < Base
         include Heredoc
 
-        MSG = 'Use meaningful heredoc delimiters.'.freeze
+        MSG = 'Use meaningful heredoc delimiters.'
 
         def on_heredoc(node)
           return if meaningful_delimiters?(node)
 
-          add_offense(node, location: :heredoc_end)
+          add_offense(node.loc.heredoc_end)
         end
 
         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

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

@@ -0,0 +1,171 @@
+# 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.
+      #
+      # This cop can be configured with the EnforcedStyleForLeadingUnderscores
+      # directive. It can be configured to allow for memoized instance variables
+      # prefixed with an underscore. Prefixing ivars with an underscore is a
+      # convention that is used to implicitly indicate that an ivar should not
+      # be set or referenced outside of the memoization method.
+      #
+      # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
+      #   # 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 ||= 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
+      #
+      # @example EnforcedStyleForLeadingUnderscores: required
+      #   # bad
+      #   def foo
+      #     @something ||= calculate_expensive_thing
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     @_foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def _foo
+      #     @_foo ||= calculate_expensive_thing
+      #   end
+      #
+      # @example EnforcedStyleForLeadingUnderscores :optional
+      #   # bad
+      #   def foo
+      #     @something ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     @_foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def _foo
+      #     @_foo ||= calculate_expensive_thing
+      #   end
+      class MemoizedInstanceVariableName < Base
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Memoized variable `%<var>s` does not match ' \
+          'method name `%<method>s`. Use `@%<suggested_var>s` instead.'
+        UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
+          'with `_`. Use `@%<suggested_var>s` instead.'
+
+        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(
+            message(ivar_assign.children.first.to_s),
+            var: ivar_assign.children.first.to_s,
+            suggested_var: suggested_var(method_name),
+            method: method_name
+          )
+          add_offense(ivar_assign.source_range, message: msg)
+        end
+        alias on_defs on_def
+
+        private
+
+        def style_parameter_name
+          'EnforcedStyleForLeadingUnderscores'
+        end
+
+        def matches?(method_name, ivar_assign)
+          return true if ivar_assign.nil? || method_name == :initialize
+
+          method_name = method_name.to_s.delete('!?')
+          variable = ivar_assign.children.first
+          variable_name = variable.to_s.sub('@', '')
+
+          variable_name_candidates(method_name).include?(variable_name)
+        end
+
+        def message(variable)
+          variable_name = variable.to_s.sub('@', '')
+
+          return UNDERSCORE_REQUIRED if style == :required &&
+                                        !variable_name.start_with?('_')
+
+          MSG
+        end
+
+        def suggested_var(method_name)
+          suggestion = method_name.to_s.delete('!?')
+
+          style == :required ? "_#{suggestion}" : suggestion
+        end
+
+        def variable_name_candidates(method_name)
+          no_underscore = method_name.sub(/\A_/, '')
+          with_underscore = "_#{method_name}"
+          case style
+          when :required
+            [with_underscore,
+             method_name.start_with?('_') ? method_name : nil].compact
+          when :disallowed
+            [method_name, no_underscore]
+          when :optional
+            [method_name, with_underscore, no_underscore]
+          else
+            raise 'Unreachable'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,15 @@ module RuboCop
       # This cop makes sure that all methods use the configured style,
       # snake_case or camelCase, for their names.
       #
+      # This cop has `IgnoredPatterns` configuration option.
+      #
+      #   Naming/MethodName:
+      #     IgnoredPatterns:
+      #       - '\A\s*onSelectionBulkChange\s*'
+      #       - '\A\s*onSelectionCleared\s*'
+      #
+      # Method names matching patterns are always allowed.
+      #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
       #   def fooBar; end
@@ -19,18 +28,48 @@ module RuboCop
       #
       #   # good
       #   def fooBar; end
-      class MethodName < Cop
+      class MethodName < Base
         include ConfigurableNaming
+        include IgnoredPattern
+        include RangeHelp
+
+        MSG = 'Use %<style>s for method names.'
+
+        def_node_matcher :sym_name, '(sym $_name)'
+        def_node_matcher :str_name, '(str $_name)'
+
+        def on_send(node)
+          return unless (attrs = node.attribute_accessor?)
+
+          attrs.last.each do |name_item|
+            name = attr_name(name_item)
+            next if !name || matches_ignored_pattern?(name)
 
-        MSG = 'Use %<style>s for method names.'.freeze
+            check_name(node, name, range_position(node))
+          end
+        end
 
         def on_def(node)
+          return if node.operator_method? ||
+                    matches_ignored_pattern?(node.method_name)
+
           check_name(node, node.method_name, node.loc.name)
         end
         alias on_defs on_def
 
         private
 
+        def attr_name(name_item)
+          sym_name(name_item) || str_name(name_item)
+        end
+
+        def range_position(node)
+          selector_end_pos = node.loc.selector.end_pos + 1
+          expr_end_pos = node.loc.expression.end_pos
+
+          range_between(selector_end_pos, expr_end_pos)
+        end
+
         def message(style)
           format(MSG, style: style)
         end