rubocop 1.10.0 → 1.14.0

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,11 +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
@@ -61,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

@@ -74,7 +74,7 @@ module RuboCop
       #   else 250
       #   end
       #
-      # @example IgnoreLiteralBranches: true
+      # @example IgnoreConstantBranches: true
       #   # good
       #   case size
       #   when "small" then SMALL_SIZE
@@ -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
@@ -82,6 +80,7 @@ module RuboCop
           end
         end
 
+        # @!method method_alias?(node)
         def_node_matcher :method_alias?, <<~PATTERN
           (alias (sym $_name) sym)
         PATTERN
@@ -94,10 +93,12 @@ module RuboCop
           found_instance_method(node, name)
         end
 
+        # @!method alias_method?(node)
         def_node_matcher :alias_method?, <<~PATTERN
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
+        # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
         def on_send(node)
           if (name = alias_method?(node))
@@ -189,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/duplicate_require.rb

@@ -24,6 +24,7 @@ module RuboCop
         REQUIRE_METHODS = Set.new(%i[require require_relative]).freeze
         RESTRICT_ON_SEND = REQUIRE_METHODS
 
+        # @!method require_call?(node)
         def_node_matcher :require_call?, <<~PATTERN
           (send {nil? (const _ :Kernel)} %REQUIRE_METHODS _)
         PATTERN

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

@@ -25,6 +25,7 @@ module RuboCop
         MSG = 'The argument to each_with_object cannot be immutable.'
         RESTRICT_ON_SEND = %i[each_with_object].freeze
 
+        # @!method each_with_object?(node)
         def_node_matcher :each_with_object?, <<~PATTERN
           ({send csend} _ :each_with_object $_)
         PATTERN

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_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_interpolation.rb

@@ -25,9 +25,7 @@ module RuboCop
         def on_interpolation(begin_node)
           return unless begin_node.children.empty?
 
-          add_offense(begin_node) do |corrector|
-            corrector.remove(begin_node.loc.expression)
-          end
+          add_offense(begin_node) { |corrector| corrector.remove(begin_node.loc.expression) }
         end
       end
     end

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

@@ -51,9 +51,7 @@ module RuboCop
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
-          node.body&.each_node(:return) do |return_node|
-            add_offense(return_node)
-          end
+          node.body&.each_node(:return) { |return_node| add_offense(return_node) }
         end
       end
     end

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

@@ -80,6 +80,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method erb_new_with_non_keyword_arguments(node)
         def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
           (send
             (const {nil? cbase} :ERB) :new $...)
@@ -111,16 +112,13 @@ module RuboCop
           kwargs = build_kwargs(node)
           overridden_kwargs = override_by_legacy_args(kwargs, node)
 
-          good_arguments = [
-            str_arg, overridden_kwargs
-          ].flatten.compact.join(', ')
+          good_arguments = [str_arg, overridden_kwargs].flatten.compact.join(', ')
 
           corrector.replace(arguments_range(node), good_arguments)
         end
 
         def correct_arguments?(arguments)
-          arguments.size == 1 ||
-            arguments.size == 2 && arguments[1].hash_type?
+          arguments.size == 1 || arguments.size == 2 && arguments[1].hash_type?
         end
 
         def build_kwargs(node)
@@ -156,8 +154,7 @@ module RuboCop
         def arguments_range(node)
           arguments = node.arguments
 
-          range_between(arguments.first.source_range.begin_pos,
-                        arguments.last.source_range.end_pos)
+          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
         end
       end
     end

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

@@ -24,8 +24,7 @@ module RuboCop
         def on_float(node)
           value, = *node
 
-          return unless value.infinite? ||
-                        value.zero? && /[1-9]/.match?(node.source)
+          return unless value.infinite? || value.zero? && /[1-9]/.match?(node.source)
 
           add_offense(node)
         end

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

@@ -92,6 +92,7 @@ module RuboCop
           end
         end
 
+        # @!method called_on_string?(node)
         def_node_matcher :called_on_string?, <<~PATTERN
           {(send {nil? const_type?} _ (str _) ...)
            (send (str ...) ...)}
@@ -139,8 +140,7 @@ module RuboCop
         end
 
         def format_method?(name, node)
-          return false if node.const_receiver? &&
-                          !node.receiver.loc.name.is?(KERNEL)
+          return false if node.const_receiver? && !node.receiver.loc.name.is?(KERNEL)
           return false unless node.method?(name)
 
           node.arguments.size > 1 && node.first_argument.str_type?
@@ -173,11 +173,9 @@ module RuboCop
           receiver = node.receiver
 
           percent = node.method?(:%) &&
-                    (STRING_TYPES.include?(receiver.type) ||
-                     node.first_argument.array_type?)
+                    (STRING_TYPES.include?(receiver.type) || node.first_argument.array_type?)
 
-          return false if percent && STRING_TYPES.include?(receiver.type) &&
-                          heredoc?(node)
+          return false if percent && STRING_TYPES.include?(receiver.type) && heredoc?(node)
 
           percent
         end

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

@@ -24,6 +24,7 @@ module RuboCop
 
         MSG = 'Use `Hash#compare_by_identity` instead of using `object_id` for keys.'
 
+        # @!method id_as_hash_key?(node)
         def_node_matcher :id_as_hash_key?, <<~PATTERN
           (send _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
         PATTERN

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

@@ -34,8 +34,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Put a method call with a HEREDOC receiver on the ' \
-        'same line as the HEREDOC opening.'
+        MSG = 'Put a method call with a HEREDOC receiver on the same line as the HEREDOC opening.'
 
         def on_send(node)
           heredoc = heredoc_node_descendent_receiver(node)

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

@@ -73,8 +73,7 @@ module RuboCop
         end
 
         def string_literal?(node)
-          node.str_type? ||
-            (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
+          node.str_type? || (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
         end
 
         def string_literals?(node1, node2)

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

@@ -48,11 +48,10 @@ module RuboCop
       class IneffectiveAccessModifier < Base
         MSG = '`%<modifier>s` (on line %<line>d) does not make singleton ' \
               'methods %<modifier>s. Use %<alternative>s instead.'
-        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
-                              '`class << self` block'
-        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
-                                'block'
+        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a `class << self` block'
+        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` block'
 
+        # @!method private_class_methods(node)
         def_node_search :private_class_methods, <<~PATTERN
           (send nil? :private_class_method $...)
         PATTERN
@@ -73,9 +72,7 @@ module RuboCop
         end
 
         def private_class_method_names(node)
-          private_class_methods(node).to_a.flatten
-                                     .select(&:basic_literal?)
-                                     .map(&:value)
+          private_class_methods(node).to_a.flatten.select(&:basic_literal?).map(&:value)
         end
 
         def format_message(modifier)

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

@@ -58,6 +58,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method class_new_call?(node)
         def_node_matcher :class_new_call?, <<~PATTERN
           (send
             (const {cbase nil?} :Class) :new
@@ -65,8 +66,7 @@ module RuboCop
         PATTERN
 
         def on_class(node)
-          return unless node.parent_class &&
-                        illegal_class_name?(node.parent_class)
+          return unless node.parent_class && illegal_class_name?(node.parent_class)
 
           message = message(node.parent_class)
 

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

@@ -23,23 +23,16 @@ module RuboCop
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)
-          return unless node
-          return if string_or_regex?(node.parent)
+          return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
           return unless node.loc.begin && node.loc.end
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         private
 
-        def string_or_regex?(node)
-          node&.dstr_type? || node&.regexp_type?
-        end
-
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')
                                            ['%{', '}']
@@ -52,8 +45,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          node.loc.is_a?(Parser::Source::Map::Heredoc) ||
-            (node.parent && heredoc?(node.parent))
+          node.loc.is_a?(Parser::Source::Map::Heredoc) || (node.parent && heredoc?(node.parent))
         end
       end
     end

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

@@ -34,8 +34,7 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
-          return if in_array_percent_literal?(begin_node) &&
-                    /\s/.match?(expanded_value)
+          return if in_array_percent_literal?(begin_node) && /\s/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
             return if final_node.dstr_type? # nested, fixed in next iteration
@@ -56,8 +55,7 @@ module RuboCop
 
         def special_keyword?(node)
           # handle strings like __FILE__
-          (node.str_type? && !node.loc.respond_to?(:begin)) ||
-            node.source_range.is?('__LINE__')
+          (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
         def autocorrected_value(node)
@@ -101,8 +99,7 @@ module RuboCop
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)
           node.basic_literal? ||
-            (COMPOSITE.include?(node.type) &&
-              node.children.all? { |child| prints_as_self?(child) })
+            (COMPOSITE.include?(node.type) && node.children.all? { |child| prints_as_self?(child) })
         end
 
         def space_literal?(node)

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

@@ -49,8 +49,7 @@ module RuboCop
       class Loop < Base
         extend AutoCorrector
 
-        MSG = 'Use `Kernel#loop` with `break` rather than ' \
-              '`begin/end/until`(or `while`).'
+        MSG = 'Use `Kernel#loop` with `break` rather than `begin/end/until`(or `while`).'
 
         def on_while_post(node)
           register_offense(node)

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

@@ -45,10 +45,8 @@ module RuboCop
       class MissingCopEnableDirective < Base
         include RangeHelp
 
-        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after ' \
-              'disabling it.'
-        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after ' \
-                    'disabling it.'
+        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after disabling it.'
+        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after disabling it.'
 
         # rubocop:disable Metrics/AbcSize
         def on_new_investigation
@@ -59,9 +57,7 @@ module RuboCop
               # the case when max_range is Float::INFINITY
               next if line_range.max - line_range.min < max_range + 2
 
-              range = source_range(processed_source.buffer,
-                                   line_range.min,
-                                   (0..0))
+              range = source_range(processed_source.buffer, line_range.min, (0..0))
 
               add_offense(range, message: message(max_range: max_range, cop: cop))
             end