rubocop 0.87.1 → 0.88.0

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

@@ -17,9 +17,9 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        node.nonempty_line_count > 3 ||
-          !node.modifier_form? &&
-            processed_source.commented?(node.loc.end)
+        node.modifier_form? ||
+          node.nonempty_line_count > 3 ||
+          processed_source.commented?(node.loc.end)
       end
 
       def non_eligible_body?(body)

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

@@ -58,6 +58,10 @@ module RuboCop
 
         private
 
+        def previous_line_comment?(node)
+          comment_line?(processed_source[node.first_line - 2])
+        end
+
         def class_send_elements(class_node)
           class_def = class_node.body
 
@@ -75,6 +79,8 @@ module RuboCop
         end
 
         def check(send_node)
+          return if previous_line_comment?(send_node)
+
           if grouped_style? && sibling_accessors(send_node).size > 1
             add_offense(send_node)
           elsif separated_style? && send_node.arguments.size > 1
@@ -94,7 +100,8 @@ module RuboCop
           send_node.parent.each_child_node(:send).select do |sibling|
             accessor?(sibling) &&
               sibling.method?(send_node.method_name) &&
-              node_visibility(sibling) == node_visibility(send_node)
+              node_visibility(sibling) == node_visibility(send_node) &&
+              !previous_line_comment?(sibling)
           end
         end
 

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of `Array()` instead of explicit `Array` check or `[*var]`.
+      #
+      # @example
+      #   # bad
+      #   paths = [paths] unless paths.is_a?(Array)
+      #   paths.each { |path| do_something(path) }
+      #
+      #   # bad (always creates a new Array instance)
+      #   [*paths].each { |path| do_something(path) }
+      #
+      #   # good (and a bit more readable)
+      #   Array(paths).each { |path| do_something(path) }
+      #
+      class ArrayCoercion < Base
+        extend AutoCorrector
+
+        SPLAT_MSG = 'Use `Array(%<arg>s)` instead of `[*%<arg>s]`.'
+        CHECK_MSG = 'Use `Array(%<arg>s)` instead of explicit `Array` check.'
+
+        def_node_matcher :array_splat?, <<~PATTERN
+          (array (splat $_))
+        PATTERN
+
+        def_node_matcher :unless_array?, <<~PATTERN
+          (if
+            (send
+              (lvar $_) :is_a?
+              (const nil? :Array)) nil?
+            (lvasgn $_
+              (array
+                (lvar $_))))
+        PATTERN
+
+        def on_array(node)
+          return unless node.square_brackets?
+
+          array_splat?(node) do |arg_node|
+            message = format(SPLAT_MSG, arg: arg_node.source)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, "Array(#{arg_node.source})")
+            end
+          end
+        end
+
+        def on_if(node)
+          unless_array?(node) do |var_a, var_b, var_c|
+            if var_a == var_b && var_c == var_b
+              message = format(CHECK_MSG, arg: var_a)
+              add_offense(node, message: message) do |corrector|
+                corrector.replace(node, "#{var_a} = Array(#{var_a})")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -25,10 +25,11 @@ module RuboCop
 
         def on_send(node)
           TARGET_METHODS.each do |target_class, target_method|
-            target_receiver = s(:const, nil, target_class)
+            next if node.method_name != target_method
 
+            target_receiver = s(:const, nil, target_class)
             next if node.receiver != target_receiver
-            next if node.method_name != target_method
+
             next if cleanup?(node)
 
             add_offense(node,

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

@@ -28,6 +28,7 @@ module RuboCop
         def on_class(class_node)
           VISIBILITY_SCOPES.each do |visibility|
             reader_names, writer_names = accessor_names(class_node, visibility)
+            next unless reader_names && writer_names
 
             accessor_macroses(class_node, visibility).each do |macro|
               check(macro, reader_names, writer_names)
@@ -48,17 +49,17 @@ module RuboCop
         private
 
         def accessor_names(class_node, visibility)
-          reader_names = Set.new
-          writer_names = Set.new
+          reader_names = nil
+          writer_names = nil
 
           accessor_macroses(class_node, visibility).each do |macro|
             names = macro.arguments.map(&:source)
 
             names.each do |name|
               if attr_reader?(macro)
-                reader_names.add(name)
+                (reader_names ||= Set.new).add(name)
               else
-                writer_names.add(name)
+                (writer_names ||= Set.new).add(name)
               end
             end
           end

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `if-elsif` constructions
+      # can be replaced with `case-when`.
+      #
+      # @example
+      #   # bad
+      #   if status == :active
+      #     perform_action
+      #   elsif status == :inactive || status == :hibernating
+      #     check_timeout
+      #   else
+      #     final_action
+      #   end
+      #
+      #   # good
+      #   case status
+      #   when :active
+      #     perform_action
+      #   when :inactive, :hibernating
+      #     check_timeout
+      #   else
+      #     final_action
+      #   end
+      #
+      class CaseLikeIf < Cop
+        include RangeHelp
+
+        MSG = 'Convert `if-elsif` to `case-when`.'
+
+        def on_if(node)
+          return unless should_check?(node)
+
+          target = find_target(node.condition)
+          return unless target
+
+          conditions = []
+          convertible = true
+
+          branch_conditions(node).each do |branch_condition|
+            conditions << []
+            convertible = collect_conditions(branch_condition, target, conditions.last)
+            break unless convertible
+          end
+
+          add_offense(node) if convertible
+        end
+
+        def autocorrect(node)
+          target = find_target(node.condition)
+
+          lambda do |corrector|
+            corrector.insert_before(node, "case #{target.source}\n#{indent(node)}")
+
+            branch_conditions(node).each do |branch_condition|
+              conditions = []
+              collect_conditions(branch_condition, target, conditions)
+
+              range = correction_range(branch_condition)
+              branch_replacement = "when #{conditions.map(&:source).join(', ')}"
+              corrector.replace(range, branch_replacement)
+            end
+          end
+        end
+
+        private
+
+        def should_check?(node)
+          !node.unless? && !node.elsif? && !node.modifier_form? && !node.ternary? &&
+            node.elsif_conditional?
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def find_target(node)
+          case node.type
+          when :begin
+            find_target(node.children.first)
+          when :or
+            find_target(node.lhs)
+          when :match_with_lvasgn
+            lhs, rhs = *node
+            if lhs.regexp_type?
+              rhs
+            elsif rhs.regexp_type?
+              lhs
+            end
+          when :send
+            find_target_in_send_node(node)
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def find_target_in_send_node(node)
+          case node.method_name
+          when :is_a?
+            node.receiver
+          when :==, :eql?, :equal?
+            find_target_in_equality_node(node)
+          when :===
+            node.arguments.first
+          when :include?, :cover?
+            receiver = deparenthesize(node.receiver)
+            node.arguments.first if receiver.range_type?
+          when :match, :match?
+            find_target_in_match_node(node)
+          end
+        end
+
+        def find_target_in_equality_node(node)
+          argument = node.arguments.first
+          receiver = node.receiver
+
+          if argument.literal? || const_reference?(argument)
+            receiver
+          elsif receiver.literal? || const_reference?(receiver)
+            argument
+          end
+        end
+
+        def find_target_in_match_node(node)
+          argument = node.arguments.first
+          receiver = node.receiver
+
+          if receiver.regexp_type?
+            argument
+          elsif argument.regexp_type?
+            receiver
+          end
+        end
+
+        def collect_conditions(node, target, conditions)
+          condition =
+            case node.type
+            when :begin
+              return collect_conditions(node.children.first, target, conditions)
+            when :or
+              return collect_conditions(node.lhs, target, conditions) &&
+                     collect_conditions(node.rhs, target, conditions)
+            when :match_with_lvasgn
+              lhs, rhs = *node
+              condition_from_binary_op(lhs, rhs, target)
+            when :send
+              condition_from_send_node(node, target)
+            end
+
+          conditions << condition if condition
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def condition_from_send_node(node, target)
+          case node.method_name
+          when :is_a?
+            node.arguments.first if node.receiver == target
+          when :==, :eql?, :equal?, :=~, :match, :match?
+            lhs, _method, rhs = *node
+            condition_from_binary_op(lhs, rhs, target)
+          when :===
+            lhs, _method, rhs = *node
+            lhs if rhs == target
+          when :include?, :cover?
+            receiver = deparenthesize(node.receiver)
+            receiver if receiver.range_type? && node.arguments.first == target
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize
+
+        def condition_from_binary_op(lhs, rhs, target)
+          lhs = deparenthesize(lhs)
+          rhs = deparenthesize(rhs)
+
+          if lhs == target
+            rhs
+          elsif rhs == target
+            lhs
+          end
+        end
+
+        def branch_conditions(node)
+          conditions = []
+          while node&.if_type?
+            conditions << node.condition
+            node = node.else_branch
+          end
+          conditions
+        end
+
+        def const_reference?(node)
+          return false unless node.const_type?
+
+          name = node.children[1].to_s
+
+          # We can no be sure if, e.g. `C`, represents a constant or a class reference
+          name.length > 1 &&
+            name == name.upcase
+        end
+
+        def deparenthesize(node)
+          node = node.children.last while node.begin_type?
+          node
+        end
+
+        def correction_range(node)
+          range_between(node.parent.loc.keyword.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end

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

@@ -46,17 +46,20 @@ module RuboCop
         private
 
         KEYWORDS = %w[begin class def end module].freeze
+        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
+
         ALLOWED_COMMENTS = %w[
           :nodoc:
           :yields:
           rubocop:disable
           rubocop:todo
         ].freeze
+        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
 
         def offensive?(comment)
           line = line(comment)
-          KEYWORDS.any? { |word| /^\s*#{word}\s/.match?(line) } &&
-            ALLOWED_COMMENTS.none? { |c| /#\s*#{c}/.match?(line) }
+          KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
+            ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
 
         def message(comment)

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

@@ -30,7 +30,7 @@ module RuboCop
         end
 
         def tail(branch)
-          branch.begin_type? ? [*branch].last : branch
+          branch.begin_type? ? Array(branch).last : branch
         end
 
         # rubocop:disable Metrics/AbcSize

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

@@ -60,6 +60,11 @@ module RuboCop
       #
       class ExponentialNotation < Cop
         include ConfigurableEnforcedStyle
+        MESSAGES = {
+          scientific: 'Use a mantissa in [1, 10[.',
+          engineering: 'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.',
+          integral: 'Use an integer as mantissa, without trailing zero.'
+        }.freeze
 
         def on_float(node)
           add_offense(node) if offense?(node)
@@ -104,14 +109,7 @@ module RuboCop
         end
 
         def message(_node)
-          case style
-          when :scientific
-            'Use a mantissa in [1, 10[.'
-          when :engineering
-            'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.'
-          when :integral
-            'Use an integer as mantissa, without trailing zero.'
-          end
+          MESSAGES[style]
         end
       end
     end

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

@@ -41,6 +41,12 @@ module RuboCop
       #   a.fdiv(b)
       class FloatDivision < Cop
         include ConfigurableEnforcedStyle
+        MESSAGES = {
+          left_coerce: 'Prefer using `.to_f` on the left side.',
+          right_coerce: 'Prefer using `.to_f` on the right side.',
+          single_coerce: 'Prefer using `.to_f` on one side only.',
+          fdiv: 'Prefer using `fdiv` for float divisions.'
+        }.freeze
 
         def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
@@ -77,16 +83,7 @@ module RuboCop
         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
+          MESSAGES[style]
         end
       end
     end