rubocop 0.75.1

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
+      # blacklisting 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/
+
+          blacklisted_delimiters.none? do |blacklisted_delimiter|
+            delimiters =~ Regexp.new(blacklisted_delimiter)
+          end
+        end
+
+        def blacklisted_delimiters
+          cop_config['Blacklist'] || []
+        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

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # 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
+      #
+      #   # good
+      #   def foo_bar; end
+      #
+      # @example EnforcedStyle: camelCase
+      #   # bad
+      #   def foo_bar; end
+      #
+      #   # good
+      #   def fooBar; end
+      class MethodName < Cop
+        include ConfigurableNaming
+        include IgnoredPattern
+
+        MSG = 'Use %<style>s for method names.'
+
+        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 message(style)
+          format(MSG, style: style)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that predicates are named properly.
+      #
+      # @example
+      #   # bad
+      #   def is_even(value)
+      #   end
+      #
+      #   def is_even?(value)
+      #   end
+      #
+      #   # good
+      #   def even?(value)
+      #   end
+      #
+      #   # bad
+      #   def has_value
+      #   end
+      #
+      #   def has_value?
+      #   end
+      #
+      #   # good
+      #   def value?
+      #   end
+      class PredicateName < Cop
+        def_node_matcher :dynamic_method_define, <<~PATTERN
+          (send nil? #method_definition_macros
+            (sym $_)
+            ...)
+        PATTERN
+
+        def on_send(node)
+          dynamic_method_define(node) do |method_name|
+            predicate_prefixes.each do |prefix|
+              next if allowed_method_name?(method_name.to_s, prefix)
+
+              add_offense(
+                node,
+                location: node.first_argument.loc.expression,
+                message: message(method_name,
+                                 expected_name(method_name.to_s, prefix))
+              )
+            end
+          end
+        end
+
+        def on_def(node)
+          predicate_prefixes.each do |prefix|
+            method_name = node.method_name.to_s
+
+            next if allowed_method_name?(method_name, prefix)
+
+            add_offense(
+              node,
+              location: :name,
+              message: message(method_name, expected_name(method_name, prefix))
+            )
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def allowed_method_name?(method_name, prefix)
+          !method_name.match(/^#{prefix}[^0-9]/) ||
+            method_name == expected_name(method_name, prefix) ||
+            method_name.end_with?('=') ||
+            predicate_whitelist.include?(method_name)
+        end
+
+        def expected_name(method_name, prefix)
+          new_name = if prefix_blacklist.include?(prefix)
+                       method_name.sub(prefix, '')
+                     else
+                       method_name.dup
+                     end
+          new_name << '?' unless method_name.end_with?('?')
+          new_name
+        end
+
+        def message(method_name, new_name)
+          "Rename `#{method_name}` to `#{new_name}`."
+        end
+
+        def prefix_blacklist
+          cop_config['NamePrefixBlacklist']
+        end
+
+        def predicate_prefixes
+          cop_config['NamePrefix']
+        end
+
+        def predicate_whitelist
+          cop_config['NameWhitelist']
+        end
+
+        def method_definition_macros(macro_name)
+          cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
+        end
+      end
+    end
+  end
+end