rubocop 1.22.1 → 1.24.0

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

@@ -19,6 +19,10 @@ module RuboCop
       # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
       # syntax hashes
       #
+      # This cop has `EnforcedShorthandSyntax` option.
+      # It can enforce either the use of the explicit hash value syntax or
+      # the use of Ruby 3.1's hash value shorthand syntax.
+      #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
       #   {:a => 2}
@@ -54,8 +58,26 @@ module RuboCop
       #   # good
       #   {a: 1, b: 2}
       #   {:c => 3, 'd' => 4}
+      #
+      # @example EnforcedShorthandSyntax: always (default)
+      #
+      #   # bad
+      #   {foo: foo, bar: bar}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      # @example EnforcedShorthandSyntax: never
+      #
+      #   # bad
+      #   {foo:, bar:}
+      #
+      #   # good
+      #   {foo: foo, bar: bar}
+      #
       class HashSyntax < Base
         include ConfigurableEnforcedStyle
+        include HashShorthandSyntax
         include RangeHelp
         extend AutoCorrector
 

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

@@ -80,11 +80,19 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
+          if then?(node)
+            # If the nested `if` is a then node, correct it first,
+            # then the next pass will use `correct_to_elsif_from_if_inside_else_form`
+            IfThenCorrector.new(node, indentation: 0).call(corrector)
+            return
+          end
+
           if node.modifier_form?
             correct_to_elsif_from_modifier_form(corrector, node)
           else
             correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
           end
+
           corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
           return unless (if_branch = node.if_branch)
 
@@ -102,15 +110,22 @@ module RuboCop
 
         def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
           corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
+
           if_condition_range = if_condition_range(node, condition)
+
           if (if_branch = node.if_branch)
             corrector.replace(if_condition_range, if_branch.source)
           else
             corrector.remove(range_by_whole_lines(if_condition_range, include_final_newline: true))
           end
+
           corrector.remove(condition)
         end
 
+        def then?(node)
+          node.loc.begin&.source == 'then'
+        end
+
         def find_end_range(node)
           end_range = node.loc.end
           return end_range if end_range

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

@@ -59,7 +59,7 @@ module RuboCop
 
           return unless eligible_token_set?(predecessor, operator, successor)
 
-          return if operator.line == successor.line
+          return if same_line?(operator, successor)
 
           next_successor = token_after_last_string(successor, index)
 

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of `map.to_h` or `collect.to_h` that could be
+      # written with just `to_h` in Ruby >= 2.6.
+      #
+      # NOTE: `Style/HashTransformKeys` and `Style/HashTransformValues` will
+      # also change this pattern if only hash keys or hash values are being
+      # transformed.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerable`.
+      #
+      # @example
+      #   # bad
+      #   something.map { |v| [v, v * 2] }.to_h
+      #
+      #   # good
+      #   something.to_h { |v| [v, v * 2] }
+      #
+      #   # bad
+      #   {foo: bar}.collect { |k, v| [k.to_s, v.do_something] }.to_h
+      #
+      #   # good
+      #   {foo: bar}.to_h { |k, v| [k.to_s, v.do_something] }
+      #
+      class MapToHash < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Pass a block to `to_h` instead of calling `%<method>s.to_h`.'
+        RESTRICT_ON_SEND = %i[to_h].freeze
+
+        # @!method map_to_h?(node)
+        def_node_matcher :map_to_h?, <<~PATTERN
+          $(send (block $(send _ {:map :collect}) ...) :to_h)
+        PATTERN
+
+        def on_send(node)
+          return unless (to_h_node, map_node = map_to_h?(node))
+
+          message = format(MSG, method: map_node.loc.selector.source)
+          add_offense(map_node.loc.selector, message: message) do |corrector|
+            # If the `to_h` call already has a block, do not auto-correct.
+            next if to_h_node.block_node
+
+            autocorrect(corrector, to_h_node, map_node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, to_h, map)
+          removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
+
+          corrector.remove(removal_range)
+          corrector.replace(map.loc.selector, 'to_h')
+        end
+      end
+    end
+  end
+end

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

@@ -54,7 +54,7 @@ module RuboCop
           return true if in_pattern_node.pattern.first_line != in_pattern_node.pattern.last_line
           return false unless in_pattern_node.body
 
-          in_pattern_node.loc.line == in_pattern_node.body.loc.line
+          same_line?(in_pattern_node, in_pattern_node.body)
         end
       end
     end

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

@@ -54,7 +54,7 @@ module RuboCop
           end
           return false unless when_node.body
 
-          when_node.loc.line == when_node.body.loc.line
+          same_line?(when_node, when_node.body)
         end
 
         def accept_node_type?(node)

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

@@ -27,6 +27,11 @@ module RuboCop
       #   # bad
       #   10_000_00 # typical representation of $10,000 in cents
       #
+      # @example AllowedNumbers: [3000]
+      #
+      #   # good
+      #   3000 # You can specify allowed numbers. (e.g. port number)
+      #
       class NumericLiterals < Base
         include IntegerNode
         extend AutoCorrector
@@ -51,9 +56,9 @@ module RuboCop
 
         def check(node)
           int = integer_part(node)
-
           # TODO: handle non-decimal literals as well
           return if int.start_with?('0')
+          return if allowed_numbers.include?(int)
           return unless int.size >= min_digits
 
           case int
@@ -99,6 +104,10 @@ module RuboCop
         def min_digits
           cop_config['MinDigits']
         end
+
+        def allowed_numbers
+          cop_config.fetch('AllowedNumbers', []).map(&:to_s)
+        end
       end
     end
   end

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

@@ -45,7 +45,7 @@ module RuboCop
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
-            corrector.replace(node, replacement(node))
+            autocorrect(corrector, node)
           end
         end
 
@@ -55,55 +55,30 @@ module RuboCop
           format(MSG, keyword: node.keyword)
         end
 
-        def replacement(node)
+        def autocorrect(corrector, node)
           if always_multiline? || cannot_replace_to_ternary?(node)
-            multiline_replacement(node)
+            IfThenCorrector.new(node, indentation: indentation_width).call(corrector)
           else
-            replaced_node = ternary_replacement(node)
-            return replaced_node unless node.parent
-            return "(#{replaced_node})" if %i[and or].include?(node.parent.type)
-            return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
-
-            replaced_node
+            corrector.replace(node, ternary_correction(node))
           end
         end
 
-        def always_multiline?
-          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
-        end
+        def ternary_correction(node)
+          replaced_node = ternary_replacement(node)
 
-        def cannot_replace_to_ternary?(node)
-          node.elsif_conditional?
-        end
+          return replaced_node unless node.parent
+          return "(#{replaced_node})" if %i[and or].include?(node.parent.type)
+          return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
 
-        def multiline_replacement(node, indentation = nil)
-          indentation = ' ' * node.source_range.column if indentation.nil?
-          if_branch_source = node.if_branch&.source || 'nil'
-          elsif_indentation = indentation if node.respond_to?(:elsif?) && node.elsif?
-          if_branch = <<~RUBY
-            #{elsif_indentation}#{node.keyword} #{node.condition.source}
-            #{indentation}#{branch_body_indentation}#{if_branch_source}
-          RUBY
-          else_branch = else_branch_to_multiline(node.else_branch, indentation)
-          if_branch + else_branch
+          replaced_node
         end
 
-        def else_branch_to_multiline(else_branch, indentation)
-          if else_branch.nil?
-            'end'
-          elsif else_branch.if_type? && else_branch.elsif?
-            multiline_replacement(else_branch, indentation)
-          else
-            <<~RUBY.chomp
-              #{indentation}else
-              #{indentation}#{branch_body_indentation}#{else_branch.source}
-              #{indentation}end
-            RUBY
-          end
+        def always_multiline?
+          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
         end
 
-        def branch_body_indentation
-          ' ' * (@config.for_cop('Layout/IndentationWidth')['Width'] || 2)
+        def cannot_replace_to_ternary?(node)
+          node.elsif_conditional?
         end
 
         def ternary_replacement(node)
@@ -141,6 +116,10 @@ module RuboCop
 
           node.respond_to?(:arguments?) && node.arguments? && !node.parenthesized_call?
         end
+
+        def indentation_width
+          @config.for_cop('Layout/IndentationWidth')['Width']
+        end
       end
     end
   end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop flags uses of OpenStruct, as it is now officially discouraged
+      # to be used for performance, version compatibility, and potential security issues.
+      #
+      # @safety
+      #
+      #   Note that this cop may flag false positives; for instance, the following legal
+      #   use of a hand-rolled `OpenStruct` type would be considered an offense:
+      #
+      #   ```
+      #   module MyNamespace
+      #     class OpenStruct # not the OpenStruct we're looking for
+      #     end
+      #
+      #     def new_struct
+      #       OpenStruct.new # resolves to MyNamespace::OpenStruct
+      #     end
+      #   end
+      #   ```
+      #
+      # @example
+      #
+      #   # bad
+      #   point = OpenStruct.new(x: 0, y: 1)
+      #
+      #   # good
+      #   Point = Struct.new(:x, :y)
+      #   point = Point.new(0, 1)
+      #
+      #   # also good
+      #   point = { x: 0, y: 1 }
+      #
+      #   # bad
+      #   test_double = OpenStruct.new(a: 'b')
+      #
+      #   # good (assumes test using rspec-mocks)
+      #   test_double = double
+      #   allow(test_double).to receive(:a).and_return('b')
+      #
+      class OpenStructUse < Base
+        MSG = 'Avoid using `OpenStruct`; use `Struct`, `Hash`, a class or test doubles instead.'
+
+        # @!method uses_open_struct?(node)
+        def_node_matcher :uses_open_struct?, <<-PATTERN
+          (const {nil? (cbase)} :OpenStruct)
+        PATTERN
+
+        def on_const(node)
+          return unless uses_open_struct?(node)
+          return if custom_class_or_module_definition?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def custom_class_or_module_definition?(node)
+          parent = node.parent
+
+          (parent.class_type? || parent.module_type?) && node.left_siblings.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -56,6 +56,7 @@ module RuboCop
       class ParenthesesAroundCondition < Base
         include SafeAssignment
         include Parentheses
+        include RangeHelp
         extend AutoCorrector
 
         def on_if(node)
@@ -73,13 +74,14 @@ module RuboCop
 
         # @!method control_op_condition(node)
         def_node_matcher :control_op_condition, <<~PATTERN
-          (begin $_ ...)
+          (begin $_ $...)
         PATTERN
 
         def process_control_op(node)
           cond = node.condition
 
-          control_op_condition(cond) do |first_child|
+          control_op_condition(cond) do |first_child, rest_children|
+            return if semicolon_separated_expressions?(first_child, rest_children)
             return if modifier_op?(first_child)
             return if parens_allowed?(cond)
 
@@ -90,6 +92,14 @@ module RuboCop
           end
         end
 
+        def semicolon_separated_expressions?(first_exp, rest_exps)
+          return false unless (second_exp = rest_exps.first)
+
+          range = range_between(first_exp.source_range.end_pos, second_exp.source_range.begin_pos)
+
+          range.source.include?(';')
+        end
+
         def modifier_op?(node)
           return false if node.if_type? && node.ternary?
           return true if node.rescue_type?

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

@@ -46,7 +46,7 @@ module RuboCop
 
           message = style == :single_quotes ? MSG_SINGLE : MSG_DOUBLE
 
-          if wrong_quotes?(node)
+          if wrong_quotes?(node) || invalid_double_quotes?(node.source)
             add_offense(node, message: message) do |corrector|
               opposite_style_detected
               autocorrect(corrector, node)
@@ -58,6 +58,16 @@ module RuboCop
 
         private
 
+        def invalid_double_quotes?(source)
+          return false unless style == :double_quotes
+
+          # The string needs single quotes if:
+          # 1. It contains a double quote
+          # 2. It contains text that would become an escape sequence with double quotes
+          # 3. It contains text that would become an interpolation with double quotes
+          !/" | (?<!\\)\\[aAbcdefkMnprsStuUxzZ0-7] | \#[@{$]/x.match?(source)
+        end
+
         def autocorrect(corrector, node)
           str = if hash_colon_key?(node)
                   # strip quotes

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

@@ -82,10 +82,20 @@ module RuboCop
         end
 
         def autocorrect_single_variable_interpolation(corrector, embedded_node, node)
-          variable_loc = embedded_node.children.first.loc
-          replacement = "#{variable_loc.expression.source}.to_s"
+          embedded_var = embedded_node.children.first
 
-          corrector.replace(node, replacement)
+          source = if require_parentheses?(embedded_var)
+                     receiver = range_between(
+                       embedded_var.loc.expression.begin_pos, embedded_var.loc.selector.end_pos
+                     )
+                     arguments = embedded_var.arguments.map(&:source).join(', ')
+
+                     "#{receiver.source}(#{arguments})"
+                   else
+                     embedded_var.source
+                   end
+
+          corrector.replace(node, "#{source}.to_s")
         end
 
         def autocorrect_other(corrector, embedded_node, node)
@@ -97,6 +107,10 @@ module RuboCop
           corrector.replace(embedded_loc.begin, '(')
           corrector.replace(embedded_loc.end, ').to_s')
         end
+
+        def require_parentheses?(node)
+          node.send_type? && !node.arguments.count.zero? && !node.parenthesized_call?
+        end
       end
     end
   end

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

@@ -80,7 +80,11 @@ module RuboCop
         end
 
         def without_character_class(loc)
-          loc.source[1..-2]
+          without_character_class = loc.source[1..-2]
+
+          # Adds `\` to prevent auto-correction that changes to an interpolated string when `[#]`.
+          # e.g. From `/[#]{0}/` to `/#{0}/`
+          loc.source == '[#]' ? "\\#{without_character_class}" : without_character_class
         end
 
         def whitespace_in_free_space_mode?(node, elem)

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

@@ -53,7 +53,7 @@ module RuboCop
                       yield __FILE__ __LINE__ __ENCODING__].freeze
 
         def self.autocorrect_incompatible_with
-          [ColonMethodCall]
+          [ColonMethodCall, Layout::DotPosition]
         end
 
         def initialize(config = nil, options = nil)

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

@@ -218,11 +218,7 @@ module RuboCop
         def find_matching_receiver_invocation(method_chain, checked_variable)
           return nil unless method_chain
 
-          receiver = if method_chain.block_type?
-                       method_chain.send_node.receiver
-                     else
-                       method_chain.receiver
-                     end
+          receiver = method_chain.receiver
 
           return receiver if receiver == checked_variable
 

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

@@ -83,8 +83,9 @@ module RuboCop
           return if block_node.body.begin_type?
           return if receiver_allowed?(block_node.receiver)
           return unless (regexp_method_send_node = extract_send_node(block_node))
+          return if match_predicate_without_receiver?(regexp_method_send_node)
 
-          regexp = find_regexp(regexp_method_send_node)
+          regexp = find_regexp(regexp_method_send_node, block_node)
           register_offense(node, block_node, regexp)
         end
 
@@ -118,15 +119,20 @@ module RuboCop
           regexp_method_send_node
         end
 
-        def find_regexp(node)
+        def find_regexp(node, block)
           return node.child_nodes.first if node.match_with_lvasgn_type?
 
-          if node.receiver.lvar_type?
+          if node.receiver.lvar_type? &&
+             (block.numblock_type? || node.receiver.source == block.arguments.first.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver
           end
         end
+
+        def match_predicate_without_receiver?(node)
+          node.send_type? && node.method?(:match?) && node.receiver.nil?
+        end
       end
     end
   end

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

@@ -39,7 +39,7 @@ module RuboCop
           return unless eligible_method?(node)
           return unless eligible_arguments?(node)
 
-          method_name = node.send_node.method_name
+          method_name = node.method_name
           return if args_match?(method_name, node.arguments)
 
           preferred_block_arguments = build_preferred_arguments_map(node, target_args(method_name))
@@ -81,7 +81,7 @@ module RuboCop
         end
 
         def eligible_method?(node)
-          node.send_node.receiver && method_names.include?(node.send_node.method_name)
+          node.receiver && method_names.include?(node.method_name)
         end
 
         def methods

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

@@ -82,7 +82,9 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, if_branch)
-          corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
+          if node.condition.or_type? || node.condition.assignment?
+            corrector.wrap(node.condition, '(', ')')
+          end
 
           correct_from_unless_to_if(corrector, node) if node.unless?
 

data/lib/rubocop/cop/team.rb

@@ -131,7 +131,7 @@ module RuboCop
           @options[:stdin] = new_source
         else
           filename = processed_source.buffer.name
-          File.open(filename, 'w') { |f| f.write(new_source) }
+          File.write(filename, new_source)
         end
         @updated_source_file = true
       end

data/lib/rubocop/cop/util.rb

@@ -126,8 +126,18 @@ module RuboCop
         StringInterpreter.interpret(string)
       end
 
+      def line(node_or_range)
+        if node_or_range.respond_to?(:line)
+          node_or_range.line
+        elsif node_or_range.respond_to?(:loc)
+          node_or_range.loc.line
+        end
+      end
+
       def same_line?(node1, node2)
-        node1.respond_to?(:loc) && node2.respond_to?(:loc) && node1.loc.line == node2.loc.line
+        line1 = line(node1)
+        line2 = line(node2)
+        line1 && line2 && line1 == line2
       end
 
       def indent(node, offset: 0)

data/lib/rubocop/formatter/html_formatter.rb

@@ -23,12 +23,15 @@ module RuboCop
         end
       end
 
+      Summary = Struct.new(:offense_count, :inspected_files, :target_files, keyword_init: true)
+      FileOffenses = Struct.new(:path, :offenses, keyword_init: true)
+
       attr_reader :files, :summary
 
       def initialize(output, options = {})
         super
         @files = []
-        @summary = OpenStruct.new(offense_count: 0)
+        @summary = Summary.new(offense_count: 0)
       end
 
       def started(target_files)
@@ -36,7 +39,7 @@ module RuboCop
       end
 
       def file_finished(file, offenses)
-        files << OpenStruct.new(path: file, offenses: offenses)
+        files << FileOffenses.new(path: file, offenses: offenses)
         summary.offense_count += offenses.count
       end
 

data/lib/rubocop/formatter/json_formatter.rb

@@ -59,12 +59,15 @@ module RuboCop
       end
 
       # TODO: Consider better solution for Offense#real_column.
+      #       The minimum value of `start_column: real_column` is 1.
+      #       So, the minimum value of `last_column` should be 1.
+      #       And non-zero value of `last_column` should be used as is.
       def hash_for_location(offense)
         {
           start_line:   offense.line,
           start_column: offense.real_column,
           last_line:    offense.last_line,
-          last_column:  offense.last_column,
+          last_column:  offense.last_column.zero? ? 1 : offense.last_column,
           length:       offense.location.length,
           # `line` and `column` exist for compatibility.
           # Use `start_line` and `start_column` instead.