rubocop 0.87.1

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of `begin...end while/until something`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # using while
+      #   begin
+      #     do_something
+      #   end while some_condition
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # using until
+      #   begin
+      #     do_something
+      #   end until some_condition
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # while replacement
+      #   loop do
+      #     do_something
+      #     break unless some_condition
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # until replacement
+      #   loop do
+      #     do_something
+      #     break if some_condition
+      #   end
+      class Loop < Cop
+        MSG = 'Use `Kernel#loop` with `break` rather than ' \
+              '`begin/end/until`(or `while`).'
+
+        def on_while_post(node)
+          register_offense(node)
+        end
+
+        def on_until_post(node)
+          register_offense(node)
+        end
+
+        private
+
+        def register_offense(node)
+          add_offense(node, location: :keyword)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there is an `# rubocop:enable ...` statement
+      # after a `# rubocop:disable ...` statement. This will prevent leaving
+      # cop disables on wide ranges of code, that latter contributors to
+      # a file wouldn't be aware of.
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: .inf
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #   # y = 1
+      #   # EOF
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # EOF
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: 2
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # With the previous, there are 2 lines on which cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   x += 1
+      #   # Including this, that's 3 lines on which the cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      class MissingCopEnableDirective < Cop
+        include RangeHelp
+
+        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after ' \
+              'disabling it.'
+        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after ' \
+                    'disabling it.'
+
+        def investigate(processed_source)
+          max_range = cop_config['MaximumRangeSize']
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each do |line_range|
+              # This has to remain a strict inequality to handle
+              # the case when max_range is Float::INFINITY
+              next if line_range.max - line_range.min < max_range + 2
+
+              range = source_range(processed_source.buffer,
+                                   line_range.min,
+                                   (0..0))
+              add_offense(range,
+                          location: range,
+                          message: message(max_range: max_range, cop: cop))
+            end
+          end
+        end
+
+        private
+
+        def message(max_range:, cop:)
+          if max_range == Float::INFINITY
+            format(MSG, cop: cop)
+          else
+            format(MSG_BOUND, cop: cop, max_range: max_range)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/RedundantCopDisableDirective, Layout/SpaceAroundOperators

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not mix named captures and numbered captures in a Regexp literal
+      # because numbered capture is ignored if they're mixed.
+      # Replace numbered captures with non-capturing groupings or
+      # named captures.
+      #
+      #   # bad
+      #   /(?<foo>FOO)(BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?<bar>BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?:BAR)/
+      #
+      #   # good
+      #   /(FOO)(BAR)/
+      #
+      class MixedRegexpCaptureTypes < Cop
+        MSG = 'Do not mix named captures and numbered captures ' \
+              'in a Regexp literal.'
+
+        def on_regexp(node)
+          return if contain_non_literal?(node)
+
+          begin
+            tree = Regexp::Parser.parse(node.content)
+          # Returns if a regular expression that cannot be processed by regexp_parser gem.
+          # https://github.com/rubocop-hq/rubocop/issues/8083
+          rescue Regexp::Scanner::ScannerError
+            return
+          end
+
+          return unless named_capture?(tree)
+          return unless numbered_capture?(tree)
+
+          add_offense(node)
+        end
+
+        private
+
+        def contain_non_literal?(node)
+          if node.respond_to?(:type) && (node.variable? || node.send_type? || node.const_type?)
+            return true
+          end
+          return false unless node.respond_to?(:children)
+
+          node.children.any? { |child| contain_non_literal?(child) }
+        end
+
+        def named_capture?(tree)
+          tree.each_expression.any? do |e|
+            e.instance_of?(Regexp::Expression::Group::Capture)
+          end
+        end
+
+        def numbered_capture?(tree)
+          tree.each_expression.any? do |e|
+            e.instance_of?(Regexp::Expression::Group::Named)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # In math and Python, we can use `x < y < z` style comparison to compare
+      # multiple value. However, we can't use the comparison in Ruby. However,
+      # the comparison is not syntax error. This cop checks the bad usage of
+      # comparison operators.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   x < y < z
+      #   10 <= x <= 20
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   x < y && y < z
+      #   10 <= x && x <= 20
+      class MultipleComparison < Cop
+        MSG = 'Use the `&&` operator to compare multiple values.'
+
+        def_node_matcher :multiple_compare?, <<~PATTERN
+          (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
+        PATTERN
+
+        def on_send(node)
+          return unless multiple_compare?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          center = multiple_compare?(node)
+          new_center = "#{center.source} && #{center.source}"
+
+          lambda do |corrector|
+            corrector.replace(center, new_center)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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.
+      #   def foo
+      #     def bar
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     bar = -> { puts 'hello' }
+      #     bar.call
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     self.class.class_eval do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      #   def foo
+      #     self.class.module_exec do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     class << self
+      #       def bar
+      #       end
+      #     end
+      #   end
+      class NestedMethodDefinition < Cop
+        MSG = 'Method definitions must not be nested. ' \
+              'Use `lambda` instead.'
+
+        def on_def(node)
+          find_nested_defs(node) do |nested_def_node|
+            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|
+            if child.def_type?
+              yield child
+            elsif child.defs_type?
+              subject, = *child
+              next if subject.lvar_type?
+
+              yield child
+            elsif !scoping_method_call?(child)
+              find_nested_defs(child, &block)
+            end
+          end
+        end
+
+        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? cbase} {:Class :Module :Struct}) :new ...) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# 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.'
+
+        # The array of regular expressions representing percent literals that,
+        # if found within a percent literal expression, will cause a
+        # NestedPercentLiteral violation to be emitted.
+        PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
+        REGEXES = PERCENT_LITERAL_TYPES.map do |percent_literal|
+          /\A#{percent_literal}\W/
+        end.freeze
+
+        def on_array(node)
+          process(node, *PERCENT_LITERAL_TYPES)
+        end
+
+        def on_percent_literal(node)
+          add_offense(node) if contains_percent_literals?(node)
+        end
+
+        private
+
+        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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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
+      #   end
+      class NextWithoutAccumulator < Cop
+        MSG = 'Use `next` with an accumulator argument in a `reduce`.'
+
+        def_node_matcher :on_body_of_reduce, <<~PATTERN
+          (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
+        PATTERN
+
+        def on_block(node)
+          on_body_of_reduce(node) do |body|
+            void_next = body.each_node(:next).find do |n|
+              n.children.empty? && parent_block_node(n) == node
+            end
+
+            add_offense(void_next) if void_next
+          end
+        end
+
+        private
+
+        def parent_block_node(node)
+          node.each_ancestor(:block).first
+        end
+      end
+    end
+  end
+end