rubocop 0.70.0 → 0.72.0

data/lib/rubocop/cop/layout/indentation_width.rb

@@ -83,7 +83,7 @@ module RuboCop
 
           check_indentation(end_loc, node.body)
 
-          return unless indentation_consistency_style == 'rails'
+          return unless indented_internal_methods_style?
 
           check_members(end_loc, [node.body])
         end
@@ -155,8 +155,8 @@ module RuboCop
 
           return unless members.any? && members.first.begin_type?
 
-          if indentation_consistency_style == 'rails'
-            check_members_for_rails_style(members)
+          if indentation_consistency_style == 'indented_internal_methods'
+            check_members_for_indented_internal_methods_style(members)
           else
             members.first.children.each do |member|
               next if member.send_type? && member.access_modifier?
@@ -176,7 +176,7 @@ module RuboCop
           end
         end
 
-        def check_members_for_rails_style(members)
+        def check_members_for_indented_internal_methods_style(members)
           each_member(members) do |member, previous_modifier|
             check_indentation(previous_modifier, member,
                               indentation_consistency_style)
@@ -195,6 +195,10 @@ module RuboCop
           end
         end
 
+        def indented_internal_methods_style?
+          indentation_consistency_style == 'indented_internal_methods'
+        end
+
         def indentation_consistency_style
           config.for_cop('Layout/IndentationConsistency')['EnforcedStyle']
         end

data/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb

@@ -26,6 +26,8 @@ module RuboCop
           'on a separate line.'
 
         def on_send(node)
+          return if node.method_name == :[]=
+
           args = node.arguments
 
           # If there is a trailing hash arg without explicit braces, like this:

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -64,7 +64,7 @@ module RuboCop
 
         def date_time_object?(node)
           child = node
-          while child.send_type?
+          while child&.send_type?
             return true if datetime? child
 
             child = child.children[0]

data/lib/rubocop/cop/mixin/hash_alignment.rb

@@ -83,6 +83,10 @@ module RuboCop
       class TableAlignment
         include ValueAlignment
 
+        def initialize
+          self.max_key_width = 0
+        end
+
         def deltas_for_first_pair(first_pair, node)
           self.max_key_width = node.keys.map { |key| key.source.length }.max
 

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -57,24 +57,20 @@ module RuboCop
         MSG = 'Use `%<preferred>s` instead of `%<bad>s`.'
 
         def on_resbody(node)
-          exception_type, @exception_name = *node
-          return unless exception_type || @exception_name
-
-          @exception_name ||= exception_type.children.first
-          return if @exception_name.const_type? ||
-                    variable_name == preferred_name
+          name = variable_name(node)
+          return unless name
+          return if preferred_name(name).to_sym == name
 
           add_offense(node, location: offense_range(node))
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            offending_name = node.exception_variable.children.first
+            offending_name = variable_name(node)
+            preferred_name = preferred_name(offending_name)
             corrector.replace(offense_range(node), preferred_name)
 
-            return unless node.body
-
-            node.body.each_descendant(:lvar) do |var|
+            node.body&.each_descendant(:lvar) do |var|
               next unless var.children.first == offending_name
 
               corrector.replace(var.loc.expression, preferred_name)
@@ -89,24 +85,26 @@ module RuboCop
           variable.loc.expression
         end
 
-        def preferred_name
-          @preferred_name ||= begin
-            name = cop_config.fetch('PreferredName', 'e')
-            name = "_#{name}" if variable_name.to_s.start_with?('_')
-            name
+        def preferred_name(variable_name)
+          preferred_name = cop_config.fetch('PreferredName', 'e')
+          if variable_name.to_s.start_with?('_')
+            "_#{preferred_name}"
+          else
+            preferred_name
           end
         end
 
-        def variable_name
-          location.source
-        end
+        def variable_name(node)
+          asgn_node = node.exception_variable
+          return unless asgn_node
 
-        def location
-          @exception_name.loc.expression
+          asgn_node.children.last
         end
 
-        def message(_node = nil)
-          format(MSG, preferred: preferred_name, bad: variable_name)
+        def message(node)
+          offending_name = variable_name(node)
+          preferred_name = preferred_name(offending_name)
+          format(MSG, preferred: preferred_name, bad: offending_name)
         end
       end
     end

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for comments put on the same line as some keywords.
       # These keywords are: `begin`, `class`, `def`, `end`, `module`.
       #
-      # Note that some comments (`:nodoc:`, `:yields:, and `rubocop:disable`)
+      # Note that some comments (`:nodoc:`, `:yields:`, and `rubocop:disable`)
       # are allowed.
       #
       # @example

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

@@ -596,7 +596,8 @@ module RuboCop
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
-            branch_else = branch.parent.loc.else
+            return unless (branch_else = branch.parent.loc.else)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for division with integers coerced to floats.
+      # It is recommended to either always use `fdiv` or coerce one side only.
+      # This cop also provides other options for code consistency.
+      #
+      # @example EnforcedStyle: single_coerce (default)
+      #   # bad
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.to_f / b
+      #   a / b.to_f
+      #
+      # @example EnforcedStyle: left_coerce
+      #   # bad
+      #   a / b.to_f
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.to_f / b
+      #
+      # @example EnforcedStyle: right_coerce
+      #   # bad
+      #   a.to_f / b
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a / b.to_f
+      #
+      # @example EnforcedStyle: fdiv
+      #   # bad
+      #   a / b.to_f
+      #   a.to_f / b
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.fdiv(b)
+      class FloatDivision < Cop
+        include ConfigurableEnforcedStyle
+
+        def_node_matcher :right_coerce?, <<-PATTERN
+          (send _ :/ (send _ :to_f))
+        PATTERN
+        def_node_matcher :left_coerce?, <<-PATTERN
+          (send (send _ :to_f) :/ _)
+        PATTERN
+        def_node_matcher :both_coerce?, <<-PATTERN
+          (send (send _ :to_f) :/ (send _ :to_f))
+        PATTERN
+        def_node_matcher :any_coerce?, <<-PATTERN
+          {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if offense_condition?(node)
+        end
+
+        private
+
+        def offense_condition?(node)
+          case style
+          when :left_coerce
+            right_coerce?(node)
+          when :right_coerce
+            left_coerce?(node)
+          when :single_coerce
+            both_coerce?(node)
+          when :fdiv
+            any_coerce?(node)
+          else
+            false
+          end
+        end
+
+        def message(_node)
+          case style
+          when :left_coerce
+            'Prefer using `.to_f` on the left side.'
+          when :right_coerce
+            'Prefer using `.to_f` on the right side.'
+          when :single_coerce
+            'Prefer using `.to_f` on one side only.'
+          when :fdiv
+            'Prefer using `fdiv` for float divisions.'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -48,6 +48,10 @@ module RuboCop
         }
         PATTERN
 
+        def_node_matcher :variable_argument?, <<-PATTERN
+          (send {str dstr} :% {send_type? lvar_type?})
+        PATTERN
+
         def on_send(node)
           formatter(node) do |selector|
             detected_style = selector == :% ? :percent : selector
@@ -70,10 +74,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          lambda do |corrector|
-            detected_method = node.method_name
+          return if variable_argument?(node)
 
-            case detected_method
+          lambda do |corrector|
+            case node.method_name
             when :%
               autocorrect_from_percent(corrector, node)
             when :format, :sprintf

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

@@ -27,6 +27,37 @@ module RuboCop
       #   else
       #     action_c
       #   end
+      #
+      # @example AllowIfModifier: false (default)
+      #   # bad
+      #   if condition_a
+      #     action_a
+      #   else
+      #     action_b if condition_b
+      #   end
+      #
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   end
+      #
+      # @example AllowIfModifier: true
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   else
+      #     action_b if condition_b
+      #   end
+      #
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   end
+      #
       class IfInsideElse < Cop
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
@@ -36,9 +67,20 @@ module RuboCop
           else_branch = node.else_branch
 
           return unless else_branch&.if_type? && else_branch&.if?
+          return if allow_if_modifier_in_else_branch?(else_branch)
 
           add_offense(else_branch, location: :keyword)
         end
+
+        private
+
+        def allow_if_modifier_in_else_branch?(else_branch)
+          allow_if_modifier? && else_branch&.modifier_form?
+        end
+
+        def allow_if_modifier?
+          cop_config['AllowIfModifier']
+        end
       end
     end
   end

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

@@ -348,7 +348,8 @@ module RuboCop
         end
 
         def ambigious_literal?(node)
-          splat?(node) || ternary_if?(node) || regexp_slash_literal?(node)
+          splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) ||
+            unary_literal?(node)
         end
 
         def splat?(node)
@@ -371,6 +372,11 @@ module RuboCop
           node.regexp_type? && node.loc.begin.source == '/'
         end
 
+        def unary_literal?(node)
+          node.numeric_type? && node.sign? ||
+            node.parent&.send_type? && node.parent&.unary_operation?
+        end
+
         def assigned_before?(node, target)
           node.assignment? &&
             node.loc.operator.begin < target.loc.begin

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

@@ -224,7 +224,7 @@ module RuboCop
         end
 
         def method_called?(send_node)
-          send_node.parent&.send_type?
+          send_node&.parent&.send_type?
         end
 
         def begin_range(node, method_call)

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

@@ -108,7 +108,7 @@ module RuboCop
         end
 
         def non_complex_send?(node)
-          return false unless node.send_type?
+          return false unless node.call_type?
 
           !node.operator_method? || node.method?(:[])
         end
@@ -149,7 +149,8 @@ module RuboCop
 
         def unsafe_autocorrect?(condition)
           condition.children.any? do |child|
-            unparenthesized_method_call?(child)
+            unparenthesized_method_call?(child) ||
+              below_ternary_precedence?(child)
           end
         end
 
@@ -157,6 +158,15 @@ module RuboCop
           method_name(child) =~ /^[a-z]/i && !child.parenthesized?
         end
 
+        def below_ternary_precedence?(child)
+          # Handle English "or", e.g. 'foo or bar ? a : b'
+          (child.or_type? && child.semantic_operator?) ||
+            # Handle English "and", e.g. 'foo and bar ? a : b'
+            (child.and_type? && child.semantic_operator?) ||
+            # Handle English "not", e.g. 'not foo ? a : b'
+            (child.send_type? && child.prefix_not?)
+        end
+
         def_node_matcher :method_name, <<-PATTERN
           {($:defined? (send nil? _) ...)
            (send {_ nil?} $_ _ ...)}

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

@@ -65,6 +65,10 @@ module RuboCop
           PunctuationCorrector.swap_comma(range)
         end
 
+        def self.autocorrect_incompatible_with
+          [Layout::HeredocArgumentClosingParenthesis]
+        end
+
         private
 
         def avoid_autocorrect?(args)

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

@@ -71,8 +71,8 @@ module RuboCop
 
         def complex_content?(strings)
           strings.any? do |s|
-            string = s.str_content
-            !string.dup.force_encoding(::Encoding::UTF_8).valid_encoding? ||
+            string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
+            !string.valid_encoding? ||
               string !~ word_regex || string =~ / /
           end
         end

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

@@ -7,7 +7,7 @@ module RuboCop
       # by a predicate method, such as receiver.length == 0,
       # receiver.length > 0, receiver.length != 0,
       # receiver.length < 1 and receiver.size == 0 that can be
-      # replaced by receiver.empty? and !receiver.empty.
+      # replaced by receiver.empty? and !receiver.empty?.
       #
       # @example
       #   # bad

data/lib/rubocop/node_pattern.rb

@@ -47,6 +47,11 @@ module RuboCop
   #                         # a `sym` node, but can have more.
   #     '(array <$str $_>)' # captures are in the order of the pattern,
   #                         # irrespective of the actual order of the children
+  #     '(array int*)'      # will match an array of 0 or more integers
+  #     '(array int ?)'     # will match 0 or 1 integer.
+  #                         # Note: Space needed to distinguish from int?
+  #     '(array int+)'      # will match an array of 1 or more integers
+  #     '(array (int $_)+)' # as above and will capture the numbers in an array
   #     '(send $...)'       # capture all the children as an array
   #     '(send $... int)'   # capture all children but the last as an array
   #     '(send _x :+ _x)'   # unification is performed on named wildcards
@@ -106,7 +111,9 @@ module RuboCop
     class Compiler
       SYMBOL       = %r{:(?:[\w+@*/?!<>=~|%^-]+|\[\]=?)}.freeze
       IDENTIFIER   = /[a-zA-Z_][a-zA-Z0-9_-]*/.freeze
-      META         = Regexp.union(%w"( ) { } [ ] $< < > $... $ ! ^ ...").freeze
+      META         = Regexp.union(
+        %w"( ) { } [ ] $< < > $... $ ! ^ ... + * ?"
+      ).freeze
       NUMBER       = /-?\d+(?:\.\d+)?/.freeze
       STRING       = /".+?"/.freeze
       METHOD_NAME  = /\#?#{IDENTIFIER}[\!\?]?\(?/.freeze
@@ -160,6 +167,21 @@ module RuboCop
       RUBY
       ANY_ORDER_TEMPLATE.location = [__FILE__, line + 1]
 
+      line = __LINE__
+      REPEATED_TEMPLATE = ERB.new <<~RUBY.gsub("-%>\n", '%>')
+        <% if captured %>(<%= accumulate %> = Array.new) && <% end %>
+        <%= CUR_NODE %>.children[<%= range %>].all? do |<%= child %>|
+          <%= with_context(expr, child, use_temp_node: false) %><% if captured %>&&
+          <%= accumulate %>.push(<%= captured %>)<% end %>
+        end <% if captured %>&&
+        (<%= captured %> = if <%= accumulate %>.empty?
+          <%= captured %>.map{[]} # Transpose hack won't work for empty case
+        else
+          <%= accumulate %>.transpose
+        end) <% end -%>
+      RUBY
+      REPEATED_TEMPLATE.location = [__FILE__, line + 1]
+
       def initialize(str, node_var = 'node0')
         @string   = str
         @root     = node_var
@@ -238,10 +260,48 @@ module RuboCop
         when REST          then compile_ellipsis
         when '$<'          then compile_any_order(next_capture)
         when '<'           then compile_any_order
-        else                    [1, compile_expr(token)]
+        else                    compile_repeated_expr(token)
+        end
+      end
+
+      def compile_repeated_expr(token)
+        before = @captures
+        expr = compile_expr(token)
+        min, max = parse_repetition_token
+        return [1, expr] if min.nil?
+
+        if @captures != before
+          captured = "captures[#{before}...#{@captures}]"
+          accumulate = next_temp_variable(:accumulate)
+        end
+        arity = min..max || Float::INFINITY
+
+        [arity, repeated_generator(expr, captured, accumulate)]
+      end
+
+      def repeated_generator(expr, captured, accumulate)
+        with_temp_variables do |child|
+          lambda do |range|
+            if range.begin == SEQ_HEAD_INDEX
+              fail_due_to 'repeated pattern at beginning of sequence'
+            end
+            REPEATED_TEMPLATE.result(binding)
+          end
         end
       end
 
+      def parse_repetition_token
+        case tokens.first
+        when '*' then min = 0
+        when '+' then min = 1
+        when '?' then min = 0
+                      max = 1
+        else          return
+        end
+        tokens.shift
+        [min, max]
+      end
+
       # @private
       # Builds Ruby code for a sequence
       # (head *first_terms variadic_term *last_terms)
@@ -276,6 +336,10 @@ module RuboCop
           last_terms_range { |r| @arities[r].inject(0, :+) } || 0
         end
 
+        def variadic_term_min_arity
+          @variadic_index ? @arities[@variadic_index].begin : 0
+        end
+
         def first_terms_range
           yield 1..(@variadic_index || @terms.size) - 1 if seq_head?
         end
@@ -289,8 +353,19 @@ module RuboCop
         end
 
         def compile_child_nb_guard
-          min = first_terms_arity + last_terms_arity
-          "#{CUR_NODE}.children.size #{@variadic_index ? '>' : '='}= #{min}"
+          fixed = first_terms_arity + last_terms_arity
+          min = fixed + variadic_term_min_arity
+          op = if @variadic_index
+                 max_variadic = @arities[@variadic_index].end
+                 if max_variadic != Float::INFINITY
+                   range = min..fixed + max_variadic
+                   return "(#{range}).cover?(#{CUR_NODE}.children.size)"
+                 end
+                 '>='
+               else
+                 '=='
+               end
+          "#{CUR_NODE}.children.size #{op} #{min}"
         end
 
         def term(index, range)
@@ -555,10 +630,14 @@ module RuboCop
       end
 
       def with_temp_variables(&block)
-        names = block.parameters.map { |_, name| "#{name}#{next_temp_value}" }
+        names = block.parameters.map { |_, name| next_temp_variable(name) }
         yield(*names)
       end
 
+      def next_temp_variable(name)
+        "#{name}#{next_temp_value}"
+      end
+
       def next_temp_value
         @temps += 1
       end