rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for `rescue` blocks targeting the `Exception` class.
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue Exception
+      #     handle_exception
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue ArgumentError
+      #     handle_exception
+      #   end
+      class RescueException < Base
+        MSG = 'Avoid rescuing the `Exception` class. Perhaps you meant to rescue `StandardError`?'
+
+        def on_resbody(node)
+          return unless node.children.first
+
+          rescue_args = node.children.first.children
+          return unless rescue_args.any? { |a| targets_exception?(a) }
+
+          add_offense(node)
+        end
+
+        def targets_exception?(rescue_arg_node)
+          rescue_arg_node.const_name == 'Exception'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Check for arguments to `rescue` that will result in a `TypeError`
+      # if an exception is raised.
+      #
+      # @example
+      #   # bad
+      #   begin
+      #     bar
+      #   rescue nil
+      #     baz
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     bar
+      #   rescue 1, 'a', "#{b}", 0.0, [], {}
+      #     baz
+      #   end
+      #
+      #   # good
+      #   begin
+      #     bar
+      #   rescue
+      #     baz
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     bar
+      #   rescue NameError
+      #     baz
+      #   end
+      class RescueType < Base
+        extend AutoCorrector
+
+        MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \
+              '`TypeError` instead of catching the actual exception.'
+        INVALID_TYPES = %i[array dstr float hash nil int str sym].freeze
+
+        def on_resbody(node)
+          invalid_exceptions = invalid_exceptions(node.exceptions)
+          return if invalid_exceptions.empty?
+
+          add_offense(
+            node.loc.keyword.join(node.children.first.source_range),
+            message: format(MSG, invalid_exceptions: invalid_exceptions.map(&:source).join(', '))
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          rescued = node.children.first
+          range = node.loc.keyword.end.join(rescued.source_range.end)
+
+          corrector.replace(range, correction(*rescued))
+        end
+
+        private
+
+        def correction(*exceptions)
+          correction = valid_exceptions(exceptions).map(&:source).join(', ')
+          correction = " #{correction}" unless correction.empty?
+
+          correction
+        end
+
+        def valid_exceptions(exceptions)
+          exceptions - invalid_exceptions(exceptions)
+        end
+
+        def invalid_exceptions(exceptions)
+          exceptions.select { |exception| INVALID_TYPES.include?(exception.type) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the use of a return with a value in a context
+      # where the value will be ignored. (initialize and setter methods)
+      #
+      # @example
+      #
+      #   # bad
+      #   def initialize
+      #     foo
+      #     return :qux if bar?
+      #     baz
+      #   end
+      #
+      #   def foo=(bar)
+      #     return 42
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     foo
+      #     return if bar?
+      #     baz
+      #   end
+      #
+      #   def foo=(bar)
+      #     return
+      #   end
+      class ReturnInVoidContext < Base
+        MSG = 'Do not return a value in `%<method>s`.'
+
+        # Returning out of these methods only exits the block itself.
+        SCOPE_CHANGING_METHODS = %i[lambda define_method define_singleton_method].freeze
+
+        def on_return(return_node)
+          return unless return_node.descendants.any?
+
+          def_node = return_node.each_ancestor(:any_def).first
+          return unless def_node&.void_context?
+          return if return_node.each_ancestor(:any_block).any? do |block_node|
+            SCOPE_CHANGING_METHODS.include?(block_node.method_name)
+          end
+
+          add_offense(
+            return_node.loc.keyword,
+            message: format(message, method: def_node.method_name)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # The safe navigation operator returns nil if the receiver is
+      # nil. If you chain an ordinary method call after a safe
+      # navigation operator, it raises NoMethodError. We should use a
+      # safe navigation operator after a safe navigation operator.
+      # This cop checks for the problem outlined above.
+      #
+      # @example
+      #
+      #   # bad
+      #   x&.foo.bar
+      #   x&.foo + bar
+      #   x&.foo[bar]
+      #
+      #   # good
+      #   x&.foo&.bar
+      #   x&.foo || bar
+      class SafeNavigationChain < Base
+        include NilMethods
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
+
+        MSG = 'Do not chain ordinary method call after safe navigation operator.'
+        PLUS_MINUS_METHODS = %i[+@ -@].freeze
+
+        # @!method bad_method?(node)
+        def_node_matcher :bad_method?, <<~PATTERN
+          {
+            (send $(csend ...) $_ ...)
+            (send $(any_block (csend ...) ...) $_ ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless require_safe_navigation?(node)
+
+          bad_method?(node) do |safe_nav, method|
+            return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
+
+            begin_range = node.loc.dot || safe_nav.source_range.end
+            location = begin_range.join(node.source_range.end)
+
+            add_offense(location) do |corrector|
+              autocorrect(corrector, offense_range: location, send_node: node)
+            end
+          end
+        end
+
+        private
+
+        def require_safe_navigation?(node)
+          parent = node.parent
+          return true unless parent&.and_type?
+
+          parent.rhs != node || parent.lhs.receiver != parent.rhs.receiver
+        end
+
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        # @return [String]
+        def add_safe_navigation_operator(offense_range:, send_node:)
+          source =
+            if brackets?(send_node)
+              format(
+                '%<method_name>s(%<arguments>s)%<method_chain>s',
+                arguments: send_node.arguments.map(&:source).join(', '),
+                method_name: send_node.method_name,
+                method_chain: send_node.source_range.end.join(send_node.source_range.end).source
+              )
+            else
+              offense_range.source
+            end
+          source.prepend('.') unless source.start_with?('.')
+          source.prepend('&')
+        end
+
+        # @param [RuboCop::Cop::Corrector] corrector
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        def autocorrect(corrector, offense_range:, send_node:)
+          corrector.replace(
+            offense_range,
+            add_safe_navigation_operator(offense_range: offense_range, send_node: send_node)
+          )
+
+          corrector.wrap(send_node, '(', ')') if require_parentheses?(send_node)
+        end
+
+        def brackets?(send_node)
+          send_node.method?(:[]) || send_node.method?(:[]=)
+        end
+
+        def require_parentheses?(send_node)
+          return true if operator_inside_hash?(send_node)
+          return false unless send_node.comparison_method?
+          return false unless (node = send_node.parent)
+
+          (node.respond_to?(:logical_operator?) && node.logical_operator?) ||
+            (node.respond_to?(:comparison_method?) && node.comparison_method?)
+        end
+
+        def operator_inside_hash?(send_node)
+          # If an operator call (without a dot) is inside a hash, it needs
+          # to be parenthesized when converted to safe navigation.
+          send_node.parent&.pair_type? && !send_node.loc.dot
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Check to make sure that if safe navigation is used in an `&&` or `||` condition,
+      # consistent and appropriate safe navigation, without excess or deficiency,
+      # is used for all method calls on the same object.
+      #
+      # @example
+      #   # bad
+      #   foo&.bar && foo&.baz
+      #
+      #   # good
+      #   foo&.bar && foo.baz
+      #
+      #   # bad
+      #   foo.bar && foo&.baz
+      #
+      #   # good
+      #   foo.bar && foo.baz
+      #
+      #   # bad
+      #   foo&.bar || foo.baz
+      #
+      #   # good
+      #   foo&.bar || foo&.baz
+      #
+      #   # bad
+      #   foo.bar || foo&.baz
+      #
+      #   # good
+      #   foo.bar || foo.baz
+      #
+      #   # bad
+      #   foo&.bar && (foobar.baz || foo&.baz)
+      #
+      #   # good
+      #   foo&.bar && (foobar.baz || foo.baz)
+      #
+      class SafeNavigationConsistency < Base
+        include NilMethods
+        extend AutoCorrector
+
+        USE_DOT_MSG = 'Use `.` instead of unnecessary `&.`.'
+        USE_SAFE_NAVIGATION_MSG = 'Use `&.` for consistency with safe navigation.'
+
+        def on_and(node)
+          all_operands = collect_operands(node, [])
+          operand_groups = all_operands.group_by { |operand| receiver_name_as_key(operand, +'') }
+
+          operand_groups.each_value do |grouped_operands|
+            next unless (dot_op, begin_of_rest_operands = find_consistent_parts(grouped_operands))
+
+            rest_operands = grouped_operands[begin_of_rest_operands..]
+            rest_operands.each do |operand|
+              next if already_appropriate_call?(operand, dot_op)
+
+              register_offense(operand, dot_op)
+            end
+          end
+        end
+        alias on_or on_and
+
+        private
+
+        def collect_operands(node, operand_nodes)
+          operand_nodes(node.lhs, operand_nodes)
+          operand_nodes(node.rhs, operand_nodes)
+
+          operand_nodes
+        end
+
+        def receiver_name_as_key(method, fully_receivers)
+          if method.parent.call_type?
+            receiver(method.parent, fully_receivers)
+          else
+            fully_receivers << method.receiver&.source.to_s
+          end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_consistent_parts(grouped_operands)
+          csend_in_and, csend_in_or, send_in_and, send_in_or = most_left_indices(grouped_operands)
+
+          return if csend_in_and && csend_in_or && csend_in_and < csend_in_or
+
+          if csend_in_and
+            ['.', (send_in_and ? [send_in_and, csend_in_and].min : csend_in_and) + 1]
+          elsif send_in_or && csend_in_or
+            send_in_or < csend_in_or ? ['.', send_in_or + 1] : ['&.', csend_in_or + 1]
+          elsif send_in_and && csend_in_or && send_in_and < csend_in_or
+            ['.', csend_in_or]
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def already_appropriate_call?(operand, dot_op)
+          return true if operand.safe_navigation? && dot_op == '&.'
+
+          (operand.dot? || operand.operator_method?) && dot_op == '.'
+        end
+
+        def register_offense(operand, dot_operator)
+          offense_range = operand.operator_method? ? operand : operand.loc.dot
+          message = dot_operator == '.' ? USE_DOT_MSG : USE_SAFE_NAVIGATION_MSG
+
+          add_offense(offense_range, message: message) do |corrector|
+            next if operand.operator_method?
+
+            corrector.replace(operand.loc.dot, dot_operator)
+          end
+        end
+
+        def operand_nodes(operand, operand_nodes)
+          if operand.operator_keyword?
+            collect_operands(operand, operand_nodes)
+          elsif operand.call_type?
+            operand_nodes << operand
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def most_left_indices(grouped_operands)
+          indices = { csend_in_and: nil, csend_in_or: nil, send_in_and: nil, send_in_or: nil }
+
+          grouped_operands.each_with_index do |operand, index|
+            indices[:csend_in_and] ||= index if operand_in_and?(operand) && operand.csend_type?
+            indices[:csend_in_or] ||= index if operand_in_or?(operand) && operand.csend_type?
+            indices[:send_in_and] ||= index if operand_in_and?(operand) && !nilable?(operand)
+            indices[:send_in_or] ||= index if operand_in_or?(operand) && !nilable?(operand)
+          end
+
+          indices.values
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def operand_in_and?(node)
+          return true if node.parent.and_type?
+
+          parent = node.parent.parent while node.parent.begin_type?
+
+          parent&.and_type?
+        end
+
+        def operand_in_or?(node)
+          return true if node.parent.or_type?
+
+          parent = node.parent.parent while node.parent.begin_type?
+
+          parent&.or_type?
+        end
+
+        def nilable?(node)
+          node.csend_type? || nil_methods.include?(node.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks to make sure safe navigation isn't used with `empty?` in
+      # a conditional.
+      #
+      # While the safe navigation operator is generally a good idea, when
+      # checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+      # do the opposite of what the author intends.
+      #
+      # @example
+      #   # bad
+      #   return if foo&.empty?
+      #   return unless foo&.empty?
+      #
+      #   # good
+      #   return if foo && foo.empty?
+      #   return unless foo && foo.empty?
+      #
+      class SafeNavigationWithEmpty < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid calling `empty?` with the safe navigation operator in conditionals.'
+
+        # @!method safe_navigation_empty_in_conditional?(node)
+        def_node_matcher :safe_navigation_empty_in_conditional?, <<~PATTERN
+          (if (csend (send ...) :empty?) ...)
+        PATTERN
+
+        def on_if(node)
+          return unless safe_navigation_empty_in_conditional?(node)
+
+          condition = node.condition
+
+          add_offense(condition) do |corrector|
+            receiver = condition.receiver.source
+
+            corrector.replace(condition, "#{receiver} && #{receiver}.#{condition.method_name}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks if a file which has a shebang line as
+      # its first line is granted execute permission.
+      #
+      # @example
+      #   # bad
+      #
+      #   # A file which has a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has a shebang line as its first line is
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has not a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   puts 'hello, world'
+      #
+      class ScriptPermission < Base
+        extend AutoCorrector
+
+        MSG = "Script file %<file>s doesn't have execute permission."
+        SHEBANG = '#!'
+
+        def on_new_investigation
+          return if @options.key?(:stdin)
+          return if Platform.windows?
+          return unless processed_source.start_with?(SHEBANG)
+          return if executable?(processed_source)
+
+          comment = processed_source.comments[0]
+          message = format_message_from(processed_source)
+
+          add_offense(comment, message: message) do
+            autocorrect if autocorrect_requested?
+          end
+        end
+
+        private
+
+        def autocorrect
+          FileUtils.chmod('+x', processed_source.file_path)
+        end
+
+        def executable?(processed_source)
+          # Returns true if stat is executable or if the operating system
+          # doesn't distinguish executable files from nonexecutable files.
+          # See at: https://github.com/ruby/ruby/blob/ruby_2_4/file.c#L5362
+          File.stat(processed_source.file_path).executable?
+        end
+
+        def format_message_from(processed_source)
+          basename = File.basename(processed_source.file_path)
+          format(MSG, file: basename)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for self-assignments.
+      #
+      # @example
+      #   # bad
+      #   foo = foo
+      #   foo, bar = foo, bar
+      #   Foo = Foo
+      #   hash['foo'] = hash['foo']
+      #   obj.attr = obj.attr
+      #
+      #   # good
+      #   foo = bar
+      #   foo, bar = bar, foo
+      #   Foo = Bar
+      #   hash['foo'] = hash['bar']
+      #   obj.attr = obj.attr2
+      #
+      #   # good (method calls possibly can return different results)
+      #   hash[foo] = hash[foo]
+      #
+      class SelfAssignment < Base
+        MSG = 'Self-assignment detected.'
+
+        ASSIGNMENT_TYPE_TO_RHS_TYPE = {
+          lvasgn: :lvar,
+          ivasgn: :ivar,
+          cvasgn: :cvar,
+          gvasgn: :gvar
+        }.freeze
+
+        def on_send(node)
+          if node.method?(:[]=)
+            handle_key_assignment(node) if node.arguments.size == 2
+          elsif node.assignment_method?
+            handle_attribute_assignment(node) if node.arguments.size == 1
+          end
+        end
+        alias on_csend on_send
+
+        def on_lvasgn(node)
+          return unless node.rhs
+
+          rhs_type = ASSIGNMENT_TYPE_TO_RHS_TYPE[node.type]
+
+          add_offense(node) if node.rhs.type == rhs_type && node.rhs.source == node.lhs.to_s
+        end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        def on_casgn(node)
+          return unless node.rhs&.const_type?
+
+          add_offense(node) if node.namespace == node.rhs.namespace &&
+                               node.short_name == node.rhs.short_name
+        end
+
+        def on_masgn(node)
+          add_offense(node) if multiple_self_assignment?(node)
+        end
+
+        def on_or_asgn(node)
+          add_offense(node) if rhs_matches_lhs?(node.rhs, node.lhs)
+        end
+        alias on_and_asgn on_or_asgn
+
+        private
+
+        def multiple_self_assignment?(node)
+          lhs = node.lhs
+          rhs = node.rhs
+          return false unless rhs.array_type?
+          return false unless lhs.children.size == rhs.children.size
+
+          lhs.children.zip(rhs.children).all? do |lhs_item, rhs_item|
+            rhs_matches_lhs?(rhs_item, lhs_item)
+          end
+        end
+
+        def rhs_matches_lhs?(rhs, lhs)
+          rhs.type == ASSIGNMENT_TYPE_TO_RHS_TYPE[lhs.type] &&
+            rhs.children.first == lhs.children.first
+        end
+
+        def handle_key_assignment(node)
+          value_node = node.arguments[1]
+
+          if value_node.send_type? && value_node.method?(:[]) &&
+             node.receiver == value_node.receiver &&
+             !node.first_argument.call_type? &&
+             node.first_argument == value_node.first_argument
+            add_offense(node)
+          end
+        end
+
+        def handle_attribute_assignment(node)
+          first_argument = node.first_argument
+          return unless first_argument.respond_to?(:arguments) && first_argument.arguments.empty?
+
+          if first_argument.call_type? &&
+             node.receiver == first_argument.receiver &&
+             first_argument.method_name.to_s == node.method_name.to_s.delete_suffix('=')
+            add_offense(node)
+          end
+        end
+      end
+    end
+  end
+end