rubocop 0.75.0 → 0.79.0

data/lib/rubocop/cop/style/copyright.rb

@@ -33,13 +33,7 @@ module RuboCop
         end
 
         def autocorrect(token)
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
-
-          regex = Regexp.new(notice)
-          unless autocorrect_notice =~ regex
-            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-                           "match Notice /#{notice}/"
-          end
+          verify_autocorrect_notice!
 
           lambda do |corrector|
             range = token.nil? ? range_between(0, 0) : token.pos
@@ -57,6 +51,16 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
+        def verify_autocorrect_notice!
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+
+          regex = Regexp.new(notice)
+          return if autocorrect_notice =~ regex
+
+          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+                         "match Notice /#{notice}/"
+        end
+
         def insert_notice_before(processed_source)
           token_index = 0
           token_index += 1 if shebang_token?(processed_source, token_index)

data/lib/rubocop/cop/style/documentation_method.rb

@@ -47,6 +47,50 @@ module RuboCop
       #   def foo.bar
       #     puts baz
       #   end
+      #
+      # @example RequireForNonPublicMethods: false (default)
+      #   # good
+      #   class Foo
+      #     protected
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   class Foo
+      #     private
+      #     def do_something
+      #     end
+      #   end
+      #
+      # @example RequireForNonPublicMethods: true
+      #   # bad
+      #   class Foo
+      #     protected
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   class Foo
+      #     private
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     protected
+      #     # Documentation
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   class Foo
+      #     private
+      #     # Documentation
+      #     def do_something
+      #     end
+      #   end
+      #
       class DocumentationMethod < Cop
         include DocumentationComment
         include DefNode

data/lib/rubocop/cop/style/double_cop_disable_directive.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 # rubocop:disable Style/DoubleCopDisableDirective
 
 module RuboCop
@@ -26,7 +26,7 @@ module RuboCop
       #
       class DoubleCopDisableDirective < Cop
         # rubocop:enable Style/For, Style/DoubleCopDisableDirective
-        # rubocop:enable Lint/UnneededCopDisableDirective, Metrics/AbcSize
+        # rubocop:enable Lint/RedundantCopDisableDirective, Metrics/AbcSize
         MSG = 'More than one disable comment on one line.'
 
         def investigate(processed_source)

data/lib/rubocop/cop/style/empty_case_condition.rb

@@ -84,8 +84,8 @@ module RuboCop
 
             next unless conditions.size > 1
 
-            range = range_between(conditions.first.loc.expression.begin_pos,
-                                  conditions.last.loc.expression.end_pos)
+            range = range_between(conditions.first.source_range.begin_pos,
+                                  conditions.last.source_range.end_pos)
 
             corrector.replace(range, conditions.map(&:source).join(' || '))
           end

data/lib/rubocop/cop/style/empty_literal.rb

@@ -84,8 +84,8 @@ module RuboCop
             # to rewrite the arguments to wrap them in parenthesis.
             args = node.parent.arguments
 
-            range_between(args[0].loc.expression.begin_pos - 1,
-                          args[-1].loc.expression.end_pos)
+            range_between(args[0].source_range.begin_pos - 1,
+                          args[-1].source_range.end_pos)
           else
             node.source_range
           end

data/lib/rubocop/cop/style/empty_method.rb

@@ -73,11 +73,11 @@ module RuboCop
         end
 
         def corrected(node)
-          has_parentheses = parentheses?(node.arguments)
-
-          arguments   = node.arguments? ? node.arguments.source : ''
-          extra_space = node.arguments? && !has_parentheses ? ' ' : ''
-          scope       = node.receiver ? "#{node.receiver.source}." : ''
+          if node.arguments?
+            arguments   = node.arguments.source
+            extra_space = ' ' unless parentheses?(node.arguments)
+          end
+          scope = node.receiver ? "#{node.receiver.source}." : ''
 
           signature = [scope, node.method_name, extra_space, arguments].join
 

data/lib/rubocop/cop/style/eval_with_location.rb

@@ -85,7 +85,7 @@ module RuboCop
         # FIXME: It's a Style/ConditionalAssignment's false positive.
         # rubocop:disable Style/ConditionalAssignment
         def with_lineno?(node)
-          if node.method_name == :eval
+          if node.method?(:eval)
             node.arguments.size == 4
           else
             node.arguments.size == 3

data/lib/rubocop/cop/style/even_odd.rb

@@ -23,7 +23,7 @@ module RuboCop
             {(send $_ :% (int 2))
              (begin (send $_ :% (int 2)))}
             ${:== :!=}
-            (int ${0 1 2}))
+            (int ${0 1}))
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/style/expand_path_arguments.rb

@@ -160,7 +160,7 @@ module RuboCop
         def depth(current_path)
           paths = current_path.split(File::SEPARATOR)
 
-          paths.reject { |path| path == '.' }.count
+          paths.count { |path| path != '.' }
         end
 
         def parent_path(current_path)

data/lib/rubocop/cop/style/format_string.rb

@@ -94,10 +94,12 @@ module RuboCop
         private
 
         def autocorrect_from_percent(corrector, node)
-          args = if %i[array hash].include?(node.first_argument.type)
-                   node.first_argument.children.map(&:source).join(', ')
+          percent_rhs = node.first_argument
+          args = case percent_rhs.type
+                 when :array, :hash
+                   percent_rhs.children.map(&:source).join(', ')
                  else
-                   node.first_argument.source
+                   percent_rhs.source
                  end
 
           corrected = "#{style}(#{node.receiver.source}, #{args})"
@@ -106,14 +108,15 @@ module RuboCop
         end
 
         def autocorrect_to_percent(corrector, node)
-          format = node.first_argument.source
+          format_arg, *param_args = node.arguments
+          format = format_arg.source
 
-          args = if node.arguments.size == 2
-                   arg = node.arguments.last
+          args = if param_args.one?
+                   arg = param_args.last
 
                    arg.hash_type? ? "{ #{arg.source} }" : arg.source
                  else
-                   "[#{node.arguments[1..-1].map(&:source).join(', ')}]"
+                   "[#{param_args.map(&:source).join(', ')}]"
                  end
 
           corrector.replace(node.loc.expression, "#{format} % #{args}")

data/lib/rubocop/cop/style/format_string_token.rb

@@ -8,7 +8,7 @@ module RuboCop
       # **Note:**
       # `unannotated` style cop only works for strings
       # which are passed as arguments to those methods:
-      # `sprintf`, `format`, `%`.
+      # `printf`, `sprintf`, `format`, `%`.
       # The reason is that *unannotated* format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
@@ -41,10 +41,7 @@ module RuboCop
       class FormatStringToken < Cop
         include ConfigurableEnforcedStyle
 
-        FORMAT_STRING_METHODS = %i[sprintf format %].freeze
-
         def on_str(node)
-          return if placeholder_argument?(node)
           return if node.each_ancestor(:xstr, :regexp).any?
 
           tokens(node) do |detected_style, token_range|
@@ -61,14 +58,16 @@ module RuboCop
 
         private
 
-        def includes_format_methods?(node)
-          node.each_ancestor(:send).any? do |ancestor|
-            FORMAT_STRING_METHODS.include?(ancestor.method_name)
-          end
-        end
+        def_node_matcher :format_string_in_typical_context?, <<~PATTERN
+          {
+            ^(send _ {:format :sprintf :printf} %0 ...)
+            ^(send %0 :% _)
+          }
+        PATTERN
 
         def unannotated_format?(node, detected_style)
-          detected_style == :unannotated && !includes_format_methods?(node)
+          detected_style == :unannotated &&
+            !format_string_in_typical_context?(node)
         end
 
         def message(detected_style)
@@ -95,11 +94,7 @@ module RuboCop
           if source_map.is_a?(Parser::Source::Map::Heredoc)
             source_map.heredoc_body
           elsif source_map.begin
-            slice_source(
-              source_map.expression,
-              source_map.expression.begin_pos + 1,
-              source_map.expression.end_pos - 1
-            )
+            source_map.expression.adjust(begin_pos: +1, end_pos: -1)
           else
             source_map.expression
           end
@@ -109,31 +104,17 @@ module RuboCop
           format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
 
           format_string.format_sequences.each do |seq|
+            next if seq.percent?
+
             detected_style = seq.style
-            token = slice_source(
-              contents,
-              contents.begin_pos + seq.begin_pos,
-              contents.begin_pos + seq.end_pos
+            token = contents.begin.adjust(
+              begin_pos: seq.begin_pos,
+              end_pos:   seq.end_pos
             )
 
             yield(detected_style, token)
           end
         end
-
-        def slice_source(source_range, new_begin, new_end)
-          Parser::Source::Range.new(
-            source_range.source_buffer,
-            new_begin,
-            new_end
-          )
-        end
-
-        def placeholder_argument?(node)
-          return false unless node.parent
-          return true if node.parent.pair_type?
-
-          placeholder_argument?(node.parent)
-        end
       end
     end
   end

data/lib/rubocop/cop/style/frozen_string_literal_comment.rb

@@ -11,6 +11,9 @@ module RuboCop
       # encoding comment. The frozen string literal comment is only valid in
       # Ruby 2.3+.
       #
+      # Note that the cop will ignore files where the comment exists but is set
+      # to `false` instead of `true`.
+      #
       # @example EnforcedStyle: always (default)
       #   # The `always` style will always add the frozen string literal comment
       #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
@@ -27,6 +30,13 @@ module RuboCop
       #     # ...
       #   end
       #
+      #   # good
+      #   # frozen_string_literal: false
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
       # @example EnforcedStyle: never
       #   # The `never` will enforce that the frozen string literal comment does
       #   # not exist in a file.

data/lib/rubocop/cop/style/guard_clause.rb

@@ -49,8 +49,9 @@ module RuboCop
 
           if body.if_type?
             check_ending_if(body)
-          elsif body.begin_type? && body.children.last.if_type?
-            check_ending_if(body.children.last)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
           end
         end
         alias on_defs on_def

data/lib/rubocop/cop/style/hash_syntax.rb

@@ -168,10 +168,10 @@ module RuboCop
         end
 
         def autocorrect_ruby19(corrector, pair_node)
-          key = pair_node.key
+          key = pair_node.key.source_range
           op = pair_node.loc.operator
 
-          range = range_between(key.source_range.begin_pos, op.end_pos)
+          range = key.join(op)
           range = range_with_surrounding_space(range: range, side: :right)
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''

data/lib/rubocop/cop/style/if_unless_modifier.rb

@@ -7,7 +7,7 @@ module RuboCop
       # written as modifier `if`/`unless`. The cop also checks for modifier
       # `if`/`unless` lines that exceed the maximum line length.
       #
-      # The maximum line length is configured in the `Metrics/LineLength`
+      # The maximum line length is configured in the `Layout/LineLength`
       # cop. The tab size is configured in the `IndentationWidth` of the
       # `Layout/Tab` cop.
       #
@@ -32,6 +32,8 @@ module RuboCop
       #   end
       class IfUnlessModifier < Cop
         include StatementModifier
+        include LineLengthHelp
+        include IgnoredPattern
 
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
@@ -66,12 +68,52 @@ module RuboCop
 
         private
 
+        def ignored_patterns
+          config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
+        end
+
         def too_long_single_line?(node)
           return false unless max_line_length
 
           range = node.source_range
-          range.first_line == range.last_line &&
-            range.last_column > max_line_length
+          return false unless range.first_line == range.last_line
+          return false unless line_length_enabled_at_line?(range.first_line)
+
+          line = range.source_line
+          return false if line_length(line) <= max_line_length
+
+          too_long_line_based_on_config?(range, line)
+        end
+
+        def too_long_line_based_on_config?(range, line)
+          return false if matches_ignored_pattern?(line)
+
+          too_long = too_long_line_based_on_ignore_cop_directives?(range, line)
+          return too_long unless too_long == :undetermined
+
+          too_long_line_based_on_allow_uri?(line)
+        end
+
+        def too_long_line_based_on_ignore_cop_directives?(range, line)
+          if ignore_cop_directives? && directive_on_source_line?(range.line - 1)
+            return line_length_without_directive(line) > max_line_length
+          end
+
+          :undetermined
+        end
+
+        def too_long_line_based_on_allow_uri?(line)
+          if allow_uri?
+            uri_range = find_excessive_uri_range(line)
+            return false if uri_range && allowed_uri_position?(line, uri_range)
+          end
+
+          true
+        end
+
+        def line_length_enabled_at_line?(line)
+          processed_source.comment_config
+                          .cop_enabled_at_line?('Layout/LineLength', line)
         end
 
         def named_capture_in_condition?(node)

data/lib/rubocop/cop/style/infinite_loop.rb

@@ -58,7 +58,7 @@ module RuboCop
           # `loop do` without further modification. The reason is that a
           # variable that's introduced inside a while/until loop is in scope
           # outside of that loop too, but a variable that's assigned for the
-          # first time inside a block can not be accessed after the block. In
+          # first time inside a block cannot be accessed after the block. In
           # those more complicated cases we don't report an offense.
           return if @variables.any? do |var|
             assigned_inside_loop?(var, range) &&
@@ -97,12 +97,13 @@ module RuboCop
         end
 
         def modifier_replacement(node)
+          body = node.body
           if node.single_line?
-            'loop { ' + node.body.source + ' }'
+            'loop { ' + body.source + ' }'
           else
-            indentation = node.body.loc.expression.source_line[LEADING_SPACE]
+            indentation = body.source_range.source_line[LEADING_SPACE]
 
-            ['loop do', node.body.source.gsub(/^/, configured_indent),
+            ['loop do', body.source.gsub(/^/, configured_indent),
              'end'].join("\n#{indentation}")
           end
         end