rubocop 1.5.1 → 1.8.0

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

@@ -111,7 +111,8 @@ module RuboCop
               braces_with_contents_inside(node, inner)
             elsif style_for_empty_braces == :no_space
               offense(range.begin_pos, range.end_pos,
-                      'Space inside empty braces detected.')
+                      'Space inside empty braces detected.',
+                      'EnforcedStyleForEmptyBraces')
             end
           end
         end
@@ -120,7 +121,8 @@ module RuboCop
           return if style_for_empty_braces != :space
 
           offense(left_brace.begin_pos, right_brace.end_pos,
-                  'Space missing inside empty braces.')
+                  'Space missing inside empty braces.',
+                  'EnforcedStyleForEmptyBraces')
         end
 
         def braces_with_contents_inside(node, inner)
@@ -164,9 +166,9 @@ module RuboCop
             if left_brace.end_pos == args_delimiter.begin_pos &&
                cop_config['SpaceBeforeBlockParameters']
               offense(left_brace.begin_pos, args_delimiter.end_pos,
-                      'Space between { and | missing.') do
-                opposite_style_detected
-              end
+                      'Space between { and | missing.')
+            else
+              correct_style_detected
             end
           else
             # We indicate the position after the left brace. Otherwise it's
@@ -179,11 +181,11 @@ module RuboCop
 
         def space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
-            unless cop_config['SpaceBeforeBlockParameters']
+            if cop_config['SpaceBeforeBlockParameters']
+              correct_style_detected
+            else
               offense(left_brace.end_pos, args_delimiter.begin_pos,
-                      'Space between { and | detected.') do
-                opposite_style_detected
-              end
+                      'Space between { and | detected.')
             end
           else
             brace_with_space = range_with_surrounding_space(range: left_brace,
@@ -220,7 +222,7 @@ module RuboCop
           end
         end
 
-        def offense(begin_pos, end_pos, msg)
+        def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
           range = range_between(begin_pos, end_pos)
           add_offense(range, message: msg) do |corrector|
             case range.source
@@ -229,6 +231,7 @@ module RuboCop
             when '{|' then corrector.replace(range, '{ |')
             else           corrector.insert_before(range, ' ')
             end
+            opposite_style_detected if style_param == 'EnforcedStyle'
           end
         end
 

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