rubocop 1.8.1 → 1.9.0

data/lib/rubocop/cop/internal_affairs/redundant_described_class_as_subject.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # This cop checks for redundant `subject(:cop) { described_class.new }`.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe RuboCop::Cop::Department::Foo do
+      #     subject(:cop) { described_class.new(config) }
+      #   end
+      #
+      #   # good
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #   end
+      #
+      class RedundantDescribedClassAsSubject < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `subject`%<additional_message>s.'
+
+        def_node_matcher :described_class_subject?, <<~PATTERN
+          (block
+            (send nil? :subject
+              (sym :cop))
+            (args)
+            (send
+              (send nil? :described_class) :new
+              $...))
+        PATTERN
+
+        def on_block(node)
+          return unless (described_class_arguments = described_class_subject?(node))
+          return if described_class_arguments.count >= 2
+
+          describe = find_describe_method_node(node)
+
+          unless (exist_config = describe.last_argument.source == ':config')
+            additional_message = ' and specify `:config` in `describe`'
+          end
+
+          message = format(MSG, additional_message: additional_message)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+
+            corrector.insert_after(describe.last_argument, ', :config') unless exist_config
+          end
+        end
+
+        private
+
+        def find_describe_method_node(block_node)
+          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_let_rubocop_config_new.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # This cop checks that `let` is `RuboCop::Config.new` with no arguments.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #     let(:config) { RuboCop::Config.new }
+      #   end
+      #
+      #   # good
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #   end
+      #
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #     let(:config) { RuboCop::Config.new(argument) }
+      #   end
+      #
+      class RedundantLetRuboCopConfigNew < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove `let` that is `RuboCop::Config.new` with no arguments%<additional_message>s.'
+
+        def_node_matcher :let_rubocop_config_new?, <<~PATTERN
+          (block
+            (send nil? :let
+              (sym :config))
+            (args)
+            (send
+              (const
+                (const nil? :RuboCop) :Config) :new))
+        PATTERN
+
+        def on_block(node)
+          return unless let_rubocop_config_new?(node)
+
+          describe = find_describe_method_node(node)
+
+          unless (exist_config = describe.last_argument.source == ':config')
+            additional_message = ' and specify `:config` in `describe`'
+          end
+
+          message = format(MSG, additional_message: additional_message)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+
+            corrector.insert_after(describe.last_argument, ', :config') unless exist_config
+          end
+        end
+
+        private
+
+        def find_describe_method_node(block_node)
+          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/class_structure.rb

@@ -213,7 +213,12 @@ module RuboCop
           name = node.method_name.to_s
           category, = categories.find { |_, names| names.include?(name) }
           key = category || name
-          visibility_key = "#{node_visibility(node)}_#{key}"
+          visibility_key =
+            if node.def_modifier?
+              "#{name}_methods"
+            else
+              "#{node_visibility(node)}_#{key}"
+            end
           expected_order.include?(visibility_key) ? visibility_key : key
         end
 
@@ -264,7 +269,7 @@ module RuboCop
 
         def source_range_with_comment(node)
           begin_pos, end_pos =
-            if node.def_type?
+            if node.def_type? && !node.method?(:initialize) || node.send_type? && node.def_modifier?
               start_node = find_visibility_start(node) || node
               end_node = find_visibility_end(node) || node
               [begin_pos_with_comment(start_node),

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -25,12 +25,18 @@ module RuboCop
       #   '10'.to_i
       #   '10.2'.to_f
       #   '10'.to_c
+      #   ['1', '2', '3'].map(&:to_i)
+      #   foo.try(:to_f)
+      #   bar.send(:to_c)
       #
       #   # good
       #
       #   Integer('10', 10)
       #   Float('10.2')
       #   Complex('10')
+      #   ['1', '2', '3'].map { |i| Integer(i, 10) }
+      #   foo.try { |i| Float(i) }
+      #   bar.send { |i| Complex(i) }
       #
       # @example IgnoredMethods: [minutes]
       #
@@ -52,22 +58,33 @@ module RuboCop
         }.freeze
         MSG = 'Replace unsafe number conversion with number '\
               'class parsing, instead of using '\
-              '%<number_object>s.%<to_method>s, use stricter '\
+              '%<current>s, use stricter '\
               '%<corrected_method>s.'
-        RESTRICT_ON_SEND = CONVERSION_METHOD_CLASS_MAPPING.keys.freeze
+        METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
 
         def_node_matcher :to_method, <<~PATTERN
-          (send $_ ${:to_i :to_f :to_c})
+          (send $_ ${#{METHODS}})
+        PATTERN
+
+        def_node_matcher :to_method_symbol, <<~PATTERN
+          {(send _ $_ ${(sym ${#{METHODS}})} ...)
+           (send _ $_ ${(block_pass (sym ${#{METHODS}}))} ...)}
         PATTERN
 
         def on_send(node)
+          handle_conversion_method(node)
+          handle_as_symbol(node)
+        end
+
+        private
+
+        def handle_conversion_method(node)
           to_method(node) do |receiver, to_method|
             next if receiver.nil? || ignore_receiver?(receiver)
 
             message = format(
               MSG,
-              number_object: receiver.source,
-              to_method: to_method,
+              current: "#{receiver.source}.#{to_method}",
               corrected_method: correct_method(node, receiver)
             )
             add_offense(node, message: message) do |corrector|
@@ -76,13 +93,31 @@ module RuboCop
           end
         end
 
-        private
+        def handle_as_symbol(node)
+          to_method_symbol(node) do |receiver, sym_node, to_method|
+            next if receiver.nil?
+
+            message = format(
+              MSG,
+              current: sym_node.source,
+              corrected_method: correct_sym_method(to_method)
+            )
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(sym_node, correct_sym_method(to_method))
+            end
+          end
+        end
 
         def correct_method(node, receiver)
           format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
                  number_object: receiver.source)
         end
 
+        def correct_sym_method(to_method)
+          body = format(CONVERSION_METHOD_CLASS_MAPPING[to_method], number_object: 'i')
+          "{ |i| #{body} }"
+        end
+
         def ignore_receiver?(receiver)
           if receiver.send_type? && ignored_method?(receiver.method_name)
             true

data/lib/rubocop/cop/lint/numbered_parameter_assignment.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of numbered parameter assignment.
+      # It emulates the following warning in Ruby 2.7:
+      #
+      #   % ruby -ve '_1 = :value'
+      #   ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
+      #   -e:1: warning: `_1' is reserved for numbered parameter; consider another name
+      #
+      # Assiging to numbered parameter (from `_1` to `_9`) cause an error in Ruby 3.0.
+      #
+      #   % ruby -ve '_1 = :value'
+      #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+      #   -e:1: _1 is reserved for numbered parameter
+      #
+      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # as well to prevent confusion.
+      #
+      # @example
+      #
+      #   # bad
+      #   _1 = :value
+      #
+      #   # good
+      #   non_numbered_parameter_name = :value
+      #
+      class NumberedParameterAssignment < Base
+        NUM_PARAM_MSG = '`_%<number>s` is reserved for numbered parameter; consider another name.'
+        LVAR_MSG = '`_%<number>s` is similar to numbered parameter; consider another name.'
+        NUMBERED_PARAMETER_RANGE = (1..9).freeze
+
+        def on_lvasgn(node)
+          lhs, _rhs = *node
+          return unless /\A_(\d+)\z/ =~ lhs
+
+          number = Regexp.last_match(1).to_i
+          template = NUMBERED_PARAMETER_RANGE.include?(number) ? NUM_PARAM_MSG : LVAR_MSG
+
+          add_offense(node, message: format(template, number: number))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/or_assignment_to_constant.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unintended or-assignment to a constant.
+      #
+      # Constants should always be assigned in the same location. And its value
+      # should always be the same. If constants are assigned in multiple
+      # locations, the result may vary depending on the order of `require`.
+      #
+      # Also, if you already have such an implementation, auto-correction may
+      # change the result.
+      #
+      # @example
+      #
+      #   # bad
+      #   CONST ||= 1
+      #
+      #   # good
+      #   CONST = 1
+      #
+      class OrAssignmentToConstant < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid using or-assignment with constants.'
+
+        def on_or_asgn(node)
+          lhs, _rhs = *node
+          return unless lhs&.casgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/symbol_conversion.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of literal strings converted to
+      # a symbol where a literal symbol could be used instead.
+      #
+      # @example
+      #   # bad
+      #   'string'.to_sym
+      #   :symbol.to_sym
+      #   'underscored_string'.to_sym
+      #   :'underscored_symbol'
+      #   'hyphenated-string'.to_sym
+      #
+      #   # good
+      #   :string
+      #   :symbol
+      #   :underscored_string
+      #   :underscored_symbol
+      #   :'hyphenated-string'
+      #
+      class SymbolConversion < Base
+        extend AutoCorrector
+
+        MSG = 'Unnecessary symbol conversion; use `%<correction>s` instead.'
+        RESTRICT_ON_SEND = %i[to_sym intern].freeze
+
+        def on_send(node)
+          return unless node.receiver.str_type? || node.receiver.sym_type?
+
+          register_offense(node, correction: node.receiver.value.to_sym.inspect)
+        end
+
+        def on_sym(node)
+          return if properly_quoted?(node.source, node.value.inspect)
+
+          # `alias` arguments are symbols but since a symbol that requires
+          # being quoted is not a valid method identifier, it can be ignored
+          return if in_alias?(node)
+
+          # The `%I[]` and `%i[]` macros are parsed as normal arrays of symbols
+          # so they need to be ignored.
+          return if in_percent_literal_array?(node)
+
+          # Symbol hash keys have a different format and need to be handled separately
+          return correct_hash_key(node) if hash_key?(node)
+
+          register_offense(node, correction: node.value.inspect)
+        end
+
+        private
+
+        def register_offense(node, correction:, message: format(MSG, correction: correction))
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, correction)
+          end
+        end
+
+        def properly_quoted?(source, value)
+          return true unless source.match?(/['"]/)
+
+          source == value ||
+            # `Symbol#inspect` uses double quotes, but allow single-quoted
+            # symbols to work as well.
+            source.tr("'", '"') == value
+        end
+
+        def in_alias?(node)
+          node.parent&.alias_type?
+        end
+
+        def in_percent_literal_array?(node)
+          node.parent&.array_type? && node.parent&.percent_literal?
+        end
+
+        def hash_key?(node)
+          node.parent&.pair_type? && node == node.parent.child_nodes.first
+        end
+
+        def correct_hash_key(node)
+          # Although some operators can be converted to symbols normally
+          # (ie. `:==`), these are not accepted as hash keys and will
+          # raise a syntax error (eg. `{ ==: ... }`). Therefore, if the
+          # symbol does not start with an alpha-numeric or underscore, it
+          # will be ignored.
+          return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
+
+          correction = node.value.inspect.delete(':')
+          return if properly_quoted?(node.source, correction)
+
+          register_offense(
+            node,
+            correction: correction,
+            message: format(MSG, correction: "#{correction}:")
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/triple_quotes.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for "triple quotes" (strings delimted by any odd number
+      # of quotes greater than 1).
+      #
+      # Ruby allows multiple strings to be implicitly concatenated by just
+      # being adjacent in a statement (ie. `"foo""bar" == "foobar"`). This sometimes
+      # gives the impression that there is something special about triple quotes, but
+      # in fact it is just extra unnecessary quotes and produces the same string. Each
+      # pair of quotes produces an additional concatenated empty string, so the result
+      # is still only the "actual" string within the delimiters.
+      #
+      # NOTE: Although this cop is called triple quotes, the same behavior is present
+      # for strings delimited by 5, 7, etc. quotation marks.
+      #
+      # @example
+      #   # bad
+      #   """
+      #     A string
+      #   """
+      #
+      #   # bad
+      #   '''
+      #     A string
+      #   '''
+      #
+      #   # good
+      #   "
+      #     A string
+      #   "
+      #
+      #   # good
+      #   <<STRING
+      #     A string
+      #   STRING
+      #
+      #   # good (but not the same spacing as the bad case)
+      #   'A string'
+      class TripleQuotes < Base
+        extend AutoCorrector
+
+        MSG = 'Delimiting a string with multiple quotes has no effect, use a single quote instead.'
+
+        def on_dstr(node)
+          return if (empty_str_nodes = empty_str_nodes(node)).none?
+
+          opening_quotes = node.source.scan(/(?<=\A)['"]*/)[0]
+          return if opening_quotes.size < 3
+
+          # If the node is composed of only empty `str` nodes, keep one
+          empty_str_nodes.shift if empty_str_nodes.size == node.child_nodes.size
+
+          add_offense(node) do |corrector|
+            empty_str_nodes.each do |str|
+              corrector.remove(str)
+            end
+          end
+        end
+
+        private
+
+        def empty_str_nodes(node)
+          node.each_child_node(:str).select { |str| str.value == '' }
+        end
+      end
+    end
+  end
+end