rubocop 0.85.0 → 0.88.0

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/bare_percent_literals.rb

@@ -60,7 +60,7 @@ module RuboCop
         end
 
         def requires_percent_q?(source)
-          style == :percent_q && source =~ /^%[^\w]/
+          style == :percent_q && /^%[^\w]/.match?(source)
         end
 
         def requires_bare_percent?(source)

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where `attr_reader` and `attr_writer`
+      # for the same method can be combined into single `attr_accessor`.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_writer :bar
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_accessor :bar
+      #   end
+      #
+      class BisectedAttrAccessor < Cop
+        include VisibilityHelp
+
+        MSG = 'Combine both accessors into `attr_accessor %<name>s`.'
+
+        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)
+            end
+          end
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+
+        def autocorrect(node)
+          macro = node.parent
+
+          lambda do |corrector|
+            corrector.replace(macro, replacement(macro, node))
+          end
+        end
+
+        private
+
+        def accessor_names(class_node, visibility)
+          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 ||= Set.new).add(name)
+              else
+                (writer_names ||= Set.new).add(name)
+              end
+            end
+          end
+
+          [reader_names, writer_names]
+        end
+
+        def accessor_macroses(class_node, visibility)
+          class_def = class_node.body
+          return [] if !class_def || class_def.def_type?
+
+          send_nodes =
+            if class_def.send_type?
+              [class_def]
+            else
+              class_def.each_child_node(:send)
+            end
+
+          send_nodes.select { |node| attr_within_visibility_scope?(node, visibility) }
+        end
+
+        def attr_within_visibility_scope?(node, visibility)
+          node.macro? &&
+            (attr_reader?(node) || attr_writer?(node)) &&
+            node_visibility(node) == visibility
+        end
+
+        def attr_reader?(send_node)
+          send_node.method?(:attr_reader) || send_node.method?(:attr)
+        end
+
+        def attr_writer?(send_node)
+          send_node.method?(:attr_writer)
+        end
+
+        def check(macro, reader_names, writer_names)
+          macro.arguments.each do |arg_node|
+            name = arg_node.source
+
+            if (attr_reader?(macro) && writer_names.include?(name)) ||
+               (attr_writer?(macro) && reader_names.include?(name))
+              add_offense(arg_node, message: format(MSG, name: name))
+            end
+          end
+        end
+
+        def replacement(macro, node)
+          class_node = macro.each_ancestor(:class, :sclass, :module).first
+          reader_names, writer_names = accessor_names(class_node, node_visibility(macro))
+
+          rest_args = rest_args(macro.arguments, reader_names, writer_names)
+
+          if attr_reader?(macro)
+            attr_reader_replacement(macro, node, rest_args)
+          elsif rest_args.empty?
+            ''
+          else
+            "#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
+          end
+        end
+
+        def rest_args(args, reader_names, writer_names)
+          args.reject do |arg|
+            name = arg.source
+            reader_names.include?(name) && writer_names.include?(name)
+          end
+        end
+
+        def attr_reader_replacement(macro, node, rest_args)
+          if rest_args.empty?
+            "attr_accessor #{node.source}"
+          else
+            "attr_accessor #{node.source}\n"\
+            "#{indent(macro)}#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
+          end
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end

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

@@ -245,14 +245,13 @@ module RuboCop
         end
 
         def whitespace_before?(range)
-          range.source_buffer.source[range.begin_pos - 1, 1] =~ /\s/
+          /\s/.match?(range.source_buffer.source[range.begin_pos - 1, 1])
         end
 
         def whitespace_after?(range, length = 1)
-          range.source_buffer.source[range.begin_pos + length, 1] =~ /\s/
+          /\s/.match?(range.source_buffer.source[range.begin_pos + length, 1])
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
           when :block
@@ -270,7 +269,6 @@ module RuboCop
             node.each_child_node { |child| get_blocks(child, &block) }
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def proper_block_style?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)

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