rubocop 0.49.1 → 0.52.0

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

@@ -31,7 +31,7 @@ module RuboCop
         def on_send(node)
           return unless multiple_compare?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -55,17 +55,17 @@ module RuboCop
       #     end
       #   end
       class NestedMethodDefinition < Cop
-        include OnMethodDef
-        extend RuboCop::NodePattern::Macros
-
         MSG = 'Method definitions must not be nested. ' \
               'Use `lambda` instead.'.freeze
 
-        def on_method_def(node, _method_name, _args, _body)
+        def on_def(node)
           find_nested_defs(node) do |nested_def_node|
-            add_offense(nested_def_node, :expression)
+            add_offense(nested_def_node)
           end
         end
+        alias on_defs on_def
+
+        private
 
         def find_nested_defs(node, &block)
           node.each_child_node do |child|
@@ -81,8 +81,6 @@ module RuboCop
           end
         end
 
-        private
-
         def scoping_method_call?(child)
           eval_call?(child) || exec_call?(child) || child.sclass_type? ||
             class_or_module_or_struct_new_call?(child)
@@ -97,7 +95,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
-          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
+          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
       end
     end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for nested percent literals.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # The percent literal for nested_attributes is parsed as four tokens,
+      #   # yielding the array [:name, :content, :"%i[incorrectly", :"nested]"].
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: %i[name content %i[incorrectly nested]]
+      #   }
+      class NestedPercentLiteral < Cop
+        include PercentLiteral
+
+        MSG = 'Within percent literals, nested percent literals do not ' \
+          'function and may be unwanted in the result.'.freeze
+
+        # The array of regular expressions representing percent literals that,
+        # if found within a percent literal expression, will cause a
+        # NestedPercentLiteral violation to be emitted.
+        REGEXES = PercentLiteral::PERCENT_LITERAL_TYPES.map do |percent_literal|
+          /#{percent_literal}\W/
+        end.freeze
+
+        def on_array(node)
+          process(node, *PercentLiteral::PERCENT_LITERAL_TYPES)
+        end
+
+        def on_percent_literal(node)
+          add_offense(node) if contains_percent_literals?(node)
+        end
+
+        private
+
+        def str_content(node)
+          if node.str_type?
+            node.children[0]
+          else
+            node.children.map { |c| str_content(c) }.join
+          end
+        end
+
+        def contains_percent_literals?(node)
+          node.each_child_node.any? do |child|
+            literal = child.children.first.to_s.scrub
+            REGEXES.any? { |regex| literal.match(regex) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -35,7 +35,7 @@ module RuboCop
               n.children.empty? && parent_block_node(n) == node
             end
 
-            add_offense(void_next, :expression) if void_next
+            add_offense(void_next) if void_next
           end
         end
 

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

@@ -18,13 +18,13 @@ module RuboCop
       #
       #   class ItemApi
       #     rescue_from ValidationError do |e| # non-iteration block with arg
-      #       return message: 'validation error' unless e.errors # allowed
+      #       return { message: 'validation error' } unless e.errors # allowed
       #       error_array = e.errors.map do |error| # block with method chain
       #         return if error.suppress? # warned
       #         return "#{error.param}: invalid" unless error.message # allowed
       #         "#{error.param}: #{error.message}"
       #       end
-      #       message: 'validation error', errors: error_array
+      #       { message: 'validation error', errors: error_array }
       #     end
       #
       #     def update_items
@@ -59,7 +59,7 @@ module RuboCop
             next if args_node.children.empty?
 
             if chained_send?(send_node)
-              add_offense(return_node, :keyword)
+              add_offense(return_node, location: :keyword)
               break
             end
           end
@@ -75,7 +75,7 @@ module RuboCop
           !return_node.children.empty?
         end
 
-        def_node_matcher :chained_send?, '(send !nil ...)'
+        def_node_matcher :chained_send?, '(send !nil? ...)'
         def_node_matcher :define_method?, <<-PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for space between a the name of a called method and a left
+      # Checks for space between the name of a called method and a left
       # parenthesis.
       #
       # @example
@@ -29,8 +29,9 @@ module RuboCop
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length > 0
 
-          add_offense(nil, space_range(node.first_argument.source_range,
-                                       space_length))
+          range = space_range(node.first_argument.source_range, space_length)
+
+          add_offense(nil, location: range)
         end
 
         private

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

@@ -37,22 +37,10 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_quotes_or_commas?(node)
 
-          add_offense(node, :expression, MSG)
-        end
-
-        private
-
-        def contains_quotes_or_commas?(node)
-          node.values.any? do |value|
-            literal = scrub_string(value.children.first.to_s)
-
-            # To avoid likely false positives (e.g. a single ' or ")
-            next if literal.gsub(/[^\p{Alnum}]/, '').empty?
-
-            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
-          end
+          add_offense(node)
         end
 
+        # rubocop:disable Performance/HashEachMethods
         def autocorrect(node)
           lambda do |corrector|
             node.values.each do |value|
@@ -67,15 +55,18 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Performance/HashEachMethods
+
+        private
+
+        def contains_quotes_or_commas?(node)
+          node.values.any? do |value|
+            literal = value.children.first.to_s.scrub
 
-        def scrub_string(string)
-          if string.respond_to?(:scrub)
-            string.scrub
-          else
-            string
-              .encode('UTF-16BE', 'UTF-8',
-                      invalid: :replace, undef: :replace, replace: '?')
-              .encode('UTF-8')
+            # To avoid likely false positives (e.g. a single ' or ")
+            next if literal.gsub(/[^\p{Alnum}]/, '').empty?
+
+            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
           end
         end
       end

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

@@ -33,7 +33,18 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_colons_or_commas?(node)
 
-          add_offense(node, :expression, MSG)
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node.children.each do |child|
+              range = child.loc.expression
+
+              corrector.remove_trailing(range, 1) if /,$/ =~ range.source
+              corrector.remove_leading(range, 1) if /^:/ =~ range.source
+            end
+          end
         end
 
         private
@@ -49,17 +60,6 @@ module RuboCop
             patterns.any? { |pat| literal =~ pat }
           end
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            node.children.each do |child|
-              range = child.loc.expression
-
-              corrector.remove_trailing(range, 1) if /,$/ =~ range.source
-              corrector.remove_leading(range, 1) if /^:/ =~ range.source
-            end
-          end
-        end
       end
     end
   end

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

@@ -25,13 +25,19 @@ module RuboCop
               'Perhaps you meant `rand(2)` or `rand`?'.freeze
 
         def_node_matcher :rand_one?, <<-PATTERN
-          (send {(const nil :Kernel) nil} :rand {(int {-1 1}) (float {-1.0 1.0})})
+          (send {(const nil? :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 
         def on_send(node)
           return unless rand_one?(node)
 
-          add_offense(node, :expression, format(MSG, node.source))
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, node.source)
         end
       end
     end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant `with_index`.
+      #
+      # @example
+      #   # bad
+      #   ary.each_with_index do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      #   # bad
+      #   ary.each.with_index do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      class RedundantWithIndex < Cop
+        MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'.freeze
+        MSG_WITH_INDEX = 'Remove redundant `with_index`.'.freeze
+
+        def_node_matcher :redundant_with_index?, <<-PATTERN
+          (block
+            $(send
+              _ {:each_with_index :with_index} ...)
+            (args
+              (arg _))
+            ...)
+        PATTERN
+
+        def on_block(node)
+          redundant_with_index?(node) do |send|
+            add_offense(node, location: with_index_range(send))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            redundant_with_index?(node) do |send|
+              if send.method_name == :each_with_index
+                corrector.replace(send.loc.selector, 'each')
+              else
+                corrector.remove(with_index_range(send))
+                corrector.remove(send.loc.dot)
+              end
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          if node.method_name == :each_with_index
+            MSG_EACH_WITH_INDEX
+          else
+            MSG_WITH_INDEX
+          end
+        end
+
+        def with_index_range(send)
+          range_between(
+            send.loc.selector.begin_pos,
+            send.loc.expression.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant `with_object`.
+      #
+      # @example
+      #   # bad
+      #   ary.each_with_object([]) do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      #   # bad
+      #   ary.each.with_object([]) do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      class RedundantWithObject < Cop
+        MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
+                               .freeze
+        MSG_WITH_OBJECT = 'Remove redundant `with_object`.'.freeze
+
+        def_node_matcher :redundant_with_object?, <<-PATTERN
+          (block
+            $(send _ {:each_with_object :with_object}
+              (_))
+            (args
+              (arg _))
+            ...)
+        PATTERN
+
+        def on_block(node)
+          redundant_with_object?(node) do |send|
+            add_offense(node, location: with_object_range(send))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            redundant_with_object?(node) do |send|
+              if send.method_name == :each_with_object
+                corrector.replace(with_object_range(send), 'each')
+              else
+                corrector.remove(with_object_range(send))
+                corrector.remove(send.loc.dot)
+              end
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          if node.method_name == :each_with_object
+            MSG_EACH_WITH_OBJECT
+          else
+            MSG_WITH_OBJECT
+          end
+        end
+
+        def with_object_range(send)
+          range_between(
+            send.loc.selector.begin_pos,
+            send.loc.expression.end_pos
+          )
+        end
+      end
+    end
+  end
+end