rubocop 1.12.1 → 1.13.0

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

@@ -19,10 +19,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
-              'any code.'
-        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in ' \
-                                    'your RuboCop config'
+        MSG = 'Include a copyright notice matching /%<notice>s/ before any code.'
+        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in your RuboCop config'
 
         def on_new_investigation
           return if notice.empty? || notice_found?(processed_source)
@@ -57,8 +55,7 @@ module RuboCop
           regex = Regexp.new(notice)
           return if autocorrect_notice&.match?(regex)
 
-          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-                         "match Notice /#{notice}/"
+          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
         end
 
         def insert_notice_before(processed_source)

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

@@ -63,15 +63,12 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless date_time?(node) ||
-                        (to_datetime?(node) && disallow_coercion?)
+          return unless date_time?(node) || (to_datetime?(node) && disallow_coercion?)
           return if historic_date?(node)
 
           message = to_datetime?(node) ? COERCION_MSG : CLASS_MSG
 
-          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/style/def_with_parentheses.rb

@@ -36,8 +36,7 @@ module RuboCop
       class DefWithParentheses < Base
         extend AutoCorrector
 
-        MSG = "Omit the parentheses in defs when the method doesn't accept " \
-              'any arguments.'
+        MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
           return if node.single_line?

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

@@ -25,8 +25,7 @@ module RuboCop
       class EachForSimpleLoop < Base
         extend AutoCorrector
 
-        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
-              'number of times.'
+        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
 
         def on_block(node)
           return unless offending_each_range(node)

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

@@ -44,19 +44,14 @@ module RuboCop
         def on_case(case_node)
           return if case_node.condition
 
-          branch_bodies = [
-            *case_node.when_branches.map(&:body),
-            case_node.else_branch
-          ].compact
+          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?)
           end
 
-          add_offense(case_node.loc.keyword) do |corrector|
-            autocorrect(corrector, case_node)
-          end
+          add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
         end
 
         private

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

@@ -123,17 +123,13 @@ module RuboCop
         def empty_check(node)
           return unless node.else? && !node.else_branch
 
-          add_offense(node.loc.else) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node.loc.else) { |corrector| autocorrect(corrector, node) }
         end
 
         def nil_check(node)
           return unless node.else_branch&.nil_type?
 
-          add_offense(node.loc.else) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node.loc.else) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -154,9 +150,7 @@ module RuboCop
           return node if node.case_type?
           return node unless node.elsif?
 
-          node.each_ancestor(:if, :case, :when).find(-> { node }) do |parent|
-            parent.loc.end
-          end
+          node.each_ancestor(:if, :case, :when).find(-> { node }) { |parent| parent.loc.end }
         end
 
         def autocorrect_forbidden?(type)

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

@@ -37,8 +37,7 @@ module RuboCop
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
 
         # @!method array_with_block(node)
-        def_node_matcher :array_with_block,
-                         '(block (send (const {nil? cbase} :Array) :new) args _)'
+        def_node_matcher :array_with_block, '(block (send (const {nil? cbase} :Array) :new) args _)'
 
         # @!method hash_with_block(node)
         def_node_matcher :hash_with_block, <<~PATTERN
@@ -84,20 +83,17 @@ module RuboCop
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.equal?(parent.arguments.first) &&
-            !parentheses?(node.parent)
+          node.equal?(parent.arguments.first) && !parentheses?(node.parent)
         end
 
         def replacement_range(node)
-          if hash_node(node) &&
-             first_argument_unparenthesized?(node)
+          if hash_node(node) && first_argument_unparenthesized?(node)
             # `some_method {}` is not same as `some_method Hash.new`
             # because the braces are interpreted as a block. We will have
             # to rewrite the arguments to wrap them in parenthesis.
             args = node.parent.arguments
 
-            range_between(args[0].source_range.begin_pos - 1,
-                          args[-1].source_range.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

@@ -45,16 +45,13 @@ module RuboCop
         extend AutoCorrector
 
         MSG_COMPACT = 'Put empty method definitions on a single line.'
-        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
-                       'next line.'
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the next line.'
 
         def on_def(node)
           return if node.body || comment_lines?(node)
           return if correct_style?(node)
 
-          add_offense(node) do |corrector|
-            corrector.replace(node, corrected(node))
-          end
+          add_offense(node) { |corrector| corrector.replace(node, corrected(node)) }
         end
         alias on_defs on_def
 
@@ -65,8 +62,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)

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

@@ -15,8 +15,7 @@ module RuboCop
       class EndBlock < Base
         extend AutoCorrector
 
-        MSG = 'Avoid the use of `END` blocks. ' \
-              'Use `Kernel#at_exit` instead.'
+        MSG = 'Avoid the use of `END` blocks. Use `Kernel#at_exit` instead.'
 
         def on_postexe(node)
           add_offense(node.loc.keyword) do |corrector|

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

@@ -79,9 +79,7 @@ module RuboCop
         def handle_disallow_style(node)
           return unless node.endless?
 
-          add_offense(node) do |corrector|
-            correct_to_multiline(corrector, node)
-          end
+          add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
 
         def correct_to_multiline(corrector, node)

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

@@ -112,13 +112,11 @@ module RuboCop
         end
 
         def special_file_keyword?(node)
-          node.str_type? &&
-            node.source == '__FILE__'
+          node.str_type? && node.source == '__FILE__'
         end
 
         def special_line_keyword?(node)
-          node.int_type? &&
-            node.source == '__LINE__'
+          node.int_type? && node.source == '__LINE__'
         end
 
         def file_and_line(node)

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

@@ -85,9 +85,7 @@ module RuboCop
           elsif (default_dir = pathname_parent_expand_path(node))
             return unless unrecommended_argument?(default_dir)
 
-            add_offense(node, message: PATHNAME_MSG) do |corrector|
-              autocorrect(corrector, node)
-            end
+            add_offense(node, message: PATHNAME_MSG) { |corrector| autocorrect(corrector, node) }
           elsif (default_dir = pathname_new_parent_expand_path(node))
             return unless unrecommended_argument?(default_dir)
 

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

@@ -106,10 +106,7 @@ module RuboCop
         end
 
         def block_body_range(block_node, send_node)
-          range_between(
-            send_node.loc.expression.end_pos,
-            block_node.loc.end.end_pos
-          )
+          range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
         end
       end
     end

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

@@ -146,10 +146,7 @@ module RuboCop
             next if seq.percent?
 
             detected_style = seq.style
-            token = contents.begin.adjust(
-              begin_pos: seq.begin_pos,
-              end_pos:   seq.end_pos
-            )
+            token = contents.begin.adjust(begin_pos: seq.begin_pos, end_pos: seq.end_pos)
 
             yield(detected_style, token)
           end

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

@@ -76,8 +76,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: '\
-                           'true`.'
+        MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: true`.'
         MSG_MISSING = 'Missing frozen string literal comment.'
         MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'
         MSG_DISABLED = 'Frozen string literal comment must be set to `true`.'
@@ -143,17 +142,13 @@ module RuboCop
         def missing_offense(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(range, message: MSG_MISSING) do |corrector|
-            insert_comment(corrector)
-          end
+          add_offense(range, message: MSG_MISSING) { |corrector| insert_comment(corrector) }
         end
 
         def missing_true_offense(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(range, message: MSG_MISSING_TRUE) do |corrector|
-            insert_comment(corrector)
-          end
+          add_offense(range, message: MSG_MISSING_TRUE) { |corrector| insert_comment(corrector) }
         end
 
         def unnecessary_comment_offense(processed_source)

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

@@ -99,12 +99,9 @@ module RuboCop
 
         def register_offense(node, scope_exiting_keyword, conditional_keyword)
           condition, = node.node_parts
-          example = [scope_exiting_keyword,
-                     conditional_keyword,
-                     condition.source].join(' ')
+          example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
           if too_long_for_single_line?(node, example)
-            example = "#{conditional_keyword} #{condition.source}; " \
-                      "#{scope_exiting_keyword}; end"
+            example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
           end
 
           add_offense(node.loc.keyword, message: format(MSG, example: example))
@@ -126,8 +123,7 @@ module RuboCop
         end
 
         def accepted_form?(node, ending: false)
-          accepted_if?(node, ending) || node.condition.multiline? ||
-            node.parent&.assignment?
+          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
         end
 
         def accepted_if?(node, ending)

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

@@ -61,11 +61,11 @@ module RuboCop
         def single_argument(node)
           first_argument = node.first_argument
           if first_argument.hash_type?
-            add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
-              corrector.replace(node, "{#{first_argument.source}}")
-            end
+            register_offense_for_hash(node, first_argument)
           elsif first_argument.splat_type?
             add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
+          elsif use_zip_method_without_argument?(first_argument)
+            register_offense_for_zip_method(node, first_argument)
           else
             add_offense(node, message: MSG_TO_H) do |corrector|
               replacement = first_argument.source
@@ -75,6 +75,31 @@ module RuboCop
           end
         end
 
+        def use_zip_method_without_argument?(first_argument)
+          return false unless first_argument&.send_type?
+
+          first_argument.method?(:zip) && first_argument.arguments.empty?
+        end
+
+        def register_offense_for_hash(node, hash_argument)
+          add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
+            corrector.replace(node, "{#{hash_argument.source}}")
+
+            parent = node.parent
+            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+          end
+        end
+
+        def register_offense_for_zip_method(node, zip_method)
+          add_offense(node, message: MSG_TO_H) do |corrector|
+            if zip_method.parenthesized?
+              corrector.insert_before(zip_method.loc.end, '[]')
+            else
+              corrector.insert_after(zip_method, '([])')
+            end
+          end
+        end
+
         def requires_parens?(node)
           node.call_type? && node.arguments.any? && !node.parenthesized?
         end

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

@@ -38,8 +38,7 @@ module RuboCop
           kv_each(node) do |target, method|
             return unless target.receiver.receiver
 
-            msg = format(message, prefer: "each_#{method[0..-2]}",
-                                  current: "#{method}.each")
+            msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
 
             add_offense(kv_range(target), message: msg) do |corrector|
               correct_key_value_each(target, corrector)

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

@@ -52,8 +52,7 @@ module RuboCop
           return if node.when_branches.size < min_branches_count
 
           hash_like_case?(node) do |condition_nodes, body_nodes|
-            if nodes_of_same_type?(condition_nodes) &&
-               nodes_of_same_type?(body_nodes)
+            if nodes_of_same_type?(condition_nodes) && nodes_of_same_type?(body_nodes)
               add_offense(node)
             end
           end

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

@@ -137,7 +137,7 @@ module RuboCop
         end
 
         def acceptable_19_syntax_symbol?(sym_name)
-          sym_name.sub!(/\A:/, '')
+          sym_name.delete_prefix!(':')
 
           if cop_config['PreferHashRocketsForNonAlnumEndingSymbols'] &&
              # Prefer { :production? => false } over { production?: false } and
@@ -174,10 +174,7 @@ module RuboCop
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''
 
-          corrector.replace(
-            range,
-            range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: ")
-          )
+          corrector.replace(range, range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: "))
 
           hash_node = pair_node.parent
           return unless hash_node.parent&.return_type? && !hash_node.braces?
@@ -194,8 +191,7 @@ module RuboCop
         end
 
         def argument_without_space?(node)
-          node.argument? &&
-            node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+          node.argument? && node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
@@ -215,8 +211,7 @@ module RuboCop
         end
 
         def force_hash_rockets?(pairs)
-          cop_config['UseHashRocketsWithSymbolValues'] &&
-            pairs.map(&:value).any?(&:sym_type?)
+          cop_config['UseHashRocketsWithSymbolValues'] && pairs.map(&:value).any?(&:sym_type?)
         end
       end
     end

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

@@ -100,9 +100,7 @@ module RuboCop
         def check_expressions(expressions)
           return unless expressions.size > 1 && expressions.uniq.one?
 
-          expressions.each do |expression|
-            add_offense(expression)
-          end
+          expressions.each { |expression| add_offense(expression) }
         end
 
         def message(node)

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

@@ -38,13 +38,13 @@ module RuboCop
         include StatementModifier
         include LineLengthHelp
         include IgnoredPattern
+        include RangeHelp
         extend AutoCorrector
 
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
                            'the usage of control flow `&&`/`||`.'
-        MSG_USE_NORMAL =
-          'Modifier form of `%<keyword>s` makes the line too long.'
+        MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
 
         def self.autocorrect_incompatible_with
           [Style::SoleNestedConditional]
@@ -67,7 +67,16 @@ module RuboCop
 
         def autocorrect(corrector, node)
           replacement = if node.modifier_form?
-                          to_normal_form(node)
+                          indentation = ' ' * node.source_range.column
+                          last_argument = node.if_branch.last_argument
+
+                          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
+                            heredoc = extract_heredoc_from(last_argument)
+                            remove_heredoc(corrector, heredoc)
+                            to_normal_form_with_heredoc(node, indentation, heredoc)
+                          else
+                            to_normal_form(node, indentation)
+                          end
                         else
                           to_modifier_form(node)
                         end
@@ -123,8 +132,7 @@ module RuboCop
         end
 
         def line_length_enabled_at_line?(line)
-          processed_source.comment_config
-                          .cop_enabled_at_line?('Layout/LineLength', line)
+          processed_source.comment_config.cop_enabled_at_line?('Layout/LineLength', line)
         end
 
         def named_capture_in_condition?(node)
@@ -132,10 +140,7 @@ module RuboCop
         end
 
         def non_eligible_node?(node)
-          non_simple_if_unless?(node) ||
-            node.chained? ||
-            node.nested_conditional? ||
-            super
+          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? || super
         end
 
         def non_simple_if_unless?(node)
@@ -153,18 +158,41 @@ module RuboCop
             node  = node.parent
           end
 
-          node && (sibling = node.children[index + 1]) &&
-            sibling.source_range.first_line == line_no
+          node && (sibling = node.children[index + 1]) && sibling.source_range.first_line == line_no
         end
 
-        def to_normal_form(node)
-          indentation = ' ' * node.source_range.column
+        def to_normal_form(node, indentation)
           <<~RUBY.chomp
             #{node.keyword} #{node.condition.source}
             #{indentation}  #{node.body.source}
             #{indentation}end
           RUBY
         end
+
+        def to_normal_form_with_heredoc(node, indentation, heredoc)
+          heredoc_body, heredoc_end = heredoc
+
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}  #{heredoc_body.source.chomp}
+            #{indentation}  #{heredoc_end.source.chomp}
+            #{indentation}end
+          RUBY
+        end
+
+        def extract_heredoc_from(last_argument)
+          heredoc_body = last_argument.loc.heredoc_body
+          heredoc_end = last_argument.loc.heredoc_end
+
+          [heredoc_body, heredoc_end]
+        end
+
+        def remove_heredoc(corrector, heredoc)
+          heredoc.each do |range|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
       end
     end
   end