rubocop 1.10.0 → 1.14.0

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

@@ -24,10 +24,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_REQUIRE_SPACE = 'Use a space between `->` and ' \
-                            '`(` in lambda literals.'
-        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and ' \
-                               '`(` in lambda literals.'
+        MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
+        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
 
         def on_send(node)
           return unless arrow_lambda_with_args?(node)

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

@@ -142,11 +142,9 @@ module RuboCop
           case style
           when :no_space
             start_ok = next_to_comment?(node, left)
-            no_space_offenses(node, left, right, MSG, start_ok: start_ok,
-                                                      end_ok: end_ok)
+            no_space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           when :space
-            space_offenses(node, left, right, MSG, start_ok: start_ok,
-                                                   end_ok: end_ok)
+            space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           else
             compact_offenses(node, left, right, start_ok, end_ok)
           end
@@ -160,21 +158,18 @@ module RuboCop
           if qualifies_for_compact?(node, left, side: :left)
             compact_offense(node, left, side: :left)
           elsif !multi_dimensional_array?(node, left, side: :left)
-            space_offenses(node, left, nil, MSG, start_ok: start_ok,
-                                                 end_ok: true)
+            space_offenses(node, left, nil, MSG, start_ok: start_ok, end_ok: true)
           end
           if qualifies_for_compact?(node, right)
             compact_offense(node, right)
           elsif !multi_dimensional_array?(node, right)
-            space_offenses(node, nil, right, MSG, start_ok: true,
-                                                  end_ok: end_ok)
+            space_offenses(node, nil, right, MSG, start_ok: true, end_ok: end_ok)
           end
         end
 
         def qualifies_for_compact?(node, token, side: :right)
           if side == :right
-            multi_dimensional_array?(node, token) &&
-              !next_to_bracket?(token)
+            multi_dimensional_array?(node, token) && !next_to_bracket?(token)
           else
             multi_dimensional_array?(node, token, side: :left) &&
               !next_to_bracket?(token, side: :left)

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

@@ -16,7 +16,7 @@ module RuboCop
       # ----
       # Lint/Debugger:
       #   WebConsole: ~
-      # ---
+      # ----
       #
       #
       # @example
@@ -59,10 +59,12 @@ module RuboCop
 
         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)

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

@@ -24,17 +24,17 @@ module RuboCop
         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 +48,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 +129,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