rubocop 1.12.1 → 1.16.1

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/boolean_symbol.rb

@@ -24,8 +24,7 @@ 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})'

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

@@ -73,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/deprecated_class_methods.rb

@@ -12,6 +12,8 @@ module RuboCop
       #   File.exists?(some_path)
       #   Dir.exists?(some_path)
       #   iterator?
+      #   Socket.gethostbyname(host)
+      #   Socket.gethostbyaddr(host)
       #
       # @example
       #
@@ -20,21 +22,23 @@ module RuboCop
       #   File.exist?(some_path)
       #   Dir.exist?(some_path)
       #   block_given?
+      #   Addrinfo.getaddrinfo(nodename, service)
+      #   Addrinfo.tcp(host, port).getnameinfo
       class DeprecatedClassMethods < Base
         extend AutoCorrector
 
         # Inner class to DeprecatedClassMethods.
-        # This class exists to add abstraction and clean naming to the
-        # objects that are going to be operated on.
+        # This class exists to add abstraction and clean naming
+        # to the deprecated objects
         class DeprecatedClassMethod
           include RuboCop::AST::Sexp
 
-          attr_reader :class_constant, :deprecated_method, :replacement_method
+          attr_reader :method, :class_constant
 
-          def initialize(deprecated:, replacement:, class_constant: nil)
-            @deprecated_method = deprecated
-            @replacement_method = replacement
+          def initialize(method, class_constant: nil, correctable: true)
+            @method = method
             @class_constant = class_constant
+            @correctable = correctable
           end
 
           def class_nodes
@@ -48,29 +52,80 @@ module RuboCop
                 [nil]
               end
           end
+
+          def correctable?
+            @correctable
+          end
+
+          def to_s
+            [class_constant, method].compact.join(delimeter)
+          end
+
+          private
+
+          def delimeter
+            CLASS_METHOD_DELIMETER
+          end
+        end
+
+        # Inner class to DeprecatedClassMethods.
+        # This class exists to add abstraction and clean naming
+        # to the replacements for deprecated objects
+        class Replacement
+          attr_reader :method, :class_constant
+
+          def initialize(method, class_constant: nil, instance_method: false)
+            @method = method
+            @class_constant = class_constant
+            @instance_method = instance_method
+          end
+
+          def to_s
+            [class_constant, method].compact.join(delimeter)
+          end
+
+          private
+
+          def delimeter
+            instance_method? ? INSTANCE_METHOD_DELIMETER : CLASS_METHOD_DELIMETER
+          end
+
+          def instance_method?
+            @instance_method
+          end
         end
 
         MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'
-        DEPRECATED_METHODS_OBJECT = [
-          DeprecatedClassMethod.new(deprecated: :exists?,
-                                    replacement: :exist?,
-                                    class_constant: :File),
-          DeprecatedClassMethod.new(deprecated: :exists?,
-                                    replacement: :exist?,
-                                    class_constant: :Dir),
-          DeprecatedClassMethod.new(deprecated: :iterator?,
-                                    replacement: :block_given?)
-        ].freeze
-
-        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
+
+        DEPRECATED_METHODS_OBJECT = {
+          DeprecatedClassMethod.new(:exists?, class_constant: :File) =>
+            Replacement.new(:exist?, class_constant: :File),
+
+          DeprecatedClassMethod.new(:exists?, class_constant: :Dir) =>
+            Replacement.new(:exist?, class_constant: :Dir),
+
+          DeprecatedClassMethod.new(:iterator?) => Replacement.new(:block_given?),
+
+          DeprecatedClassMethod.new(:gethostbyaddr, class_constant: :Socket, correctable: false) =>
+            Replacement.new(:getnameinfo, class_constant: :Addrinfo, instance_method: true),
+
+          DeprecatedClassMethod.new(:gethostbyname, class_constant: :Socket, correctable: false) =>
+            Replacement.new(:getaddrinfo, class_constant: :Addrinfo, instance_method: true)
+        }.freeze
+
+        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.keys.map(&:method).freeze
+
+        CLASS_METHOD_DELIMETER = '.'
+        INSTANCE_METHOD_DELIMETER = '#'
 
         def on_send(node)
-          check(node) do |data|
-            message = format(MSG, current: deprecated_method(data),
-                                  prefer: replacement_method(data))
+          check(node) do |deprecated|
+            message = format(MSG, current: deprecated, prefer: replacement(deprecated))
 
             add_offense(node.loc.selector, message: message) do |corrector|
-              corrector.replace(node.loc.selector, data.replacement_method.to_s)
+              if deprecated.correctable?
+                corrector.replace(node.loc.selector, replacement(deprecated).method)
+              end
             end
           end
         end
@@ -78,29 +133,16 @@ module RuboCop
         private
 
         def check(node)
-          DEPRECATED_METHODS_OBJECT.each do |data|
-            next unless data.class_nodes.include?(node.receiver)
-            next unless node.method?(data.deprecated_method)
+          DEPRECATED_METHODS_OBJECT.each_key do |deprecated|
+            next unless deprecated.class_nodes.include?(node.receiver)
+            next unless node.method?(deprecated.method)
 
-            yield data
+            yield deprecated
           end
         end
 
-        def deprecated_method(data)
-          method_call(data.class_constant, data.deprecated_method)
-        end
-
-        def replacement_method(data)
-          method_call(data.class_constant, data.replacement_method)
-        end
-
-        def method_call(class_constant, method)
-          if class_constant
-            format('%<constant>s.%<method>s', constant: class_constant,
-                                              method: method)
-          else
-            format('%<method>s', method: method)
-          end
+        def replacement(deprecated)
+          DEPRECATED_METHODS_OBJECT[deprecated]
         end
       end
     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,8 +41,7 @@ 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
 
@@ -62,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

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

@@ -104,8 +104,7 @@ module RuboCop
         def offense_range(duplicate_branch)
           parent = duplicate_branch.parent
 
-          if parent.respond_to?(:else_branch) &&
-             parent.else_branch.equal?(duplicate_branch)
+          if parent.respond_to?(:else_branch) && parent.else_branch.equal?(duplicate_branch)
             if parent.if_type? && parent.ternary?
               duplicate_branch.source_range
             else

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

@@ -28,9 +28,7 @@ module RuboCop
 
           return unless duplicates?(keys)
 
-          consecutive_duplicates(keys).each do |key|
-            add_offense(key)
-          end
+          consecutive_duplicates(keys).each { |key| add_offense(key) }
         end
       end
     end

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

@@ -50,11 +50,9 @@ module RuboCop
       #
       #   alias bar foo
       class DuplicateMethods < Base
-        MSG = 'Method `%<method>s` is defined at both %<defined>s and ' \
-              '%<current>s.'
+        MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
 
-        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer
-                              attr_accessor attr].freeze
+        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -192,9 +190,7 @@ module RuboCop
             namespace, mod_name = *ancestor.defined_module
             loop do
               if mod_name == const_name
-                return qualified_name(ancestor.parent_module_name,
-                                      namespace,
-                                      mod_name)
+                return qualified_name(ancestor.parent_module_name, namespace, mod_name)
               end
 
               break if namespace.nil?

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

@@ -74,9 +74,7 @@ module RuboCop
           return unless first_else
           return unless first_else.source_range.line == node.loc.else.line
 
-          add_offense(first_else) do |corrector|
-            autocorrect(corrector, node, first_else)
-          end
+          add_offense(first_else) { |corrector| autocorrect(corrector, node, first_else) }
         end
 
         def autocorrect(corrector, node, first_else)

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

@@ -7,7 +7,11 @@ module RuboCop
       # Such empty blocks are typically an oversight or we should provide a comment
       # be clearer what we're aiming for.
       #
-      # Empty lambdas are ignored by default.
+      # Empty lambdas and procs are ignored by default.
+      #
+      # NOTE: For backwards compatibility, the configuration that allows/disallows
+      # empty lambdas and procs is called `AllowEmptyLambdas`, even though it also
+      # applies to procs.
       #
       # @example
       #   # bad
@@ -40,6 +44,10 @@ module RuboCop
       #   end
       #   (callable || placeholder).call
       #
+      #   proc { }
+      #
+      #   Proc.new { }
+      #
       # @example AllowEmptyLambdas: false
       #   # bad
       #   allow(subject).to receive(:callable).and_return(-> {})
@@ -48,12 +56,16 @@ module RuboCop
       #   end
       #   (callable || placeholder).call
       #
+      #   proc { }
+      #
+      #   Proc.new { }
+      #
       class EmptyBlock < Base
         MSG = 'Empty block detected.'
 
         def on_block(node)
           return if node.body
-          return if allow_empty_lambdas? && node.lambda?
+          return if allow_empty_lambdas? && lambda_or_proc?(node)
           return if cop_config['AllowComments'] && allow_comment?(node)
 
           add_offense(node)
@@ -76,6 +88,10 @@ module RuboCop
           regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
           Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
         end
+
+        def lambda_or_proc?(node)
+          node.lambda? || node.proc?
+        end
       end
     end
   end

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

@@ -50,9 +50,7 @@ module RuboCop
         def on_ensure(node)
           return if node.body
 
-          add_offense(node.loc.keyword) do |corrector|
-            corrector.remove(node.loc.keyword)
-          end
+          add_offense(node.loc.keyword) { |corrector| corrector.remove(node.loc.keyword) }
         end
       end
     end

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

@@ -40,9 +40,7 @@ module RuboCop
         end
 
         def contains_only_comments?
-          processed_source.lines.all? do |line|
-            line.blank? || comment_line?(line)
-          end
+          processed_source.lines.all? { |line| line.blank? || comment_line?(line) }
         end
       end
     end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of `in` pattern branches without a body.
+      #
+      # @example
+      #
+      #   # bad
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #   end
+      #
+      #   # good
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #     nil
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #     # noop
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #     # noop
+      #   end
+      #
+      class EmptyInPattern < Base
+        extend TargetRubyVersion
+
+        MSG = 'Avoid `in` branches without a body.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(node)
+          node.in_pattern_branches.each do |branch|
+            next if branch.body || cop_config['AllowComments'] && comment_lines?(node)
+
+            add_offense(branch)
+          end
+        end
+      end
+    end
+  end
+end