rubocop 1.18.2 → 1.19.1

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

@@ -6,6 +6,11 @@ module RuboCop
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
       #
+      # Methods that can be either procedural or functional and cannot be
+      # categorised from their usage alone is ignored.
+      # `lambda`, `proc`, and `it` are their defaults.
+      # Additional methods can be added to the `IgnoredMethods`.
+      #
       # @example EnforcedStyle: line_count_based (default)
       #   # bad - single line block
       #   items.each do |item| item / 5 end
@@ -132,9 +137,21 @@ module RuboCop
       #     puts foo
       #   end
       #
+      # @example IgnoredMethods: ['lambda', 'proc', 'it' ] (default)
+      #
+      #   # good
+      #   foo = lambda do |x|
+      #     puts "Hello, #{x}"
+      #   end
+      #
+      #   foo = lambda do |x|
+      #     x * 100
+      #   end
+      #
       class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        include RangeHelp
         extend AutoCorrector
 
         ALWAYS_BRACES_MESSAGE = 'Prefer `{...}` over `do...end` for blocks.'
@@ -231,6 +248,11 @@ module RuboCop
           corrector.insert_before(e, ' ') unless whitespace_before?(e)
           corrector.insert_after(b, ' ') unless whitespace_after?(b)
           corrector.replace(b, 'do')
+
+          if (comment = processed_source.comment_at_line(e.line))
+            move_comment_before_block(corrector, comment, loc.node, e)
+          end
+
           corrector.replace(e, 'end')
         end
 
@@ -252,6 +274,15 @@ module RuboCop
           /\s/.match?(range.source_buffer.source[range.begin_pos + length, 1])
         end
 
+        def move_comment_before_block(corrector, comment, block_node, closing_brace)
+          range = range_between(closing_brace.end_pos, comment.loc.expression.end_pos)
+
+          corrector.remove(range_with_surrounding_space(range: range, side: :right))
+          corrector.insert_after(closing_brace, "\n")
+
+          corrector.insert_before(block_node, "#{comment.text}\n")
+        end
+
         def get_blocks(node, &block)
           case node.type
           when :block

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

@@ -12,6 +12,7 @@ module RuboCop
       #
       # Auto-correction removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
+      # It is marked as unsafe auto-correction as it may remove meaningful comments.
       #
       # @example
       #   # bad
@@ -50,7 +51,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless (match = line(comment).match(/(?<keyword>\S+).*#/)) && offensive?(comment)
+            next unless offensive?(comment) && (match = line(comment).match(/(?<keyword>\S+).*#/))
 
             register_offense(comment, match[:keyword])
           end

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

@@ -26,7 +26,7 @@ module RuboCop
         # `when` nodes contain the entire branch including the condition.
         # We only need the contents of the branch, not the condition.
         def expand_when_branches(when_branches)
-          when_branches.map { |branch| branch.children[1] }
+          when_branches.map(&:body)
         end
 
         def tail(branch)
@@ -272,6 +272,16 @@ module RuboCop
           check_node(node, branches)
         end
 
+        def on_case_match(node)
+          return unless style == :assign_to_condition
+          return unless node.else_branch
+
+          in_pattern_branches = expand_when_branches(node.in_pattern_branches)
+          branches = [*in_pattern_branches, node.else_branch]
+
+          check_node(node, branches)
+        end
+
         private
 
         def check_assignment_to_condition(node)
@@ -297,7 +307,7 @@ module RuboCop
         end
 
         # @!method candidate_condition?(node)
-        def_node_matcher :candidate_condition?, '[{if case} !#allowed_ternary?]'
+        def_node_matcher :candidate_condition?, '[{if case case_match} !#allowed_ternary?]'
 
         def allowed_ternary?(assignment)
           assignment.if_type? && assignment.ternary? && !include_ternary?
@@ -319,7 +329,7 @@ module RuboCop
         end
 
         def move_assignment_outside_condition(corrector, node)
-          if node.case_type?
+          if node.case_type? || node.case_match_type?
             CaseCorrector.correct(corrector, self, node)
           elsif node.ternary?
             TernaryCorrector.correct(corrector, node)
@@ -333,7 +343,7 @@ module RuboCop
 
           if ternary_condition?(condition)
             TernaryCorrector.move_assignment_inside_condition(corrector, node)
-          elsif condition.case_type?
+          elsif condition.case_type? || condition.case_match_type?
             CaseCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.if_type?
             IfCorrector.move_assignment_inside_condition(corrector, node)
@@ -631,7 +641,11 @@ module RuboCop
           end
 
           def extract_branches(case_node)
-            when_branches = expand_when_branches(case_node.when_branches)
+            when_branches = if case_node.case_type?
+                              expand_when_branches(case_node.when_branches)
+                            else
+                              expand_when_branches(case_node.in_pattern_branches)
+                            end
 
             [when_branches, case_node.else_branch]
           end

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

@@ -36,13 +36,7 @@ module RuboCop
             next unless comment.text.scan(/# rubocop:(?:disable|todo)/).size > 1
 
             add_offense(comment) do |corrector|
-              prefix = if comment.text.start_with?('# rubocop:disable')
-                         '# rubocop:disable'
-                       else
-                         '# rubocop:todo'
-                       end
-
-              corrector.replace(comment, comment.text[/#{prefix} \S+/])
+              corrector.replace(comment, comment.text.gsub(%r{ # rubocop:(disable|todo)}, ','))
             end
           end
         end

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

@@ -62,7 +62,7 @@ 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
+          last_child = find_last_child(def_node.body)
 
           last_child.last_line == node.last_line
         end
@@ -73,6 +73,17 @@ module RuboCop
 
           find_def_node_from_ascendant(node.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
       end
     end
   end

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

@@ -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: range, side: :right))
+            else
+              corrector.replace(range, text)
+            end
+          end
         end
       end
     end

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

@@ -43,7 +43,7 @@ module RuboCop
       #   RUBY
       #
       # This cop works only when a string literal is given as a code string.
-      # No offence is reported if a string variable is given as below:
+      # No offense is reported if a string variable is given as below:
       #
       # @example
       #   # not checked

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

@@ -93,18 +93,43 @@ module RuboCop
 
         def add_block_argument(node, corrector)
           if node.arguments?
-            last_arg = node.arguments.last
-            arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
-            replacement = ' &block'
-            replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
-            corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
-          elsif node.call_type? || node.zsuper_type?
-            corrector.insert_after(node, '(&block)')
+            insert_argument(node, corrector)
+          elsif empty_arguments?(node)
+            corrector.replace(node.arguments, '(&block)')
+          elsif call_like?(node)
+            correct_call_node(node, corrector)
           else
             corrector.insert_after(node.loc.name, '(&block)')
           end
         end
 
+        def empty_arguments?(node)
+          # Is there an arguments node with only parentheses?
+          node.arguments.is_a?(RuboCop::AST::Node) && node.arguments.loc.begin
+        end
+
+        def call_like?(node)
+          node.call_type? || node.zsuper_type? || node.super_type?
+        end
+
+        def insert_argument(node, corrector)
+          last_arg = node.arguments.last
+          arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
+          replacement = ' &block'
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
+          corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
+        end
+
+        def correct_call_node(node, corrector)
+          corrector.insert_after(node, '(&block)')
+          return unless node.parenthesized?
+
+          args_begin = Util.args_begin(node)
+          args_end = Util.args_end(node)
+          range = range_between(args_begin.begin_pos, args_end.end_pos)
+          corrector.remove(range)
+        end
+
         def block_body_range(block_node, send_node)
           range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
         end

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

@@ -5,11 +5,17 @@ module RuboCop
     module Style
       # This cop is designed to help you transition from mutable string literals
       # to frozen string literals.
-      # It will add the comment `# frozen_string_literal: true` to the top of
-      # files to enable frozen string literals. Frozen string literals may be
+      # It will add the `# frozen_string_literal: true` magic comment to the top
+      # of files to enable frozen string literals. Frozen string literals may be
       # default in future Ruby. The comment will be added below a shebang and
       # encoding comment.
       #
+      # Note that the cop will ignore files where the comment exists but is set
+      # to `false` instead of `true`.
+      #
+      # To require a blank line after this comment, please see
+      # `Layout/EmptyLineAfterMagicComment` cop.
+      #
       # @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

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

@@ -29,6 +29,7 @@ module RuboCop
       #   # good
       #   [{ one: 1 }, { two: 2 }]
       class HashAsLastArrayItem < Base
+        include RangeHelp
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
@@ -74,6 +75,7 @@ module RuboCop
           return if node.children.empty? # Empty hash cannot be "unbraced"
 
           add_offense(node, message: 'Omit the braces around the hash.') do |corrector|
+            remove_last_element_trailing_comma(corrector, node.parent)
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end
@@ -82,6 +84,15 @@ module RuboCop
         def braces_style?
           style == :braces
         end
+
+        def remove_last_element_trailing_comma(corrector, node)
+          range = range_with_surrounding_space(
+            range: node.children.last.source_range,
+            side: :right
+          ).end.resize(1)
+
+          corrector.remove(range) if range.source == ','
+        end
       end
     end
   end

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

@@ -74,7 +74,7 @@ module RuboCop
             ruby19_no_mixed_keys_check(pairs)
           elsif style == :no_mixed_keys
             no_mixed_keys_check(pairs)
-          elsif node.source.include?('=>')
+          else
             ruby19_check(pairs)
           end
         end

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

@@ -27,11 +27,8 @@ module RuboCop
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
       class HashTransformKeys < Base
         include HashTransformMethod
-        extend TargetRubyVersion
         extend AutoCorrector
 
-        minimum_target_ruby_version 2.5
-
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block

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

@@ -7,6 +7,22 @@ module RuboCop
       # each branch of a conditional expression. Such expressions should normally
       # be placed outside the conditional expression - before or after it.
       #
+      # This cop is marked unsafe auto-correction as the order of method invocations
+      # must be guaranteed in the following case:
+      #
+      # [source,ruby]
+      # ----
+      # if method_that_modifies_global_state # 1
+      #   method_that_relies_on_global_state # 2
+      #   foo                                # 3
+      # else
+      #   method_that_relies_on_global_state # 2
+      #   bar                                # 3
+      # end
+      # ----
+      #
+      # In such a case, auto-correction may change the invocation order.
+      #
       # NOTE: The cop is poorly named and some people might think that it actually
       # checks for duplicated conditional branches. The name will probably be changed
       # in a future major RuboCop release.
@@ -124,21 +140,30 @@ module RuboCop
           return if branches.any?(&:nil?)
 
           tails = branches.map { |branch| tail(branch) }
-          check_expressions(node, tails, :after_condition) if duplicated_expressions?(tails)
+          check_expressions(node, tails, :after_condition) if duplicated_expressions?(node, tails)
 
           heads = branches.map { |branch| head(branch) }
-          check_expressions(node, heads, :before_condition) if duplicated_expressions?(heads)
+          check_expressions(node, heads, :before_condition) if duplicated_expressions?(node, heads)
         end
 
-        def duplicated_expressions?(expressions)
-          expressions.size > 1 && expressions.uniq.one?
+        def duplicated_expressions?(node, expressions)
+          unique_expressions = expressions.uniq
+          return false unless expressions.size >= 1 && unique_expressions.one?
+
+          unique_expression = unique_expressions.first
+          return true unless unique_expression.assignment?
+
+          lhs = unique_expression.child_nodes.first
+          node.condition.child_nodes.none? { |n| n.source == lhs.source if n.variable? }
         end
 
-        def check_expressions(node, expressions, insert_position)
+        def check_expressions(node, expressions, insert_position) # rubocop:disable Metrics/MethodLength
           inserted_expression = false
 
           expressions.each do |expression|
             add_offense(expression) do |corrector|
+              next if node.if_type? && node.ternary?
+
               range = range_by_whole_lines(expression.source_range, include_final_newline: true)
               corrector.remove(range)
               next if inserted_expression