rubocop 0.42.0 → 0.52.1

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

@@ -1,20 +1,30 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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_.?!]+$/
 
@@ -23,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
 
@@ -35,10 +45,10 @@ module RuboCop
                   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 cop_config['IgnoreExecutableScripts'] &&
-                            shebang?(first_line)
+                  return if ignore_executable_scripts? && shebang?(first_line)
                   other_message(basename)
                 end
 
@@ -51,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
 
@@ -67,6 +77,10 @@ module RuboCop
           line && line.start_with?('#!')
         end
 
+        def ignore_executable_scripts?
+          cop_config['IgnoreExecutableScripts']
+        end
+
         def expect_matching_definition?
           cop_config['ExpectMatchingDefinition']
         end
@@ -75,38 +89,38 @@ module RuboCop
           cop_config['Regex']
         end
 
+        def allowed_acronyms
+          cop_config['AllowedAcronyms'] || []
+        end
+
         def filename_good?(basename)
           basename = basename.sub(/\.[^\.]+$/, '')
           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([:class, :module, :casgn], node) do |child|
+          on_node(%i[class module casgn], node) do |child|
             next unless (const = child.defined_module)
 
             const_namespace, const_name = *const
-            next unless name == const_name
+            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)
-          expected = expected.dup
-
-          match_partial = lambda do |ns|
-            next if ns.nil?
-            while ns
-              return expected.empty? || expected == [:Object] if ns.cbase_type?
-              ns, name = *ns
-              name == expected.last ? expected.pop : (return false)
-            end
-          end
+          match_partial = partial_matcher!(expected)
 
           match_partial.call(namespace)
 
@@ -115,16 +129,45 @@ module RuboCop
             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 = %w[lib spec test src]
           start_index = nil
 
           # To find the closest namespace root take the path components, and

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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that all variables use the configured style,
+      # snake_case or camelCase, for their names.
+      #
+      # @example EnforcedStyle: snake_case (default)
+      #   # bad
+      #   fooBar = 1
+      #
+      #   # good
+      #   foo_bar = 1
+      #
+      # @example EnforcedStyle: camelCase
+      #   # bad
+      #   foo_bar = 1
+      #
+      #   # good
+      #   fooBar = 1
+      class VariableName < Cop
+        include ConfigurableNaming
+
+        MSG = 'Use %<style>s for variable names.'.freeze
+
+        def on_lvasgn(node)
+          name, = *node
+          return unless name
+          check_name(node, name, node.loc.name)
+        end
+        alias on_ivasgn    on_lvasgn
+        alias on_cvasgn    on_lvasgn
+        alias on_arg       on_lvasgn
+        alias on_optarg    on_lvasgn
+        alias on_restarg   on_lvasgn
+        alias on_kwoptarg  on_lvasgn
+        alias on_kwarg     on_lvasgn
+        alias on_kwrestarg on_lvasgn
+        alias on_blockarg  on_lvasgn
+
+        private
+
+        def message(style)
+          format(MSG, style: style)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that all numbered variables use the
+      # configured style, snake_case, normalcase or non_integer,
+      # for their numbering.
+      #
+      # @example EnforcedStyle: snake_case
+      #   # bad
+      #
+      #   variable1 = 1
+      #
+      #   # good
+      #
+      #   variable_1 = 1
+      #
+      # @example EnforcedStyle: normalcase (default)
+      #   # bad
+      #
+      #   variable_1 = 1
+      #
+      #   # good
+      #
+      #   variable1 = 1
+      #
+      # @example EnforcedStyle: non_integer
+      #   # bad
+      #
+      #   variable1 = 1
+      #
+      #   variable_1 = 1
+      #
+      #   # good
+      #
+      #   variableone = 1
+      #
+      #   variable_one = 1
+      class VariableNumber < Cop
+        include ConfigurableNumbering
+
+        MSG = 'Use %<style>s for variable numbers.'.freeze
+
+        def on_arg(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+        alias on_lvasgn on_arg
+        alias on_ivasgn on_arg
+        alias on_cvasgn on_arg
+
+        private
+
+        def message(style)
+          format(MSG, style: style)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/offense.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,8 +7,8 @@ module RuboCop
       include Comparable
 
       # @api private
-      COMPARISON_ATTRIBUTES = [:line, :column, :cop_name,
-                               :message, :severity].freeze
+      COMPARISON_ATTRIBUTES = %i[line column cop_name
+                                 message severity].freeze
 
       # @api public
       #
@@ -45,7 +44,7 @@ module RuboCop
       # @!attribute [r] cop_name
       #
       # @return [String]
-      #   a cop class name without namespace.
+      #   a cop class name without department.
       #   i.e. type of the violation.
       #
       # @example
@@ -73,7 +72,7 @@ module RuboCop
       # @return [Boolean]
       #   whether this offense is automatically corrected.
       def corrected
-        @status == :unsupported ? nil : @status == :corrected
+        @status == :corrected
       end
       alias corrected? corrected
 
@@ -138,6 +137,11 @@ module RuboCop
         location.last_line
       end
 
+      # @api private
+      def last_column
+        location.last_column
+      end
+
       # @api private
       def column_range
         location.column_range

data/lib/rubocop/cop/performance/caller.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `caller[n]`
+      # can be replaced by `caller(n..n).first`.
+      #
+      # @example
+      #   # bad
+      #   caller[1]
+      #   caller.first
+      #   caller_locations[1]
+      #   caller_locations.first
+      #
+      #   # good
+      #   caller(2..2).first
+      #   caller(1..1).first
+      #   caller_locations(2..2).first
+      #   caller_locations(1..1).first
+      class Caller < Cop
+        MSG_BRACE = 'Use `%<method>s(%<n>d..%<n>d).first`' \
+                    ' instead of `%<method>s[%<m>d]`.'.freeze
+        MSG_FIRST = 'Use `%<method>s(%<n>d..%<n>d).first`' \
+                    ' instead of `%<method>s.first`.'.freeze
+
+        def_node_matcher :slow_caller?, <<-PATTERN
+          {
+            (send nil? {:caller :caller_locations})
+            (send nil? {:caller :caller_locations} int)
+          }
+        PATTERN
+
+        def_node_matcher :caller_with_scope_method?, <<-PATTERN
+          {
+            (send #slow_caller? :first)
+            (send #slow_caller? :[] int)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless caller_with_scope_method?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          method_name = node.receiver.method_name
+          caller_arg = node.receiver.first_argument
+          n = caller_arg ? int_value(caller_arg) : 1
+
+          if node.method_name == :[]
+            m = int_value(node.first_argument)
+            n += m
+            format(MSG_BRACE, n: n, m: m, method: method_name)
+          else
+            format(MSG_FIRST, n: n, method: method_name)
+          end
+        end
+
+        def int_value(node)
+          node.children[0]
+        end
+      end
+    end
+  end
+end