rubocop 0.78.0

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

@@ -0,0 +1,63 @@
+# 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
+      #
+      #   # using while
+      #   while some_condition
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # using until
+      #   until some_condition
+      #     do_something
+      #   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/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.source_range, 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_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
+        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? {: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

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `Dir[...]` and `Dir.glob(...)` do not make any guarantees about
+      # the order in which files are returned. The final order is
+      # determined by the operating system and file system.
+      # This means that using them in cases where the order matters,
+      # such as requiring files, can lead to intermittent failures
+      # that are hard to debug. To ensure this doesn't happen,
+      # always sort the list.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir["./lib/**/*.rb"].each do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir["./lib/**/*.rb"].sort.each do |file|
+      #     require file
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file|
+      #     require file
+      #   end
+      #
+      class NonDeterministicRequireOrder < Cop
+        MSG = 'Sort files before requiring them.'
+
+        def on_block(node)
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          loop_variable(node.arguments) do |var_name|
+            return unless var_is_required?(node.body, var_name)
+
+            add_offense(node.send_node)
+          end
+        end
+
+        def autocorrect(node)
+          if unsorted_dir_block?(node)
+            lambda do |corrector|
+              corrector.replace(node.loc.expression, "#{node.source}.sort.each")
+            end
+          else
+            lambda do |corrector|
+              source = node.receiver.source
+              corrector.replace(node.loc.expression, "#{source}.sort.each")
+            end
+          end
+        end
+
+        private
+
+        def unsorted_dir_loop?(node)
+          unsorted_dir_block?(node) || unsorted_dir_each?(node)
+        end
+
+        def_node_matcher :unsorted_dir_block?, <<~PATTERN
+          (send (const nil? :Dir) :glob ...)
+        PATTERN
+
+        def_node_matcher :unsorted_dir_each?, <<~PATTERN
+          (send (send (const nil? :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        def_node_matcher :loop_variable, <<~PATTERN
+          (args (arg $_))
+        PATTERN
+
+        def_node_search :var_is_required?, <<~PATTERN
+          (send nil? :require (lvar %1))
+        PATTERN
+      end
+    end
+  end
+end