rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/style/random_with_offset.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the use of randomly generated numbers,
+      # added/subtracted with integer literals, as well as those with
+      # Integer#succ and Integer#pred methods. Prefer using ranges instead,
+      # as it clearly states the intentions.
+      #
+      # @example
+      #   # bad
+      #   rand(6) + 1
+      #   1 + rand(6)
+      #   rand(6) - 1
+      #   1 - rand(6)
+      #   rand(6).succ
+      #   rand(6).pred
+      #   Random.rand(6) + 1
+      #   Kernel.rand(6) + 1
+      #   rand(0..5) + 1
+      #
+      #   # good
+      #   rand(1..6)
+      #   rand(1...7)
+      class RandomWithOffset < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer ranges when generating random numbers instead of integers with offsets.'
+        RESTRICT_ON_SEND = %i[+ - succ pred next].freeze
+
+        # @!method integer_op_rand?(node)
+        def_node_matcher :integer_op_rand?, <<~PATTERN
+          (send
+            int {:+ :-}
+            (send
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
+              :rand
+              {int (range int int)}))
+        PATTERN
+
+        # @!method rand_op_integer?(node)
+        def_node_matcher :rand_op_integer?, <<~PATTERN
+          (send
+            (send
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
+              :rand
+              {int (range int int)})
+            {:+ :-}
+            int)
+        PATTERN
+
+        # @!method rand_modified?(node)
+        def_node_matcher :rand_modified?, <<~PATTERN
+          (send
+            (send
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
+              :rand
+              {int (range int int)})
+            {:succ :pred :next})
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver
+          return unless integer_op_rand?(node) || rand_op_integer?(node) || rand_modified?(node)
+
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
+
+        # @!method random_call(node)
+        def_node_matcher :random_call, <<~PATTERN
+          {(send (send $_ _ $_) ...)
+           (send _ _ (send $_ _ $_))}
+        PATTERN
+
+        def autocorrect(corrector, node)
+          if integer_op_rand?(node)
+            corrector.replace(node, corrected_integer_op_rand(node))
+          elsif rand_op_integer?(node)
+            corrector.replace(node, corrected_rand_op_integer(node))
+          elsif rand_modified?(node)
+            corrector.replace(node, corrected_rand_modified(node))
+          end
+        end
+
+        def corrected_integer_op_rand(node)
+          random_call(node) do |prefix_node, random_node|
+            prefix = prefix_from_prefix_node(prefix_node)
+            left_int, right_int = boundaries_from_random_node(random_node)
+
+            offset = to_int(node.receiver)
+
+            if node.method?(:+)
+              "#{prefix}(#{offset + left_int}..#{offset + right_int})"
+            else
+              "#{prefix}(#{offset - right_int}..#{offset - left_int})"
+            end
+          end
+        end
+
+        def corrected_rand_op_integer(node)
+          random_call(node) do |prefix_node, random_node|
+            prefix = prefix_from_prefix_node(prefix_node)
+            left_int, right_int = boundaries_from_random_node(random_node)
+
+            offset = to_int(node.first_argument)
+
+            if node.method?(:+)
+              "#{prefix}(#{left_int + offset}..#{right_int + offset})"
+            else
+              "#{prefix}(#{left_int - offset}..#{right_int - offset})"
+            end
+          end
+        end
+
+        def corrected_rand_modified(node)
+          random_call(node) do |prefix_node, random_node|
+            prefix = prefix_from_prefix_node(prefix_node)
+            left_int, right_int = boundaries_from_random_node(random_node)
+
+            if %i[succ next].include?(node.method_name)
+              "#{prefix}(#{left_int + 1}..#{right_int + 1})"
+            elsif node.method?(:pred)
+              "#{prefix}(#{left_int - 1}..#{right_int - 1})"
+            end
+          end
+        end
+
+        def prefix_from_prefix_node(node)
+          [node&.source, 'rand'].compact.join('.')
+        end
+
+        def boundaries_from_random_node(random_node)
+          case random_node.type
+          when :int
+            [0, to_int(random_node) - 1]
+          when :irange
+            [to_int(random_node.begin), to_int(random_node.end)]
+          when :erange
+            [to_int(random_node.begin), to_int(random_node.end) - 1]
+          end
+        end
+
+        # @!method to_int(node)
+        def_node_matcher :to_int, <<~PATTERN
+          (int $_)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_argument.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for a redundant argument passed to certain methods.
+      #
+      # NOTE: This cop is limited to methods with single parameter.
+      #
+      # Method names and their redundant arguments can be configured like this:
+      #
+      # [source,yaml]
+      # ----
+      # Methods:
+      #   join: ''
+      #   sum: 0
+      #   split: ' '
+      #   chomp: "\n"
+      #   chomp!: "\n"
+      #   foo: 2
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because of the following limitations:
+      #
+      #   1. This cop matches by method names only and hence cannot tell apart
+      #      methods with same name in different classes.
+      #   2. This cop may be unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
+      #      That depends on the nature of the target methods, of course. For example, the default
+      #      argument to join is `$OUTPUT_FIELD_SEPARATOR` (or `$,`) rather than `''`, and if that
+      #      global is changed, `''` is no longer a redundant argument.
+      #
+      # @example
+      #   # bad
+      #   array.join('')
+      #   [1, 2, 3].join("")
+      #   array.sum(0)
+      #   exit(true)
+      #   exit!(false)
+      #   string.split(" ")
+      #   "first\nsecond".split(" ")
+      #   string.chomp("\n")
+      #   string.chomp!("\n")
+      #   A.foo(2)
+      #
+      #   # good
+      #   array.join
+      #   [1, 2, 3].join
+      #   array.sum
+      #   exit
+      #   exit!
+      #   string.split
+      #   "first second".split
+      #   string.chomp
+      #   string.chomp!
+      #   A.foo
+      class RedundantArgument < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Argument %<arg>s is redundant because it is implied by default.'
+        NO_RECEIVER_METHODS = %i[exit exit!].freeze
+
+        def on_send(node)
+          return if !NO_RECEIVER_METHODS.include?(node.method_name) && node.receiver.nil?
+          return if node.arguments.count != 1
+          return unless redundant_argument?(node)
+
+          offense_range = argument_range(node)
+          message = format(MSG, arg: node.first_argument.source)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.remove(offense_range)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def redundant_argument?(node)
+          redundant_argument = redundant_arg_for_method(node.method_name.to_s)
+          return false if redundant_argument.nil?
+
+          target_argument = if node.first_argument.respond_to?(:value)
+                              node.first_argument.value
+                            else
+                              node.first_argument
+                            end
+
+          argument_matched?(target_argument, redundant_argument)
+        end
+
+        def redundant_arg_for_method(method_name)
+          arg = cop_config['Methods'].fetch(method_name) { return }
+
+          @mem ||= {}
+          @mem[method_name] ||= arg.inspect
+        end
+
+        def argument_range(node)
+          if node.parenthesized?
+            range_between(node.loc.begin.begin_pos, node.loc.end.end_pos)
+          else
+            range_with_surrounding_space(node.first_argument.source_range, newlines: false)
+          end
+        end
+
+        def argument_matched?(target_argument, redundant_argument)
+          argument = if target_argument.is_a?(AST::Node)
+                       target_argument.source
+                     elsif exclude_cntrl_character?(target_argument, redundant_argument)
+                       target_argument.inspect
+                     else
+                       target_argument.to_s
+                     end
+
+          argument == redundant_argument
+        end
+
+        def exclude_cntrl_character?(target_argument, redundant_argument)
+          return true unless (target_argument_string = target_argument.to_s).valid_encoding?
+
+          !target_argument_string.sub(/\A'/, '"').sub(/'\z/, '"').match?(/[[:cntrl:]]/) ||
+            !redundant_argument.match?(/[[:cntrl:]]/)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_array_constructor.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of array using redundant `Array` constructor.
+      # Autocorrect replaces to array literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Array.new([])
+      #   Array[]
+      #   Array([])
+      #   Array.new(['foo', 'foo', 'foo'])
+      #   Array['foo', 'foo', 'foo']
+      #   Array(['foo', 'foo', 'foo'])
+      #
+      #   # good
+      #   []
+      #   ['foo', 'foo', 'foo']
+      #   Array.new(3, 'foo')
+      #   Array.new(3) { 'foo' }
+      #
+      class RedundantArrayConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Array` constructor.'
+
+        RESTRICT_ON_SEND = %i[new [] Array].freeze
+
+        # @!method redundant_array_constructor(node)
+        def_node_matcher :redundant_array_constructor, <<~PATTERN
+          {
+            (send
+              (const {nil? cbase} :Array) :new
+              $(array ...))
+            (send
+              (const {nil? cbase} :Array) :[]
+              $...)
+            (send
+              nil? :Array
+              $(array ...))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (array_literal = redundant_array_constructor(node))
+
+          receiver = node.receiver
+          selector = node.loc.selector
+
+          if node.method?(:new)
+            range = receiver.source_range.join(selector)
+            replacement = array_literal
+          elsif node.method?(:Array)
+            range = selector
+            replacement = array_literal
+          else
+            range = receiver
+            replacement = selector.begin.join(node.source_range.end)
+          end
+
+          register_offense(range, node, replacement)
+        end
+
+        private
+
+        def register_offense(range, node, replacement)
+          add_offense(range) do |corrector|
+            corrector.replace(node, replacement.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_assignment.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant assignment before returning.
+      #
+      # @example
+      #   # bad
+      #   def test
+      #     x = foo
+      #     x
+      #   end
+      #
+      #   # bad
+      #   def test
+      #     if x
+      #       z = foo
+      #       z
+      #     elsif y
+      #       z = bar
+      #       z
+      #     end
+      #   end
+      #
+      #   # good
+      #   def test
+      #     foo
+      #   end
+      #
+      #   # good
+      #   def test
+      #     if x
+      #       foo
+      #     elsif y
+      #       bar
+      #     end
+      #   end
+      #
+      class RedundantAssignment < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant assignment before returning detected.'
+
+        # @!method redundant_assignment?(node)
+        def_node_matcher :redundant_assignment?, <<~PATTERN
+          (... $(lvasgn _name _expression) (lvar _name))
+        PATTERN
+
+        def on_def(node)
+          check_branch(node.body)
+        end
+        alias on_defs on_def
+
+        private
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def check_branch(node)
+          return unless node
+
+          case node.type
+          when :case       then check_case_node(node)
+          when :case_match then check_case_match_node(node)
+          when :if         then check_if_node(node)
+          when :rescue, :resbody
+            check_rescue_node(node)
+          when :ensure then check_ensure_node(node)
+          when :begin, :kwbegin
+            check_begin_node(node)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def check_case_node(node)
+          node.when_branches.each { |when_node| check_branch(when_node.body) }
+          check_branch(node.else_branch)
+        end
+
+        def check_case_match_node(node)
+          node.in_pattern_branches.each { |in_pattern_node| check_branch(in_pattern_node.body) }
+          check_branch(node.else_branch)
+        end
+
+        def check_if_node(node)
+          return if node.modifier_form? || node.ternary?
+
+          check_branch(node.if_branch)
+          check_branch(node.else_branch)
+        end
+
+        def check_rescue_node(node)
+          node.child_nodes.each { |child_node| check_branch(child_node) }
+        end
+
+        def check_ensure_node(node)
+          check_branch(node.branch)
+        end
+
+        def check_begin_node(node)
+          if (assignment = redundant_assignment?(node))
+            add_offense(assignment) do |corrector|
+              expression = assignment.children[1]
+              corrector.replace(assignment, expression.source)
+              corrector.remove(assignment.right_sibling)
+            end
+          else
+            last_expr = node.children.last
+            check_branch(last_expr)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_begin.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant `begin` blocks.
+      #
+      # Currently it checks for code like this:
+      #
+      # @example
+      #
+      #   # bad
+      #   def redundant
+      #     begin
+      #       ala
+      #       bala
+      #     rescue StandardError => e
+      #       something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def preferred
+      #     ala
+      #     bala
+      #   rescue StandardError => e
+      #     something
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   do_something
+      #
+      #   # bad
+      #   # When using Ruby 2.5 or later.
+      #   do_something do
+      #     begin
+      #       something
+      #     rescue => ex
+      #       anything
+      #     end
+      #   end
+      #
+      #   # good
+      #   # In Ruby 2.5 or later, you can omit `begin` in `do-end` block.
+      #   do_something do
+      #     something
+      #   rescue => ex
+      #     anything
+      #   end
+      #
+      #   # good
+      #   # Stabby lambdas don't support implicit `begin` in `do-end` blocks.
+      #   -> do
+      #     begin
+      #       foo
+      #     rescue Bar
+      #       baz
+      #     end
+      #   end
+      class RedundantBegin < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant `begin` block detected.'
+
+        def self.autocorrect_incompatible_with
+          [Style::BlockDelimiters]
+        end
+
+        # @!method offensive_kwbegins(node)
+        def_node_search :offensive_kwbegins, <<~PATTERN
+          [(kwbegin ...) !#allowable_kwbegin?]
+        PATTERN
+
+        def on_def(node)
+          return unless node.body&.kwbegin_type?
+          return if node.endless?
+
+          register_offense(node.body)
+        end
+        alias on_defs on_def
+
+        def on_block(node)
+          return if target_ruby_version < 2.5
+          return if node.send_node.lambda_literal?
+          return if node.braces?
+          return unless node.body&.kwbegin_type?
+
+          register_offense(node.body)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_kwbegin(node)
+          return unless (target_node = offensive_kwbegins(node).to_a.last)
+
+          register_offense(target_node)
+        end
+
+        private
+
+        def allowable_kwbegin?(node)
+          empty_begin?(node) ||
+            begin_block_has_multiline_statements?(node) ||
+            contain_rescue_or_ensure?(node) ||
+            valid_context_using_only_begin?(node)
+        end
+
+        def register_offense(node)
+          offense_range = node.loc.begin
+
+          add_offense(offense_range) do |corrector|
+            if node.parent&.assignment?
+              replace_begin_with_statement(corrector, offense_range, node)
+            else
+              remove_begin(corrector, offense_range, node)
+            end
+
+            if use_modifier_form_after_multiline_begin_block?(node)
+              correct_modifier_form_after_multiline_begin_block(corrector, node)
+            end
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        def replace_begin_with_statement(corrector, offense_range, node)
+          first_child = node.children.first
+
+          source = first_child.source
+          source = "(#{source})" if first_child.if_type? && first_child.modifier_form?
+
+          corrector.replace(offense_range, source)
+          corrector.remove(range_between(offense_range.end_pos, first_child.source_range.end_pos))
+
+          restore_removed_comments(corrector, offense_range, node, first_child)
+        end
+
+        def remove_begin(corrector, offense_range, node)
+          if node.parent.respond_to?(:endless?) && node.parent.endless?
+            offense_range = range_with_surrounding_space(offense_range, newlines: true)
+          end
+
+          corrector.remove(offense_range)
+        end
+
+        # Restore comments that occur between "begin" and "first_child".
+        # These comments will be moved to above the assignment line.
+        def restore_removed_comments(corrector, offense_range, node, first_child)
+          comments_range = range_between(offense_range.end_pos, first_child.source_range.begin_pos)
+          comments = comments_range.source
+
+          corrector.insert_before(node.parent, comments) unless comments.blank?
+        end
+
+        def use_modifier_form_after_multiline_begin_block?(node)
+          return false unless (parent = node.parent)
+
+          node.multiline? && parent.if_type? && parent.modifier_form?
+        end
+
+        def correct_modifier_form_after_multiline_begin_block(corrector, node)
+          condition_range = condition_range(node.parent)
+
+          corrector.insert_after(node.children.first, " #{condition_range.source}")
+          corrector.remove(range_by_whole_lines(condition_range, include_final_newline: true))
+        end
+
+        def condition_range(node)
+          range_between(node.loc.keyword.begin_pos, node.condition.source_range.end_pos)
+        end
+
+        def empty_begin?(node)
+          node.children.empty?
+        end
+
+        def begin_block_has_multiline_statements?(node)
+          node.children.count >= 2
+        end
+
+        def contain_rescue_or_ensure?(node)
+          first_child = node.children.first
+
+          first_child.type?(:rescue, :ensure)
+        end
+
+        def valid_context_using_only_begin?(node)
+          parent = node.parent
+
+          valid_begin_assignment?(node) || parent&.post_condition_loop? ||
+            parent&.send_type? || parent&.operator_keyword?
+        end
+
+        def valid_begin_assignment?(node)
+          node.parent&.assignment? && !node.children.one?
+        end
+      end
+    end
+  end
+end