rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for use of the `File.expand_path` arguments.
+      # Likewise, it also checks for the `Pathname.new` argument.
+      #
+      # Contrastive bad case and good case are alternately shown in
+      # the following examples.
+      #
+      # @example
+      #   # bad
+      #   File.expand_path('..', __FILE__)
+      #
+      #   # good
+      #   File.expand_path(__dir__)
+      #
+      #   # bad
+      #   File.expand_path('../..', __FILE__)
+      #
+      #   # good
+      #   File.expand_path('..', __dir__)
+      #
+      #   # bad
+      #   File.expand_path('.', __FILE__)
+      #
+      #   # good
+      #   File.expand_path(__FILE__)
+      #
+      #   # bad
+      #   Pathname(__FILE__).parent.expand_path
+      #
+      #   # good
+      #   Pathname(__dir__).expand_path
+      #
+      #   # bad
+      #   Pathname.new(__FILE__).parent.expand_path
+      #
+      #   # good
+      #   Pathname.new(__dir__).expand_path
+      #
+      class ExpandPathArguments < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `expand_path(%<new_path>s%<new_default_dir>s)` instead of ' \
+              '`expand_path(%<current_path>s, __FILE__)`.'
+        PATHNAME_MSG = 'Use `Pathname(__dir__).expand_path` instead of ' \
+                       '`Pathname(__FILE__).parent.expand_path`.'
+        PATHNAME_NEW_MSG = 'Use `Pathname.new(__dir__).expand_path` ' \
+                           'instead of ' \
+                           '`Pathname.new(__FILE__).parent.expand_path`.'
+
+        RESTRICT_ON_SEND = %i[expand_path].freeze
+
+        # @!method file_expand_path(node)
+        def_node_matcher :file_expand_path, <<~PATTERN
+          (send
+            (const {nil? cbase} :File) :expand_path
+            $_
+            $_)
+        PATTERN
+
+        # @!method pathname_parent_expand_path(node)
+        def_node_matcher :pathname_parent_expand_path, <<~PATTERN
+          (send
+            (send
+              (send nil? :Pathname
+                $_) :parent) :expand_path)
+        PATTERN
+
+        # @!method pathname_new_parent_expand_path(node)
+        def_node_matcher :pathname_new_parent_expand_path, <<~PATTERN
+          (send
+            (send
+              (send
+                (const {nil? cbase} :Pathname) :new
+                $_) :parent) :expand_path)
+        PATTERN
+
+        def on_send(node)
+          if (current_path, default_dir = file_expand_path(node))
+            inspect_offense_for_expand_path(node, current_path, default_dir)
+          elsif (default_dir = pathname_parent_expand_path(node))
+            return unless unrecommended_argument?(default_dir)
+
+            add_offense(node, message: PATHNAME_MSG) { |corrector| autocorrect(corrector, node) }
+          elsif (default_dir = pathname_new_parent_expand_path(node))
+            return unless unrecommended_argument?(default_dir)
+
+            add_offense(node, message: PATHNAME_NEW_MSG) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          if (current_path, default_dir = file_expand_path(node))
+            autocorrect_expand_path(corrector, current_path, default_dir)
+          elsif (dir = pathname_parent_expand_path(node) || pathname_new_parent_expand_path(node))
+            corrector.replace(dir, '__dir__')
+            remove_parent_method(corrector, dir)
+          end
+        end
+
+        def unrecommended_argument?(default_dir)
+          default_dir.source == '__FILE__'
+        end
+
+        def inspect_offense_for_expand_path(node, current_path, default_dir)
+          return unless unrecommended_argument?(default_dir) && current_path.str_type?
+
+          current_path = strip_surrounded_quotes!(current_path.source)
+
+          parent_path = parent_path(current_path)
+          new_path = parent_path == '' ? '' : "'#{parent_path}', "
+
+          new_default_dir = depth(current_path).zero? ? '__FILE__' : '__dir__'
+
+          message = format(
+            MSG,
+            new_path: new_path,
+            new_default_dir: new_default_dir,
+            current_path: "'#{current_path}'"
+          )
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect_expand_path(corrector, current_path, default_dir)
+          stripped_current_path = strip_surrounded_quotes!(current_path.source)
+
+          case depth(stripped_current_path)
+          when 0
+            range = arguments_range(current_path.parent)
+
+            corrector.replace(range, '__FILE__')
+          when 1
+            range = arguments_range(current_path.parent)
+
+            corrector.replace(range, '__dir__')
+          else
+            new_path = "'#{parent_path(stripped_current_path)}'"
+
+            corrector.replace(current_path, new_path)
+            corrector.replace(default_dir, '__dir__')
+          end
+        end
+
+        def strip_surrounded_quotes!(path_string)
+          path_string.slice!(path_string.length - 1)
+          path_string.slice!(0)
+
+          path_string
+        end
+
+        def depth(current_path)
+          paths = current_path.split(File::SEPARATOR)
+
+          paths.count { |path| path != '.' }
+        end
+
+        def parent_path(current_path)
+          paths = current_path.split(File::SEPARATOR)
+
+          paths.delete('.')
+          paths.each_with_index do |path, index|
+            if path == '..'
+              paths.delete_at(index)
+              break
+            end
+          end
+
+          paths.join(File::SEPARATOR)
+        end
+
+        def remove_parent_method(corrector, default_dir)
+          node = default_dir.parent.parent.parent.children.first
+
+          corrector.remove(node.loc.dot)
+          corrector.remove(node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of explicit block argument to avoid writing
+      # block literal that just passes its arguments to another block.
+      #
+      # NOTE: This cop only registers an offense if the block args match the
+      # yield args exactly.
+      #
+      # @example
+      #   # bad
+      #   def with_tmp_dir
+      #     Dir.mktmpdir do |tmp_dir|
+      #       Dir.chdir(tmp_dir) { |dir| yield dir } # block just passes arguments
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def nine_times
+      #     9.times { yield }
+      #   end
+      #
+      #   # good
+      #   def with_tmp_dir(&block)
+      #     Dir.mktmpdir do |tmp_dir|
+      #       Dir.chdir(tmp_dir, &block)
+      #     end
+      #   end
+      #
+      #   with_tmp_dir do |dir|
+      #     puts "dir is accessible as a parameter and pwd is set: #{dir}"
+      #   end
+      #
+      #   # good
+      #   def nine_times(&block)
+      #     9.times(&block)
+      #   end
+      #
+      class ExplicitBlockArgument < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Consider using explicit block argument in the ' \
+              "surrounding method's signature over `yield`."
+
+        # @!method yielding_block?(node)
+        def_node_matcher :yielding_block?, <<~PATTERN
+          (block $_ (args $...) (yield $...))
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Lint::UnusedMethodArgument]
+        end
+
+        def initialize(config = nil, options = nil)
+          super
+          @def_nodes = Set.new
+        end
+
+        def on_yield(node)
+          block_node = node.parent
+
+          yielding_block?(block_node) do |send_node, block_args, yield_args|
+            return unless yielding_arguments?(block_args, yield_args)
+
+            def_node = block_node.each_ancestor(:any_def).first
+            # if `yield` is being called outside of a method context, ignore
+            # this is not a valid ruby pattern, but can happen in haml or erb,
+            # so this can cause crashes in haml_lint
+            return unless def_node
+
+            block_name = extract_block_name(def_node)
+
+            add_offense(block_node) do |corrector|
+              corrector.remove(block_body_range(block_node, send_node))
+
+              add_block_argument(send_node, corrector, block_name)
+              add_block_argument(def_node, corrector, block_name) if @def_nodes.add?(def_node)
+            end
+          end
+        end
+
+        private
+
+        def extract_block_name(def_node)
+          if def_node.block_argument?
+            def_node.last_argument.name
+          else
+            'block'
+          end
+        end
+
+        def yielding_arguments?(block_args, yield_args)
+          yield_args = yield_args.dup.fill(
+            nil,
+            yield_args.length, block_args.length - yield_args.length
+          )
+
+          yield_args.zip(block_args).all? do |yield_arg, block_arg|
+            next false unless yield_arg && block_arg
+
+            block_arg && yield_arg.children.first == block_arg.children.first
+          end
+        end
+
+        def add_block_argument(node, corrector, block_name)
+          if node.arguments?
+            insert_argument(node, corrector, block_name)
+          elsif empty_arguments?(node)
+            corrector.replace(node.arguments, "(&#{block_name})")
+          elsif call_like?(node)
+            correct_call_node(node, corrector, block_name)
+          else
+            corrector.insert_after(node.loc.name, "(&#{block_name})")
+          end
+        end
+
+        def empty_arguments?(node)
+          # Is there an arguments node with only parentheses?
+          node.arguments.is_a?(RuboCop::AST::Node) && node.arguments.loc.begin
+        end
+
+        def call_like?(node)
+          node.type?(:call, :zsuper, :super)
+        end
+
+        def insert_argument(node, corrector, block_name)
+          last_arg = node.last_argument
+          arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
+          replacement = " &#{block_name}"
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
+          corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
+        end
+
+        def correct_call_node(node, corrector, block_name)
+          new_arguments = if node.zsuper_type?
+                            args = build_new_arguments_for_zsuper(node) << "&#{block_name}"
+                            args.join(', ')
+                          else
+                            "&#{block_name}"
+                          end
+          corrector.insert_after(node, "(#{new_arguments})")
+          return unless node.parenthesized?
+
+          args_begin = Util.args_begin(node)
+          args_end = Util.args_end(node)
+          range = range_between(args_begin.begin_pos, args_end.end_pos)
+          corrector.remove(range)
+        end
+
+        def build_new_arguments_for_zsuper(node)
+          def_node = node.each_ancestor(:any_def).first
+          def_node.arguments.map do |arg|
+            arg.optarg_type? ? arg.node_parts[0] : arg.source
+          end
+        end
+
+        def block_body_range(block_node, send_node)
+          range_between(send_node.source_range.end_pos, block_node.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces consistency when using exponential notation
+      # for numbers in the code (eg 1.2e4). Different styles are supported:
+      #
+      # * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+      # * `engineering` which enforces the exponent to be a multiple of 3 and the mantissa
+      #   to be between 0.1 (inclusive) and 1000 (exclusive).
+      # * `integral` which enforces the mantissa to always be a whole number without
+      #   trailing zeroes.
+      #
+      # @example EnforcedStyle: scientific (default)
+      #   # Enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+      #
+      #   # bad
+      #   10e6
+      #   0.3e4
+      #   11.7e5
+      #   3.14e0
+      #
+      #   # good
+      #   1e7
+      #   3e3
+      #   1.17e6
+      #   3.14
+      #
+      # @example EnforcedStyle: engineering
+      #   # Enforces using multiple of 3 exponents,
+      #   # mantissa should be between 0.1 (inclusive) and 1000 (exclusive)
+      #
+      #   # bad
+      #   3.2e7
+      #   0.1e5
+      #   12e5
+      #   1232e6
+      #
+      #   # good
+      #   32e6
+      #   10e3
+      #   1.2e6
+      #   1.232e9
+      #
+      # @example EnforcedStyle: integral
+      #   # Enforces the mantissa to have no decimal part and no
+      #   # trailing zeroes.
+      #
+      #   # bad
+      #   3.2e7
+      #   0.1e5
+      #   120e4
+      #
+      #   # good
+      #   32e6
+      #   1e4
+      #   12e5
+      #
+      class ExponentialNotation < Base
+        include ConfigurableEnforcedStyle
+        MESSAGES = {
+          scientific: 'Use a mantissa >= 1 and < 10.',
+          engineering: 'Use an exponent divisible by 3 and a mantissa >= 0.1 and < 1000.',
+          integral: 'Use an integer as mantissa, without trailing zero.'
+        }.freeze
+
+        def on_float(node)
+          add_offense(node) if offense?(node)
+        end
+
+        private
+
+        def scientific?(node)
+          mantissa, = node.source.split('e')
+          /^-?[1-9](\.\d*[0-9])?$/.match?(mantissa)
+        end
+
+        def engineering?(node)
+          mantissa, exponent = node.source.split('e')
+          return false unless /^-?\d+$/.match?(exponent)
+          return false unless (exponent.to_i % 3).zero?
+          return false if /^-?\d{4}/.match?(mantissa)
+          return false if /^-?0\d/.match?(mantissa)
+          return false if /^-?0.0/.match?(mantissa)
+
+          true
+        end
+
+        def integral(node)
+          mantissa, = node.source.split('e')
+          /^-?[1-9](\d*[1-9])?$/.match?(mantissa)
+        end
+
+        def offense?(node)
+          return false unless node.source['e']
+
+          case style
+          when :scientific
+            !scientific?(node)
+          when :engineering
+            !engineering?(node)
+          when :integral
+            !integral(node)
+          else
+            false
+          end
+        end
+
+        def message(_node)
+          MESSAGES[style]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Suggests `ENV.fetch` for the replacement of `ENV[]`.
+      # `ENV[]` silently fails and returns `nil` when the environment variable is unset,
+      # which may cause unexpected behaviors when the developer forgets to set it.
+      # On the other hand, `ENV.fetch` raises `KeyError` or returns the explicitly
+      # specified default value.
+      #
+      # @example
+      #   # bad
+      #   ENV['X']
+      #   x = ENV['X']
+      #
+      #   # good
+      #   ENV.fetch('X')
+      #   x = ENV.fetch('X')
+      #
+      #   # also good
+      #   !ENV['X']
+      #   ENV['X'].some_method # (e.g. `.nil?`)
+      #
+      class FetchEnvVar < Base
+        extend AutoCorrector
+
+        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        RESTRICT_ON_SEND = [:[]].freeze
+
+        # @!method env_with_bracket?(node)
+        def_node_matcher :env_with_bracket?, <<~PATTERN
+          (send (const nil? :ENV) :[] $_)
+        PATTERN
+
+        def on_send(node)
+          env_with_bracket?(node) do |name_node|
+            break unless offensive?(node)
+
+            message = format(MSG, key: name_node.source)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, new_code(name_node))
+            end
+          end
+        end
+
+        private
+
+        def allowed_var?(node)
+          env_key_node = node.children.last
+          env_key_node.str_type? && cop_config['AllowedVars'].include?(env_key_node.value)
+        end
+
+        def used_as_flag?(node)
+          return false if node.root?
+          return true if used_if_condition_in_body(node)
+
+          node.parent.send_type? && (node.parent.prefix_bang? || node.parent.comparison_method?)
+        end
+
+        def used_if_condition_in_body(node)
+          if_node = node.ancestors.find(&:if_type?)
+
+          return false unless (condition = if_node&.condition)
+          return true if condition.send_type? && (condition.child_nodes == node.child_nodes)
+
+          used_in_condition?(node, condition)
+        end
+
+        def used_in_condition?(node, condition)
+          if condition.send_type?
+            return true if condition.assignment_method? && partial_matched?(node, condition)
+            return false if !condition.comparison_method? && !condition.predicate_method?
+          end
+
+          condition.child_nodes.any?(node)
+        end
+
+        # Avoid offending in the following cases:
+        # `ENV['key'] if ENV['key'] = x`
+        def partial_matched?(node, condition)
+          node.child_nodes == node.child_nodes & condition.child_nodes
+        end
+
+        def offensive?(node)
+          !(allowed_var?(node) || allowable_use?(node))
+        end
+
+        # Check if the node is a receiver and receives a message with dot syntax.
+        def message_chained_with_dot?(node)
+          return false if node.root?
+
+          parent = node.parent
+          return false if !parent.call_type? || parent.children.first != node
+
+          parent.dot? || parent.safe_navigation?
+        end
+
+        # The following are allowed cases:
+        #
+        # - Used as a flag (e.g., `if ENV['X']` or `!ENV['X']`) because
+        #   it simply checks whether the variable is set.
+        # - Receiving a message with dot syntax, e.g. `ENV['X'].nil?`.
+        # - `ENV['key']` assigned by logical AND/OR assignment.
+        # - `ENV['key']` is the LHS of a `||`.
+        def allowable_use?(node)
+          used_as_flag?(node) || message_chained_with_dot?(node) || assigned?(node) || or_lhs?(node)
+        end
+
+        # The following are allowed cases:
+        #
+        # - `ENV['key']` is a receiver of `||=`, e.g. `ENV['X'] ||= y`.
+        # - `ENV['key']` is a receiver of `&&=`, e.g. `ENV['X'] &&= y`.
+        def assigned?(node)
+          return false unless (parent = node.parent)&.assignment?
+
+          lhs, _method, _rhs = *parent
+          node == lhs
+        end
+
+        def or_lhs?(node)
+          return false unless (parent = node.parent)&.or_type?
+
+          parent.lhs == node || parent.parent&.or_type?
+        end
+
+        def new_code(name_node)
+          "ENV.fetch(#{name_node.source}, nil)"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer to use `File.empty?('path/to/file')` when checking if a file is empty.
+      #
+      # @safety
+      #   This cop is unsafe, because `File.size`, `File.read`, and `File.binread`
+      #   raise `ENOENT` exception when there is no file corresponding to the path,
+      #   while `File.empty?` does not raise an exception.
+      #
+      # @example
+      #   # bad
+      #   File.zero?('path/to/file')
+      #   File.size('path/to/file') == 0
+      #   File.size('path/to/file') >= 0
+      #   File.size('path/to/file').zero?
+      #   File.read('path/to/file').empty?
+      #   File.binread('path/to/file') == ''
+      #   FileTest.zero?('path/to/file')
+      #
+      #   # good
+      #   File.empty?('path/to/file')
+      #   FileTest.empty?('path/to/file')
+      #
+      class FileEmpty < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<file_class>s.empty?(%<arg>s)` instead.'
+        RESTRICT_ON_SEND = %i[>= != == zero? empty?].freeze
+
+        minimum_target_ruby_version 2.4
+
+        # @!method offensive?(node)
+        def_node_matcher :offensive?, <<~PATTERN
+          {
+            (send $(const {nil? cbase} {:File :FileTest}) :zero? $_)
+            (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) {:== :>=} (int 0))
+            (send (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) :!) {:== :>=} (int 0))
+            (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) :zero?)
+            (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) {:!= :==} (str empty?))
+            (send (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) :!) {:!= :==} (str empty?))
+            (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) :empty?)
+          }
+        PATTERN
+
+        def on_send(node)
+          offensive?(node) do |const_node, arg_node|
+            add_offense(node,
+                        message: format(MSG, file_class: const_node.source,
+                                             arg: arg_node.source)) do |corrector|
+              corrector.replace(node,
+                                "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})")
+            end
+          end
+        end
+
+        private
+
+        def bang(node)
+          if (node.method?(:==) && node.child_nodes.first.method?(:!)) ||
+             (%i[>= !=].include?(node.method_name) && !node.child_nodes.first.method?(:!))
+            '!'
+          end
+        end
+      end
+    end
+  end
+end