rubocop 1.9.1 → 1.13.0

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

@@ -18,8 +18,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use only a single space inside array percent literal.'
-        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX =
-          /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
+        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
 
         def on_array(node)
           process(node, '%i', '%I', '%w', '%W')
@@ -36,11 +35,7 @@ module RuboCop
         private
 
         def each_unnecessary_space_match(node, &blk)
-          each_match_range(
-            contents_range(node),
-            MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX,
-            &blk
-          )
+          each_match_range(contents_range(node), MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX, &blk)
         end
       end
     end

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

@@ -89,7 +89,7 @@ module RuboCop
           # preventing auto-correction to single-line empty braces. It will
           # conflict with auto-correction by `Layout/SpaceInsideBlockBraces` cop
           # if auto-corrected to a single-line empty braces.
-          # See: https://github.com/rubocop-hq/rubocop/issues/7363
+          # See: https://github.com/rubocop/rubocop/issues/7363
           return if node.body.nil? && node.multiline?
 
           left_brace = node.loc.begin
@@ -129,8 +129,7 @@ module RuboCop
           args_delimiter = node.arguments.loc.begin # Can be ( | or nil.
 
           check_left_brace(inner, node.loc.begin, args_delimiter)
-          check_right_brace(inner, node.loc.begin, node.loc.end,
-                            node.single_line?)
+          check_right_brace(inner, node.loc.begin, node.loc.end, node.single_line?)
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
@@ -143,8 +142,7 @@ module RuboCop
 
         def check_right_brace(inner, left_brace, right_brace, single_line)
           if single_line && /\S$/.match?(inner)
-            no_space(right_brace.begin_pos, right_brace.end_pos,
-                     'Space missing inside }.')
+            no_space(right_brace.begin_pos, right_brace.end_pos, 'Space missing inside }.')
           else
             return if multiline_block?(left_brace, right_brace) &&
                       aligned_braces?(left_brace, right_brace)
@@ -174,8 +172,7 @@ module RuboCop
             # We indicate the position after the left brace. Otherwise it's
             # difficult to distinguish between space missing to the left and to
             # the right of the brace in autocorrect.
-            no_space(left_brace.end_pos, left_brace.end_pos + 1,
-                     'Space missing inside {.')
+            no_space(left_brace.end_pos, left_brace.end_pos + 1, 'Space missing inside {.')
           end
         end
 
@@ -188,8 +185,7 @@ module RuboCop
                       'Space between { and | detected.')
             end
           else
-            brace_with_space = range_with_surrounding_space(range: left_brace,
-                                                            side: :right)
+            brace_with_space = range_with_surrounding_space(range: left_brace, side: :right)
             space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
                   'Space inside { detected.')
           end
@@ -200,8 +196,7 @@ module RuboCop
         end
 
         def space_inside_right_brace(right_brace)
-          brace_with_space = range_with_surrounding_space(range: right_brace,
-                                                          side: :left)
+          brace_with_space = range_with_surrounding_space(range: right_brace, side: :left)
           space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
                 'Space inside } detected.')
         end

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

@@ -90,8 +90,7 @@ module RuboCop
           expect_space    = expect_space?(token1, token2)
 
           if offense?(token1, expect_space)
-            incorrect_style_detected(token1, token2,
-                                     expect_space, is_empty_braces)
+            incorrect_style_detected(token1, token2, expect_space, is_empty_braces)
           else
             correct_style_detected
           end

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

@@ -107,8 +107,7 @@ module RuboCop
           current_token = tokens.reverse.find(&:left_ref_bracket?)
           previous_token = previous_token(current_token)
 
-          if node.method?(:[]=) ||
-             previous_token && !previous_token.right_bracket?
+          if node.method?(:[]=) || previous_token && !previous_token.right_bracket?
             tokens.find(&:left_ref_bracket?)
           else
             current_token

data/lib/rubocop/cop/legacy/corrections_proxy.rb

@@ -11,11 +11,7 @@ module RuboCop
         end
 
         def <<(callable)
-          suppress_clobbering do
-            @corrector.transaction do
-              callable.call(@corrector)
-            end
-          end
+          suppress_clobbering { @corrector.transaction { callable.call(@corrector) } }
         end
 
         def empty?
@@ -24,9 +20,7 @@ module RuboCop
 
         def concat(corrections)
           if corrections.is_a?(CorrectionsProxy)
-            suppress_clobbering do
-              corrector.merge!(corrections.corrector)
-            end
+            suppress_clobbering { corrector.merge!(corrections.corrector) }
           else
             corrections.each { |correction| self << correction }
           end

data/lib/rubocop/cop/legacy/corrector.rb

@@ -13,9 +13,7 @@ module RuboCop
             merge!(corr.send(:corrector))
           else
             # warn "Corrector.new with corrections is deprecated." unless corr.empty? TODO
-            corr.each do |c|
-              corrections << c
-            end
+            corr.each { |c| corrections << c }
           end
         end
 

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

@@ -25,12 +25,7 @@ module RuboCop
 
         SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
 
-        MISTAKES = {
-          '=-' => '-=',
-          '=+' => '+=',
-          '=*' => '*=',
-          '=!' => '!='
-        }.freeze
+        MISTAKES = { '=-' => '-=', '=+' => '+=', '=*' => '*=', '=!' => '!=' }.freeze
 
         def on_asgn(node)
           return unless (rhs = rhs(node))

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

@@ -6,6 +6,8 @@ module RuboCop
       # This cop checks for ambiguous block association with method
       # when param passed without parentheses.
       #
+      # This cop can customize ignored methods with `IgnoredMethods`.
+      #
       # @example
       #
       #   # bad
@@ -26,7 +28,14 @@ module RuboCop
       #   # good
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
+      #
+      # @example IgnoredMethods: [change]
+      #
+      #   # good
+      #   expect { do_something }.to change { object.attribute }
       class AmbiguousBlockAssociation < Base
+        include IgnoredMethods
+
         MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
               'block will be associated with the `%<method>s` method ' \
               'call.'
@@ -35,8 +44,7 @@ module RuboCop
           return unless node.arguments?
 
           return unless ambiguous_block_association?(node)
-          return if node.parenthesized? ||
-                    node.last_argument.lambda? || allowed_method?(node)
+          return if node.parenthesized? || node.last_argument.lambda? || allowed_method?(node)
 
           message = message(node)
 
@@ -47,19 +55,18 @@ module RuboCop
         private
 
         def ambiguous_block_association?(send_node)
-          send_node.last_argument.block_type? &&
-            !send_node.last_argument.send_node.arguments?
+          send_node.last_argument.block_type? && !send_node.last_argument.send_node.arguments?
         end
 
         def allowed_method?(node)
-          node.assignment? || node.operator_method? || node.method?(:[])
+          node.assignment? || node.operator_method? || node.method?(:[]) ||
+            ignored_method?(node.last_argument.send_node.source)
         end
 
         def message(send_node)
           block_param = send_node.last_argument
 
-          format(MSG, param: block_param.source,
-                      method: block_param.send_node.source)
+          format(MSG, param: block_param.source, method: block_param.send_node.source)
         end
       end
     end

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

@@ -21,6 +21,7 @@ module RuboCop
               'Use `%<double_colon>sBigDecimal()` instead.'
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method big_decimal_new(node)
         def_node_matcher :big_decimal_new, <<~PATTERN
           (send
             (const ${nil? cbase} :BigDecimal) :new ...)

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

@@ -24,9 +24,9 @@ module RuboCop
       class BooleanSymbol < Base
         extend AutoCorrector
 
-        MSG = 'Symbol with a boolean name - ' \
-              'you probably meant to use `%<boolean>s`.'
+        MSG = 'Symbol with a boolean name - you probably meant to use `%<boolean>s`.'
 
+        # @!method boolean_symbol?(node)
         def_node_matcher :boolean_symbol?, '(sym {:true :false})'
 
         def on_sym(node)

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

@@ -66,10 +66,12 @@ module RuboCop
 
         MSG = 'Do not define constants this way within a block.'
 
+        # @!method constant_assigned_in_block?(node)
         def_node_matcher :constant_assigned_in_block?, <<~PATTERN
           ({^block_type? [^begin_type? ^^block_type?]} nil? ...)
         PATTERN
 
+        # @!method module_defined_in_block?(node)
         def_node_matcher :module_defined_in_block?, <<~PATTERN
           ({^block_type? [^begin_type? ^^block_type?]} ...)
         PATTERN

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

@@ -58,6 +58,7 @@ module RuboCop
       class ConstantResolution < Base
         MSG = 'Fully qualify this constant to avoid possibly ambiguous resolution.'
 
+        # @!method unqualified_const?(node)
         def_node_matcher :unqualified_const?, <<~PATTERN
           (const nil? #const_name?)
         PATTERN
@@ -72,8 +73,7 @@ module RuboCop
 
         def const_name?(name)
           name = name.to_s
-          (allowed_names.empty? || allowed_names.include?(name)) &&
-            !ignored_names.include?(name)
+          (allowed_names.empty? || allowed_names.include?(name)) && !ignored_names.include?(name)
         end
 
         def allowed_names

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

@@ -3,8 +3,21 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for calls to debugger or pry.
-      # The cop can be configured to define which methods and receivers must be fixed.
+      # This cop checks for debug calls (such as `debugger` or `binding.pry`) that should
+      # not be kept for production code.
+      #
+      # The cop can be configured using `DebuggerMethods`. By default, a number of gems
+      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `Pry`, `Rails`,
+      # and `WebConsole`). Additional methods can be added.
+      #
+      # Specific default groups can be disabled if necessary:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   WebConsole: ~
+      # ----
+      #
       #
       # @example
       #
@@ -33,14 +46,34 @@ module RuboCop
       #   def some_method
       #     do_something
       #   end
+      #
+      # @example DebuggerMethods: [my_debugger]
+      #
+      #   # bad (ok during development)
+      #
+      #   def some_method
+      #     my_debugger
+      #   end
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
         RESTRICT_ON_SEND = [].freeze
 
+        # @!method kernel?(node)
+        def_node_matcher :kernel?, <<~PATTERN
+          (const {nil? cbase} :Kernel)
+        PATTERN
+
+        # @!method valid_receiver?(node, arg1)
+        def_node_matcher :valid_receiver?, <<~PATTERN
+          {
+            (const {nil? cbase} %1)
+            (send {nil? #kernel?} %1)
+          }
+        PATTERN
+
         def on_send(node)
-          return unless debugger_method?(node.method_name)
-          return if !node.receiver.nil? && !debugger_receiver?(node)
+          return unless debugger_method?(node)
 
           add_offense(node)
         end
@@ -51,19 +84,32 @@ module RuboCop
           format(MSG, source: node.source)
         end
 
-        def debugger_method?(name)
-          cop_config.fetch('DebuggerMethods', []).include?(name.to_s)
+        def debugger_methods
+          @debugger_methods ||= begin
+            config = cop_config.fetch('DebuggerMethods', [])
+            values = config.is_a?(Array) ? config : config.values.flatten
+            values.map do |v|
+              next unless v
+
+              *receiver, method_name = v.split('.')
+              {
+                receiver: receiver.empty? ? nil : receiver.join.to_sym,
+                method_name: method_name.to_sym
+              }
+            end.compact
+          end
         end
 
-        def debugger_receiver?(node)
-          receiver = case node.receiver
-                     when RuboCop::AST::SendNode
-                       node.receiver.method_name
-                     when RuboCop::AST::ConstNode
-                       node.receiver.const_name
-                     end
+        def debugger_method?(send_node)
+          debugger_methods.any? do |method|
+            next unless method[:method_name] == send_node.method_name
 
-          cop_config.fetch('DebuggerReceivers', []).include?(receiver.to_s)
+            if method[:receiver].nil?
+              send_node.receiver.nil?
+            else
+              valid_receiver?(send_node.receiver, method[:receiver])
+            end
+          end
         end
       end
     end

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

@@ -58,8 +58,7 @@ module RuboCop
           DeprecatedClassMethod.new(deprecated: :exists?,
                                     replacement: :exist?,
                                     class_constant: :Dir),
-          DeprecatedClassMethod.new(deprecated: :iterator?,
-                                    replacement: :block_given?)
+          DeprecatedClassMethod.new(deprecated: :iterator?, replacement: :block_given?)
         ].freeze
 
         RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
@@ -96,8 +95,7 @@ module RuboCop
 
         def method_call(class_constant, method)
           if class_constant
-            format('%<constant>s.%<method>s', constant: class_constant,
-                                              method: method)
+            format('%<constant>s.%<method>s', constant: class_constant, method: method)
           else
             format('%<method>s', method: method)
           end

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

@@ -42,7 +42,7 @@ module RuboCop
           #        Maybe further investigation of RuboCop AST will lead to an essential solution.
           return unless node.loc
 
-          constant = node.absolute? ? consntant_name(node, node.short_name.to_s) : node.source
+          constant = node.absolute? ? constant_name(node, node.short_name.to_s) : node.source
           return unless (deprecated_constant = deprecated_constants[constant])
 
           alternative = deprecated_constant['Alternative']
@@ -55,10 +55,10 @@ module RuboCop
 
         private
 
-        def consntant_name(node, nested_constant_name)
+        def constant_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}")
+          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
         end
 
         def message(good, bad, deprecated_version)

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

@@ -41,9 +41,11 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)`' \
-          ' instead of `%<original>s`.'
+        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)` instead of `%<original>s`.'
 
+        NO_ARG_ALGORITHM = %w[BF DES IDEA RC4].freeze
+
+        # @!method algorithm_const(node)
         def_node_matcher :algorithm_const, <<~PATTERN
           (send
             $(const
@@ -59,9 +61,7 @@ module RuboCop
 
           message = message(node)
 
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         private
@@ -104,7 +104,7 @@ module RuboCop
         def algorithm_name(node)
           name = node.loc.name.source
 
-          if openssl_class(node) == 'OpenSSL::Cipher'
+          if openssl_class(node) == 'OpenSSL::Cipher' && !NO_ARG_ALGORITHM.include?(name)
             name.scan(/.{3}/).join('-')
           else
             name
@@ -124,16 +124,23 @@ module RuboCop
           algorithm_name = algorithm_name(algorithm_constant)
 
           if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
-            build_cipher_arguments(node, algorithm_name)
+            build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
           else
             (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
           end
         end
 
-        def build_cipher_arguments(node, algorithm_name)
+        def build_cipher_arguments(node, algorithm_name, no_arguments)
           algorithm_parts = algorithm_name.downcase.split('-')
           size_and_mode = sanitize_arguments(node.arguments).map(&:downcase)
-          "'#{(algorithm_parts + size_and_mode + ['cbc']).take(3).join('-')}'"
+
+          if NO_ARG_ALGORITHM.include?(algorithm_parts.first.upcase) && no_arguments
+            "'#{algorithm_parts.first}'"
+          else
+            mode = 'cbc' unless size_and_mode == ['cbc']
+
+            "'#{(algorithm_parts + size_and_mode + [mode]).compact.take(3).join('-')}'"
+          end
         end
       end
     end