rubocop 1.5.2 → 1.8.1

data/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb

@@ -112,13 +112,13 @@ module RuboCop
 
         def incorrect_style_detected(token1, token2,
                                      expect_space, is_empty_braces)
-          return unless ambiguous_or_unexpected_style_detected(style, token1.text == token2.text)
-
           brace = (token1.text == '{' ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
+          detected_style = expect_space ? 'no_space' : 'space'
 
           add_offense(range, message: message(brace, is_empty_braces, expect_space)) do |corrector|
             autocorrect(corrector, range)
+            ambiguous_or_unexpected_style_detected(detected_style, token1.text == token2.text)
           end
         end
 

data/lib/rubocop/cop/lint/ambiguous_assignment.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for mistyped shorthand assignments.
+      #
+      # @example
+      #   # bad
+      #   x =- y
+      #   x =+ y
+      #   x =* y
+      #   x =! y
+      #
+      #   # good
+      #   x -= y # or x = -y
+      #   x += y # or x = +y
+      #   x *= y # or x = *y
+      #   x != y # or x = !y
+      #
+      class AmbiguousAssignment < Base
+        include RangeHelp
+
+        MSG = 'Suspicious assignment detected. Did you mean `%<op>s`?'
+
+        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
+
+        MISTAKES = {
+          '=-' => '-=',
+          '=+' => '+=',
+          '=*' => '*=',
+          '=!' => '!='
+        }.freeze
+
+        def on_asgn(node)
+          return unless (rhs = rhs(node))
+
+          range = range_between(node.loc.operator.end_pos - 1, rhs.source_range.begin_pos + 1)
+          source = range.source
+          return unless MISTAKES.key?(source)
+
+          add_offense(range, message: format(MSG, op: MISTAKES[source]))
+        end
+
+        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
+
+        private
+
+        def rhs(node)
+          if node.casgn_type?
+            node.children[2]
+          else
+            node.children[1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb

@@ -17,6 +17,7 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   x / x
       #   x.top >= x.top
       #
       #   if a.x != 0 && a.x != 0
@@ -27,15 +28,19 @@ module RuboCop
       #     left_child || left_child
       #   end
       #
+      #   # good
+      #   x + x
+      #   1 << 1
+      #
       class BinaryOperatorWithIdenticalOperands < Base
         MSG = 'Binary operator `%<op>s` has identical operands.'
-        MATH_OPERATORS = %i[+ - * / % ** << >> | ^].to_set.freeze
+        ALLOWED_MATH_OPERATORS = %i[+ * ** << >>].to_set.freeze
 
         def on_send(node)
           return unless node.binary_operation?
 
           lhs, operation, rhs = *node
-          return if MATH_OPERATORS.include?(node.method_name) && lhs.basic_literal?
+          return if ALLOWED_MATH_OPERATORS.include?(node.method_name)
 
           add_offense(node, message: format(MSG, op: operation)) if lhs == rhs
         end

data/lib/rubocop/cop/lint/deprecated_constants.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for deprecated constants.
+      #
+      # It has `DeprecatedConstants` config. If there is an alternative method, you can set
+      # alternative value as `Alternative`. And you can set the deprecated version as
+      # `DeprecatedVersion`. These options can be omitted if they are not needed.
+      #
+      #   DeprecatedConstants:
+      #     'DEPRECATED_CONSTANT':
+      #       Alternative: 'alternative_value'
+      #       DeprecatedVersion: 'deprecated_version'
+      #
+      # By default, `NIL`, `TRUE`, `FALSE` and `Random::DEFAULT` are configured.
+      #
+      # @example
+      #
+      #   # bad
+      #   NIL
+      #   TRUE
+      #   FALSE
+      #   Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class.
+      #
+      #   # good
+      #   nil
+      #   true
+      #   false
+      #   Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2.
+      #
+      class DeprecatedConstants < Base
+        extend AutoCorrector
+
+        SUGGEST_GOOD_MSG = 'Use `%<good>s` instead of `%<bad>s`%<deprecated_message>s.'
+        DO_NOT_USE_MSG = 'Do not use `%<bad>s`%<deprecated_message>s.'
+
+        def on_const(node)
+          constant = node.absolute? ? consntant_name(node, node.short_name.to_s) : node.source
+          return unless (deprecated_constant = deprecated_constants[constant])
+
+          alternative = deprecated_constant['Alternative']
+          version = deprecated_constant['DeprecatedVersion']
+
+          add_offense(node, message: message(alternative, node.source, version)) do |corrector|
+            corrector.replace(node, alternative)
+          end
+        end
+
+        private
+
+        def consntant_name(node, nested_constant_name)
+          return nested_constant_name unless node.namespace.const_type?
+
+          consntant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
+        end
+
+        def message(good, bad, deprecated_version)
+          deprecated_message = ", deprecated since Ruby #{deprecated_version}" if deprecated_version
+
+          if good
+            format(SUGGEST_GOOD_MSG, good: good, bad: bad, deprecated_message: deprecated_message)
+          else
+            format(DO_NOT_USE_MSG, bad: bad, deprecated_message: deprecated_message)
+          end
+        end
+
+        def deprecated_constants
+          cop_config.fetch('DeprecatedConstants', {})
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/duplicate_branch.rb

@@ -6,6 +6,15 @@ module RuboCop
       # This cop checks that there are no repeated bodies
       # within `if/unless`, `case-when` and `rescue` constructs.
       #
+      # With `IgnoreLiteralBranches: true`, branches are not registered
+      # as offenses if they return a basic literal value (string, symbol,
+      # integer, float, rational, complex, `true`, `false`, or `nil`), or
+      # return an array, hash, regexp or range that only contains one of
+      # the above basic literal values.
+      #
+      # With `IgnoreConstantBranches: true`, branches are not registered
+      # as offenses if they return a constant value.
+      #
       # @example
       #   # bad
       #   if foo
@@ -56,14 +65,33 @@ module RuboCop
       #     handle_error
       #   end
       #
+      # @example IgnoreLiteralBranches: true
+      #   # good
+      #   case size
+      #   when "small" then 100
+      #   when "medium" then 250
+      #   when "large" then 1000
+      #   else 250
+      #   end
+      #
+      # @example IgnoreLiteralBranches: true
+      #   # good
+      #   case size
+      #   when "small" then SMALL_SIZE
+      #   when "medium" then MEDIUM_SIZE
+      #   when "large" then LARGE_SIZE
+      #   else MEDIUM_SIZE
+      #   end
+      #
       class DuplicateBranch < Base
         include RescueNode
 
         MSG = 'Duplicate branch body detected.'
 
         def on_branching_statement(node)
-          branches = node.branches.compact
-          branches.each_with_object(Set.new) do |branch, previous|
+          branches(node).each_with_object(Set.new) do |branch, previous|
+            next unless consider_branch?(branch)
+
             add_offense(offense_range(branch)) unless previous.add?(branch)
           end
         end
@@ -87,6 +115,40 @@ module RuboCop
             parent.source_range
           end
         end
+
+        def branches(node)
+          node.branches.compact
+        end
+
+        def consider_branch?(branch)
+          return false if ignore_literal_branches? && literal_branch?(branch)
+          return false if ignore_constant_branches? && const_branch?(branch)
+
+          true
+        end
+
+        def ignore_literal_branches?
+          cop_config.fetch('IgnoreLiteralBranches', false)
+        end
+
+        def ignore_constant_branches?
+          cop_config.fetch('IgnoreConstantBranches', false)
+        end
+
+        def literal_branch?(branch) # rubocop:disable Metrics/CyclomaticComplexity
+          return false if !branch.literal? || branch.xstr_type?
+          return true if branch.basic_literal?
+
+          branch.each_descendant.all? do |node|
+            node.basic_literal? ||
+              node.pair_type? || # hash keys and values are contained within a `pair` node
+              (node.const_type? && ignore_constant_branches?)
+          end
+        end
+
+        def const_branch?(branch)
+          branch.const_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/lambda_without_literal_block.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks uses of lambda without a literal block.
+      # It emulates the following warning in Ruby 3.0:
+      #
+      #   % ruby -vwe 'lambda(&proc {})'
+      #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+      #   -e:1: warning: lambda without a literal block is deprecated; use the proc without
+      #   lambda instead
+      #
+      # This way, proc object is never converted to lambda.
+      # Auto-correction replaces with compatible proc argument.
+      #
+      # @example
+      #
+      #   # bad
+      #   lambda(&proc { do_something })
+      #   lambda(&Proc.new { do_something })
+      #
+      #   # good
+      #   proc { do_something }
+      #   Proc.new { do_something }
+      #   lambda { do_something } # If you use lambda.
+      #
+      class LambdaWithoutLiteralBlock < Base
+        extend AutoCorrector
+
+        MSG = 'lambda without a literal block is deprecated; use the proc without lambda instead.'
+        RESTRICT_ON_SEND = %i[lambda].freeze
+
+        def on_send(node)
+          return if node.parent&.block_type? || !node.first_argument
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, node.first_argument.source.delete('&'))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -11,6 +11,11 @@ module RuboCop
       # that are hard to debug. To ensure this doesn't happen,
       # always sort the list.
       #
+      # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
+      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      #
+      # This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+      #
       # @example
       #
       #   # bad
@@ -23,8 +28,6 @@ module RuboCop
       #     require file
       #   end
       #
-      # @example
-      #
       #   # bad
       #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
       #     require file
@@ -35,28 +38,28 @@ module RuboCop
       #     require file
       #   end
       #
-      # @example
-      #
       #   # bad
       #   Dir['./lib/**/*.rb'].each(&method(:require))
       #
       #   # good
       #   Dir['./lib/**/*.rb'].sort.each(&method(:require))
       #
-      # @example
-      #
       #   # bad
       #   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
       #
       #   # good
       #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
       #
+      #   # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher.
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require))
+      #
       class NonDeterministicRequireOrder < Base
         extend AutoCorrector
 
         MSG = 'Sort files before requiring them.'
 
         def on_block(node)
+          return if target_ruby_version >= 3.0
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 
@@ -70,6 +73,7 @@ module RuboCop
         end
 
         def on_block_pass(node)
+          return if target_ruby_version >= 3.0
           return unless method_require?(node)
           return unless unsorted_dir_pass?(node.parent)
 

data/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb

@@ -61,7 +61,8 @@ module RuboCop
         end
 
         def comment_range_with_surrounding_space(range)
-          if previous_line_blank?(range)
+          if previous_line_blank?(range) &&
+             processed_source.comment_config.comment_only_line?(range.line)
             # When the previous line is blank, it should be retained
             range_with_surrounding_space(range: range, side: :right)
           else

data/lib/rubocop/cop/lint/redundant_dir_glob_sort.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Sort globbed results by default in Ruby 3.0.
+      # This cop checks for redundant `sort` method to `Dir.glob` and `Dir[]`.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob('./lib/**/*.rb').sort.each do |file|
+      #   end
+      #
+      #   Dir['./lib/**/*.rb'].sort.each do |file|
+      #   end
+      #
+      #   # good
+      #   Dir.glob('./lib/**/*.rb').each do |file|
+      #   end
+      #
+      #   Dir['./lib/**/*.rb'].each do |file|
+      #   end
+      #
+      class RedundantDirGlobSort < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.0
+
+        MSG = 'Remove redundant `sort`.'
+        RESTRICT_ON_SEND = %i[sort].freeze
+        GLOB_METHODS = %i[glob []].freeze
+
+        def on_send(node)
+          return unless (receiver = node.receiver)
+          return unless receiver.receiver&.const_type? && receiver.receiver.short_name == :Dir
+          return unless GLOB_METHODS.include?(receiver.method_name)
+
+          selector = node.loc.selector
+
+          add_offense(selector) do |corrector|
+            corrector.remove(selector)
+            corrector.remove(node.loc.dot)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/redundant_splat_expansion.rb

@@ -8,47 +8,66 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   a = *[1, 2, 3]
       #   a = *'a'
       #   a = *1
-      #
-      #   begin
-      #     foo
-      #   rescue *[StandardError, ApplicationError]
-      #     bar
-      #   end
-      #
-      #   case foo
-      #   when *[1, 2, 3]
-      #     bar
-      #   else
-      #     baz
-      #   end
-      #
-      # @example
+      #   ['a', 'b', *%w(c d e), 'f', 'g']
       #
       #   # good
-      #
       #   c = [1, 2, 3]
       #   a = *c
       #   a, b = *c
       #   a, *b = *c
       #   a = *1..10
       #   a = ['a']
+      #   ['a', 'b', 'c', 'd', 'e', 'f', 'g']
       #
+      #   # bad
+      #   do_something(*['foo', 'bar', 'baz'])
+      #
+      #   # good
+      #   do_something('foo', 'bar', 'baz')
+      #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue *[StandardError, ApplicationError]
+      #     bar
+      #   end
+      #
+      #   # good
       #   begin
       #     foo
       #   rescue StandardError, ApplicationError
       #     bar
       #   end
       #
+      #   # bad
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      #   # good
       #   case foo
       #   when 1, 2, 3
       #     bar
       #   else
       #     baz
       #   end
+      #
+      # @example AllowPercentLiteralArrayArgument: true (default)
+      #
+      #   # good
+      #   do_something(*%w[foo bar baz])
+      #
+      # @example AllowPercentLiteralArrayArgument: false
+      #
+      #   # bad
+      #   do_something(*%w[foo bar baz])
+      #
       class RedundantSplatExpansion < Base
         extend AutoCorrector
 
@@ -75,6 +94,9 @@ module RuboCop
           redundant_splat_expansion(node) do
             if array_splat?(node) &&
                (method_argument?(node) || part_of_an_array?(node))
+              return if allow_percent_literal_array_argument? &&
+                        use_percent_literal_array_argument?(node)
+
               add_offense(node, message: ARRAY_PARAM_MSG) do |corrector|
                 autocorrect(corrector, node)
               end
@@ -170,6 +192,17 @@ module RuboCop
             elements.join(', ')
           end
         end
+
+        def use_percent_literal_array_argument?(node)
+          argument = node.children.first
+
+          node.parent.send_type? &&
+            (argument.percent_literal?(:string) || argument.percent_literal?(:symbol))
+        end
+
+        def allow_percent_literal_array_argument?
+          cop_config.fetch('AllowPercentLiteralArrayArgument', true)
+        end
       end
     end
   end