rubocop 0.83.0 → 0.84.0

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

@@ -2,7 +2,6 @@
 
 module RuboCop
   module Cop
-    # rubocop:disable Layout/LineLength
     module Layout
       # This cop checks the indentation of the first argument in a method call.
       # Arguments after the first one are checked by Layout/ArgumentAlignment,
@@ -143,7 +142,6 @@ module RuboCop
       #   second_param
       #
       class FirstArgumentIndentation < Cop
-        # rubocop:enable Layout/LineLength
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp

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

@@ -125,9 +125,7 @@ module RuboCop
 
         def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
           # if the right bracket is on the same line as the last value, accept
-          if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
-            return
-          end
+          return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
 
           expected_column = base_column(left_bracket, left_parenthesis)
           @column_delta = expected_column - right_bracket.column

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

@@ -36,9 +36,7 @@ module RuboCop
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
           if (last_arg = args.last)
-            if last_arg.hash_type? && !last_arg.braces?
-              args = args.concat(args.pop.children)
-            end
+            args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
           end
 
           check_method_line_break(node, args)

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

@@ -98,13 +98,9 @@ module RuboCop
           lambda do |corrector|
             fix_closing_parenthesis(node, corrector)
 
-            if internal_trailing_comma?(node)
-              remove_internal_trailing_comma(node, corrector)
-            end
+            remove_internal_trailing_comma(node, corrector) if internal_trailing_comma?(node)
 
-            if external_trailing_comma?(node)
-              fix_external_trailing_comma(node, corrector)
-            end
+            fix_external_trailing_comma(node, corrector) if external_trailing_comma?(node)
           end
         end
 

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

@@ -263,9 +263,7 @@ module RuboCop
         def offense(body_node, indentation, style)
           # This cop only auto-corrects the first statement in a def body, for
           # example.
-          if body_node.begin_type? && !parentheses?(body_node)
-            body_node = body_node.children.first
-          end
+          body_node = body_node.children.first if body_node.begin_type? && !parentheses?(body_node)
 
           # Since autocorrect changes a number of lines, and not only the line
           # where the reported offending range is, we avoid auto-correction if

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

@@ -81,9 +81,7 @@ module RuboCop
 
             expr_before_body ||= node.loc.begin
 
-            if expr_before_body.line == node.body.first_line
-              autocorrect_body(corrector, node, node.body)
-            end
+            autocorrect_body(corrector, node, node.body) if expr_before_body.line == node.body.first_line
           end
         end
 

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

@@ -37,9 +37,7 @@ module RuboCop
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
           if (last_arg = args.last)
-            if last_arg.hash_type? && !last_arg.braces?
-              args = args.concat(args.pop.children)
-            end
+            args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
           end
 
           check_line_breaks(node, args)

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

@@ -72,9 +72,7 @@ module RuboCop
           left = previous_token(operator)
           right = next_token(operator)
 
-          if !right.comment? && valid_right_token?(right, operator)
-            no_space_offenses(node, operator, right, MSG)
-          end
+          no_space_offenses(node, operator, right, MSG) if !right.comment? && valid_right_token?(right, operator)
           return unless valid_left_token?(left, operator)
 
           no_space_offenses(node, left, operator, MSG) if add_left_offense
@@ -121,9 +119,7 @@ module RuboCop
 
         def right_token_for_auto_correction(operator)
           right_token = next_token(operator)
-          if !right_token.comment? && valid_right_token?(right_token, operator)
-            return right_token
-          end
+          return right_token if !right_token.comment? && valid_right_token?(right_token, operator)
 
           operator
         end

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

@@ -20,9 +20,7 @@ module RuboCop
             next unless token2.comment?
             next unless token1.line == token2.line
 
-            if token1.pos.end == token2.pos.begin
-              add_offense(token2.pos, location: token2.pos)
-            end
+            add_offense(token2.pos, location: token2.pos) if token1.pos.end == token2.pos.begin
           end
         end
 

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

@@ -78,9 +78,7 @@ module RuboCop
           return unless node.square_brackets?
 
           left, right = array_brackets(node)
-          if empty_brackets?(left, right)
-            return empty_offenses(node, left, right, EMPTY_MSG)
-          end
+          return empty_offenses(node, left, right, EMPTY_MSG) if empty_brackets?(left, right)
 
           start_ok = next_to_newline?(node, left)
           end_ok = node.single_line? ? false : end_has_own_line?(right)

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

@@ -72,9 +72,7 @@ module RuboCop
 
           right_token = closing_bracket(tokens, left_token)
 
-          if empty_brackets?(left_token, right_token)
-            return empty_offenses(node, left_token, right_token, EMPTY_MSG)
-          end
+          return empty_offenses(node, left_token, right_token, EMPTY_MSG) if empty_brackets?(left_token, right_token)
 
           if style == :no_space
             no_space_offenses(node, left_token, right_token, MSG)
@@ -130,9 +128,7 @@ module RuboCop
           tokens[i..-1].each do |token|
             inner_left_brackets_needing_closure += 1 if token.left_bracket?
             inner_left_brackets_needing_closure -= 1 if token.right_bracket?
-            if inner_left_brackets_needing_closure.zero? && token.right_bracket?
-              return token
-            end
+            return token if inner_left_brackets_needing_closure.zero? && token.right_bracket?
           end
         end
 

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

@@ -60,8 +60,10 @@ module RuboCop
           end
 
           ast.each_node(:send).find do |send_node|
-            offense_position?(send_node.first_argument, diagnostic) &&
-              unary_operator?(send_node.first_argument, diagnostic)
+            first_argument = send_node.first_argument
+
+            first_argument &&
+              offense_position?(first_argument, diagnostic) && unary_operator?(first_argument, diagnostic)
           end
         end
 

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Algorithmic constants for `OpenSSL::Cipher` and `OpenSSL::Digest`
+      # deprecated since OpenSSL version 2.2.0. Prefer passing a string
+      # instead.
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Cipher instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Cipher::AES.new(128, :GCM)
+      #
+      #   # good
+      #   OpenSSL::Cipher.new('AES-128-GCM')
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Digest instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.new
+      #
+      #   # good
+      #   OpenSSL::Digest.new('SHA256')
+      #
+      # @example
+      #
+      #   # Example for ::Digest inherited class methods.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.digest('foo')
+      #
+      #   # good
+      #   OpenSSL::Digest.digest('SHA256', 'foo')
+      #
+      class DeprecatedOpenSSLConstant < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)`' \
+          ' instead of `%<original>s`.'
+
+        def_node_matcher :algorithm_const, <<~PATTERN
+          (send
+            $(const
+              (const
+                (const {nil? cbase} :OpenSSL) {:Cipher :Digest})
+              _)
+            ...)
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if algorithm_const(node)
+        end
+
+        def autocorrect(node)
+          algorithm_constant, = algorithm_const(node)
+
+          lambda do |corrector|
+            corrector.remove(algorithm_constant.loc.double_colon)
+            corrector.remove(algorithm_constant.loc.name)
+
+            corrector.replace(
+              correction_range(node),
+              "#{node.loc.selector.source}(#{replacement_args(node)})"
+            )
+          end
+        end
+
+        private
+
+        def message(node)
+          algorithm_constant, = algorithm_const(node)
+          parent_constant = openssl_class(algorithm_constant)
+          replacement_args = replacement_args(node)
+          method = node.loc.selector.source
+
+          format(
+            MSG,
+            constant: parent_constant,
+            method: method,
+            replacement_args: replacement_args,
+            original: node.source
+          )
+        end
+
+        def correction_range(node)
+          begin_pos = node.loc.selector.column
+          end_pos = node.loc.expression.last_column
+          range_between(begin_pos, end_pos)
+        end
+
+        def openssl_class(node)
+          node.children.first.source
+        end
+
+        def algorithm_name(node)
+          name = node.loc.name.source
+
+          if openssl_class(node) == 'OpenSSL::Cipher'
+            name.scan(/.{3}/).join('-')
+          else
+            name
+          end
+        end
+
+        def sanitize_arguments(arguments)
+          arguments.flat_map { |arg| arg.source.tr(":'", '').split('-') }
+        end
+
+        def replacement_args(node)
+          algorithm_constant, = algorithm_const(node)
+          algorithm_name = algorithm_name(algorithm_constant)
+
+          if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
+            build_cipher_arguments(node, algorithm_name)
+          else
+            (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
+          end
+        end
+
+        def build_cipher_arguments(node, algorithm_name)
+          algorithm_parts = algorithm_name.split('-')
+          size_and_mode = sanitize_arguments(node.arguments)
+          "'#{(algorithm_parts + size_and_mode + ['CBC']).take(3).join('-')}'"
+        end
+      end
+    end
+  end
+end

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

@@ -141,13 +141,9 @@ module RuboCop
           arguments = node.arguments
           overridden_kwargs = kwargs.dup
 
-          if arguments[2]
-            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
-          end
+          overridden_kwargs[0] = "trim_mode: #{arguments[2].source}" if arguments[2]
 
-          if arguments[3] && !arguments[3].hash_type?
-            overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"
-          end
+          overridden_kwargs[1] = "eoutvar: #{arguments[3].source}" if arguments[3] && !arguments[3].hash_type?
 
           overridden_kwargs
         end

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

@@ -21,9 +21,7 @@ module RuboCop
         MSG = '`(...)` interpreted as grouped expression.'
 
         def on_send(node)
-          return unless node.arguments.one?
-          return if node.operator_method? || node.setter_method?
-          return if grouped_parentheses?(node)
+          return if valid_context?(node)
 
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length.positive?
@@ -45,6 +43,16 @@ module RuboCop
 
         private
 
+        def valid_context?(node)
+          return true unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
+
+          node.operator_method? || node.setter_method? || grouped_parentheses?(node)
+        end
+
+        def first_argument_starts_with_left_parenthesis?(node)
+          node.first_argument.source.start_with?('(')
+        end
+
         def grouped_parentheses?(node)
           first_argument = node.first_argument
 

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

@@ -48,9 +48,7 @@ module RuboCop
               match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match
 
-              if LEADING_QUOTE.match?(range.source)
-                corrector.remove_leading(range, 1)
-              end
+              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
             end
           end
         end

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

@@ -69,10 +69,21 @@ module RuboCop
 
         def on_resbody(node)
           return if node.body
-          return if cop_config['AllowComments'] && comment_lines?(node)
+          return if cop_config['AllowComments'] && comment_between_rescue_and_end?(node)
 
           add_offense(node)
         end
+
+        private
+
+        def comment_between_rescue_and_end?(node)
+          end_line = nil
+          node.each_ancestor(:kwbegin) do |ancestor|
+            end_line = ancestor.loc.end.line
+            break
+          end
+          processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
+        end
       end
     end
   end

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

@@ -16,9 +16,7 @@ module RuboCop
                                                 config, options)
           cop = new(config, options)
 
-          if processed_source.parser_error
-            cop.add_offense_from_error(processed_source.parser_error)
-          end
+          cop.add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
 
           processed_source.diagnostics.each do |diagnostic|
             cop.add_offense_from_diagnostic(diagnostic,

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

@@ -227,9 +227,7 @@ module RuboCop
             add_offense(node, message: format(MSG, current: cur_vis))
           else
             # was the previous modifier never applied to any defs?
-            if unused
-              add_offense(unused, message: format(MSG, current: cur_vis))
-            end
+            add_offense(unused, message: format(MSG, current: cur_vis)) if unused
             # once we have already warned about a certain modifier, don't
             # warn again even if it is never applied to any method defs
             unused = node

data/lib/rubocop/cop/migration/department_name.rb

@@ -27,11 +27,9 @@ module RuboCop
             Regexp.last_match(4).scan(/[^,]+|[\W]+/) do |name|
               trimmed_name = name.strip
 
-              break if contain_plain_comment?(trimmed_name)
+              check_cop_name(trimmed_name, comment, offset) unless valid_content_token?(trimmed_name)
 
-              unless valid_content_token?(trimmed_name)
-                check_cop_name(trimmed_name, comment, offset)
-              end
+              break if contain_unexpected_character_for_department_name?(name)
 
               offset += name.length
             end
@@ -43,9 +41,7 @@ module RuboCop
           cop_name = range.source
           qualified_cop_name = Cop.registry.qualified_cop_name(cop_name,
                                                                nil, shall_warn)
-          unless qualified_cop_name.include?('/')
-            qualified_cop_name = qualified_legacy_cop_name(cop_name)
-          end
+          qualified_cop_name = qualified_legacy_cop_name(cop_name) unless qualified_cop_name.include?('/')
 
           ->(corrector) { corrector.replace(range, qualified_cop_name) }
         end
@@ -68,8 +64,8 @@ module RuboCop
             !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
         end
 
-        def contain_plain_comment?(name)
-          name == '#'
+        def contain_unexpected_character_for_department_name?(name)
+          name.match?(%r{[^A-z/, ]})
         end
 
         def qualified_legacy_cop_name(cop_name)