rubocop 1.5.0 → 1.7.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/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/interpolation_check.rb

@@ -23,10 +23,11 @@ module RuboCop
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)
-          parent = node.parent
-          return if parent && (parent.dstr_type? || parent.regexp_type?)
+          return unless node
+          return if string_or_regex?(node.parent)
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
+          return unless node.loc.begin && node.loc.end
 
           add_offense(node) do |corrector|
             autocorrect(corrector, node)
@@ -35,6 +36,10 @@ module RuboCop
 
         private
 
+        def string_or_regex?(node)
+          node&.dstr_type? || node&.regexp_type?
+        end
+
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')
                                            ['%{', '}']

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

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

@@ -106,23 +106,13 @@ module RuboCop
           error && error.ancestors[1] == SystemCallError
         end
 
-        def silence_warnings
-          # Replaces Kernel::silence_warnings since it hides any warnings,
-          # including the RuboCop ones
-          old_verbose = $VERBOSE
-          $VERBOSE = nil
-          yield
-        ensure
-          $VERBOSE = old_verbose
-        end
-
         def evaluate_exceptions(group)
           rescued_exceptions = group.exceptions
 
           if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
-                silence_warnings do
+                RuboCop::Util.silence_warnings do
                   # Avoid printing deprecation warnings about constants
                   converted << Kernel.const_get(exception.source)
                 end

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

@@ -8,6 +8,14 @@ module RuboCop
       # given by `ruby -cw` prior to Ruby 2.6:
       # "shadowing outer local variable - foo".
       #
+      # NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed
+      # because `Ractor` should not access outer variables.
+      # eg. following syle is encouraged:
+      #
+      #   worker_id, pipe = env
+      #   Ractor.new(worker_id, pipe) do |worker_id, pipe|
+      #   end
+      #
       # @example
       #
       #   # bad
@@ -34,12 +42,17 @@ module RuboCop
       class ShadowingOuterLocalVariable < Base
         MSG = 'Shadowing outer local variable - `%<variable>s`.'
 
+        def_node_matcher :ractor_block?, <<~PATTERN
+          (block (send (const nil? :Ractor) :new ...) ...)
+        PATTERN
+
         def self.joining_forces
           VariableForce
         end
 
         def before_declaring_variable(variable, variable_table)
           return if variable.should_be_unused?
+          return if ractor_block?(variable.scope.node)
 
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable