rubocop 0.85.1 → 0.89.1

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+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 < Base
+        include VisibilityHelp
+        extend AutoCorrector
+
+        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
+
+        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
+
+            next unless (attr_reader?(macro) && writer_names.include?(name)) ||
+                        (attr_writer?(macro) && reader_names.include?(name))
+
+            add_offense(arg_node, message: format(MSG, name: name)) do |corrector|
+              macro = arg_node.parent
+
+              corrector.replace(macro, replacement(macro, arg_node))
+            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_comments.rb

@@ -16,34 +16,30 @@ module RuboCop
       #   # Multiple lines
       #   # of comments...
       #
-      class BlockComments < Cop
+      class BlockComments < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use block comments.'
         BEGIN_LENGTH = "=begin\n".length
         END_LENGTH = "\n=end".length
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
+        def on_new_investigation
+          processed_source.comments.each do |comment|
             next unless comment.document?
 
-            add_offense(comment)
-          end
-        end
-
-        def autocorrect(comment)
-          eq_begin, eq_end, contents = parts(comment)
+            add_offense(comment) do |corrector|
+              eq_begin, eq_end, contents = parts(comment)
 
-          lambda do |corrector|
-            corrector.remove(eq_begin)
-            unless contents.length.zero?
-              corrector.replace(contents,
-                                contents.source
-                                  .gsub(/\A/, '# ')
-                                  .gsub(/\n\n/, "\n#\n")
-                                  .gsub(/\n(?=[^#])/, "\n# "))
+              corrector.remove(eq_begin)
+              unless contents.length.zero?
+                corrector.replace(
+                  contents,
+                  contents.source.gsub(/\A/, '# ').gsub(/\n\n/, "\n#\n").gsub(/\n(?=[^#])/, "\n# ")
+                )
+              end
+              corrector.remove(eq_end)
             end
-            corrector.remove(eq_end)
           end
         end
 

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

@@ -132,14 +132,14 @@ module RuboCop
       #     puts foo
       #   end
       #
-      class BlockDelimiters < Cop
+      class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        extend AutoCorrector
 
         ALWAYS_BRACES_MESSAGE = 'Prefer `{...}` over `do...end` for blocks.'
 
-        BRACES_REQUIRED_MESSAGE = 'Brace delimiters `{...}` required for ' \
-          "'%<method_name>s' method."
+        BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
         def on_send(node)
           return unless node.arguments?
@@ -158,22 +158,26 @@ module RuboCop
 
         def on_block(node)
           return if ignored_node?(node)
+          return if proper_block_style?(node)
 
-          add_offense(node, location: :begin) unless proper_block_style?(node)
+          message = message(node)
+          add_offense(node.loc.begin, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           return if correction_would_break_code?(node)
 
           if node.braces?
-            replace_braces_with_do_end(node.loc)
+            replace_braces_with_do_end(corrector, node.loc)
           else
-            replace_do_end_with_braces(node.loc)
+            replace_do_end_with_braces(corrector, node.loc)
           end
         end
 
-        private
-
         def line_count_based_message(node)
           if node.multiline?
             'Avoid using `{...}` for multi-line blocks.'
@@ -219,40 +223,35 @@ module RuboCop
           end
         end
 
-        def replace_braces_with_do_end(loc)
+        def replace_braces_with_do_end(corrector, loc)
           b = loc.begin
           e = loc.end
 
-          lambda do |corrector|
-            corrector.insert_before(b, ' ') unless whitespace_before?(b)
-            corrector.insert_before(e, ' ') unless whitespace_before?(e)
-            corrector.insert_after(b, ' ') unless whitespace_after?(b)
-            corrector.replace(b, 'do')
-            corrector.replace(e, 'end')
-          end
+          corrector.insert_before(b, ' ') unless whitespace_before?(b)
+          corrector.insert_before(e, ' ') unless whitespace_before?(e)
+          corrector.insert_after(b, ' ') unless whitespace_after?(b)
+          corrector.replace(b, 'do')
+          corrector.replace(e, 'end')
         end
 
-        def replace_do_end_with_braces(loc)
+        def replace_do_end_with_braces(corrector, loc)
           b = loc.begin
           e = loc.end
 
-          lambda do |corrector|
-            corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
+          corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
 
-            corrector.replace(b, '{')
-            corrector.replace(e, '}')
-          end
+          corrector.replace(b, '{')
+          corrector.replace(e, '}')
         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_equality.rb

@@ -29,13 +29,20 @@ module RuboCop
       #   (1..100).include?(7)
       #   some_string =~ /something/
       #
-      class CaseEquality < Cop
+      class CaseEquality < Base
+        extend AutoCorrector
+
         MSG = 'Avoid the use of the case equality operator `===`.'
 
-        def_node_matcher :case_equality?, '(send #const? :=== _)'
+        def_node_matcher :case_equality?, '(send $#const? :=== $_)'
 
         def on_send(node)
-          case_equality?(node) { add_offense(node, location: :selector) }
+          case_equality?(node) do |lhs, rhs|
+            add_offense(node.loc.selector) do |corrector|
+              replacement = replacement(lhs, rhs)
+              corrector.replace(node, replacement) if replacement
+            end
+          end
         end
 
         private
@@ -47,6 +54,18 @@ module RuboCop
             true
           end
         end
+
+        def replacement(lhs, rhs)
+          case lhs.type
+          when :regexp
+            "#{rhs.source} =~ #{lhs.source}"
+          when :begin
+            child = lhs.children.first
+            "#{lhs.source}.include?(#{rhs.source})" if child&.range_type?
+          when :const
+            "#{rhs.source}.is_a?(#{lhs.source})"
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,220 @@
+# 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 < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        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
+
+          return unless convertible
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          target = find_target(node.condition)
+
+          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
+
+        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
+          return unless 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
+          return unless 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/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
+
+        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/class_and_module_children.rb

@@ -21,9 +21,10 @@ module RuboCop
       #   end
       #
       # The compact style is only forced for classes/modules with one child.
-      class ClassAndModuleChildren < Cop
+      class ClassAndModuleChildren < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         NESTED_MSG = 'Use nested module/class definitions instead of ' \
                      'compact style.'
@@ -40,14 +41,6 @@ module RuboCop
           check_style(node, node.body)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            return if node.class_type? && node.parent_class && style != :nested
-
-            nest_or_compact(corrector, node)
-          end
-        end
-
         private
 
         def nest_or_compact(corrector, node)
@@ -129,13 +122,23 @@ module RuboCop
         def check_nested_style(node)
           return unless compact_node_name?(node)
 
-          add_offense(node, location: :name, message: NESTED_MSG)
+          add_offense(node.loc.name, message: NESTED_MSG) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def check_compact_style(node, body)
           return unless one_child?(body) && !compact_node_name?(node)
 
-          add_offense(node, location: :name, message: COMPACT_MSG)
+          add_offense(node.loc.name, message: COMPACT_MSG) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          return if node.class_type? && node.parent_class && style != :nested
+
+          nest_or_compact(corrector, node)
         end
 
         def one_child?(body)
@@ -143,7 +146,7 @@ module RuboCop
         end
 
         def compact_node_name?(node)
-          node.loc.name.source =~ /::/
+          /::/.match?(node.loc.name.source)
         end
       end
     end

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

@@ -23,8 +23,9 @@ module RuboCop
       #   var.kind_of?(Time)
       #   var.kind_of?(String)
       #
-      class ClassCheck < Cop
+      class ClassCheck < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Prefer `Object#%<prefer>s` over `Object#%<current>s`.'
 
@@ -34,15 +35,12 @@ module RuboCop
           class_check?(node) do |method_name|
             return if style == method_name
 
-            add_offense(node, location: :selector)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
+            message = message(node)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
 
-            corrector.replace(node.loc.selector, replacement)
+              corrector.replace(node.loc.selector, replacement)
+            end
           end
         end
 

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

@@ -20,7 +20,9 @@ module RuboCop
       #       # ...
       #     end
       #   end
-      class ClassMethods < Cop
+      class ClassMethods < Base
+        extend AutoCorrector
+
         MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'
 
         def on_class(node)
@@ -36,23 +38,17 @@ module RuboCop
         end
         alias on_module on_class
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.name, 'self') }
-        end
-
         private
 
         def check_defs(name, node)
           # check if the class/module name matches the definee for the defs node
           return unless name == node.receiver
 
-          add_offense(node.receiver, location: :name)
-        end
-
-        def message(node)
-          _, class_name = *node
+          message = format(MSG, method: node.method_name, class: name.source)
 
-          format(MSG, method: node.parent.method_name, class: class_name)
+          add_offense(node.receiver.loc.name, message: message) do |corrector|
+            corrector.replace(node.receiver, 'self')
+          end
         end
       end
     end