rubocop 0.86.0 → 0.87.0

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

@@ -19,7 +19,7 @@ module RuboCop
       #
       #   # good
       #   fooBar = 1
-      class VariableName < Cop
+      class VariableName < Base
         include ConfigurableNaming
 
         MSG = 'Use %<style>s for variable names.'

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

@@ -37,7 +37,7 @@ module RuboCop
       #   variableone = 1
       #
       #   variable_one = 1
-      class VariableNumber < Cop
+      class VariableNumber < Base
         include ConfigurableNumbering
 
         MSG = 'Use %<style>s for variable numbers.'

data/lib/rubocop/cop/offense.rb

@@ -54,14 +54,28 @@ module RuboCop
       # @api private
       attr_reader :status
 
+      # @api public
+      #
+      # @!attribute [r] corrector
+      #
+      # @return [Corrector | nil]
+      #   the autocorrection for this offense, or `nil` when not available
+      attr_reader :corrector
+
+      PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
+                                     :end_pos)
+
+      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
+
       # @api private
-      def initialize(severity, location, message, cop_name,
-                     status = :uncorrected)
+      def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists
+                     status = :uncorrected, corrector = nil)
         @severity = RuboCop::Cop::Severity.new(severity)
         @location = location
         @message = message.freeze
         @cop_name = cop_name.freeze
         @status = status
+        @corrector = corrector
         freeze
       end
 

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for grouping of accessors in `class` and `module` bodies.
+      # By default it enforces accessors to be placed in grouped declarations,
+      # but it can be configured to enforce separating them in multiple declarations.
+      #
+      # @example EnforcedStyle: grouped (default)
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar, :baz
+      #   end
+      #
+      # @example EnforcedStyle: separated
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar, :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_reader :baz
+      #   end
+      #
+      class AccessorGrouping < Cop
+        include ConfigurableEnforcedStyle
+
+        GROUPED_MSG = 'Group together all `%<accessor>s` attributes.'
+        SEPARATED_MSG = 'Use one attribute per `%<accessor>s`.'
+
+        ACCESSOR_METHODS = %i[attr_reader attr_writer attr_accessor attr].freeze
+
+        def on_class(node)
+          class_send_elements(node).each do |macro|
+            next unless accessor?(macro)
+
+            check(macro)
+          end
+        end
+        alias on_module on_class
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, correction(node))
+          end
+        end
+
+        private
+
+        def class_send_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def || class_def.def_type?
+            []
+          elsif class_def.send_type?
+            [class_def]
+          else
+            class_def.each_child_node(:send).to_a
+          end
+        end
+
+        def accessor?(send_node)
+          send_node.macro? && ACCESSOR_METHODS.include?(send_node.method_name)
+        end
+
+        def check(send_node)
+          if grouped_style? && sibling_accessors(send_node).size > 1
+            add_offense(send_node)
+          elsif separated_style? && send_node.arguments.size > 1
+            add_offense(send_node)
+          end
+        end
+
+        def grouped_style?
+          style == :grouped
+        end
+
+        def separated_style?
+          style == :separated
+        end
+
+        def sibling_accessors(send_node)
+          send_node.parent.each_child_node(:send).select do |sibling|
+            sibling.macro? && sibling.method?(send_node.method_name)
+          end
+        end
+
+        def message(send_node)
+          msg = grouped_style? ? GROUPED_MSG : SEPARATED_MSG
+          format(msg, accessor: send_node.method_name)
+        end
+
+        def correction(node)
+          if grouped_style?
+            accessors = sibling_accessors(node)
+            if node == accessors.first
+              group_accessors(node, accessors)
+            else
+              ''
+            end
+          else
+            separate_accessors(node)
+          end
+        end
+
+        def group_accessors(node, accessors)
+          accessor_names = accessors.flat_map do |accessor|
+            accessor.arguments.map(&:source)
+          end
+
+          "#{node.method_name} #{accessor_names.join(', ')}"
+        end
+
+        def separate_accessors(node)
+          node.arguments.map do |arg|
+            if arg == node.arguments.first
+              "#{node.method_name} #{arg.source}"
+            else
+              indent = ' ' * node.loc.column
+              "#{indent}#{node.method_name} #{arg.source}"
+            end
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# 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
+        MSG = 'Combine both accessors into `attr_accessor :%<name>s`.'
+
+        def on_class(class_node)
+          reader_names, writer_names = accessor_names(class_node)
+
+          accessor_macroses(class_node).each do |macro|
+            check(macro, reader_names, writer_names)
+          end
+        end
+        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)
+          reader_names = Set.new
+          writer_names = Set.new
+
+          accessor_macroses(class_node).each do |macro|
+            names = macro.arguments.map(&:value)
+
+            names.each do |name|
+              if attr_reader?(macro)
+                reader_names.add(name)
+              else
+                writer_names.add(name)
+              end
+            end
+          end
+
+          [reader_names, writer_names]
+        end
+
+        def accessor_macroses(class_node)
+          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| node.macro? && (attr_reader?(node) || attr_writer?(node)) }
+        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.value
+
+            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)
+          rest_args = macro.arguments
+          rest_args.delete(node)
+          args = rest_args.map(&:source).join(', ')
+
+          if attr_reader?(macro)
+            if args.empty?
+              "attr_accessor #{node.source}"
+            else
+              "attr_accessor #{node.source}\n#{indent(macro)}#{macro.method_name} #{args}"
+            end
+          elsif args.empty?
+            ''
+          else
+            "#{indent(macro)}#{macro.method_name} #{args}"
+          end
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,15 @@ module RuboCop
       #     @@test = 10
       #   end
       #
+      #   class A
+      #     def self.test(name, value)
+      #       class_variable_set("@@#{name}", value)
+      #     end
+      #   end
+      #
+      #   class A; end
+      #   A.class_variable_set(:@@test, 10)
+      #
       #   # good
       #   class A
       #     @test = 10
@@ -30,6 +39,12 @@ module RuboCop
       #     end
       #   end
       #
+      #   class A
+      #     def self.test(name)
+      #       class_variable_get("@@#{name}") # you can access without offense
+      #     end
+      #   end
+      #
       class ClassVars < Cop
         MSG = 'Replace class var %<class_var>s with a class ' \
               'instance var.'
@@ -38,6 +53,12 @@ module RuboCop
           add_offense(node, location: :name)
         end
 
+        def on_send(node)
+          return unless node.method?(:class_variable_set)
+
+          add_offense(node.first_argument)
+        end
+
         def message(node)
           class_var, = *node
           format(MSG, class_var: class_var)

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

@@ -50,7 +50,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :historic_date?, <<~PATTERN
-          (send _ _ _ (const (const nil? :Date) _))
+          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
         PATTERN
 
         def_node_matcher :to_datetime?, <<~PATTERN

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

@@ -21,8 +21,8 @@ module RuboCop
               "file's directory."
 
         def_node_matcher :dir_replacement?, <<~PATTERN
-          {(send (const nil? :File) :expand_path (send (const nil? :File) :dirname  #file_keyword?))
-           (send (const nil? :File) :dirname     (send (const nil? :File) :realpath #file_keyword?))}
+          {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))
+           (send (const {nil? cbase} :File) :dirname     (send (const {nil? cbase} :File) :realpath #file_keyword?))}
         PATTERN
 
         def on_send(node)

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

@@ -25,13 +25,13 @@ module RuboCop
         STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
                   '`String.new`.'
 
-        def_node_matcher :array_node, '(send (const nil? :Array) :new)'
-        def_node_matcher :hash_node, '(send (const nil? :Hash) :new)'
-        def_node_matcher :str_node, '(send (const nil? :String) :new)'
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
+        def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
         def_node_matcher :array_with_block,
-                         '(block (send (const nil? :Array) :new) args _)'
+                         '(block (send (const {nil? cbase} :Array) :new) args _)'
         def_node_matcher :hash_with_block,
-                         '(block (send (const nil? :Hash) :new) args _)'
+                         '(block (send (const {nil? cbase} :Hash) :new) args _)'
 
         def on_send(node)
           add_offense(node, message: ARR_MSG)  if offense_array_node?(node)

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

@@ -53,7 +53,7 @@ module RuboCop
 
         def_node_matcher :file_expand_path, <<~PATTERN
           (send
-            (const nil? :File) :expand_path
+            (const {nil? cbase} :File) :expand_path
             $_
             $_)
         PATTERN
@@ -69,7 +69,7 @@ module RuboCop
           (send
             (send
               (send
-                (const nil? :Pathname) :new
+                (const {nil? cbase} :Pathname) :new
                 $_) :parent) :expand_path)
         PATTERN
 

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

@@ -33,6 +33,18 @@ module RuboCop
           add_offense(node, location: :keyword,
                             message: format(MSG, keyword: node.keyword))
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            keyword = node.if? ? 'if' : 'unless'
+
+            corrector.replace(node, <<~RUBY.chop)
+              #{keyword} #{node.condition.source}
+              #{node.if_branch.source}
+              end
+            RUBY
+          end
+        end
       end
     end
   end

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

@@ -8,11 +8,20 @@ module RuboCop
       #
       # @example
       #
-      #   Thread.list.find_all do |t|
+      #   # bad
+      #   Thread.list.select do |t|
       #     t.alive?
       #   end.map do |t|
       #     t.object_id
       #   end
+      #
+      #   # good
+      #   alive_threads = Thread.list.select do |t|
+      #     t.alive?
+      #   end
+      #   alive_threads.map do |t|
+      #     t.object_id
+      #   end
       class MultilineBlockChain < Cop
         include RangeHelp