rubocop 0.75.1

data/lib/rubocop/cop/lint/multiple_compare.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 MultipleCompare < 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_local_exit_from_iterator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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
+      #       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 }
+      #     end
+      #
+      #     def update_items
+      #       transaction do # block without arguments
+      #         return unless update_necessary? # allowed
+      #         find_each do |item| # block without method chain
+      #           return if item.stock == 0 # false-negative...
+      #           item.update!(foobar: true)
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      class NonLocalExitFromIterator < Cop
+        MSG = 'Non-local exit from iterator, without return value. ' \
+              '`next`, `break`, `Array#find`, `Array#any?`, etc. ' \
+              'is preferred.'
+
+        def on_return(return_node)
+          return if return_value?(return_node)
+
+          return_node.each_ancestor(:block, :def, :defs) do |node|
+            break if scoped_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?(node.send_node)
+
+            next unless node.arguments?
+
+            if chained_send?(node.send_node)
+              add_offense(return_node, location: :keyword)
+              break
+            end
+          end
+        end
+
+        private
+
+        def scoped_node?(node)
+          node.def_type? || node.defs_type? || node.lambda?
+        end
+
+        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
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop warns the usage of unsafe number conversions. Unsafe
+      # number conversion can cause unexpected error if auto type conversion
+      # fails. Cop prefer parsing with number class instead.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   '10'.to_i
+      #   '10.2'.to_f
+      #   '10'.to_c
+      #
+      #   # good
+      #
+      #   Integer('10', 10)
+      #   Float('10.2')
+      #   Complex('10')
+      class NumberConversion < Cop
+        CONVERSION_METHOD_CLASS_MAPPING = {
+          to_i: "#{Integer.name}(%<number_object>s, 10)",
+          to_f: "#{Float.name}(%<number_object>s)",
+          to_c: "#{Complex.name}(%<number_object>s)"
+        }.freeze
+        MSG = 'Replace unsafe number conversion with number '\
+              'class parsing, instead of using '\
+              '%<number_object>s.%<to_method>s, use stricter '\
+              '%<corrected_method>s.'
+
+        def_node_matcher :to_method, <<~PATTERN
+          (send $_ ${:to_i :to_f :to_c})
+        PATTERN
+
+        def_node_matcher :datetime?, <<~PATTERN
+          (send (const {nil? (cbase)} {:Time :DateTime}) ...)
+        PATTERN
+
+        def on_send(node)
+          to_method(node) do |receiver, to_method|
+            next if receiver.nil? || date_time_object?(receiver)
+
+            message = format(
+              MSG,
+              number_object: receiver.source,
+              to_method: to_method,
+              corrected_method: correct_method(node, receiver)
+            )
+            add_offense(node, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression,
+                              correct_method(node, node.receiver))
+          end
+        end
+
+        private
+
+        def date_time_object?(node)
+          child = node
+          while child&.send_type?
+            return true if datetime? child
+
+            child = child.children[0]
+          end
+        end
+
+        def correct_method(node, receiver)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
+                 number_object: receiver.source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # Checks the proper ordering of magic comments and whether
+      # a magic comment is not placed before a shebang.
+      #
+      # @example
+      #   # bad
+      #
+      #   # frozen_string_literal: true
+      #   # encoding: ascii
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:UTF-8>]
+      #
+      #   # good
+      #
+      #   # encoding: ascii
+      #   # frozen_string_literal: true
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+      #
+      #   # good
+      #
+      #   #!/usr/bin/env ruby
+      #   # encoding: ascii
+      #   # frozen_string_literal: true
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+      #
+      class OrderedMagicComments < Cop
+        include FrozenStringLiteral
+
+        MSG = 'The encoding magic comment should precede all other ' \
+              'magic comments.'
+
+        def investigate(processed_source)
+          return if processed_source.buffer.source.empty?
+
+          encoding_line, frozen_string_literal_line = magic_comment_lines
+
+          return unless encoding_line && frozen_string_literal_line
+          return if encoding_line < frozen_string_literal_line
+
+          range = processed_source.buffer.line_range(encoding_line + 1)
+
+          add_offense(range, location: range)
+        end
+
+        def autocorrect(_node)
+          encoding_line, frozen_string_literal_line = magic_comment_lines
+
+          range1 = processed_source.buffer.line_range(encoding_line + 1)
+          range2 =
+            processed_source.buffer.line_range(frozen_string_literal_line + 1)
+
+          lambda do |corrector|
+            corrector.replace(range1, range2.source)
+            corrector.replace(range2, range1.source)
+          end
+        end
+
+        private
+
+        def magic_comment_lines
+          lines = [nil, nil]
+
+          magic_comments.each.with_index do |comment, index|
+            if comment.encoding_specified?
+              lines[0] = index
+            elsif comment.frozen_string_literal_specified?
+              lines[1] = index
+            end
+
+            return lines if lines[0] && lines[1]
+          end
+
+          lines
+        end
+
+        def magic_comments
+          leading_comment_lines.map { |line| MagicComment.parse(line) }
+        end
+      end
+    end
+  end
+end