rubocop 0.86.0 → 0.87.1

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

@@ -18,7 +18,7 @@ module RuboCop
               'name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
-        BLACKLISTED = %i[+@ -@ [] []= << === `].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === `].freeze
 
         def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
@@ -33,7 +33,7 @@ module RuboCop
         private
 
         def op_method?(name)
-          return false if BLACKLISTED.include?(name)
+          return false if EXCLUDED.include?(name)
 
           !/\A\w/.match?(name) || OP_LIKE_METHODS.include?(name)
         end

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

@@ -28,7 +28,7 @@ module RuboCop
       #
       #   # good
       #   def fooBar; end
-      class MethodName < Cop
+      class MethodName < Base
         include ConfigurableNaming
         include IgnoredPattern
         include RangeHelp

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

@@ -49,7 +49,7 @@ module RuboCop
         def on_def(node)
           return unless node.arguments?
 
-          check(node, node.arguments.reject(&:forward_args_type?))
+          check(node, node.arguments)
         end
         alias on_defs on_def
       end

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

@@ -28,6 +28,8 @@ module RuboCop
       #   def value?
       #   end
       class PredicateName < Cop
+        include AllowedMethods
+
         def_node_matcher :dynamic_method_define, <<~PATTERN
           (send nil? #method_definition_macros
             (sym $_)
@@ -70,7 +72,7 @@ module RuboCop
           !method_name.match?(/^#{prefix}[^0-9]/) ||
             method_name == expected_name(method_name, prefix) ||
             method_name.end_with?('=') ||
-            allowed_methods.include?(method_name)
+            allowed_method?(method_name)
         end
 
         def expected_name(method_name, prefix)
@@ -95,10 +97,6 @@ module RuboCop
           cop_config['NamePrefix']
         end
 
-        def allowed_methods
-          cop_config['AllowedMethods']
-        end
-
         def method_definition_macros(macro_name)
           cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
         end

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,140 @@
+# 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
+        include VisibilityHelp
+
+        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_sclass on_class
+        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|
+            accessor?(sibling) &&
+              sibling.method?(send_node.method_name) &&
+              node_visibility(sibling) == node_visibility(send_node)
+          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,145 @@
+# 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)
+
+            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 = Set.new
+          writer_names = Set.new
+
+          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)
+              else
+                writer_names.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/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