rubocop 0.80.1 → 0.85.0

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_in_lambda_literal.rb

@@ -46,7 +46,7 @@ module RuboCop
           children = lambda_node.parent.children
           lambda do |corrector|
             if style == :require_space
-              corrector.insert_before(children[1].source_range, ' ')
+              corrector.insert_before(children[1], ' ')
             else
               corrector.remove(space_after_arrow(lambda_node))
             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_block_braces.rb

@@ -117,7 +117,7 @@ module RuboCop
             range = range_between(left_brace.end_pos, right_brace.begin_pos)
             inner = range.source
 
-            if inner =~ /\S/
+            if /\S/.match?(inner)
               braces_with_contents_inside(node, inner)
             elsif style_for_empty_braces == :no_space
               offense(range.begin_pos, range.end_pos,
@@ -142,7 +142,7 @@ module RuboCop
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
-          if inner =~ /\A\S/
+          if /\A\S/.match?(inner)
             no_space_inside_left_brace(left_brace, args_delimiter)
           else
             space_inside_left_brace(left_brace, args_delimiter)

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

@@ -35,7 +35,7 @@ module RuboCop
 
           lambda do |corrector|
             corrector.replace(
-              node.source_range,
+              node,
               expression
                 .sub(/\s+#{operator_escaped}/, operator)
                 .sub(/#{operator_escaped}\s+/, operator)
@@ -53,7 +53,7 @@ module RuboCop
           # account for multiline range literals
           expression.sub!(/#{escaped_op}\n\s*/, op)
 
-          return unless expression =~ /(\s#{escaped_op})|(#{escaped_op}\s)/
+          return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
 
           add_offense(node)
         end

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

@@ -130,9 +130,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/layout/trailing_whitespace.rb

@@ -14,14 +14,14 @@ module RuboCop
       #   # good
       #   x = 0
       #
-      # @example AllowInHeredoc: false (default)
+      # @example AllowInHeredoc: false
       #   # The line in this example contains spaces after the 0.
       #   # bad
       #   code = <<~RUBY
       #     x = 0
       #   RUBY
       #
-      # @example AllowInHeredoc: true
+      # @example AllowInHeredoc: true (default)
       #   # The line in this example contains spaces after the 0.
       #   # good
       #   code = <<~RUBY

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

@@ -38,17 +38,58 @@ module RuboCop
                      'a whitespace to the right of the `%<operator>s` if it ' \
                      'should be a %<possible>s.'
 
+        def autocorrect(node)
+          lambda do |corrector|
+            add_parentheses(node, corrector)
+          end
+        end
+
         private
 
         def relevant_diagnostic?(diagnostic)
           diagnostic.reason == :ambiguous_prefix
         end
 
+        def find_offense_node_by(diagnostic)
+          ast = processed_source.ast
+          ast.each_node(:splat, :block_pass, :kwsplat) do |node|
+            next unless offense_position?(node, diagnostic)
+
+            offense_node = offense_node(node)
+            return offense_node if offense_node
+          end
+
+          ast.each_node(:send).find do |send_node|
+            first_argument = send_node.first_argument
+
+            first_argument &&
+              offense_position?(first_argument, diagnostic) &&
+              unary_operator?(first_argument, diagnostic)
+          end
+        end
+
         def alternative_message(diagnostic)
           operator = diagnostic.location.source
           hash = AMBIGUITIES[operator]
           format(MSG_FORMAT, hash)
         end
+
+        def offense_position?(node, diagnostic)
+          node.source_range.begin_pos == diagnostic.location.begin_pos
+        end
+
+        def offense_node(node)
+          case node.type
+          when :splat, :block_pass
+            node.parent
+          when :kwsplat
+            node.parent.parent
+          end
+        end
+
+        def unary_operator?(node, diagnostic)
+          node.source.start_with?(diagnostic.arguments[:prefix])
+        end
       end
     end
   end

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

@@ -28,12 +28,26 @@ module RuboCop
               "if it's surely a regexp literal, or add a whitespace to the " \
               'right of the `/` if it should be a division.'
 
+        def autocorrect(node)
+          lambda do |corrector|
+            add_parentheses(node, corrector)
+          end
+        end
+
         private
 
         def relevant_diagnostic?(diagnostic)
           diagnostic.reason == :ambiguous_literal
         end
 
+        def find_offense_node_by(diagnostic)
+          node = processed_source.ast.each_node(:regexp).find do |regexp_node|
+            regexp_node.source_range.begin_pos == diagnostic.location.begin_pos
+          end
+
+          node.parent
+        end
+
         def alternative_message(_diagnostic)
           MSG
         end

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

@@ -32,6 +32,18 @@ module RuboCop
 
           add_offense(node, message: format(MSG, boolean: node.value))
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            boolean_literal = node.source.delete(':')
+            parent = node.parent
+            if parent&.pair_type? && node.equal?(parent.children[0])
+              corrector.remove(parent.loc.operator)
+              boolean_literal = "#{node.source} =>"
+            end
+            corrector.replace(node, boolean_literal)
+          end
+        end
       end
     end
   end

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

@@ -69,7 +69,7 @@ module RuboCop
         end
 
         def binding_irb?(node)
-          target_ruby_version >= 2.4 && binding_irb_call?(node)
+          binding_irb_call?(node)
         end
       end
     end

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

@@ -0,0 +1,137 @@
+# 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)
+          return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+
+          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)
+          range_between(node.loc.dot.end_pos, node.loc.expression.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 do |arg|
+            argument = arg.str_type? ? arg.value : arg.source
+
+            argument.tr(":'", '').split('-')
+          end
+        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/duplicate_methods.rb

@@ -95,10 +95,6 @@ module RuboCop
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
-        def_node_matcher :attr?, <<~PATTERN
-          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
-        PATTERN
-
         def_node_matcher :sym_name, '(sym $_name)'
 
         def on_send(node)
@@ -108,7 +104,7 @@ module RuboCop
             return if possible_dsl?(node)
 
             found_instance_method(node, name)
-          elsif (attr = attr?(node))
+          elsif (attr = node.attribute_accessor?)
             on_attr(node, *attr)
           end
         end

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

@@ -8,26 +8,49 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   case foo
-      #   when bar then 1
-      #   when baz then # nothing
+      #   when bar
+      #     do_something
+      #   when baz
       #   end
       #
       # @example
       #
       #   # good
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     nil
+      #   end
       #
-      #   case foo
-      #   when bar then 1
-      #   when baz then 2
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     # noop
       #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     # do nothing
+      #   end
+      #
       class EmptyWhen < Cop
         MSG = 'Avoid `when` branches without a body.'
 
         def on_case(node)
           node.each_when do |when_node|
             next if when_node.body
+            next if cop_config['AllowComments'] && comment_lines?(node)
 
             add_offense(when_node, location: when_node.source_range)
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for *return* from an *ensure* block.
+      # This cop checks for `return` from an `ensure` block.
       # Explicit return from an ensure block alters the control flow
       # as the return will take precedence over any exception being raised,
       # and the exception will be silently thrown away as if it were rescued.
@@ -29,6 +29,8 @@ module RuboCop
       #     do_something_else
       #   end
       class EnsureReturn < Cop
+        include RangeHelp
+
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
@@ -37,7 +39,22 @@ module RuboCop
           return unless ensure_body
 
           ensure_body.each_node(:return) do |return_node|
-            add_offense(return_node)
+            next if return_node.arguments.size >= 2
+
+            add_offense(return_node, location: :keyword)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.arguments?
+              corrector.replace(node, node.source.gsub(/return\s*/, ''))
+            else
+              range = range_by_whole_lines(
+                node.loc.expression, include_final_newline: true
+              )
+              corrector.remove(range)
+            end
           end
         end
       end