rubocop 0.49.1 → 0.52.0

data/lib/rubocop/cop/{style/op_method.rb → naming/binary_operator_parameter_name.rb}

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop makes sure that certain binary operator methods have their
       # sole  parameter named `other`.
       #
@@ -13,24 +13,25 @@ module RuboCop
       #
       #   # good
       #   def +(other); end
-      class OpMethod < Cop
-        MSG = 'When defining the `%s` operator, ' \
+      class BinaryOperatorParameterName < Cop
+        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, :expression, 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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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)
+          return unless node.loc.name.source =~ /_/
+
+          add_offense(node, location: :name)
+        end
+        alias on_module on_class
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks whether constant names are written using
+      # SCREAMING_SNAKE_CASE.
+      #
+      # 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
+        # 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,
+          # `Class.new(...)` or `Struct.new(...)`
+          # SomeClass = SomeOtherClass
+          # 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
+end

data/lib/rubocop/cop/{style → naming}/file_name.rb

@@ -4,16 +4,27 @@ require 'pathname'
 
 module RuboCop
   module Cop
-    module Style
+    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.
+      #
+      # @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_.?!]+$/
 
@@ -22,7 +33,7 @@ module RuboCop
           return if config.file_to_include?(file_path)
 
           for_bad_filename(file_path) do |range, msg|
-            add_offense(nil, range, msg)
+            add_offense(nil, location: range, message: msg)
           end
         end
 
@@ -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
 
@@ -87,8 +98,10 @@ module RuboCop
           basename =~ (regex || SNAKE_CASE)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def find_class_or_module(node, namespace)
-          return nil if node.nil?
+          return nil unless node
+
           name = namespace.pop
 
           on_node(%i[class module casgn], node) do |child|
@@ -96,13 +109,15 @@ 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)
 
-            return node if namespace.empty?
-            return node if 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)

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.'.freeze
+
+        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,59 @@
+# 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.'.freeze
+
+        def on_heredoc(node)
+          return if meaningful_delimiters?(node)
+
+          add_offense(node, location: :heredoc_end)
+        end
+
+        private
+
+        def meaningful_delimiters?(node)
+          delimiters = delimiters(node)
+
+          return false unless delimiters =~ /\w/
+
+          blacklisted_delimiters.none? do |blacklisted_delimiter|
+            delimiters =~ Regexp.new(blacklisted_delimiter)
+          end
+        end
+
+        def delimiters(node)
+          node.source.match(OPENING_DELIMITER).captures.first
+        end
+
+        def blacklisted_delimiters
+          cop_config['Blacklist'] || []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# 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.
+      #
+      # @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
+
+        MSG = 'Use %<style>s for method names.'.freeze
+
+        def on_def(node)
+          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,101 @@
+# 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
+      #
+      #   # good
+      #   def even?(value)
+      #   end
+      #
+      #   # bad
+      #   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.start_with?(prefix) ||
+            method_name == expected_name(method_name, prefix) ||
+            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