rubocop 1.12.0 → 1.16.0

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

@@ -103,8 +103,7 @@ module RuboCop
         end
 
         def setter_method?(method_name)
-          method_name.to_s.end_with?(EQUAL) &&
-            !%i[!= == === >= <=].include?(method_name)
+          method_name.to_s.end_with?(EQUAL) && !%i[!= == === >= <=].include?(method_name)
         end
 
         def assignment_rhs_exist?(node)
@@ -214,14 +213,10 @@ module RuboCop
         include IgnoredNode
         extend AutoCorrector
 
-        MSG = 'Use the return of the conditional for variable assignment ' \
-              'and comparison.'
-        ASSIGN_TO_CONDITION_MSG =
-          'Assign variables inside of conditionals'
-        VARIABLE_ASSIGNMENT_TYPES =
-          %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
-        ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES +
-                           %i[and_asgn or_asgn op_asgn masgn].freeze
+        MSG = 'Use the return of the conditional for variable assignment and comparison.'
+        ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals'
+        VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
+        ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Layout/LineLength'
         INDENTATION_WIDTH = 'Layout/IndentationWidth'
         ENABLED = 'Enabled'
@@ -368,9 +363,7 @@ module RuboCop
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -411,9 +404,7 @@ module RuboCop
 
         def longest_line(node, assignment)
           assignment_regex = /\s*#{Regexp.escape(assignment).gsub('\ ', '\s*')}/
-          lines = node.source.lines.map do |line|
-            line.chomp.sub(assignment_regex, '')
-          end
+          lines = node.source.lines.map { |line| line.chomp.sub(assignment_regex, '') }
           longest_line = lines.max_by(&:length)
           assignment + longest_line
         end
@@ -457,9 +448,7 @@ module RuboCop
           expression = node.loc.expression
           begin_pos = expression.begin_pos - (expression.column - column - 2)
 
-          Parser::Source::Range.new(expression.source_buffer,
-                                    begin_pos,
-                                    expression.begin_pos)
+          Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
         end
 
         def assignment(node)
@@ -532,9 +521,7 @@ module RuboCop
             _variable, *_operator, if_rhs = *node.if_branch
             _else_variable, *_operator, else_rhs = *node.else_branch
 
-            expr = "#{node.condition.source} ? " \
-                   "#{if_rhs.source} : " \
-                   "#{else_rhs.source}"
+            expr = "#{node.condition.source} ? #{if_rhs.source} : #{else_rhs.source}"
 
             element_assignment?(node.if_branch) ? "(#{expr})" : expr
           end
@@ -596,8 +583,7 @@ module RuboCop
           def move_branch_inside_condition(corrector, branch, condition,
                                            assignment, column)
             branch_assignment = tail(branch)
-            corrector.insert_before(branch_assignment,
-                                    assignment.source)
+            corrector.insert_before(branch_assignment, assignment.source)
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
 

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
@@ -63,7 +62,7 @@ module RuboCop
             ARR_MSG
           elsif offense_hash_node?(node)
             HASH_MSG
-          elsif str_node(node) && !frozen_string_literals_enabled?
+          elsif str_node(node) && !frozen_strings?
             format(STR_MSG, prefer: preferred_string_literal)
           end
         end
@@ -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
@@ -129,6 +125,13 @@ module RuboCop
             end
           end
         end
+
+        def frozen_strings?
+          return true if frozen_string_literals_enabled?
+
+          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteral')['Enabled']
+          frozen_string_cop_enabled && !frozen_string_literals_disabled?
+        end
       end
     end
   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

@@ -10,9 +10,6 @@ module RuboCop
       # 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`.
-      #
       # @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
@@ -79,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`.'
@@ -146,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
@@ -85,6 +110,9 @@ module RuboCop
           else
             add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
               corrector.replace(node, args_to_hash(node.arguments))
+
+              parent = node.parent
+              add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
             end
           end
         end