rubocop 1.19.0 → 1.33.0

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

@@ -3,12 +3,27 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of double negation (`!!`) to convert something to a boolean value.
+      # Checks for uses of double negation (`!!`) to convert something to a boolean value.
       #
       # When using `EnforcedStyle: allowed_in_returns`, allow double negation in contexts
       # that use boolean as a return value. When using `EnforcedStyle: forbidden`, double negation
       # should be forbidden always.
       #
+      # NOTE: when `something` is a boolean value
+      # `!!something` and `!something.nil?` are not the same thing.
+      # As you're unlikely to write code that can accept values of any type
+      # this is rarely a problem in practice.
+      #
+      # @safety
+      #   Autocorrection is unsafe when the value is `false`, because the result
+      #   of the expression will change.
+      #
+      #   [source,ruby]
+      #   ----
+      #   !!false     #=> false
+      #   !false.nil? #=> true
+      #   ----
+      #
       # @example
       #   # bad
       #   !!something
@@ -22,16 +37,27 @@ module RuboCop
       #     !!return_value
       #   end
       #
+      #   define_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      #   define_singleton_method :foo? do
+      #     !!return_value
+      #   end
+      #
       # @example EnforcedStyle: forbidden
       #   # bad
       #   def foo?
       #     !!return_value
       #   end
       #
-      # Please, note that when something is a boolean value
-      # !!something and !something.nil? are not the same thing.
-      # As you're unlikely to write code that can accept values of any type
-      # this is rarely a problem in practice.
+      #   define_method :foo? do
+      #     !!return_value
+      #   end
+      #
+      #   define_singleton_method :foo? do
+      #     !!return_value
+      #   end
       class DoubleNegation < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -62,17 +88,69 @@ module RuboCop
         def end_of_method_definition?(node)
           return false unless (def_node = find_def_node_from_ascendant(node))
 
-          last_child = def_node.child_nodes.last
+          conditional_node = find_conditional_node_from_ascendant(node)
+          last_child = find_last_child(def_node.send_type? ? def_node : def_node.body)
 
-          last_child.last_line == node.last_line
+          if conditional_node
+            double_negative_condition_return_value?(node, last_child, conditional_node)
+          else
+            last_child.last_line <= node.last_line
+          end
         end
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
           return parent if parent.def_type? || parent.defs_type?
+          return node.parent.child_nodes.first if define_mehod?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
+
+        def define_mehod?(node)
+          return false unless node.block_type?
+
+          child = node.child_nodes.first
+          return false unless child.send_type?
+
+          child.method?(:define_method) || child.method?(:define_singleton_method)
+        end
+
+        def find_conditional_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.conditional?
+
+          find_conditional_node_from_ascendant(parent)
+        end
+
+        def find_last_child(node)
+          case node.type
+          when :rescue
+            find_last_child(node.body)
+          when :ensure
+            find_last_child(node.child_nodes.first)
+          else
+            node.child_nodes.last
+          end
+        end
+
+        def double_negative_condition_return_value?(node, last_child, conditional_node)
+          parent = find_parent_not_enumerable(node)
+          if parent.begin_type?
+            node.loc.line == parent.loc.last_line
+          else
+            last_child.last_line <= conditional_node.last_line
+          end
+        end
+
+        def find_parent_not_enumerable(node)
+          return unless (parent = node.parent)
+
+          if parent.pair_type? || parent.hash_type? || parent.array_type?
+            find_parent_not_enumerable(parent)
+          else
+            parent
+          end
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for loops which iterate a constant number of times,
+      # Checks for loops which iterate a constant number of times,
       # using a Range literal and `#each`. This can be done more readably using
       # `Integer#times`.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for inject / reduce calls where the passed in object is
+      # Looks for inject / reduce calls where the passed in object is
       # returned at the end and so could be replaced by each_with_object without
       # the need to return the object at the end.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for pipes for empty block parameters. Pipes for empty
+      # Checks for pipes for empty block parameters. Pipes for empty
       # block parameters do not cause syntax errors, but they are redundant.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for case statements with an empty condition.
+      # Checks for case statements with an empty condition.
       #
       # @example
       #
@@ -47,8 +47,7 @@ module RuboCop
           branch_bodies = [*case_node.when_branches.map(&:body), case_node.else_branch].compact
 
           return if branch_bodies.any? do |body|
-            body.return_type? ||
-            body.each_descendant.any?(&:return_type?)
+            body.return_type? || body.each_descendant.any?(&:return_type?)
           end
 
           add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
@@ -70,7 +69,7 @@ module RuboCop
 
           keep_first_when_comment(case_range, corrector)
 
-          when_nodes[1..-1].each do |when_node|
+          when_nodes[1..].each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
           end
         end
@@ -79,6 +78,8 @@ module RuboCop
           when_nodes.each do |when_node|
             conditions = when_node.conditions
 
+            replace_then_with_line_break(corrector, conditions, when_node)
+
             next unless conditions.size > 1
 
             range = range_between(conditions.first.source_range.begin_pos,
@@ -97,6 +98,14 @@ module RuboCop
           line_beginning = case_range.adjust(begin_pos: -case_range.column)
           corrector.insert_before(line_beginning, comments)
         end
+
+        def replace_then_with_line_break(corrector, conditions, when_node)
+          return unless when_node.parent.parent && when_node.then?
+
+          range = range_between(conditions.last.source_range.end_pos, when_node.loc.begin.end_pos)
+
+          corrector.replace(range, "\n")
+        end
       end
     end
   end

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

@@ -6,6 +6,34 @@ module RuboCop
       # Checks for empty else-clauses, possibly including comments and/or an
       # explicit `nil` depending on the EnforcedStyle.
       #
+      # @example EnforcedStyle: both (default)
+      #   # warn on empty else and else with nil in it
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
       # @example EnforcedStyle: empty
       #   # warn only on empty else
       #
@@ -62,13 +90,13 @@ module RuboCop
       #     statement
       #   end
       #
-      # @example EnforcedStyle: both (default)
-      #   # warn on empty else and else with nil in it
+      # @example AllowComments: false (default)
       #
       #   # bad
       #   if condition
       #     statement
       #   else
+      #     # something comment
       #     nil
       #   end
       #
@@ -76,19 +104,26 @@ module RuboCop
       #   if condition
       #     statement
       #   else
+      #     # something comment
       #   end
       #
+      # @example AllowComments: true
+      #
       #   # good
       #   if condition
       #     statement
       #   else
-      #     statement
+      #     # something comment
+      #     nil
       #   end
       #
       #   # good
       #   if condition
       #     statement
+      #   else
+      #     # something comment
       #   end
+      #
       class EmptyElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
@@ -108,6 +143,8 @@ module RuboCop
         private
 
         def check(node)
+          return if cop_config['AllowComments'] && comment_in_else?(node.loc)
+
           empty_check(node) if empty_style?
           nil_check(node) if nil_style?
         end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for using empty heredoc to reduce redundancy.
+      #
+      # @example
+      #
+      #   # bad
+      #   <<~EOS
+      #   EOS
+      #
+      #   <<-EOS
+      #   EOS
+      #
+      #   <<EOS
+      #   EOS
+      #
+      #   # good
+      #   ''
+      #
+      #   # bad
+      #   do_something(<<~EOS)
+      #   EOS
+      #
+      #   do_something(<<-EOS)
+      #   EOS
+      #
+      #   do_something(<<EOS)
+      #   EOS
+      #
+      #   # good
+      #   do_something('')
+      #
+      class EmptyHeredoc < Base
+        include Heredoc
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use an empty string literal instead of heredoc.'
+
+        def on_heredoc(node)
+          heredoc_body = node.loc.heredoc_body
+
+          return unless heredoc_body.source.empty?
+
+          add_offense(node) do |corrector|
+            heredoc_end = node.loc.heredoc_end
+
+            corrector.replace(node, preferred_string_literal)
+            corrector.remove(range_by_whole_lines(heredoc_body, include_final_newline: true))
+            corrector.remove(range_by_whole_lines(heredoc_end, include_final_newline: true))
+          end
+        end
+
+        private
+
+        def preferred_string_literal
+          enforce_double_quotes? ? '""' : "''"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for parentheses for empty lambda parameters. Parentheses
+      # Checks for parentheses for empty lambda parameters. Parentheses
       # for empty lambda parameters do not cause syntax errors, but they are
       # redundant.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of a method, the result of which
+      # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
       # @example
@@ -119,7 +119,7 @@ module RuboCop
               # because the braces are interpreted as a block. We will have
               # to rewrite the arguments to wrap them in parenthesis.
               args = node.parent.arguments
-              "(#{args[1..-1].map(&:source).unshift('{}').join(', ')})"
+              "(#{args[1..].map(&:source).unshift('{}').join(', ')})"
             else
               '{}'
             end

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

@@ -3,13 +3,17 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the formatting of empty method definitions.
+      # Checks for the formatting of empty method definitions.
       # By default it enforces empty method definitions to go on a single
       # line (compact style), but it can be configured to enforce the `end`
       # to go on its own line (expanded style).
       #
       # NOTE: A method definition is not considered empty if it contains
-      #       comments.
+      # comments.
+      #
+      # NOTE: Autocorrection will not be applied for the `compact` style
+      # if the resulting code is longer than the `Max` configuration for
+      # `Layout/LineLength`, but an offense will still be registered.
       #
       # @example EnforcedStyle: compact (default)
       #   # bad
@@ -51,7 +55,12 @@ module RuboCop
           return if node.body || comment_lines?(node)
           return if correct_style?(node)
 
-          add_offense(node) { |corrector| corrector.replace(node, corrected(node)) }
+          add_offense(node) do |corrector|
+            correction = corrected(node)
+            next if compact_style? && max_line_length && correction.size > max_line_length
+
+            corrector.replace(node, correction)
+          end
         end
         alias on_defs on_def
 
@@ -62,7 +71,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          compact_style? && compact?(node) || expanded_style? && expanded?(node)
+          (compact_style? && compact?(node)) || (expanded_style? && expanded?(node))
         end
 
         def corrected(node)
@@ -98,6 +107,12 @@ module RuboCop
         def expanded_style?
           style == :expanded
         end
+
+        def max_line_length
+          return unless config.for_cop('Layout/LineLength')['Enabled']
+
+          config.for_cop('Layout/LineLength')['Max']
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks ensures source files have no utf-8 encoding comments.
+      # Checks ensures source files have no utf-8 encoding comments.
       # @example
       #   # bad
       #   # encoding: UTF-8
@@ -13,38 +13,49 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
+        MSG = 'Unnecessary utf-8 encoding comment.'
         ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
         SHEBANG = '#!'
 
         def on_new_investigation
           return if processed_source.buffer.source.empty?
 
-          line_number = encoding_line_number(processed_source)
-          return unless (@message = offense(processed_source, line_number))
+          comments.each do |line_number, comment|
+            next unless offense?(comment)
 
-          range = processed_source.buffer.line_range(line_number + 1)
-          add_offense(range, message: @message) do |corrector|
-            corrector.remove(range_with_surrounding_space(range: range, side: :right))
+            register_offense(line_number, comment)
           end
         end
 
         private
 
-        def offense(processed_source, line_number)
-          line = processed_source[line_number]
+        def comments
+          processed_source.lines.each.with_index.with_object({}) do |(line, line_number), comments|
+            next if line.start_with?(SHEBANG)
 
-          MSG_UNNECESSARY if encoding_omitable?(line)
+            comment = MagicComment.parse(line)
+            return comments unless comment.valid?
+
+            comments[line_number + 1] = comment
+          end
         end
 
-        def encoding_omitable?(line)
-          ENCODING_PATTERN.match?(line)
+        def offense?(comment)
+          comment.encoding_specified? && comment.encoding.casecmp('utf-8').zero?
         end
 
-        def encoding_line_number(processed_source)
-          line_number = 0
-          line_number += 1 if processed_source[line_number].start_with?(SHEBANG)
-          line_number
+        def register_offense(line_number, comment)
+          range = processed_source.buffer.line_range(line_number)
+
+          add_offense(range) do |corrector|
+            text = comment.without(:encoding)
+
+            if text.blank?
+              corrector.remove(range_with_surrounding_space(range, side: :right))
+            else
+              corrector.replace(range, text)
+            end
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for END blocks.
+      # Checks for END blocks.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for endless methods.
+      # Checks for endless methods.
       #
       # It can enforce either the use of endless methods definitions
       # for single-lined method bodies, or disallow endless methods.

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for consistent usage of `ENV['HOME']`. If `nil` is used as
+      # the second argument of `ENV.fetch`, it is treated as a bad case like `ENV[]`.
+      #
+      # @safety
+      #   The cop is unsafe because the result when `nil` is assigned to `ENV['HOME']` changes:
+      #
+      #   [source,ruby]
+      #   ----
+      #   ENV['HOME'] = nil
+      #   ENV['HOME'] # => nil
+      #   Dir.home    # => '/home/foo'
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   ENV['HOME']
+      #   ENV.fetch('HOME', nil)
+      #
+      #   # good
+      #   Dir.home
+      #
+      #   # good
+      #   ENV.fetch('HOME', default)
+      #
+      class EnvHome < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Dir.home` instead.'
+        RESTRICT_ON_SEND = %i[[] fetch].freeze
+
+        # @!method env_home?(node)
+        def_node_matcher :env_home?, <<~PATTERN
+          (send
+            (const {cbase nil?} :ENV) {:[] :fetch}
+            (str "HOME")
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless env_home?(node)
+          return if node.arguments.count == 2 && !node.arguments[1].nil_type?
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, 'Dir.home')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop ensures that eval methods (`eval`, `instance_eval`, `class_eval`
+      # Ensures that eval methods (`eval`, `instance_eval`, `class_eval`
       # and `module_eval`) are given filename and line number values (`__FILE__`
       # and `__LINE__`). This data is used to ensure that any errors raised
       # within the evaluated code will be given the correct identification

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where `Integer#even?` or `Integer#odd?`
+      # Checks for places where `Integer#even?` or `Integer#odd?`
       # can be used.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for use of the `File.expand_path` arguments.
+      # Checks for use of the `File.expand_path` arguments.
       # Likewise, it also checks for the `Pathname.new` argument.
       #
       # Contrastive bad case and good case are alternately shown in