rubocop 1.9.1 → 1.22.3

data/lib/rubocop/cop/mixin/rational_literal.rb

@@ -8,6 +8,7 @@ module RuboCop
 
       private
 
+      # @!method rational_literal?(node)
       def_node_matcher :rational_literal?, <<~PATTERN
         (send
           (int _) :/

data/lib/rubocop/cop/mixin/require_library.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Ensure a require statement is present for a standard library determined
+    # by variable library_name
+    module RequireLibrary
+      extend NodePattern::Macros
+
+      def ensure_required(corrector, node, library_name)
+        node = node.parent while node.parent&.parent?
+
+        if node.parent&.begin_type?
+          return if @required_libs.include?(library_name)
+
+          remove_subsequent_requires(corrector, node, library_name)
+        end
+
+        RequireLibraryCorrector.correct(corrector, node, library_name)
+      end
+
+      def remove_subsequent_requires(corrector, node, library_name)
+        node.right_siblings.each do |sibling|
+          next unless require_library_name?(sibling, library_name)
+
+          range = range_by_whole_lines(sibling.source_range, include_final_newline: true)
+          corrector.remove(range)
+        end
+      end
+
+      def on_send(node)
+        return if node.parent&.parent?
+
+        name = require_any_library?(node)
+        return if name.nil?
+
+        @required_libs.add(name)
+      end
+
+      private
+
+      def on_new_investigation
+        # Holds the required files at top-level
+        @required_libs = Set.new
+        super
+      end
+
+      # @!method require_any_library?(node)
+      def_node_matcher :require_any_library?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str $_))
+      PATTERN
+
+      # @!method require_library_name?(node, library_name)
+      def_node_matcher :require_library_name?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str %1))
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/mixin/rescue_node.rb

@@ -5,17 +5,13 @@ module RuboCop
     # Common functionality for checking `rescue` nodes.
     module RescueNode
       def on_new_investigation
-        @modifier_locations = processed_source
-                              .tokens
-                              .select(&:rescue_modifier?)
-                              .map(&:pos)
+        @modifier_locations = processed_source.tokens.select(&:rescue_modifier?).map(&:pos)
       end
 
       private
 
       def rescue_modifier?(node)
-        node&.resbody_type? &&
-          @modifier_locations.include?(node.loc.keyword)
+        node&.resbody_type? && @modifier_locations.include?(node.loc.keyword)
       end
 
       # @deprecated Use ResbodyNode#exceptions instead

data/lib/rubocop/cop/mixin/safe_assignment.rb

@@ -10,10 +10,14 @@ module RuboCop
 
       private
 
+      # @!method empty_condition?(node)
       def_node_matcher :empty_condition?, '(begin)'
+
+      # @!method setter_method?(node)
       def_node_matcher :setter_method?, '[(send ...) setter_method?]'
-      def_node_matcher :safe_assignment?,
-                       '(begin {equals_asgn? #setter_method?})'
+
+      # @!method safe_assignment?(node)
+      def_node_matcher :safe_assignment?, '(begin {equals_asgn? #setter_method?})'
 
       def safe_assignment_allowed?
         cop_config['AllowSafeAssignment']

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -28,13 +28,11 @@ module RuboCop
       end
 
       def space_missing?(token1, token2)
-        token1.line == token2.line &&
-          token2.column == token1.column + offset
+        same_line?(token1, token2) && token2.column == token1.column + offset
       end
 
       def space_required_before?(token)
-        !(allowed_type?(token) ||
-          (token.right_curly_brace? && space_forbidden_before_rcurly?))
+        !(allowed_type?(token) || (token.right_curly_brace? && space_forbidden_before_rcurly?))
       end
 
       def allowed_type?(token)

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -10,7 +10,7 @@ module RuboCop
       MSG = 'Space found before %<token>s.'
 
       def on_new_investigation
-        each_missing_space(processed_source.tokens) do |token, pos_before|
+        each_missing_space(processed_source.sorted_tokens) do |token, pos_before|
           add_offense(pos_before, message: format(MSG, token: kind(token))) do |corrector|
             PunctuationCorrector.remove_space(corrector, pos_before)
           end
@@ -25,15 +25,14 @@ module RuboCop
           next unless space_missing?(token1, token2)
           next if space_required_after?(token1)
 
-          pos_before_punctuation = range_between(token1.end_pos,
-                                                 token2.begin_pos)
+          pos_before_punctuation = range_between(token1.end_pos, token2.begin_pos)
 
           yield token2, pos_before_punctuation
         end
       end
 
       def space_missing?(token1, token2)
-        token1.line == token2.line && token2.begin_pos > token1.end_pos
+        same_line?(token1, token2) && token2.begin_pos > token1.end_pos
       end
 
       def space_required_after?(token)

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -48,15 +48,13 @@ module RuboCop
       end
 
       def to_modifier_form(node)
-        expression = [node.body.source,
-                      node.keyword,
-                      node.condition.source].compact.join(' ')
+        expression = [node.body.source, node.keyword, node.condition.source].compact.join(' ')
         parenthesized = parenthesize?(node) ? "(#{expression})" : expression
         [parenthesized, first_line_comment(node)].compact.join(' ')
       end
 
       def first_line_comment(node)
-        comment = processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        comment = processed_source.find_comment { |c| same_line?(c, node) }
         return unless comment
 
         comment_source = comment.loc.expression.source

data/lib/rubocop/cop/mixin/string_literals_help.rb

@@ -4,18 +4,20 @@ module RuboCop
   module Cop
     # Common functionality for cops checking single/double quotes.
     module StringLiteralsHelp
-      include StringHelp
-
       private
 
-      def wrong_quotes?(node)
-        src = node.source
+      def wrong_quotes?(src_or_node)
+        src = src_or_node.is_a?(RuboCop::AST::Node) ? src_or_node.source : src_or_node
         return false if src.start_with?('%', '?')
 
         if style == :single_quotes
           !double_quotes_required?(src)
         else
-          !/" | \\[^'] | \#(@|\{)/x.match?(src)
+          # The string needs single quotes if:
+          # 1. It contains a double quote
+          # 2. It contains text that would become an escape sequence with double quotes
+          # 3. It contains text that would become an interpolation with double quotes
+          !/" | (?<!\\)\\[aAbcdefkMnprsStuUxzZ0-7] | \#[@{$]/x.match?(src)
         end
       end
     end

data/lib/rubocop/cop/mixin/symbol_help.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Classes that include this module just implement functions for working
+    # with symbol nodes.
+    module SymbolHelp
+      def hash_key?(node)
+        node.parent&.pair_type? && node == node.parent.child_nodes.first
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/trailing_body.rb

@@ -6,12 +6,11 @@ module RuboCop
     module TrailingBody
       def trailing_body?(node)
         body = node.to_a.reverse[0]
-        body && node.multiline? &&
-          body_on_first_line?(node, body)
+        body && node.multiline? && body_on_first_line?(node, body)
       end
 
       def body_on_first_line?(node, body)
-        node.source_range.first_line == body.source_range.first_line
+        same_line?(node, body)
       end
 
       def first_part_of(body)

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -95,8 +95,7 @@ module RuboCop
 
         line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
 
-        line == node.last_argument.last_line &&
-          node.last_line == node.last_argument.last_line
+        line == node.last_argument.last_line && node.last_line == node.last_argument.last_line
       end
 
       # A single argument with the closing bracket on the same line as the end

data/lib/rubocop/cop/mixin/uncommunicative_name.rb

@@ -6,10 +6,8 @@ module RuboCop
     module UncommunicativeName
       CASE_MSG = 'Only use lowercase characters for %<name_type>s.'
       NUM_MSG = 'Do not end %<name_type>s with a number.'
-      LENGTH_MSG = '%<name_type>s must be at least %<min>s ' \
-                   'characters long.'
-      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a ' \
-                      '%<name_type>s.'
+      LENGTH_MSG = '%<name_type>s must be at least %<min>s characters long.'
+      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a %<name_type>s.'
 
       def check(node, args)
         args.each do |arg|
@@ -53,12 +51,10 @@ module RuboCop
       end
 
       def name_type(node)
-        @name_type ||= begin
-          case node.type
-          when :block then 'block parameter'
-          when :def, :defs then 'method parameter'
-          end
-        end
+        @name_type ||= case node.type
+                       when :block then 'block parameter'
+                       when :def, :defs then 'method parameter'
+                       end
       end
 
       def num_offense(node, range)
@@ -81,9 +77,7 @@ module RuboCop
 
       def arg_range(arg, length)
         begin_pos = arg.source_range.begin_pos
-        Parser::Source::Range.new(processed_source.buffer,
-                                  begin_pos,
-                                  begin_pos + length)
+        Parser::Source::Range.new(processed_source.buffer, begin_pos, begin_pos + length)
       end
 
       def forbidden_offense(node, range, name)

data/lib/rubocop/cop/mixin/unused_argument.rb

@@ -8,9 +8,7 @@ module RuboCop
         extend NodePattern::Macros
 
         def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_argument(variable)
-          end
+          scope.variables.each_value { |variable| check_argument(variable) }
         end
 
         private

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -28,6 +28,7 @@ module RuboCop
         end || right.last
       end
 
+      # @!method visibility_block?(node)
       def_node_matcher :visibility_block?, <<~PATTERN
         (send nil? { :private :protected :public })
       PATTERN

data/lib/rubocop/cop/naming/ascii_identifiers.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/AsciiComments
-
 module RuboCop
   module Cop
     module Naming
@@ -70,16 +68,14 @@ module RuboCop
         private
 
         def should_check?(token)
-          token.type == :tIDENTIFIER ||
-            (token.type == :tCONSTANT && cop_config['AsciiConstants'])
+          token.type == :tIDENTIFIER || (token.type == :tCONSTANT && cop_config['AsciiConstants'])
         end
 
         def first_offense_range(identifier)
           expression    = identifier.pos
           first_offense = first_non_ascii_chars(identifier.text)
 
-          start_position = expression.begin_pos +
-                           identifier.text.index(first_offense)
+          start_position = expression.begin_pos + identifier.text.index(first_offense)
           end_position   = start_position + first_offense.length
 
           range_between(start_position, end_position)
@@ -92,4 +88,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Style/AsciiComments

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -16,12 +16,12 @@ module RuboCop
       class BinaryOperatorParameterName < Base
         extend AutoCorrector
 
-        MSG = 'When defining the `%<opr>s` operator, ' \
-              'name its argument `other`.'
+        MSG = 'When defining the `%<opr>s` operator, name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
         EXCLUDED = %i[+@ -@ [] []= << === ` =~].freeze
 
+        # @!method op_method_candidate?(node)
         def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
         PATTERN

data/lib/rubocop/cop/naming/block_parameter_name.rb

@@ -24,7 +24,7 @@ module RuboCop
       #   # With `AllowNamesEndingInNumbers` set to false
       #   foo { |num1, num2| num1 * num2 }
       #
-      #   # With `MinParamNameLength` set to number greater than 1
+      #   # With `MinNameLength` set to number greater than 1
       #   baz { |a, b, c| do_stuff(a, b, c) }
       #
       #   # good

data/lib/rubocop/cop/naming/constant_name.rb

@@ -23,6 +23,7 @@ module RuboCop
         # than just standard ASCII characters
         SNAKE_CASE = /^[[:digit:][:upper:]_]+$/.freeze
 
+        # @!method class_or_struct_return_method?(node)
         def_node_matcher :class_or_struct_return_method?, <<~PATTERN
           (send
             (const _ {:Class :Struct}) :new
@@ -53,7 +54,7 @@ module RuboCop
         private
 
         def allowed_assignment?(value)
-          value && %i[block const casgn].include?(value.type) ||
+          (value && %i[block const casgn].include?(value.type)) ||
             allowed_method_call_on_rhs?(value) ||
             class_or_struct_return_method?(value) ||
             allowed_conditional_expression_on_rhs?(value)
@@ -64,6 +65,7 @@ module RuboCop
             (node.receiver.nil? || !literal_receiver?(node))
         end
 
+        # @!method literal_receiver?(node)
         def_node_matcher :literal_receiver?, <<~PATTERN
           {(send literal? ...)
            (send (begin literal?) ...)}

data/lib/rubocop/cop/naming/file_name.rb

@@ -27,22 +27,17 @@ module RuboCop
       class FileName < Base
         include RangeHelp
 
-        MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) ' \
-                         'should use snake_case.'
-        MSG_NO_DEFINITION = '%<basename>s should define a class or module ' \
-                            'called `%<namespace>s`.'
+        MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) should use snake_case.'
+        MSG_NO_DEFINITION = '%<basename>s should define a class or module called `%<namespace>s`.'
         MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
 
         SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
         def on_new_investigation
           file_path = processed_source.file_path
-          return if config.file_to_exclude?(file_path) ||
-                    config.allowed_camel_case_file?(file_path)
+          return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
 
-          for_bad_filename(file_path) do |range, msg|
-            add_offense(range, message: msg)
-          end
+          for_bad_filename(file_path) { |range, msg| add_offense(range, message: msg) }
         end
 
         private
@@ -62,8 +57,7 @@ module RuboCop
         def perform_class_and_module_naming_checks(file_path, basename)
           return unless expect_matching_definition?
 
-          if check_definition_path_hierarchy? &&
-             !matching_definition?(file_path)
+          if check_definition_path_hierarchy? && !matching_definition?(file_path)
             msg = no_definition_message(basename, file_path)
           elsif !matching_class?(basename)
             msg = no_definition_message(basename, basename)
@@ -136,8 +130,7 @@ module RuboCop
 
             const_namespace, const_name = *const
             next if name != const_name && !match_acronym?(name, const_name)
-            next unless namespace.empty? ||
-                        match_namespace(child, const_namespace, namespace)
+            next unless namespace.empty? || match_namespace(child, const_namespace, namespace)
 
             return node
           end
@@ -181,9 +174,7 @@ module RuboCop
           expected = expected.to_s
           name = name.to_s
 
-          allowed_acronyms.any? do |acronym|
-            expected.gsub(acronym.capitalize, acronym) == name
-          end
+          allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
         end
 
         def to_namespace(path)