rubocop 0.88.0 → 0.89.0

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

@@ -25,7 +25,7 @@ module RuboCop
         extend AutoCorrector
 
         def on_hash(node)
-          return unless node.parent&.array_type?
+          return unless last_array_item?(node)
 
           if braces_style?
             check_braces(node)
@@ -36,6 +36,13 @@ module RuboCop
 
         private
 
+        def last_array_item?(node)
+          parent = node.parent
+          return false unless parent
+
+          parent.array_type? && parent.values.last == node
+        end
+
         def check_braces(node)
           return if node.braces?
 

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

@@ -62,6 +62,7 @@ module RuboCop
         MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash."
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
 
+        # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
         def on_hash(node)
           pairs = node.pairs
 
@@ -73,10 +74,11 @@ module RuboCop
             ruby19_no_mixed_keys_check(pairs)
           elsif style == :no_mixed_keys
             no_mixed_keys_check(pairs)
-          else
+          elsif node.source.include?('=>')
             ruby19_check(pairs)
           end
         end
+        # rubocop:enable Metrics/PerceivedComplexity, Metrics/AbcSize
 
         def ruby19_check(pairs)
           check(pairs, '=>', MSG_19) if sym_indices?(pairs)
@@ -174,7 +176,7 @@ module RuboCop
 
           corrector.replace(
             range,
-            range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
+            range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: ")
           )
 
           hash_node = pair_node.parent
@@ -199,7 +201,8 @@ module RuboCop
         def autocorrect_hash_rockets(corrector, pair_node)
           op = pair_node.loc.operator
 
-          corrector.wrap(pair_node.key, ':', pair_node.inverse_delimiter(true))
+          key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
+          corrector.replace(pair_node.key, key_with_hash_rocket)
           corrector.remove(range_with_surrounding_space(range: op))
         end
 

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

@@ -81,7 +81,7 @@ module RuboCop
 
         private
 
-        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity
+        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
           return if branches.any?(&:nil?)

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

@@ -61,7 +61,7 @@ module RuboCop
       class IfInsideElse < Cop
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
-        def on_if(node) # rubocop:todo Metrics/CyclomaticComplexity
+        def on_if(node)
           return if node.ternary? || node.unless?
 
           else_branch = node.else_branch

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

@@ -148,26 +148,6 @@ module RuboCop
             sibling.source_range.first_line == line_no
         end
 
-        def parenthesize?(node)
-          # Parenthesize corrected expression if changing to modifier-if form
-          # would change the meaning of the parent expression
-          # (due to the low operator precedence of modifier-if)
-          parent = node.parent
-          return false if parent.nil?
-          return true if parent.assignment? || parent.operator_keyword?
-
-          node.parent.send_type? && !node.parent.parenthesized?
-        end
-
-        def to_modifier_form(node)
-          expression = [node.body.source,
-                        node.keyword,
-                        node.condition.source,
-                        first_line_comment(node)].compact.join(' ')
-
-          parenthesize?(node) ? "(#{expression})" : expression
-        end
-
         def to_normal_form(node)
           indentation = ' ' * node.source_range.column
           <<~RUBY.chomp

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

@@ -99,7 +99,7 @@ module RuboCop
         def modifier_replacement(node)
           body = node.body
           if node.single_line?
-            'loop { ' + body.source + ' }'
+            "loop { #{body.source} }"
           else
             indentation = body.source_range.source_line[LEADING_SPACE]
 

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

@@ -64,12 +64,11 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if part_of_ignored_node?(node)
-
           inverse_candidate?(node) do |_method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if possible_class_hierarchy_check?(lhs, rhs, method)
             return if negated?(node)
+            return if part_of_ignored_node?(node)
+            return if possible_class_hierarchy_check?(lhs, rhs, method)
 
             add_offense(node,
                         message: format(MSG, method: method,

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

@@ -60,6 +60,7 @@ module RuboCop
               call_with_ambiguous_arguments?(node) ||
               call_in_logical_operators?(node) ||
               call_in_optional_arguments?(node) ||
+              call_in_single_line_inheritance?(node) ||
               allowed_multiline_call_with_parentheses?(node) ||
               allowed_chained_call_with_parentheses?(node)
           end
@@ -86,6 +87,10 @@ module RuboCop
               (node.parent.optarg_type? || node.parent.kwoptarg_type?)
           end
 
+          def call_in_single_line_inheritance?(node)
+            node.parent&.class_type? && node.parent&.single_line?
+          end
+
           def call_with_ambiguous_arguments?(node)
             call_with_braced_block?(node) ||
               call_as_argument_or_chain?(node) ||

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

@@ -18,8 +18,8 @@ module RuboCop
               'no arguments.'
 
         def on_send(node)
-          return if ineligible_node?(node)
           return unless !node.arguments? && node.parenthesized?
+          return if ineligible_node?(node)
           return if ignored_method?(node.method_name)
           return if same_name_assignment?(node)
 

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

@@ -36,9 +36,16 @@ module RuboCop
         private
 
         def implements_respond_to_missing?(node)
-          node.parent.each_child_node(node.type).any? do |sibling|
-            sibling.method?(:respond_to_missing?)
+          return false unless (grand_parent = node.parent.parent)
+
+          grand_parent.each_descendant(node.type) do |descendant|
+            return true if descendant.method?(:respond_to_missing?)
+
+            child = descendant.children.first
+            return true if child.respond_to?(:method?) && child.method?(:respond_to_missing?)
           end
+
+          false
         end
       end
     end

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

@@ -77,13 +77,13 @@ module RuboCop
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else
-            "begin\n" + (' ' * (node.loc.column + indent))
+            "begin\n#{' ' * (node.loc.column + indent)}"
           end
         end
 
         def keyword_end_str(node, node_buf)
           if /[^\s)]/.match?(node_buf.source_line(node.loc.end.line))
-            "\n" + (' ' * node.loc.column) + 'end'
+            "\n#{' ' * node.loc.column}end"
           else
             'end'
           end

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

@@ -53,7 +53,7 @@ module RuboCop
         end
 
         def max_line_length
-          config.for_cop('Layout/LineLength')['Max'] || 80
+          config.for_cop('Layout/LineLength')['Max'] || 120
         end
       end
     end

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

@@ -53,7 +53,11 @@ module RuboCop
           'negative?' => '<'
         }.freeze
 
+        COMPARISON_METHODS = %i[== > < positive? negative? zero?].to_set.freeze
+
         def on_send(node)
+          return unless COMPARISON_METHODS.include?(node.method_name)
+
           numeric, replacement = check(node)
           return unless numeric
 

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where keyword arguments can be used instead of
+      # boolean arguments when defining methods.
+      #
+      # @example
+      #   # bad
+      #   def some_method(bar = false)
+      #     puts bar
+      #   end
+      #
+      #   # bad - common hack before keyword args were introduced
+      #   def some_method(options = {})
+      #     bar = options.fetch(:bar, false)
+      #     puts bar
+      #   end
+      #
+      #   # good
+      #   def some_method(bar: false)
+      #     puts bar
+      #   end
+      #
+      class OptionalBooleanParameter < Base
+        MSG = 'Use keyword arguments when defining method with boolean argument.'
+        BOOLEAN_TYPES = %i[true false].freeze
+
+        def on_def(node)
+          node.arguments.each do |arg|
+            next unless arg.optarg_type?
+
+            _name, value = *arg
+            add_offense(arg) if BOOLEAN_TYPES.include?(value.type)
+          end
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -131,8 +131,8 @@ module RuboCop
             @assignments = assignments
           end
 
-          def tsort_each_node
-            @assignments.each { |a| yield a }
+          def tsort_each_node(&block)
+            @assignments.each(&block)
           end
 
           def tsort_each_child(assignment)

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

@@ -102,12 +102,12 @@ module RuboCop
           delimiters_regexp = Regexp.union(delimiters)
           node
             .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp.match?(s.scrub) }
+            .any? { |s| delimiters_regexp.match?(s) }
         end
 
         def string_source(node)
           if node.is_a?(String)
-            node
+            node.scrub
           elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
             node.source
           end

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

@@ -56,6 +56,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless node.receiver
           return unless integer_op_rand?(node) ||
                         rand_op_integer?(node) ||
                         rand_modified?(node)

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

@@ -90,10 +90,10 @@ module RuboCop
         end
 
         def else_source(else_branch)
-          if else_branch.basic_conditional? &&
-             else_branch.modifier_form? ||
-             else_branch.range_type?
+          if require_parentheses?(else_branch)
             "(#{else_branch.source})"
+          elsif without_argument_parentheses_method?(else_branch)
+            "#{else_branch.method_name}(#{else_branch.arguments.map(&:source).join(', ')})"
           else
             else_branch.source
           end
@@ -118,6 +118,18 @@ module RuboCop
 
           corrector.wrap(node.else_branch, '(', ')')
         end
+
+        def require_parentheses?(node)
+          node.basic_conditional? &&
+            node.modifier_form? ||
+            node.range_type? ||
+            node.rescue_type? ||
+            node.respond_to?(:semantic_operator?) && node.semantic_operator?
+        end
+
+        def without_argument_parentheses_method?(node)
+          node.send_type? && !node.arguments.empty? && !node.parenthesized?
+        end
       end
     end
   end

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

@@ -23,9 +23,13 @@ module RuboCop
         MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
                 'just the message.'
 
+        RAISE_METHODS = %i[raise fail].freeze
+
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
         # `raise RuntimeError.new('message')` to `raise 'message'`.
         def on_send(node)
+          return unless RAISE_METHODS.include?(node.method_name)
+
           fix_exploded(node) || fix_compact(node)
         end
 

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

@@ -92,18 +92,18 @@ module RuboCop
 
         def each_escape(node)
           pattern_source(node).each_char.with_index.reduce(
-            [nil, false]
-          ) do |(previous, within_character_class), (current, index)|
+            [nil, 0]
+          ) do |(previous, char_class_depth), (current, index)|
             if previous == '\\'
-              yield [current, index - 1, within_character_class]
+              yield [current, index - 1, !char_class_depth.zero?]
 
-              [nil, within_character_class]
-            elsif previous == '[' && current != ':'
-              [current, true]
-            elsif previous != ':' && current == ']'
-              [current, false]
+              [nil, char_class_depth]
+            elsif previous == '['
+              [current, char_class_depth + 1]
+            elsif current == ']'
+              [current, char_class_depth - 1]
             else
-              [current, within_character_class]
+              [current, char_class_depth]
             end
           end
         end

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

@@ -55,6 +55,8 @@ module RuboCop
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
+        SORT_METHODS = %i[sort sort_by].freeze
+
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
@@ -71,20 +73,25 @@ module RuboCop
           }
         MATCHER
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
-          redundant_sort?(node) do |sort_node, sorter, accessor|
-            range = range_between(
-              sort_node.loc.selector.begin_pos,
-              node.loc.expression.end_pos
-            )
+          return unless sort_method?(node)
 
-            add_offense(node,
-                        location: range,
-                        message: message(node,
-                                         sorter,
-                                         accessor))
+          if (sort_node, sorter, accessor = redundant_sort?(node.parent))
+            ancestor = node.parent
+          elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
+            ancestor = node.parent.parent
+          else
+            return
           end
+
+          add_offense(ancestor,
+                      location: offense_range(sort_node, ancestor),
+                      message: message(ancestor,
+                                       sorter,
+                                       accessor))
         end
+        # rubocop:enable Metrics/AbcSize
 
         def autocorrect(node)
           sort_node, sorter, accessor = redundant_sort?(node)
@@ -108,6 +115,14 @@ module RuboCop
 
         private
 
+        def sort_method?(node)
+          SORT_METHODS.include?(node.method_name)
+        end
+
+        def offense_range(sort_node, ancestor)
+          range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
+        end
+
         def message(node, sorter, accessor)
           accessor_source = range_between(
             node.loc.selector.begin_pos,

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

@@ -191,6 +191,8 @@ module RuboCop
         end
 
         def command_or_kernel_call?(name, node)
+          return unless node.method?(name)
+
           node.command?(name) || kernel_call?(node, name)
         end