rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,6 +6,9 @@ module RuboCop
       # This cop checks for nested method definitions.
       #
       # @example
+      #
+      #   # bad
+      #
       #   # `bar` definition actually produces methods in the same scope
       #   # as the outer `foo` method. Furthermore, the `bar` method
       #   # will be redefined every time `foo` is invoked.
@@ -15,18 +17,55 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     bar = -> { puts 'hello' }
+      #     bar.call
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     self.class_eval do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      #   def foo
+      #     self.module_exec do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     class << self
+      #       def bar
+      #       end
+      #     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|
@@ -36,24 +75,27 @@ module RuboCop
               subject, = *child
               next if subject.lvar_type?
               yield child
-            elsif !ignored_child?(child)
+            elsif !scoping_method_call?(child)
               find_nested_defs(child, &block)
             end
           end
         end
 
-        private
-
-        def ignored_child?(child)
-          eval_call?(child) || class_or_module_or_struct_new_call?(child)
+        def scoping_method_call?(child)
+          eval_call?(child) || exec_call?(child) || child.sclass_type? ||
+            class_or_module_or_struct_new_call?(child)
         end
 
         def_node_matcher :eval_call?, <<-PATTERN
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
+        def_node_matcher :exec_call?, <<-PATTERN
+          (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+        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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,13 +6,18 @@ module RuboCop
       # Don't omit the accumulator when calling `next` in a `reduce` block.
       #
       # @example
+      #
       #   # bad
+      #
       #   result = (1..4).reduce(0) do |acc, i|
       #     next if i.odd?
       #     acc + i
       #   end
       #
+      # @example
+      #
       #   # good
+      #
       #   result = (1..4).reduce(0) do |acc, i|
       #     next acc if i.odd?
       #     acc + i
@@ -31,14 +35,14 @@ 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
 
         private
 
         def parent_block_node(node)
-          node.each_ancestor.find { |n| n.type == :block }
+          node.each_ancestor(:block).first
         end
       end
     end

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

@@ -1,25 +1,30 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for non-local exit from iterator, without return value.
-      # It warns only when satisfies all of these: `return` doesn't have return
-      # value, the block is preceded by a method chain, the block has arguments,
-      # and the method which receives the block is not `define_method`.
+      # This cop checks for non-local exits from iterators without a return
+      # value. It registers an offense under these conditions:
+      #
+      #  - No value is returned,
+      #  - the block is preceded by a method chain,
+      #  - the block has arguments,
+      #  - the method which receives the block is not `define_method`
+      #    or `define_singleton_method`,
+      #  - the return is not contained in an inner scope, e.g. a lambda or a
+      #    method definition.
       #
       # @example
       #
       #   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
@@ -40,36 +45,40 @@ module RuboCop
 
         def on_return(return_node)
           return if return_value?(return_node)
-          return_node.each_ancestor(:block) do |block_node|
-            send_node, args_node, _body_node = *block_node
 
-            # `return` does not exit to outside of lambda block, this is safe.
-            break if block_node.lambda?
-            # if a proc is passed to `Module#define_method`, `return` will not
-            # cause a non-local exit error
+          return_node.each_ancestor(:block, :def, :defs) do |node|
+            break if scoped_node?(node)
+
+            send_node, args_node, _body_node = *node
+
+            # if a proc is passed to `Module#define_method` or
+            # `Object#define_singleton_method`, `return` will not cause a
+            # non-local exit error
             break if define_method?(send_node)
 
             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
         end
 
-        def return_value?(return_node)
-          !return_node.children.empty?
-        end
+        private
 
-        def chained_send?(send_node)
-          receiver_node, _selector_node = *send_node
-          !receiver_node.nil?
+        def scoped_node?(node)
+          node.def_type? || node.defs_type? || node.lambda?
         end
 
-        def define_method?(send_node)
-          _receiver, selector = *send_node
-          selector == :define_method
+        def return_value?(return_node)
+          !return_node.children.empty?
         end
+
+        def_node_matcher :chained_send?, '(send !nil? ...)'
+        def_node_matcher :define_method?, <<-PATTERN
+          (send _ {:define_method :define_singleton_method} _)
+        PATTERN
       end
     end
   end

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

@@ -1,39 +1,43 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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
       #
+      #   # bad
+      #
       #   puts (x + y)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   puts(x + y)
       class ParenthesesAsGroupedExpression < Cop
         MSG = '`(...)` interpreted as grouped expression.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return if args.size > 1
-          return if operator?(method_name) || node.asgn_method_call?
-          return unless args.first && args.first.source.start_with?('(')
+          return unless node.arguments.one?
+          return if node.operator_method? || node.setter_method?
+
+          return unless node.first_argument.source.start_with?('(')
 
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length > 0
-          expr = args.first.source_range
-          space_range =
-            Parser::Source::Range.new(expr.source_buffer,
-                                      expr.begin_pos - space_length,
-                                      expr.begin_pos)
 
-          add_offense(nil, space_range)
+          range = space_range(node.first_argument.source_range, space_length)
+
+          add_offense(nil, location: range)
         end
 
         private
 
         def spaces_before_left_parenthesis(node)
-          receiver, method_name, _args = *node
+          receiver = node.receiver
           receiver_length = if receiver
                               receiver.source.length
                             else
@@ -42,11 +46,15 @@ module RuboCop
           without_receiver = node.source[receiver_length..-1]
 
           # Escape question mark if any.
-          method_regexp = Regexp.escape(method_name)
+          method_regexp = Regexp.escape(node.method_name)
 
           match = without_receiver.match(/^\s*\.?\s*#{method_regexp}(\s+)\(/)
           match ? match.captures[0].length : 0
         end
+
+        def space_range(expr, space_length)
+          range_between(expr.begin_pos - space_length, expr.begin_pos)
+        end
       end
     end
   end

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

@@ -1,59 +1,74 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for quotes and commas in %w, e.g.
+      # This cop checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
       #
-      #   `%w('foo', "bar")`
-      #
-      # it is more likely that the additional characters are unintended (for
+      # It is more likely that the additional characters are unintended (for
       # example, mistranslating an array of literals to percent string notation)
       # rather than meant to be part of the resulting strings.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   %w('foo', "bar")
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   %w(foo bar)
       class PercentStringArray < Cop
         include PercentLiteral
 
+        QUOTES_AND_COMMAS = [/,$/, /^'.*'$/, /^".*"$/].freeze
+        LEADING_QUOTE = /^['"]/
+        TRAILING_QUOTE = /['"]?,?$/
+
         MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
           'unwanted in the resulting strings.'.freeze
 
         def on_array(node)
-          process(node, *%w(%w %W))
+          process(node, '%w', '%W')
         end
 
         def on_percent_literal(node)
-          if contains_quotes_or_commas?(node)
-            add_offense(node, :expression, MSG)
-          end
-        end
-
-        private
-
-        def contains_quotes_or_commas?(node)
-          patterns = [/,$/, /^'.*'$/, /^".*"$/]
+          return unless contains_quotes_or_commas?(node)
 
-          node.children.any? do |child|
-            literal = child.children.first
-
-            # To avoid likely false positives (e.g. a single ' or ")
-            next if literal.to_s.gsub(/[^\p{Alnum}]/, '').empty?
-
-            patterns.any? { |pat| literal =~ pat }
-          end
+          add_offense(node)
         end
 
+        # rubocop:disable Performance/HashEachMethods
         def autocorrect(node)
           lambda do |corrector|
-            node.children.each do |child|
-              range = child.loc.expression
+            node.values.each do |value|
+              range = value.loc.expression
 
-              match = /['"]?,?$/.match(range.source)
+              match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match
 
-              corrector.remove_leading(range, 1) if /^['"]/ =~ range.source
+              if range.source =~ LEADING_QUOTE
+                corrector.remove_leading(range, 1)
+              end
             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
+
+            # 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
     end
   end

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

@@ -1,16 +1,25 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for colons and commas in %i, e.g.
+      # This cop checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
       #
-      #   `%i(:foo, :bar)`
-      #
-      # it is more likely that the additional characters are unintended (for
+      # It is more likely that the additional characters are unintended (for
       # example, mistranslating an array of literals to percent string notation)
       # rather than meant to be part of the resulting symbols.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   %i(:foo, :bar)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   %i(foo bar)
       class PercentSymbolArray < Cop
         include PercentLiteral
 
@@ -18,12 +27,23 @@ module RuboCop
           'unwanted in the resulting symbols.'.freeze
 
         def on_array(node)
-          process(node, *%w(%i %I))
+          process(node, '%i', '%I')
         end
 
         def on_percent_literal(node)
-          if contains_colons_or_commas?(node)
-            add_offense(node, :expression, MSG)
+          return unless contains_colons_or_commas?(node)
+
+          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
 
@@ -40,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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,26 +8,36 @@ module RuboCop
       #
       # @example
       #
-      #   @bad
+      #   # bad
+      #
       #   rand 1
       #   Kernel.rand(-1)
       #   rand 1.0
       #   rand(-1.0)
       #
-      #   @good
-      #   0
+      # @example
+      #
+      #   # good
+      #
+      #   0 # just use 0 instead
       class RandOne < Cop
         MSG = '`%s` always returns `0`. ' \
               '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)
-          if rand_one?(node)
-            add_offense(node, :expression, format(MSG, node.source))
-          end
+          return unless rand_one?(node)
+
+          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