rubocop 0.78.0

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  module Cop
+    module Naming
+      # 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
+        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_REGEX = '`%<basename>s` should match `%<regex>s`.'
+
+        SNAKE_CASE = /^[\da-z_.?!]+$/.freeze
+
+        def investigate(processed_source)
+          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)
+          end
+        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?
+
+                  other_message(basename)
+                end
+
+          yield source_range(processed_source.buffer, 1, 0), 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 bad_filename_allowed?
+          ignore_executable_scripts? && processed_source.start_with?('#!')
+        end
+
+        def no_definition_message(basename, file_path)
+          format(MSG_NO_DEFINITION,
+                 basename: basename,
+                 namespace: to_namespace(file_path).join('::'))
+        end
+
+        def other_message(basename)
+          if regex
+            format(MSG_REGEX, basename: basename, regex: regex)
+          else
+            format(MSG_SNAKE_CASE, basename: basename)
+          end
+        end
+
+        def ignore_executable_scripts?
+          cop_config['IgnoreExecutableScripts']
+        end
+
+        def expect_matching_definition?
+          cop_config['ExpectMatchingDefinition']
+        end
+
+        def regex
+          cop_config['Regex']
+        end
+
+        def allowed_acronyms
+          cop_config['AllowedAcronyms'] || []
+        end
+
+        def filename_good?(basename)
+          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)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def find_class_or_module(node, namespace)
+          return nil unless node
+
+          name = namespace.pop
+
+          on_node(%i[class module casgn], node) do |child|
+            next unless (const = child.defined_module)
+
+            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)
+
+            return node
+          end
+
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def match_namespace(node, namespace, expected)
+          match_partial = partial_matcher!(expected)
+
+          match_partial.call(namespace)
+
+          node.each_ancestor(:class, :module, :sclass, :casgn) do |ancestor|
+            return false if ancestor.sclass_type?
+
+            match_partial.call(ancestor.defined_module)
+          end
+
+          match?(expected)
+        end
+
+        def partial_matcher!(expected)
+          lambda do |namespace|
+            while namespace
+              return match?(expected) if namespace.cbase_type?
+
+              namespace, name = *namespace
+
+              if name == expected.last || match_acronym?(expected.last, name)
+                expected.pop
+              end
+            end
+
+            false
+          end
+        end
+
+        def match?(expected)
+          expected.empty? || expected == [:Object]
+        end
+
+        def match_acronym?(expected, name)
+          expected = expected.to_s
+          name = name.to_s
+
+          allowed_acronyms.any? do |acronym|
+            expected.gsub(acronym.capitalize, acronym) == name
+          end
+        end
+
+        def to_namespace(path)
+          components = Pathname(path).each_filename.to_a
+          # 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.
+          start = %w[lib spec test src]
+          start_index = nil
+
+          # To find the closest namespace root take the path components, and
+          # then work through them backwards until we find a candidate. This
+          # makes sure we work from the actual root in the case of a path like
+          # /home/user/src/project_name/lib.
+          components.reverse.each_with_index do |c, i|
+            if start.include?(c)
+              start_index = components.size - i
+              break
+            end
+          end
+
+          if start_index.nil?
+            [to_module_name(components.last)]
+          else
+            components[start_index..-1].map { |c| to_module_name(c) }
+          end
+        end
+
+        def to_module_name(basename)
+          words = basename.sub(/\..*/, '').split('_')
+          words.map(&:capitalize).join.to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks that your heredocs are using the configured case.
+      # By default it is configured to enforce uppercase heredocs.
+      #
+      # @example EnforcedStyle: uppercase (default)
+      #   # bad
+      #   <<-sql
+      #     SELECT * FROM foo
+      #   sql
+      #
+      #   # good
+      #   <<-SQL
+      #     SELECT * FROM foo
+      #   SQL
+      #
+      # @example EnforcedStyle: lowercase
+      #   # bad
+      #   <<-SQL
+      #     SELECT * FROM foo
+      #   SQL
+      #
+      #   # good
+      #   <<-sql
+      #     SELECT * FROM foo
+      #   sql
+      class HeredocDelimiterCase < Cop
+        include Heredoc
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use %<style>s heredoc delimiters.'
+
+        def on_heredoc(node)
+          return if correct_case_delimiters?(node)
+
+          add_offense(node, location: :heredoc_end)
+        end
+
+        private
+
+        def message(_node)
+          format(MSG, style: style)
+        end
+
+        def correct_case_delimiters?(node)
+          delimiter_string(node) == correct_delimiters(node)
+        end
+
+        def correct_delimiters(node)
+          if style == :uppercase
+            delimiter_string(node).upcase
+          else
+            delimiter_string(node).downcase
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks that your heredocs are using meaningful delimiters.
+      # By default it disallows `END` and `EO*`, and can be configured through
+      # forbidden listing additional delimiters.
+      #
+      # @example
+      #
+      #   # good
+      #   <<-SQL
+      #     SELECT * FROM foo
+      #   SQL
+      #
+      #   # bad
+      #   <<-END
+      #     SELECT * FROM foo
+      #   END
+      #
+      #   # bad
+      #   <<-EOS
+      #     SELECT * FROM foo
+      #   EOS
+      class HeredocDelimiterNaming < Cop
+        include Heredoc
+
+        MSG = 'Use meaningful heredoc delimiters.'
+
+        def on_heredoc(node)
+          return if meaningful_delimiters?(node)
+
+          add_offense(node, location: :heredoc_end)
+        end
+
+        private
+
+        def meaningful_delimiters?(node)
+          delimiters = delimiter_string(node)
+
+          return false unless delimiters =~ /\w/
+
+          forbidden_delimiters.none? do |forbidden_delimiter|
+            delimiters =~ Regexp.new(forbidden_delimiter)
+          end
+        end
+
+        def forbidden_delimiters
+          cop_config['ForbiddenDelimiters'] || []
+        end
+      end
+    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 referencd 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 < Cop
+        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(node, location: 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